{"messages":[{"content":"You are a constitutional council ranking individual git commits for ownership allocation.\n\nCompare these two commits. Decide which contributed more lasting value to the project.\n\nJudge substance, not spectacle:\n- Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise.\n- Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one.\n- Do not favor a side merely because its patch is longer or noisier.\n- Weight what the change does for the project, not the contributor's name.\n\nReturn ONLY a JSON object: {\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}\nThe explanation must cite concrete differences in the patches (1-3 sentences).\n\nSide A — contributor: tommy-mor\nSide A — commit message:\n[d1ad77cf] Add transparent HTML evidence graph for epochs and rankings.\n\nPersist verbatim commits, comparisons, attempts, and judgments in the ledger, serve them as linkable HTML indexes, and keep ranking resumable across restarts.\n\nCo-authored-by: Cursor <cursoragent@cursor.com>\n\nSide A — unified diff (full patch):\ndiff --git a/constitution.py b/constitution.py\nindex a58257e1881b21d1d6fa8e68a3faa222e4f661ef..f819007252f435680b8356fb4da83469b21e33af 100644\n--- a/constitution.py\n+++ b/constitution.py\n@@ -156,6 +156,8 @@ DEFAULT_REPOSITORIES = [\n         \"refs\": [\"refs/heads/**\"],\n     },\n ]\n+PUBLIC_BASE_URL = os.environ.get(\"PUBLIC_BASE_URL\", \"https://token.slug.social\").rstrip(\"/\")\n+EVIDENCE_SCHEMA_VERSION = 2\n DEFAULT_CONTRIBUTORS = {\n     \"tommy-mor\": [\"thmorriss@gmail.com\"],\n     \"christopher-whitman\": [\n@@ -206,6 +208,9 @@ class Emission:\n     ranking: dict         # author -> score str\n     models_used: list\n     discovery_snapshot_id: str = \"\"  # empty only for pre-discovery ledger history\n+    evidence_schema_version: int = 1\n+    ranking_run_id: str = \"\"\n+    ranking_event_id: str = \"\"\n \n \n @event\n@@ -237,7 +242,299 @@ class GitDiscovery:\n     commits: list\n \n \n+@event\n+class Evidence:\n+    \"\"\"Versioned, content-addressed constitutional evidence envelope.\"\"\"\n+    schema_version: int\n+    event_id: str\n+    epoch: int\n+    kind: str\n+    recorded_at_ms: int\n+    previous_event_sha256: str\n+    payload: dict\n+\n+\n store = JsonlStore(JSONL_PATH)\n+_LEDGER_LOCK = asyncio.Lock()\n+\n+\n+# ===========================================================================\n+# §1e. EVIDENCE — content-addressed, append-only, publicly linkable\n+# ===========================================================================\n+#\n+# Every epoch, commit, comparison input, provider attempt, and judgment is\n+# recorded as Evidence. Authoritative payloads keep exact bytes as base64 plus\n+# SHA-256; decoded text is for display only.\n+\n+\n+def _canonical_json(obj) -> bytes:\n+    return json.dumps(obj, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=False).encode()\n+\n+\n+def _sha256_hex(data: bytes) -> str:\n+    return hashlib.sha256(data).hexdigest()\n+\n+\n+def _bytes_blob(data: bytes | str) -> dict:\n+    raw = data.encode(\"utf-8\") if isinstance(data, str) else data\n+    return {\n+        \"encoding\": \"base64\",\n+        \"data\": base64.b64encode(raw).decode(\"ascii\"),\n+        \"byte_length\": len(raw),\n+        \"sha256\": _sha256_hex(raw),\n+        \"text\": raw.decode(\"utf-8\", \"replace\"),\n+    }\n+\n+\n+def _decode_blob(blob: dict | None) -> bytes:\n+    if not blob:\n+        return b\"\"\n+    return base64.b64decode(blob[\"data\"].encode(\"ascii\"))\n+\n+\n+def _content_id(prefix: str, material) -> str:\n+    digest = _sha256_hex(_canonical_json(material) if not isinstance(material, bytes) else material)\n+    return f\"{prefix}_{digest}\"\n+\n+\n+def _html_escape(text: str) -> str:\n+    return (\n+        text.replace(\"&\", \"&amp;\")\n+        .replace(\"<\", \"&lt;\")\n+        .replace(\">\", \"&gt;\")\n+        .replace('\"', \"&quot;\")\n+    )\n+\n+\n+def _evidence_path(kind: str, entity_id: str) -> str:\n+    routes = {\n+        \"epoch\": f\"/epochs/{entity_id}\",\n+        \"commit\": f\"/commits/{entity_id}\",\n+        \"comparison\": f\"/comparisons/{entity_id}\",\n+        \"attempt\": f\"/attempts/{entity_id}\",\n+        \"judgment\": f\"/judgments/{entity_id}\",\n+        \"event\": f\"/events/{entity_id}\",\n+    }\n+    return routes[kind]\n+\n+\n+def _evidence_url(kind: str, entity_id: str) -> str:\n+    return PUBLIC_BASE_URL + _evidence_path(kind, entity_id)\n+\n+\n+def _previous_event_sha256(events: list) -> str:\n+    for event_ in reversed(events):\n+        if isinstance(event_, Evidence):\n+            return event_.event_id.split(\"_\", 1)[-1]\n+        if isinstance(event_, (GitDiscovery, Emission)):\n+            return _sha256_hex(_canonical_json(to_dict(event_)))\n+    return \"0\" * 64\n+\n+\n+def _public_repo_row(repo: dict) -> dict:\n+    \"\"\"Strip credential-bearing clone URLs from published config.\"\"\"\n+    url = repo[\"url\"]\n+    if \"@\" in url and \"://\" in url:\n+        scheme, rest = url.split(\"://\", 1)\n+        url = f\"{scheme}://{rest.split('@', 1)[-1]}\"\n+    return {\"id\": repo[\"id\"], \"url\": url, \"refs\": repo[\"refs\"]}\n+\n+\n+def _ledger_lock_path() -> pathlib.Path:\n+    env = os.environ.get(\"LEDGER_LOCK_PATH\")\n+    if env:\n+        return pathlib.Path(env)\n+    return pathlib.Path(str(store.path) + \".lock\")\n+\n+\n+async def append_evidence(epoch: int, kind: str, payload: dict) -> Evidence:\n+    \"\"\"Durably append one Evidence event under process + file locks.\"\"\"\n+    # Logical identity ignores chain links / wall clock so restarts stay idempotent.\n+    event_id = _content_id(\"ev\", {\n+        \"schema_version\": EVIDENCE_SCHEMA_VERSION,\n+        \"epoch\": epoch,\n+        \"kind\": kind,\n+        \"payload\": payload,\n+    })\n+    async with _LEDGER_LOCK:\n+        lock_path = _ledger_lock_path()\n+        lock_path.parent.mkdir(parents=True, exist_ok=True)\n+        with lock_path.open(\"a+b\") as lock_file:\n+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)\n+            try:\n+                events = store.read()\n+                existing = next(\n+                    (\n+                        e for e in events\n+                        if isinstance(e, Evidence) and e.event_id == event_id\n+                    ),\n+                    None,\n+                )\n+                if existing:\n+                    return existing\n+                recorded_at_ms = int(time.time() * 1000)\n+                previous = _previous_event_sha256(events)\n+                evidence = Evidence(\n+                    schema_version=EVIDENCE_SCHEMA_VERSION,\n+                    event_id=event_id,\n+                    epoch=epoch,\n+                    kind=kind,\n+                    recorded_at_ms=recorded_at_ms,\n+                    previous_event_sha256=previous,\n+                    payload=payload,\n+                )\n+\n+                def append_once(current):\n+                    if any(\n+                        isinstance(e, Evidence) and e.event_id == event_id\n+                        for e in current\n+                    ):\n+                        return None\n+                    return evidence\n+\n+                appended = await store.atomic(append_once)\n+                result = appended or next(\n+                    e for e in store.read()\n+                    if isinstance(e, Evidence) and e.event_id == event_id\n+                )\n+                try:\n+                    with open(store.path, \"rb\") as fh:\n+                        os.fsync(fh.fileno())\n+                except OSError:\n+                    pass\n+            finally:\n+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)\n+    await broadcast_audit(\n+        kind,\n+        f\"{kind}: {payload.get('summary') or event_id[:24]}\",\n+        phase=PROCESS_STATE.get(\"phase\"),\n+        progress=PROCESS_STATE.get(\"progress\"),\n+        evidence_event_id=result.event_id,\n+        evidence_url=_evidence_url(\"event\", result.event_id),\n+    )\n+    return result\n+\n+\n+def evidence_by_kind(kind: str | None = None) -> list[Evidence]:\n+    rows = [e for e in store.read() if isinstance(e, Evidence)]\n+    if kind is None:\n+        return rows\n+    return [e for e in rows if e.kind == kind]\n+\n+\n+def find_evidence(event_id: str) -> Evidence | None:\n+    return next(\n+        (e for e in store.read() if isinstance(e, Evidence) and e.event_id == event_id),\n+        None,\n+    )\n+\n+\n+def find_evidence_payload(kind: str, key: str, value: str) -> Evidence | None:\n+    for e in evidence_by_kind(kind):\n+        if e.payload.get(key) == value:\n+            return e\n+    return None\n+\n+\n+def commit_id_for_oid(oid: str) -> str:\n+    return _content_id(\"c\", {\"oid\": oid})\n+\n+\n+def comparison_id_for(material: dict) -> str:\n+    return _content_id(\"cmp\", material)\n+\n+\n+def attempt_id_for(comparison_id: str, model_id: str, attempt_number: int) -> str:\n+    return _content_id(\"att\", {\n+        \"comparison_id\": comparison_id,\n+        \"model_id\": model_id,\n+        \"attempt_number\": attempt_number,\n+    })\n+\n+\n+def judgment_id_for(material: dict) -> str:\n+    return _content_id(\"jud\", material)\n+\n+\n+def _blob_text(blob) -> str:\n+    if blob is None:\n+        return \"\"\n+    if isinstance(blob, str):\n+        return blob\n+    if isinstance(blob, dict):\n+        if isinstance(blob.get(\"text\"), str):\n+            return blob[\"text\"]\n+        try:\n+            return _decode_blob(blob).decode(\"utf-8\", \"replace\")\n+        except Exception:\n+            return \"\"\n+    return str(blob)\n+\n+\n+def _discovery_for_epoch(epoch: int) -> GitDiscovery | None:\n+    return next(\n+        (\n+            e for e in store.read()\n+            if isinstance(e, GitDiscovery) and e.epoch == epoch\n+        ),\n+        None,\n+    )\n+\n+\n+def _emission_for_epoch(epoch: int) -> Emission | None:\n+    return next(\n+        (\n+            e for e in store.read()\n+            if isinstance(e, Emission) and e.epoch == epoch\n+        ),\n+        None,\n+    )\n+\n+\n+def _epochs_in_ledger() -> list[int]:\n+    epochs: set[int] = set()\n+    for e in store.read():\n+        if isinstance(e, (GitDiscovery, Emission, Evidence)):\n+            epochs.add(e.epoch)\n+    return sorted(epochs)\n+\n+\n+def _legacy_commit_row(commit_id: str) -> tuple[GitDiscovery | None, dict | None]:\n+    for discovery in store.read():\n+        if not isinstance(discovery, GitDiscovery):\n+            continue\n+        for commit in discovery.commits:\n+            if commit_id_for_oid(commit[\"oid\"]) == commit_id:\n+                return discovery, commit\n+    return None, None\n+\n+\n+def _legacy_observation(commit_id: str) -> tuple[GitDiscovery | None, dict | None]:\n+    for discovery in store.read():\n+        if not isinstance(discovery, GitDiscovery):\n+            continue\n+        for obs in discovery.observations:\n+            if commit_id_for_oid(obs[\"oid\"]) == commit_id:\n+                return discovery, obs\n+    return None, None\n+\n+\n+def build_pairwise_prompt(side_a: dict, side_b: dict) -> str:\n+    return f\"\"\"You are ranking contributions to an open source project.\n+Compare these two sides (each may be one or more commits). Decide which side contributed more.\n+Return ONLY a JSON object: {{\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}}\n+\n+Side A — commit messages:\n+{side_a['message']}\n+\n+Side A — unified diffs (full patches):\n+{side_a['diff']}\n+\n+Side B — commit messages:\n+{side_b['message']}\n+\n+Side B — unified diffs (full patches):\n+{side_b['diff']}\"\"\"\n \n \n # ===========================================================================\n@@ -565,45 +862,126 @@ async def fetch_top_models(n=3):\n \n \n def _retry_llm_pairwise(exc: BaseException) -> bool:\n-    if isinstance(exc, (json.JSONDecodeError, KeyError, IndexError, TypeError)):\n+    if isinstance(exc, (json.JSONDecodeError, KeyError, IndexError, TypeError, ValueError)):\n         return True\n     if isinstance(exc, httpx.HTTPStatusError):\n         return exc.response.status_code in (408, 425, 429, 500, 502, 503, 504)\n     return isinstance(exc, httpx.RequestError)\n \n \n-@retry(\n-    retry=retry_if_exception(_retry_llm_pairwise),\n-    stop=stop_after_attempt(6),\n-    wait=wait_exponential(multiplier=1, min=1, max=120),\n-    reraise=True,\n-)\n-async def llm_pairwise_compare(model_id, side_a, side_b):\n-    prompt = f\"\"\"You are ranking contributions to an open source project.\n-Compare these two sides (each may be one or more commits). Decide which side contributed more.\n-Return ONLY a JSON object: {{\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}}\n+def _retry_wait_seconds(attempt_number: int) -> float:\n+    return min(120.0, float(2 ** (attempt_number - 1)))\n \n-Side A — commit messages:\n-{side_a['message']}\n \n-Side A — unified diffs (full patches):\n-{side_a['diff']}\n-\n-Side B — commit messages:\n-{side_b['message']}\n-\n-Side B — unified diffs (full patches):\n-{side_b['diff']}\"\"\"\n-\n-    async with httpx.AsyncClient(timeout=httpx.Timeout(120.0, connect=30.0)) as client:\n-        resp = await client.post(\n-            f\"{OPENROUTER_BASE_URL}/api/v1/chat/completions\",\n-            headers={\"Authorization\": f\"Bearer {OPENROUTER_API_KEY}\"},\n-            json={\"model\": model_id, \"messages\": [{\"role\": \"user\", \"content\": prompt}]},\n+async def llm_pairwise_compare(\n+    model_id,\n+    side_a,\n+    side_b,\n+    *,\n+    epoch: int | None = None,\n+    comparison_id: str | None = None,\n+    persist: bool = False,\n+):\n+    \"\"\"Pairwise LLM compare. When persist=True, every attempt is ledger evidence.\"\"\"\n+    prompt = build_pairwise_prompt(side_a, side_b)\n+    request_obj = {\n+        \"model\": model_id,\n+        \"messages\": [{\"role\": \"user\", \"content\": prompt}],\n+    }\n+    request_bytes = _canonical_json(request_obj)\n+    max_attempts = 6\n+    last_error = None\n+    for attempt_number in range(1, max_attempts + 1):\n+        attempt_id = attempt_id_for(\n+            comparison_id or \"ad-hoc\", model_id, attempt_number\n         )\n-        resp.raise_for_status()\n-        content = resp.json()[\"choices\"][0][\"message\"][\"content\"]\n-        return json.loads(content)\n+        if persist and epoch is not None and comparison_id is not None:\n+            await append_evidence(epoch, \"llm.attempt_started\", {\n+                \"attempt_id\": attempt_id,\n+                \"comparison_id\": comparison_id,\n+                \"model_id\": model_id,\n+                \"attempt_number\": attempt_number,\n+                \"summary\": f\"{model_id} attempt {attempt_number}\",\n+                \"request\": _bytes_blob(request_bytes),\n+            })\n+        started = time.monotonic()\n+        raw_response = b\"\"\n+        http_status = None\n+        try:\n+            async with httpx.AsyncClient(timeout=httpx.Timeout(120.0, connect=30.0)) as client:\n+                resp = await client.post(\n+                    f\"{OPENROUTER_BASE_URL}/api/v1/chat/completions\",\n+                    headers={\n+                        \"Authorization\": f\"Bearer {OPENROUTER_API_KEY}\",\n+                        \"Content-Type\": \"application/json\",\n+                    },\n+                    content=request_bytes,\n+                )\n+            http_status = resp.status_code\n+            raw_response = resp.content\n+            resp.raise_for_status()\n+            content = resp.json()[\"choices\"][0][\"message\"][\"content\"]\n+            result = json.loads(content)\n+            if result.get(\"winner\") not in {\"A\", \"B\"}:\n+                raise ValueError(\"winner must be A or B\")\n+            ratio_parts = str(result[\"ratio\"]).split(\":\")\n+            if len(ratio_parts) != 2:\n+                raise ValueError(\"ratio must be N:M\")\n+            winner_weight, loser_weight = float(ratio_parts[0]), float(ratio_parts[1])\n+            if winner_weight <= 0 or loser_weight <= 0:\n+                raise ValueError(\"ratio weights must be positive\")\n+            if persist and epoch is not None and comparison_id is not None:\n+                await append_evidence(epoch, \"llm.attempt_finished\", {\n+                    \"attempt_id\": attempt_id,\n+                    \"comparison_id\": comparison_id,\n+                    \"model_id\": model_id,\n+                    \"attempt_number\": attempt_number,\n+                    \"ok\": True,\n+                    \"http_status\": http_status,\n+                    \"response\": _bytes_blob(raw_response),\n+                    \"duration_ms\": int((time.monotonic() - started) * 1000),\n+                    \"summary\": f\"{model_id} attempt {attempt_number} ok\",\n+                })\n+                await append_evidence(epoch, \"llm.judgment\", {\n+                    \"judgment_id\": judgment_id_for({\n+                        \"attempt_id\": attempt_id,\n+                        \"comparison_id\": comparison_id,\n+                        \"model_id\": model_id,\n+                        \"winner\": result[\"winner\"],\n+                        \"ratio\": result[\"ratio\"],\n+                        \"explanation\": result.get(\"explanation\", \"\"),\n+                    }),\n+                    \"attempt_id\": attempt_id,\n+                    \"comparison_id\": comparison_id,\n+                    \"model_id\": model_id,\n+                    \"winner\": result[\"winner\"],\n+                    \"ratio\": result[\"ratio\"],\n+                    \"explanation\": result.get(\"explanation\", \"\"),\n+                    \"summary\": f\"{model_id}: {result['winner']} ({result['ratio']})\",\n+                })\n+            return result\n+        except Exception as exc:\n+            last_error = exc\n+            retryable = _retry_llm_pairwise(exc)\n+            if persist and epoch is not None and comparison_id is not None:\n+                await append_evidence(epoch, \"llm.attempt_finished\", {\n+                    \"attempt_id\": attempt_id,\n+                    \"comparison_id\": comparison_id,\n+                    \"model_id\": model_id,\n+                    \"attempt_number\": attempt_number,\n+                    \"ok\": False,\n+                    \"retryable\": retryable,\n+                    \"http_status\": http_status,\n+                    \"response\": _bytes_blob(raw_response) if raw_response else None,\n+                    \"error\": {\"type\": type(exc).__name__, \"message\": str(exc)},\n+                    \"duration_ms\": int((time.monotonic() - started) * 1000),\n+                    \"summary\": f\"{model_id} attempt {attempt_number} failed\",\n+                })\n+            if retryable and attempt_number < max_attempts:\n+                await asyncio.sleep(_retry_wait_seconds(attempt_number))\n+                continue\n+            raise\n+    raise RuntimeError(f\"council model failed: {model_id}\") from last_error\n \n \n # ===========================================================================\n@@ -1007,6 +1385,56 @@ def _release_discovery_file_lock(lock_file) -> None:\n     lock_file.close()\n \n \n+async def _persist_discovery_evidence(discovery: GitDiscovery) -> None:\n+    \"\"\"Record commit + discovery-completed evidence for a snapshot (idempotent).\"\"\"\n+    public_config = {\n+        \"repositories\": [\n+            _public_repo_row(r) for r in discovery.configuration[\"repositories\"]\n+        ],\n+        \"contributors\": discovery.configuration[\"contributors\"],\n+    }\n+    for commit in discovery.commits:\n+        commit_id = commit_id_for_oid(commit[\"oid\"])\n+        await append_evidence(discovery.epoch, \"git.commit\", {\n+            \"commit_id\": commit_id,\n+            \"oid\": commit[\"oid\"],\n+            \"contributor\": commit[\"contributor\"],\n+            \"message\": _bytes_blob(commit[\"message\"]),\n+            \"patch\": _bytes_blob(commit[\"patch\"] or \"\"),\n+            \"patch_sha256\": commit.get(\"patch_sha256\"),\n+            \"patch_identity\": commit.get(\"patch_identity\"),\n+            \"first_sources\": commit.get(\"first_sources\", []),\n+            \"committer_timestamp_ms\": commit.get(\"committer_timestamp_ms\"),\n+            \"summary\": f\"{commit['oid'][:20]} {commit['contributor']}\",\n+            \"urls\": {\n+                \"commit\": _evidence_url(\"commit\", commit_id),\n+                \"epoch\": _evidence_url(\"epoch\", str(discovery.epoch)),\n+            },\n+        })\n+    await append_evidence(discovery.epoch, \"git.discovery_completed\", {\n+        \"snapshot_id\": discovery.snapshot_id,\n+        \"config_digest\": discovery.config_digest,\n+        \"configuration\": public_config,\n+        \"observation_count\": len(discovery.observations),\n+        \"eligible_count\": len(discovery.commits),\n+        \"commit_ids\": [commit_id_for_oid(c[\"oid\"]) for c in discovery.commits],\n+        \"observations\": [\n+            {\n+                \"oid\": o[\"oid\"],\n+                \"eligible\": o[\"eligible\"],\n+                \"exclusion_reason\": o.get(\"exclusion_reason\"),\n+                \"commit_id\": commit_id_for_oid(o[\"oid\"]),\n+            }\n+            for o in discovery.observations\n+        ],\n+        \"summary\": (\n+            f\"Discovered {len(discovery.observations)} commits; \"\n+            f\"{len(discovery.commits)} eligible\"\n+        ),\n+        \"urls\": {\"epoch\": _evidence_url(\"epoch\", str(discovery.epoch))},\n+    })\n+\n+\n async def discover_repositories(epoch_n: int, boundary_ms: int) -> GitDiscovery:\n     async with _DISCOVERY_LOCK:\n         lock_file = await asyncio.to_thread(_acquire_discovery_file_lock)\n@@ -1020,6 +1448,7 @@ async def discover_repositories(epoch_n: int, boundary_ms: int) -> GitDiscovery:\n                 None,\n             )\n             if existing:\n+                await _persist_discovery_evidence(existing)\n                 return existing\n             candidate = await asyncio.to_thread(\n                 _build_discovery, epoch_n, boundary_ms, events\n@@ -1034,12 +1463,12 @@ async def discover_repositories(epoch_n: int, boundary_ms: int) -> GitDiscovery:\n                 return candidate\n \n             appended = await store.atomic(append_if_new)\n-            if appended:\n-                return appended\n-            return next(\n+            discovery = appended or next(\n                 e for e in store.read()\n                 if isinstance(e, GitDiscovery) and e.epoch == epoch_n\n             )\n+            await _persist_discovery_evidence(discovery)\n+            return discovery\n         finally:\n             await asyncio.to_thread(_release_discovery_file_lock, lock_file)\n \n@@ -1068,6 +1497,9 @@ async def broadcast_audit(\n     *,\n     progress: int | None = None,\n     phase: str | None = None,\n+    evidence_event_id: str | None = None,\n+    evidence_url: str | None = None,\n+    links: dict | None = None,\n ) -> dict:\n     global AUDIT_SEQUENCE\n     AUDIT_SEQUENCE += 1\n@@ -1083,6 +1515,12 @@ async def broadcast_audit(\n         \"message\": message,\n         **PROCESS_STATE,\n     }\n+    if evidence_event_id:\n+        payload[\"evidence_event_id\"] = evidence_event_id\n+    if evidence_url:\n+        payload[\"evidence_url\"] = evidence_url\n+    if links:\n+        payload[\"links\"] = links\n     AUDIT_HISTORY.append(payload)\n     del AUDIT_HISTORY[:-200]\n     wire = _sse_event(\"audit\", payload)\n@@ -1097,27 +1535,91 @@ async def broadcast_js(js: str):\n         await queue.put(js)\n \n \n-async def rank_commits(commits: list[dict]):\n+def _author_side_for_llm(author: str, author_commits: dict) -> dict:\n+    cs = author_commits[author]\n+    return {\n+        \"message\": \"\\n\".join(f\"[{c['sha']}] {c['message']}\" for c in cs),\n+        \"diff\": \"\\n\\n\".join(f\"=== {c['sha']} ===\\n{c['diff']}\" for c in cs),\n+        \"commit_ids\": [c[\"commit_id\"] for c in cs],\n+        \"contributor\": author,\n+    }\n+\n+\n+def _find_judgment(comparison_id: str, model_id: str) -> dict | None:\n+    for e in evidence_by_kind(\"llm.judgment\"):\n+        p = e.payload\n+        if p.get(\"comparison_id\") == comparison_id and p.get(\"model_id\") == model_id:\n+            return p\n+    return None\n+\n+\n+def _find_ranking_models(ranking_run_id: str) -> list[str] | None:\n+    for e in evidence_by_kind(\"ranking.started\"):\n+        if e.payload.get(\"ranking_run_id\") == ranking_run_id:\n+            models = e.payload.get(\"models\")\n+            if isinstance(models, list) and models:\n+                return [str(m) for m in models]\n+    return None\n+\n+\n+async def rank_commits(commits: list[dict], *, epoch: int = -1):\n     if not commits:\n-        return {}, []\n+        return {}, [], {\"ranking_run_id\": \"\", \"ranking_event_id\": \"\"}\n \n+    commit_ids = sorted(commit_id_for_oid(row[\"oid\"]) for row in commits)\n+    ranking_run_id = _content_id(\"rank\", {\n+        \"epoch\": epoch,\n+        \"commit_ids\": commit_ids,\n+    })\n     contributors = sorted(set(c[\"contributor\"] for c in commits))\n+\n     if len(contributors) == 1:\n+        await append_evidence(epoch, \"ranking.started\", {\n+            \"ranking_run_id\": ranking_run_id,\n+            \"commit_ids\": commit_ids,\n+            \"contributors\": contributors,\n+            \"models\": [],\n+            \"summary\": f\"ranking epoch {epoch}: single contributor\",\n+        })\n+        ranking = {contributors[0]: Decimal(\"1\")}\n+        completed = await append_evidence(epoch, \"ranking.completed\", {\n+            \"ranking_run_id\": ranking_run_id,\n+            \"models\": [],\n+            \"ranking\": {contributors[0]: \"1\"},\n+            \"judgment_ids\": [],\n+            \"summary\": f\"Only {contributors[0]} is eligible; rank is 1.0\",\n+        })\n         await broadcast_audit(\n             \"ranking\",\n             f\"Only {contributors[0]} is eligible; rank is 1.0\",\n             progress=90,\n             phase=\"finalizing\",\n+            evidence_event_id=completed.event_id,\n+            evidence_url=_evidence_url(\"event\", completed.event_id),\n+            links={\"epoch\": _evidence_url(\"epoch\", str(epoch))},\n         )\n-        return {contributors[0]: Decimal(\"1\")}, []\n+        return ranking, [], {\n+            \"ranking_run_id\": ranking_run_id,\n+            \"ranking_event_id\": completed.event_id,\n+        }\n+\n     if not (OPENROUTER_API_KEY or \"\").strip():\n         raise RuntimeError(\n             \"OPENROUTER_API_KEY is required when multiple contributors need ranking\"\n         )\n \n-    models = await fetch_top_models(n=3)\n+    models = _find_ranking_models(ranking_run_id)\n+    if models is None:\n+        models = await fetch_top_models(n=3)\n     if not models:\n         raise RuntimeError(\"no council models available for contributor ranking\")\n+    await append_evidence(epoch, \"ranking.started\", {\n+        \"ranking_run_id\": ranking_run_id,\n+        \"commit_ids\": commit_ids,\n+        \"contributors\": contributors,\n+        \"models\": models,\n+        \"summary\": f\"Council selected: {', '.join(models)}\",\n+    })\n     await broadcast_audit(\n         \"council\",\n         f\"Council selected: {', '.join(models)}\",\n@@ -1129,30 +1631,55 @@ async def rank_commits(commits: list[dict]):\n     ]))\n \n     authors = contributors\n-    author_idx = {a: i for i, a in enumerate(authors)}\n-\n     author_commits = {a: [] for a in authors}\n-    for c in sorted(commits, key=lambda row: row[\"oid\"]):\n-        author_commits[c[\"contributor\"]].append({\n-            \"message\": c[\"message\"],\n-            \"sha\": c[\"oid\"].split(\":\", 1)[1][:8],\n-            \"diff\": c[\"patch\"],\n+    for row in sorted(commits, key=lambda r: r[\"oid\"]):\n+        author_commits[row[\"contributor\"]].append({\n+            \"message\": row[\"message\"],\n+            \"sha\": row[\"oid\"].split(\":\", 1)[1][:8],\n+            \"diff\": row[\"patch\"],\n+            \"commit_id\": commit_id_for_oid(row[\"oid\"]),\n         })\n \n-    # TODO do we want ot coagulate the commits into a single block? or rank the many commits\n-    def author_side_for_llm(author):\n-        cs = author_commits[author]\n-        return {\n-            \"message\": \"\\n\".join(f\"[{c['sha']}] {c['message']}\" for c in cs),\n-            \"diff\": \"\\n\\n\".join(f\"=== {c['sha']} ===\\n{c['diff']}\" for c in cs),\n-        }\n+    judgment_ids: list[str] = []\n \n     async def compare_fn(i, j):\n         a1, a2 = authors[i], authors[j]\n+        side_a = _author_side_for_llm(a1, author_commits)\n+        side_b = _author_side_for_llm(a2, author_commits)\n+        prompt = build_pairwise_prompt(side_a, side_b)\n+        comparison_material = {\n+            \"ranking_run_id\": ranking_run_id,\n+            \"side_a\": {\n+                \"contributor\": a1,\n+                \"commit_ids\": side_a[\"commit_ids\"],\n+                \"message\": _bytes_blob(side_a[\"message\"]),\n+                \"diff\": _bytes_blob(side_a[\"diff\"]),\n+            },\n+            \"side_b\": {\n+                \"contributor\": a2,\n+                \"commit_ids\": side_b[\"commit_ids\"],\n+                \"message\": _bytes_blob(side_b[\"message\"]),\n+                \"diff\": _bytes_blob(side_b[\"diff\"]),\n+            },\n+            \"prompt\": _bytes_blob(prompt),\n+        }\n+        comparison_id = comparison_id_for(comparison_material)\n+        comparison_material = {\n+            **comparison_material,\n+            \"comparison_id\": comparison_id,\n+            \"summary\": f\"Comparing {a1} with {a2}\",\n+        }\n+        cmp_ev = await append_evidence(epoch, \"comparison.input\", comparison_material)\n         await broadcast_audit(\n             \"comparison\",\n             f\"Comparing {a1} with {a2}\",\n             phase=\"ranking\",\n+            evidence_event_id=cmp_ev.event_id,\n+            evidence_url=_evidence_url(\"comparison\", comparison_id),\n+            links={\n+                \"comparison\": _evidence_url(\"comparison\", comparison_id),\n+                \"epoch\": _evidence_url(\"epoch\", str(epoch)),\n+            },\n         )\n         await broadcast_js(exec_event(Three[Selector(\"#emission-status\")][MORPH][\n             [\"div#emission-status\", f\"Comparing {a1} vs {a2}…\"]\n@@ -1160,19 +1687,46 @@ async def rank_commits(commits: list[dict]):\n         results = []\n         for model in models:\n             try:\n-                result = await llm_pairwise_compare(model, author_side_for_llm(a1), author_side_for_llm(a2))\n-                if result[\"winner\"] not in {\"A\", \"B\"}:\n-                    raise ValueError(\"winner must be A or B\")\n+                existing = _find_judgment(comparison_id, model)\n+                if existing:\n+                    result = {\n+                        \"winner\": existing[\"winner\"],\n+                        \"ratio\": existing[\"ratio\"],\n+                        \"explanation\": existing.get(\"explanation\", \"\"),\n+                    }\n+                    judgment_ids.append(existing[\"judgment_id\"])\n+                else:\n+                    result = await llm_pairwise_compare(\n+                        model,\n+                        side_a,\n+                        side_b,\n+                        epoch=epoch,\n+                        comparison_id=comparison_id,\n+                        persist=True,\n+                    )\n+                    judgment = _find_judgment(comparison_id, model)\n+                    if judgment:\n+                        judgment_ids.append(judgment[\"judgment_id\"])\n                 w, l = (i, j) if result[\"winner\"] == \"A\" else (j, i)\n                 ratio = result[\"ratio\"].split(\":\")\n                 winner_weight, loser_weight = float(ratio[0]), float(ratio[1])\n-                if winner_weight <= 0 or loser_weight <= 0:\n-                    raise ValueError(\"ratio weights must be positive\")\n                 results.append((w, l, winner_weight, loser_weight))\n+                jud_id = (existing or _find_judgment(comparison_id, model) or {}).get(\n+                    \"judgment_id\"\n+                )\n                 await broadcast_audit(\n                     \"vote\",\n                     f\"{model}: {authors[w]} over {authors[l]} ({result['ratio']})\",\n                     phase=\"ranking\",\n+                    evidence_url=(\n+                        _evidence_url(\"judgment\", jud_id) if jud_id else None\n+                    ),\n+                    links={\n+                        \"judgment\": (\n+                            _evidence_url(\"judgment\", jud_id) if jud_id else None\n+                        ),\n+                        \"comparison\": _evidence_url(\"comparison\", comparison_id),\n+                    },\n                 )\n                 await broadcast_js(exec_event(Three[Selector(\"#emission-log\")][PREPEND][\n                     [\"div.log-vote\",\n@@ -1212,16 +1766,25 @@ async def rank_commits(commits: list[dict]):\n \n     if not pairs:\n         ranking = {authors[0]: Decimal(\"1\")} if authors else {}\n-        return ranking, models\n-\n-    scores = rank_centrality(pairs)\n-    ranking = {authors[i]: Decimal(str(scores[i])) for i in range(len(authors))}\n+    else:\n+        scores = rank_centrality(pairs)\n+        ranking = {authors[i]: Decimal(str(scores[i])) for i in range(len(authors))}\n     ranking_rows = sorted(ranking.items(), key=lambda x: x[1], reverse=True)\n+    completed = await append_evidence(epoch, \"ranking.completed\", {\n+        \"ranking_run_id\": ranking_run_id,\n+        \"models\": models,\n+        \"ranking\": {a: str(s) for a, s in ranking_rows},\n+        \"judgment_ids\": judgment_ids,\n+        \"summary\": \"Ranking: \" + \", \".join(f\"{a} {s:.4f}\" for a, s in ranking_rows),\n+    })\n     await broadcast_audit(\n         \"ranking\",\n         \"Ranking: \" + \", \".join(f\"{a} {s:.4f}\" for a, s in ranking_rows),\n         progress=90,\n         phase=\"finalizing\",\n+        evidence_event_id=completed.event_id,\n+        evidence_url=_evidence_url(\"event\", completed.event_id),\n+        links={\"epoch\": _evidence_url(\"epoch\", str(epoch))},\n     )\n     await broadcast_js(exec_event(Three[Selector(\"#emission-log\")][PREPEND][\n         [\"div.log-ranking\",\n@@ -1229,7 +1792,10 @@ async def rank_commits(commits: list[dict]):\n             *[[\"span.rank-entry\", f\"{a} {float(s):.3f}  \"] for a, s in ranking_rows],\n         ]\n     ]))\n-    return ranking, models\n+    return ranking, models, {\n+        \"ranking_run_id\": ranking_run_id,\n+        \"ranking_event_id\": completed.event_id,\n+    }\n \n \n # ===========================================================================\n@@ -1245,11 +1811,19 @@ def pool_remaining(events: list) -> Decimal:\n \n async def run_emission(epoch_n, boundary_ms):\n     PROCESS_STATE[\"running\"] = True\n+    started = await append_evidence(epoch_n, \"epoch.started\", {\n+        \"boundary_ms\": boundary_ms,\n+        \"summary\": f\"Epoch {epoch_n} emission started\",\n+        \"urls\": {\"epoch\": _evidence_url(\"epoch\", str(epoch_n))},\n+    })\n     await broadcast_audit(\n         \"start\",\n         f\"Epoch {epoch_n} emission started\",\n         progress=2,\n         phase=\"starting\",\n+        evidence_event_id=started.event_id,\n+        evidence_url=_evidence_url(\"epoch\", str(epoch_n)),\n+        links={\"epoch\": _evidence_url(\"epoch\", str(epoch_n))},\n     )\n     await broadcast_js(exec_event(Three[Selector(\"#emission-log\")][PREPEND][\n         [\"div.log-start\", f\"⚡ Epoch {epoch_n} emission started\"]\n@@ -1270,8 +1844,21 @@ async def run_emission(epoch_n, boundary_ms):\n         ),\n         progress=30,\n         phase=\"discovery\",\n+        links={\n+            \"epoch\": _evidence_url(\"epoch\", str(epoch_n)),\n+            **{\n+                f\"commit_{i}\": _evidence_url(\"commit\", commit_id_for_oid(c[\"oid\"]))\n+                for i, c in enumerate(discovery.commits[:12])\n+                if isinstance(c, dict) and c.get(\"oid\")\n+            },\n+        },\n     )\n-    ranking, models = await rank_commits(discovery.commits)\n+    ranked = await rank_commits(discovery.commits, epoch=epoch_n)\n+    if len(ranked) == 2:\n+        ranking, models = ranked\n+        ranking_info = {}\n+    else:\n+        ranking, models, ranking_info = ranked\n \n     def make_emission(events):\n         if epoch_n in {e.epoch for e in events if isinstance(e, Emission)}:\n@@ -1304,6 +1891,9 @@ async def run_emission(epoch_n, boundary_ms):\n             distributions={a: str(amount) for a, amount in distributions.items()},\n             ranking={a: str(s) for a, s in normalized_ranking.items()},\n             models_used=models,\n+            evidence_schema_version=EVIDENCE_SCHEMA_VERSION,\n+            ranking_run_id=ranking_info.get(\"ranking_run_id\", \"\"),\n+            ranking_event_id=ranking_info.get(\"ranking_event_id\", \"\"),\n         )\n \n     entry = await store.atomic(make_emission)\n@@ -1392,9 +1982,71 @@ async def epoch_loop():\n # §8. API — 2-line read forwards + computed endpoints\n # ===========================================================================\n \n+def _evidence_summary(event_: Evidence) -> dict:\n+    payload = event_.payload\n+    summary = {\n+        \"type\": \"evidence\",\n+        \"schema_version\": event_.schema_version,\n+        \"event_id\": event_.event_id,\n+        \"epoch\": event_.epoch,\n+        \"kind\": event_.kind,\n+        \"recorded_at_ms\": event_.recorded_at_ms,\n+        \"previous_event_sha256\": event_.previous_event_sha256,\n+        \"summary\": payload.get(\"summary\"),\n+        \"urls\": {\"event\": _evidence_url(\"event\", event_.event_id)},\n+    }\n+    for key in (\n+        \"commit_id\", \"comparison_id\", \"attempt_id\", \"judgment_id\",\n+        \"ranking_run_id\", \"snapshot_id\", \"oid\", \"model_id\",\n+    ):\n+        if key in payload:\n+            summary[key] = payload[key]\n+    return summary\n+\n+\n+def _strip_heavy_fields(obj: dict) -> dict:\n+    \"\"\"Bounded listing: drop multi-megabyte blobs unless full=1.\"\"\"\n+    out = {}\n+    for key, value in obj.items():\n+        if key in {\"patch\", \"message\", \"prompt\", \"request\", \"response\", \"diff\"}:\n+            if isinstance(value, dict) and \"sha256\" in value:\n+                out[key] = {\n+                    \"sha256\": value[\"sha256\"],\n+                    \"byte_length\": value.get(\"byte_length\"),\n+                    \"encoding\": value.get(\"encoding\"),\n+                }\n+            elif isinstance(value, str) and len(value) > 256:\n+                out[key] = value[:256] + \"…\"\n+            else:\n+                out[key] = value\n+        elif key == \"commits\" and isinstance(value, list):\n+            out[key] = [\n+                {\n+                    k: v for k, v in row.items()\n+                    if k != \"patch\"\n+                } | (\n+                    {\"patch_sha256\": row.get(\"patch_sha256\")}\n+                    if isinstance(row, dict) else {}\n+                )\n+                for row in value\n+            ]\n+        else:\n+            out[key] = value\n+    return out\n+\n+\n @app.get(\"/api/ledger\")\n-async def get_ledger(offset: int = 0, limit: int = 100):\n-    return [to_dict(e) for e in store.read()[offset:offset + limit]]\n+async def get_ledger(offset: int = 0, limit: int = 100, full: int = 0):\n+    \"\"\"List of ledger dicts (backward-compatible). Heavy blobs stripped unless full=1.\"\"\"\n+    limit = max(1, min(limit, 500))\n+    rows = []\n+    for e in store.read()[offset:offset + limit]:\n+        if isinstance(e, Evidence) and not full:\n+            rows.append(_evidence_summary(e))\n+        else:\n+            d = to_dict(e)\n+            rows.append(d if full else _strip_heavy_fields(d))\n+    return rows\n \n \n @app.get(\"/api/epoch\")\n@@ -1555,6 +2207,582 @@ async def sse_stream(request: Request):\n     )\n \n \n+# ===========================================================================\n+# §9b. EVIDENCE HTML — pure indexes/details (no JSON evidence APIs)\n+# ===========================================================================\n+\n+def _a(href: str, label: str) -> list:\n+    return [\"a\", {\"href\": href}, label]\n+\n+\n+def _pre_blob(text: str) -> list:\n+    return [\"pre.blob\", text if text else \"(empty)\"]\n+\n+\n+def _evidence_page(title: str, body: list) -> HTMLResponse:\n+    return HTMLResponse(render([\"html\",\n+        [\"head\",\n+            [\"meta\", {\"charset\": \"utf-8\"}],\n+            [\"meta\", {\"name\": \"viewport\", \"content\": \"width=device-width, initial-scale=1\"}],\n+            [\"title\", title],\n+            [\"style\", RawContent(_WATCH_CSS)],\n+        ],\n+        [\"body.evidence-doc\",\n+            [\"main\", body],\n+            [\"script\", RawContent(_FORM_INTERCEPT_JS)],\n+        ],\n+    ]))\n+\n+\n+def _evidence_nav(*extra: list) -> list:\n+    crumbs = [\n+        _a(\"/\", \"constitution\"), \" · \",\n+        _a(\"/epochs\", \"epochs\"), \" · \",\n+        _a(\"/watch\", \"watch\"),\n+    ]\n+    for item in extra:\n+        crumbs.extend([\" · \", item])\n+    return [\"p.note\", *crumbs]\n+\n+\n+def _dl_rows(rows: list[tuple[str, object]]) -> list:\n+    items = []\n+    for key, value in rows:\n+        if value is None or value == \"\":\n+            continue\n+        items.append([\"div.kv\",\n+            [\"span.k\", key],\n+            [\"span.v\", value if isinstance(value, list) else str(value)],\n+        ])\n+    return [\"div.kv-list\", *items] if items else [\"p.note\", \"(none)\"]\n+\n+\n+def _link_list(pairs: list[tuple[str, str]]) -> list:\n+    if not pairs:\n+        return [\"p.note\", \"(none)\"]\n+    out: list = [\"ul\"]\n+    for label, href in pairs:\n+        out.append([\"li\", _a(href, label)])\n+    return out\n+\n+\n+@app.get(\"/epochs\")\n+async def epochs_index():\n+    epochs = _epochs_in_ledger()\n+    rows = []\n+    for epoch in epochs:\n+        discovery = _discovery_for_epoch(epoch)\n+        emission = _emission_for_epoch(epoch)\n+        evidence_n = sum(\n+            1 for e in evidence_by_kind() if e.epoch == epoch\n+        )\n+        detail = []\n+        if discovery:\n+            detail.append(\n+                f\"{len(discovery.commits)} eligible / \"\n+                f\"{len(discovery.observations)} observed\"\n+            )\n+        if emission:\n+            detail.append(f\"emitted {emission.total_emitted}\")\n+        if evidence_n:\n+            detail.append(f\"{evidence_n} evidence events\")\n+        elif discovery or emission:\n+            detail.append(\"legacy (no Evidence envelopes)\")\n+        rows.append([\"li\",\n+            _a(_evidence_path(\"epoch\", str(epoch)), f\"epoch {epoch}\"),\n+            \" — \",\n+            \", \".join(detail) if detail else \"recorded\",\n+        ])\n+    return _evidence_page(\"epochs\", [\n+        _evidence_nav(),\n+        [\"div.eyebrow\", \"transparent constitutional evidence\"],\n+        [\"h1\", \"epochs\"],\n+        [\"p\", \"Each epoch indexes discovery, commits, comparisons, judgments, ranking, and emission.\"],\n+        [\"ul\", *rows] if rows else [\"p.note\", \"No epochs in the ledger yet.\"],\n+    ])\n+\n+\n+@app.get(\"/epochs/{epoch}\")\n+async def epoch_detail(epoch: int):\n+    discovery = _discovery_for_epoch(epoch)\n+    emission = _emission_for_epoch(epoch)\n+    evidence_rows = [e for e in evidence_by_kind() if e.epoch == epoch]\n+    commit_evs = [e for e in evidence_rows if e.kind == \"git.commit\"]\n+    comparison_evs = [e for e in evidence_rows if e.kind == \"comparison.input\"]\n+    judgment_evs = [e for e in evidence_rows if e.kind == \"llm.judgment\"]\n+    ranking_started = next(\n+        (e for e in evidence_rows if e.kind == \"ranking.started\"), None\n+    )\n+    ranking_completed = next(\n+        (e for e in evidence_rows if e.kind == \"ranking.completed\"), None\n+    )\n+    legacy = not evidence_rows and (discovery is not None or emission is not None)\n+\n+    commit_links: list[tuple[str, str]] = []\n+    if commit_evs:\n+        for e in commit_evs:\n+            cid = e.payload.get(\"commit_id\") or \"\"\n+            label = (\n+                f\"{e.payload.get('oid', cid)[:24]} \"\n+                f\"({e.payload.get('contributor', '?')})\"\n+            )\n+            commit_links.append((label, _evidence_path(\"commit\", cid)))\n+    elif discovery:\n+        for c in discovery.commits:\n+            cid = commit_id_for_oid(c[\"oid\"])\n+            commit_links.append((\n+                f\"{c['oid'][:24]} ({c.get('contributor', '?')})\",\n+                _evidence_path(\"commit\", cid),\n+            ))\n+\n+    comparison_links = [\n+        (\n+            e.payload.get(\"summary\") or e.payload.get(\"comparison_id\", e.event_id),\n+            _evidence_path(\"comparison\", e.payload[\"comparison_id\"]),\n+        )\n+        for e in comparison_evs\n+        if e.payload.get(\"comparison_id\")\n+    ]\n+    judgment_links = [\n+        (\n+            e.payload.get(\"summary\") or e.payload.get(\"judgment_id\", e.event_id),\n+            _evidence_path(\"judgment\", e.payload[\"judgment_id\"]),\n+        )\n+        for e in judgment_evs\n+        if e.payload.get(\"judgment_id\")\n+    ]\n+    event_links = [\n+        (f\"{e.kind} · {e.event_id[:28]}\", _evidence_path(\"event\", e.event_id))\n+        for e in evidence_rows\n+    ]\n+\n+    excluded = []\n+    if discovery:\n+        for obs in discovery.observations:\n+            if obs.get(\"eligible\"):\n+                continue\n+            oid = obs.get(\"oid\", \"?\")\n+            reason = obs.get(\"exclusion_reason\") or \"excluded\"\n+            excluded.append([\"li\",\n+                f\"{oid[:28]} — {reason} — \",\n+                [\"span.note\", \"legacy evidence unavailable\"],\n+            ])\n+\n+    ranking_nodes: list = []\n+    if ranking_completed:\n+        ranking_nodes = [\n+            [\"p\", ranking_completed.payload.get(\"summary\") or \"ranking completed\"],\n+            _dl_rows([\n+                (\"ranking_run_id\", ranking_completed.payload.get(\"ranking_run_id\")),\n+                (\"models\", \", \".join(ranking_completed.payload.get(\"models\") or [])),\n+                (\"event\", _a(\n+                    _evidence_path(\"event\", ranking_completed.event_id),\n+                    ranking_completed.event_id,\n+                )),\n+            ]),\n+            [\"pre.blob\", json.dumps(\n+                ranking_completed.payload.get(\"ranking\") or {},\n+                indent=2, sort_keys=True,\n+            )],\n+        ]\n+    elif emission:\n+        if legacy and len(emission.ranking or {}) <= 1:\n+            ranking_nodes.append([\"p.note\",\n+                \"Single-contributor epoch — no LLM judgments.\"\n+            ])\n+        ranking_nodes.extend([\n+            [\"p\", \"Projected from Emission (no ranking Evidence event).\"],\n+            [\"pre.blob\", json.dumps(emission.ranking, indent=2, sort_keys=True)],\n+        ])\n+    else:\n+        ranking_nodes = [[\"p.note\", \"No ranking recorded.\"]]\n+    if ranking_started and not ranking_completed:\n+        ranking_nodes.insert(0, [\"p.note\",\n+            f\"Ranking started: {ranking_started.event_id}\"\n+        ])\n+\n+    if emission:\n+        emission_node = _dl_rows([\n+            (\"total_emitted\", emission.total_emitted),\n+            (\"pool_before\", emission.pool_before),\n+            (\"pool_after\", emission.pool_after),\n+            (\"discovery_snapshot_id\", emission.discovery_snapshot_id),\n+            (\"ranking_run_id\", emission.ranking_run_id or None),\n+            (\"models_used\", \", \".join(emission.models_used or [])),\n+            (\"distributions\", json.dumps(emission.distributions, sort_keys=True)),\n+        ])\n+    else:\n+        emission_node = [\"p.note\", \"No emission for this epoch.\"]\n+\n+    single_contributor = False\n+    if discovery:\n+        single_contributor = len({c.get(\"contributor\") for c in discovery.commits}) <= 1\n+    elif emission:\n+        single_contributor = len(emission.ranking or {}) <= 1\n+\n+    body = [\n+        _evidence_nav(),\n+        [\"div.eyebrow\", f\"epoch {epoch}\"],\n+        [\"h1\", f\"epoch {epoch}\"],\n+    ]\n+    if legacy:\n+        body.append([\"p.note\",\n+            \"Legacy epoch: projected from GitDiscovery/Emission without Evidence \"\n+            \"envelopes. Eligible commits use discovery patches; discarded observation \"\n+            \"metadata is marked legacy evidence unavailable. Single-contributor \"\n+            \"epochs have no LLM judgments.\"\n+        ])\n+    if discovery:\n+        body.extend([\n+            [\"h2\", \"discovery\"],\n+            _dl_rows([\n+                (\"snapshot_id\", discovery.snapshot_id),\n+                (\"config_digest\", discovery.config_digest),\n+                (\"initial_snapshot\", discovery.initial_snapshot),\n+                (\"observations\", len(discovery.observations)),\n+                (\"eligible\", len(discovery.commits)),\n+            ]),\n+        ])\n+    no_comparisons_note = \"No comparisons.\"\n+    if single_contributor:\n+        no_comparisons_note += \" Single-contributor — no LLM judgments.\"\n+    body.extend([\n+        [\"h2\", \"commits\"],\n+        _link_list(commit_links),\n+        [\"h2\", \"excluded observations\"],\n+        [\"ul\", *excluded] if excluded else [\"p.note\", \"(none)\"],\n+        [\"h2\", \"comparisons\"],\n+        _link_list(comparison_links) if comparison_links else [\"p.note\", no_comparisons_note],\n+        [\"h2\", \"judgments\"],\n+        _link_list(judgment_links) if judgment_links else [\"p.note\", \"No judgments recorded.\"],\n+        [\"h2\", \"ranking\"],\n+        *ranking_nodes,\n+        [\"h2\", \"emission\"],\n+        emission_node,\n+        [\"h2\", \"evidence events\"],\n+        _link_list(event_links) if event_links else [\"p.note\", \"(none)\"],\n+    ])\n+    return _evidence_page(f\"epoch {epoch}\", body)\n+\n+\n+@app.get(\"/commits/{commit_id}\")\n+async def commit_detail(commit_id: str):\n+    ev = find_evidence_payload(\"git.commit\", \"commit_id\", commit_id)\n+    discovery, legacy_row = (None, None)\n+    if not ev:\n+        discovery, legacy_row = _legacy_commit_row(commit_id)\n+    if not ev and not legacy_row:\n+        discovery, obs = _legacy_observation(commit_id)\n+        if obs is not None:\n+            epoch = discovery.epoch if discovery else \"?\"\n+            return _evidence_page(f\"commit {commit_id[:24]}\", [\n+                _evidence_nav(\n+                    _a(_evidence_path(\"epoch\", str(epoch)), f\"epoch {epoch}\")\n+                ),\n+                [\"div.eyebrow\", \"commit\"],\n+                [\"h1\", commit_id],\n+                [\"p.note\", \"legacy evidence unavailable\"],\n+                _dl_rows([\n+                    (\"oid\", obs.get(\"oid\")),\n+                    (\"eligible\", obs.get(\"eligible\")),\n+                    (\"exclusion_reason\", obs.get(\"exclusion_reason\")),\n+                    (\"epoch\", str(epoch)),\n+                ]),\n+            ])\n+        return _evidence_page(\"commit not found\", [\n+            _evidence_nav(),\n+            [\"h1\", \"commit not found\"],\n+            [\"p\", commit_id],\n+        ])\n+    if ev:\n+        p = ev.payload\n+        epoch = ev.epoch\n+        oid = p.get(\"oid\", \"\")\n+        contributor = p.get(\"contributor\", \"\")\n+        message = _blob_text(p.get(\"message\"))\n+        patch = _blob_text(p.get(\"patch\"))\n+        meta = _dl_rows([\n+            (\"commit_id\", commit_id),\n+            (\"oid\", oid),\n+            (\"contributor\", contributor),\n+            (\"patch_sha256\", p.get(\"patch_sha256\")),\n+            (\"patch_identity\", p.get(\"patch_identity\")),\n+            (\"committer_timestamp_ms\", p.get(\"committer_timestamp_ms\")),\n+            (\"evidence_event\", _a(_evidence_path(\"event\", ev.event_id), ev.event_id)),\n+            (\"epoch\", _a(_evidence_path(\"epoch\", str(epoch)), str(epoch))),\n+        ])\n+        legacy_note = None\n+    else:\n+        assert legacy_row is not None and discovery is not None\n+        epoch = discovery.epoch\n+        oid = legacy_row.get(\"oid\", \"\")\n+        contributor = legacy_row.get(\"contributor\", \"\")\n+        message = legacy_row.get(\"message\") or \"\"\n+        patch = legacy_row.get(\"patch\") or \"\"\n+        meta = _dl_rows([\n+            (\"commit_id\", commit_id),\n+            (\"oid\", oid),\n+            (\"contributor\", contributor),\n+            (\"patch_sha256\", legacy_row.get(\"patch_sha256\")),\n+            (\"patch_identity\", legacy_row.get(\"patch_identity\")),\n+            (\"committer_timestamp_ms\", legacy_row.get(\"committer_timestamp_ms\")),\n+            (\"epoch\", _a(_evidence_path(\"epoch\", str(epoch)), str(epoch))),\n+            (\"source\", \"legacy GitDiscovery projection\"),\n+        ])\n+        legacy_note = [\"p.note\", \"Projected from GitDiscovery — Evidence envelope absent.\"]\n+    return _evidence_page(f\"commit {commit_id[:24]}\", [\n+        _evidence_nav(_a(_evidence_path(\"epoch\", str(epoch)), f\"epoch {epoch}\")),\n+        [\"div.eyebrow\", \"commit\"],\n+        [\"h1\", commit_id],\n+        *([legacy_note] if legacy_note else []),\n+        meta,\n+        [\"p\", _a(f\"/commits/{commit_id}/patch\", \"download patch\")],\n+        [\"h2\", \"message\"],\n+        _pre_blob(message),\n+        [\"h2\", \"patch\"],\n+        _pre_blob(patch),\n+    ])\n+\n+\n+@app.get(\"/commits/{commit_id}/patch\")\n+async def commit_patch_download(commit_id: str):\n+    ev = find_evidence_payload(\"git.commit\", \"commit_id\", commit_id)\n+    if ev:\n+        raw = _decode_blob(ev.payload.get(\"patch\")) or _blob_text(ev.payload.get(\"patch\")).encode()\n+    else:\n+        _, row = _legacy_commit_row(commit_id)\n+        if not row:\n+            return PlainTextResponse(\"not found\", status_code=404)\n+        raw = (row.get(\"patch\") or \"\").encode(\"utf-8\")\n+    return Response(\n+        content=raw,\n+        media_type=\"text/plain; charset=utf-8\",\n+        headers={\n+            \"Content-Disposition\": f'attachment; filename=\"{commit_id}.patch\"'\n+        },\n+    )\n+\n+\n+@app.get(\"/comparisons/{comparison_id}\")\n+async def comparison_detail(comparison_id: str):\n+    ev = find_evidence_payload(\"comparison.input\", \"comparison_id\", comparison_id)\n+    if not ev:\n+        return _evidence_page(\"comparison not found\", [\n+            _evidence_nav(),\n+            [\"h1\", \"comparison not found\"],\n+            [\"p\", comparison_id],\n+        ])\n+    p = ev.payload\n+    side_a = p.get(\"side_a\") or {}\n+    side_b = p.get(\"side_b\") or {}\n+    attempt_links = []\n+    for a in evidence_by_kind(\"llm.attempt_started\"):\n+        if a.payload.get(\"comparison_id\") == comparison_id:\n+            aid = a.payload.get(\"attempt_id\")\n+            if aid:\n+                attempt_links.append((\n+                    f\"{a.payload.get('model_id')} #{a.payload.get('attempt_number')}\",\n+                    _evidence_path(\"attempt\", aid),\n+                ))\n+    judgment_links = []\n+    for j in evidence_by_kind(\"llm.judgment\"):\n+        if j.payload.get(\"comparison_id\") == comparison_id:\n+            jid = j.payload.get(\"judgment_id\")\n+            if jid:\n+                judgment_links.append((\n+                    j.payload.get(\"summary\") or jid,\n+                    _evidence_path(\"judgment\", jid),\n+                ))\n+    commit_links = []\n+    for cid in (side_a.get(\"commit_ids\") or []) + (side_b.get(\"commit_ids\") or []):\n+        commit_links.append((cid, _evidence_path(\"commit\", cid)))\n+    return _evidence_page(f\"comparison {comparison_id[:24]}\", [\n+        _evidence_nav(_a(_evidence_path(\"epoch\", str(ev.epoch)), f\"epoch {ev.epoch}\")),\n+        [\"div.eyebrow\", \"comparison\"],\n+        [\"h1\", comparison_id],\n+        _dl_rows([\n+            (\"summary\", p.get(\"summary\")),\n+            (\"ranking_run_id\", p.get(\"ranking_run_id\")),\n+            (\"evidence_event\", _a(_evidence_path(\"event\", ev.event_id), ev.event_id)),\n+            (\"side_a\", side_a.get(\"contributor\")),\n+            (\"side_b\", side_b.get(\"contributor\")),\n+        ]),\n+        [\"p\", _a(f\"/comparisons/{comparison_id}/prompt\", \"download prompt\")],\n+        [\"h2\", \"commits\"],\n+        _link_list(commit_links),\n+        [\"h2\", \"attempts\"],\n+        _link_list(attempt_links),\n+        [\"h2\", \"judgments\"],\n+        _link_list(judgment_links),\n+        [\"h2\", \"prompt\"],\n+        _pre_blob(_blob_text(p.get(\"prompt\"))),\n+        [\"h2\", f\"side A — {side_a.get('contributor', '?')}\"],\n+        [\"h3\", \"message\"],\n+        _pre_blob(_blob_text(side_a.get(\"message\"))),\n+        [\"h3\", \"diff\"],\n+        _pre_blob(_blob_text(side_a.get(\"diff\"))),\n+        [\"h2\", f\"side B — {side_b.get('contributor', '?')}\"],\n+        [\"h3\", \"message\"],\n+        _pre_blob(_blob_text(side_b.get(\"message\"))),\n+        [\"h3\", \"diff\"],\n+        _pre_blob(_blob_text(side_b.get(\"diff\"))),\n+    ])\n+\n+\n+@app.get(\"/comparisons/{comparison_id}/prompt\")\n+async def comparison_prompt_download(comparison_id: str):\n+    ev = find_evidence_payload(\"comparison.input\", \"comparison_id\", comparison_id)\n+    if not ev:\n+        return PlainTextResponse(\"not found\", status_code=404)\n+    raw = _decode_blob(ev.payload.get(\"prompt\")) or _blob_text(ev.payload.get(\"prompt\")).encode()\n+    return Response(\n+        content=raw,\n+        media_type=\"text/plain; charset=utf-8\",\n+        headers={\n+            \"Content-Disposition\": f'attachment; filename=\"{comparison_id}.prompt.txt\"'\n+        },\n+    )\n+\n+\n+@app.get(\"/attempts/{attempt_id}\")\n+async def attempt_detail(attempt_id: str):\n+    started = find_evidence_payload(\"llm.attempt_started\", \"attempt_id\", attempt_id)\n+    finished = find_evidence_payload(\"llm.attempt_finished\", \"attempt_id\", attempt_id)\n+    if not started and not finished:\n+        return _evidence_page(\"attempt not found\", [\n+            _evidence_nav(),\n+            [\"h1\", \"attempt not found\"],\n+            [\"p\", attempt_id],\n+        ])\n+    base = started or finished\n+    assert base is not None\n+    p = {**(started.payload if started else {}), **(finished.payload if finished else {})}\n+    judgment = None\n+    for j in evidence_by_kind(\"llm.judgment\"):\n+        if j.payload.get(\"attempt_id\") == attempt_id:\n+            judgment = j\n+            break\n+    comparison_id = p.get(\"comparison_id\")\n+    return _evidence_page(f\"attempt {attempt_id[:24]}\", [\n+        _evidence_nav(\n+            _a(_evidence_path(\"epoch\", str(base.epoch)), f\"epoch {base.epoch}\"),\n+            *(\n+                [_a(_evidence_path(\"comparison\", comparison_id), \"comparison\")]\n+                if comparison_id else []\n+            ),\n+        ),\n+        [\"div.eyebrow\", \"llm attempt\"],\n+        [\"h1\", attempt_id],\n+        _dl_rows([\n+            (\"model_id\", p.get(\"model_id\")),\n+            (\"attempt_number\", p.get(\"attempt_number\")),\n+            (\"ok\", p.get(\"ok\")),\n+            (\"http_status\", p.get(\"http_status\")),\n+            (\"duration_ms\", p.get(\"duration_ms\")),\n+            (\"error\", json.dumps(p[\"error\"]) if p.get(\"error\") else None),\n+            (\"started_event\",\n+             _a(_evidence_path(\"event\", started.event_id), started.event_id)\n+             if started else None),\n+            (\"finished_event\",\n+             _a(_evidence_path(\"event\", finished.event_id), finished.event_id)\n+             if finished else None),\n+            (\"judgment\",\n+             _a(\n+                 _evidence_path(\"judgment\", judgment.payload[\"judgment_id\"]),\n+                 judgment.payload[\"judgment_id\"],\n+             ) if judgment and judgment.payload.get(\"judgment_id\") else None),\n+        ]),\n+        [\"h2\", \"request\"],\n+        _pre_blob(_blob_text(p.get(\"request\"))),\n+        [\"h2\", \"response\"],\n+        _pre_blob(_blob_text(p.get(\"response\"))),\n+    ])\n+\n+\n+@app.get(\"/judgments/{judgment_id}\")\n+async def judgment_detail(judgment_id: str):\n+    ev = find_evidence_payload(\"llm.judgment\", \"judgment_id\", judgment_id)\n+    if not ev:\n+        return _evidence_page(\"judgment not found\", [\n+            _evidence_nav(),\n+            [\"h1\", \"judgment not found\"],\n+            [\"p\", judgment_id],\n+        ])\n+    p = ev.payload\n+    return _evidence_page(f\"judgment {judgment_id[:24]}\", [\n+        _evidence_nav(\n+            _a(_evidence_path(\"epoch\", str(ev.epoch)), f\"epoch {ev.epoch}\"),\n+            *(\n+                [_a(_evidence_path(\"comparison\", p[\"comparison_id\"]), \"comparison\")]\n+                if p.get(\"comparison_id\") else []\n+            ),\n+            *(\n+                [_a(_evidence_path(\"attempt\", p[\"attempt_id\"]), \"attempt\")]\n+                if p.get(\"attempt_id\") else []\n+            ),\n+        ),\n+        [\"div.eyebrow\", \"judgment\"],\n+        [\"h1\", judgment_id],\n+        _dl_rows([\n+            (\"model_id\", p.get(\"model_id\")),\n+            (\"winner\", p.get(\"winner\")),\n+            (\"ratio\", p.get(\"ratio\")),\n+            (\"evidence_event\", _a(_evidence_path(\"event\", ev.event_id), ev.event_id)),\n+        ]),\n+        [\"h2\", \"explanation\"],\n+        _pre_blob(p.get(\"explanation\") or \"\"),\n+    ])\n+\n+\n+@app.get(\"/events/{event_id}\")\n+async def event_detail(event_id: str):\n+    ev = find_evidence(event_id)\n+    if not ev:\n+        return _evidence_page(\"event not found\", [\n+            _evidence_nav(),\n+            [\"h1\", \"event not found\"],\n+            [\"p\", event_id],\n+        ])\n+    p = ev.payload\n+    related = []\n+    for key, kind in (\n+        (\"commit_id\", \"commit\"),\n+        (\"comparison_id\", \"comparison\"),\n+        (\"attempt_id\", \"attempt\"),\n+        (\"judgment_id\", \"judgment\"),\n+    ):\n+        if p.get(key):\n+            related.append((f\"{key}: {p[key]}\", _evidence_path(kind, p[key])))\n+    related.append((f\"epoch {ev.epoch}\", _evidence_path(\"epoch\", str(ev.epoch))))\n+    display_payload = {}\n+    for key, value in p.items():\n+        if isinstance(value, dict) and value.get(\"encoding\") == \"base64\":\n+            display_payload[key] = {\n+                \"sha256\": value.get(\"sha256\"),\n+                \"byte_length\": value.get(\"byte_length\"),\n+                \"text_preview\": (_blob_text(value)[:2000]\n+                                 + (\"…\" if value.get(\"byte_length\", 0) > 2000 else \"\")),\n+            }\n+        else:\n+            display_payload[key] = value\n+    return _evidence_page(f\"event {event_id[:24]}\", [\n+        _evidence_nav(_a(_evidence_path(\"epoch\", str(ev.epoch)), f\"epoch {ev.epoch}\")),\n+        [\"div.eyebrow\", ev.kind],\n+        [\"h1\", event_id],\n+        _dl_rows([\n+            (\"kind\", ev.kind),\n+            (\"epoch\", ev.epoch),\n+            (\"recorded_at_ms\", ev.recorded_at_ms),\n+            (\"previous_event_sha256\", ev.previous_event_sha256),\n+            (\"schema_version\", ev.schema_version),\n+        ]),\n+        [\"h2\", \"links\"],\n+        _link_list(related),\n+        [\"h2\", \"payload\"],\n+        _pre_blob(json.dumps(display_payload, indent=2, sort_keys=True, default=str)),\n+    ])\n+\n+\n # ===========================================================================\n # §10. UI — hiccup pages + signed snippet POST handler\n # ===========================================================================\n@@ -1765,6 +2993,12 @@ button:disabled { cursor: default; opacity: .4; }\n .event time, .event-kind { color: var(--meta); font-family: var(--font-code); font-size: 10px; }\n .event-kind { text-transform: uppercase; }\n .event-message { color: var(--prose); font-family: var(--font-prose); }\n+.event-links {\n+  font-family: var(--font-code);\n+  font-size: 10px;\n+  grid-column: 1 / -1;\n+}\n+.event-links a { margin-right: 10px; }\n \n code {\n   background: var(--g1);\n@@ -1776,9 +3010,33 @@ code {\n   padding: 1px 4px;\n }\n \n+body.evidence-doc { max-width: 840px; }\n+.kv-list { display: flex; flex-direction: column; gap: 4px; margin: 8px 0; }\n+.kv { display: grid; gap: 8px; grid-template-columns: 140px 1fr; }\n+.kv .k { color: var(--meta); font-family: var(--font-code); font-size: 11px; }\n+.kv .v { color: var(--prose); word-break: break-word; }\n+pre.blob {\n+  background: var(--g1);\n+  border: var(--bv) solid;\n+  border-color: var(--lo) var(--hi) var(--hi) var(--lo);\n+  color: var(--code-fg);\n+  font-family: var(--font-code);\n+  font-size: 11px;\n+  line-height: 1.45;\n+  margin: 8px 0 16px;\n+  max-height: 70vh;\n+  overflow: auto;\n+  padding: 10px;\n+  white-space: pre-wrap;\n+  word-break: break-word;\n+}\n+ul { padding-left: 1.2em; }\n+li { margin: 4px 0; }\n+\n @media (max-width: 520px) {\n   .event { grid-template-columns: 72px 1fr; }\n   .event-message { grid-column: 1 / -1; }\n+  .kv { grid-template-columns: 1fr; }\n }\n \"\"\"\n \n@@ -1796,6 +3054,8 @@ def _watch_initial_state() -> dict:\n                     f\"Epoch {event_.epoch}: observed {len(event_.observations)} commits; \"\n                     f\"{len(event_.commits)} eligible\"\n                 ),\n+                \"evidence_url\": _evidence_path(\"epoch\", str(event_.epoch)),\n+                \"links\": {\"epoch\": _evidence_path(\"epoch\", str(event_.epoch))},\n             })\n         elif isinstance(event_, Emission):\n             feed.append({\n@@ -1806,6 +3066,17 @@ def _watch_initial_state() -> dict:\n                     f\"Epoch {event_.epoch}: emitted {event_.total_emitted} SLG; \"\n                     f\"ranking {event_.ranking}\"\n                 ),\n+                \"evidence_url\": _evidence_path(\"epoch\", str(event_.epoch)),\n+                \"links\": {\"epoch\": _evidence_path(\"epoch\", str(event_.epoch))},\n+            })\n+        elif isinstance(event_, Evidence):\n+            feed.append({\n+                \"id\": event_.event_id,\n+                \"timestamp_ms\": event_.recorded_at_ms,\n+                \"kind\": event_.kind,\n+                \"message\": event_.payload.get(\"summary\") or event_.kind,\n+                \"evidence_url\": _evidence_path(\"event\", event_.event_id),\n+                \"links\": {\"epoch\": _evidence_path(\"epoch\", str(event_.epoch))},\n             })\n     feed.extend(AUDIT_HISTORY)\n     return {\n@@ -1852,6 +3123,25 @@ function addEvent(event) {\n   message.className = 'event-message';\n   message.textContent = event.message;\n   row.append(when, kind, message);\n+  const linkPairs = [];\n+  if (event.evidence_url) linkPairs.push(['evidence', event.evidence_url]);\n+  if (event.links && typeof event.links === 'object') {\n+    for (const [label, href] of Object.entries(event.links)) {\n+      if (href) linkPairs.push([label, href]);\n+    }\n+  }\n+  if (linkPairs.length) {\n+    const links = document.createElement('span');\n+    links.className = 'event-links';\n+    for (const [label, href] of linkPairs) {\n+      const a = document.createElement('a');\n+      a.href = href;\n+      a.textContent = label;\n+      links.appendChild(a);\n+      links.appendChild(document.createTextNode(' '));\n+    }\n+    row.appendChild(links);\n+  }\n   feed.prepend(row);\n   while (feed.children.length > 200) feed.lastElementChild.remove();\n }\n@@ -1957,6 +3247,7 @@ async def watch():\n                 [\"div#audit-feed\"],\n             ],\n             [\"p\", [\"a\", {\"href\": \"/\"}, \"← constitution\"], \" · \",\n+                  [\"a\", {\"href\": \"/epochs\"}, \"epochs\"], \" · \",\n                   [\"a\", {\"href\": \"/api/status\"}, \"status JSON\"], \" · \",\n                   [\"a\", {\"href\": \"/api/ledger\"}, \"ledger\"]],\n         ]],\n@@ -1984,6 +3275,7 @@ async def index(request: Request):\n             [\"p\", [\"a\", {\"href\": \"/login\"}, \"Login with GitHub to check your emissions\"]],\n             [\"p\",\n                 [\"a\", {\"href\": \"/watch\"}, \"Watch emission process live\"], \" | \",\n+                [\"a\", {\"href\": \"/epochs\"}, \"Epoch evidence\"], \" | \",\n                 [\"a\", {\"href\": \"/api/epoch\"}, \"Current epoch\"], \" | \",\n                 [\"a\", {\"href\": \"/api/ledger\"}, \"Full ledger\"], \" | \",\n                 [\"a\", {\"href\": \"/api/halvening\"}, \"Jubilee countdown\"],\n@@ -2010,6 +3302,7 @@ async def index(request: Request):\n         redeem_form,\n         [\"p\",\n             [\"a\", {\"href\": \"/api/epoch\"}, \"Current epoch\"], \" | \",\n+            [\"a\", {\"href\": \"/epochs\"}, \"Epoch evidence\"], \" | \",\n             [\"a\", {\"href\": \"/api/ledger\"}, \"Full ledger\"], \" | \",\n             [\"a\", {\"href\": \"/watch\"}, \"Watch emission live\"],\n         ],\ndiff --git a/tests/integration.clj b/tests/integration.clj\nindex 06b9715e63966d14311b159cbc7058952bff2fbc..204b0fedfbad57846205cb140c4ed9406b5f8e0e 100644\n--- a/tests/integration.clj\n+++ b/tests/integration.clj\n@@ -404,6 +404,7 @@\n        \"ALLOW_TEST_TRIGGERS\"  \"1\"\n        \"OPENROUTER_BASE_URL\"  (str \"http://127.0.0.1:\" or-port)\n        \"SLUG_MODEL_RANK_PARENT\" \"\"\n+       \"PUBLIC_BASE_URL\"      (str \"http://127.0.0.1:\" server-port)\n        \"PATH\"                 (get (into {} (System/getenv)) \"PATH\" \"\")})\n \n     (bind !server  (atom nil))\n@@ -506,19 +507,55 @@\n         (assert! (>= (:compare-requests or-state) 3) \"at least 3 pairwise LLM calls (2 authors × 3 models)\")\n \n         (bind ledger2 (get-json base-url \"/api/ledger\"))\n-        (assert! (= 3 (count ledger2))\n-                 \"ledger has seed, discovery, and emission entries\")\n-        (bind discovery-entry (second ledger2))\n-        (assert! (= \"gitdiscovery\" (:type discovery-entry))\n+        (assert! (>= (count ledger2) 3)\n+                 \"ledger has seed + discovery + emission (+ evidence)\")\n+        (bind discovery-entry\n+          (first (filter #(= \"gitdiscovery\" (:type %)) ledger2)))\n+        (assert! (some? discovery-entry)\n                  \"discovery is persisted before emission\")\n         (assert! (= 2 (count (:repositories discovery-entry)))\n                  \"discovery records both repositories\")\n         (assert! (= 2 (count (:commits discovery-entry)))\n                  \"discovery admits one contribution from each repository\")\n+        (bind evidence-kinds\n+          (set (keep :kind (filter #(= \"evidence\" (:type %)) ledger2))))\n+        (assert! (contains? evidence-kinds \"git.commit\")\n+                 \"evidence includes git.commit\")\n+        (assert! (contains? evidence-kinds \"comparison.input\")\n+                 \"evidence includes comparison.input\")\n+        (assert! (contains? evidence-kinds \"llm.judgment\")\n+                 \"evidence includes llm.judgment\")\n         (bind rank-after (get-json base-url \"/api/ranking\"))\n         (assert! (= 1 (:epoch rank-after))           \"latest ranking is epoch 1\")\n \n-        ;; 12. kill and restart — prove replay determinism\n+        ;; 11b. HTML evidence indexes are crawlable\n+        (println \"\\nchecking HTML evidence indexes…\")\n+        (bind epochs-html (slurp (str base-url \"/epochs\")))\n+        (assert! (str/includes? epochs-html \"/epochs/1\")\n+                 \"epochs index links epoch 1\")\n+        (bind epoch-html (slurp (str base-url \"/epochs/1\")))\n+        (assert! (str/includes? epoch-html \"/commits/\")\n+                 \"epoch page links commits\")\n+        (assert! (str/includes? epoch-html \"/comparisons/\")\n+                 \"epoch page links comparisons\")\n+        (assert! (str/includes? epoch-html \"/judgments/\")\n+                 \"epoch page links judgments\")\n+        (bind commit-href\n+          (second (re-find #\"/commits/(c_[a-f0-9]+)\" epoch-html)))\n+        (assert! (some? commit-href) \"found a commit id on epoch page\")\n+        (bind commit-html (slurp (str base-url \"/commits/\" commit-href)))\n+        (assert! (str/includes? commit-html \"download patch\")\n+                 \"commit page offers patch download\")\n+        (bind patch-bytes\n+          (let [tmp (doto (java.io.File/createTempFile \"patch\" \".bin\") .deleteOnExit)\n+                r   @(p/process [\"curl\" \"-sS\" \"-o\" (.getAbsolutePath tmp)\n+                                 (str base-url \"/commits/\" commit-href \"/patch\")]\n+                                {:out :string :err :string})]\n+            (assert! (zero? (:exit r)) \"patch download succeeds\")\n+            (slurp tmp)))\n+        (assert! (pos? (count patch-bytes)) \"patch download is non-empty\")\n+\n+        ;; 12. kill and restart — prove replay determinism + no duplicate LLM calls\n         (println \"\\nkilling server for replay test…\")\n         (.destroyForcibly (:proc server))\n         (deref server)\n@@ -533,12 +570,15 @@\n                  \"restarted server responds to /api/epoch\")\n \n         (bind replayed-ledger (get-json base-url \"/api/ledger\"))\n-        (assert! (= 3 (count replayed-ledger))\n-                 \"ledger still has 3 entries after replay\")\n+        (assert! (= (count ledger2) (count replayed-ledger))\n+                 \"ledger entry count unchanged after replay\")\n         (bind replayed-rank   (get-json base-url \"/api/ranking\"))\n         (assert! (= (get-in rank-after [:ranking :alice])\n                     (get-in replayed-rank [:ranking :alice]))\n-                 \"alice's rank score (epoch 1) identical after replay\"))\n+                 \"alice's rank score (epoch 1) identical after replay\")\n+        (bind epoch-html2 (slurp (str base-url \"/epochs/1\")))\n+        (assert! (str/includes? epoch-html2 \"/judgments/\")\n+                 \"epoch HTML evidence still linked after restart\"))\n \n       (finally\n         (when-some [s @!server]\ndiff --git a/tests/test_evidence.py b/tests/test_evidence.py\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..76adcd343eec3a65dec58fda93b068356fb1adcd\n--- /dev/null\n+++ b/tests/test_evidence.py\n@@ -0,0 +1,214 @@\n+\"\"\"HTML evidence graph: byte fidelity, resume, legacy projection, private ack.\"\"\"\n+\n+from __future__ import annotations\n+\n+import asyncio\n+import base64\n+import hashlib\n+import json\n+\n+import pytest\n+\n+import constitution as c\n+\n+\n+@pytest.fixture\n+def evidence_store(tmp_path, monkeypatch):\n+    monkeypatch.setattr(c, \"store\", c.JsonlStore(tmp_path / \"ledger.jsonl\"))\n+    monkeypatch.setattr(c, \"PUBLIC_BASE_URL\", \"http://test.local\")\n+    return tmp_path\n+\n+\n+def test_bytes_blob_roundtrip_crlf_nul_invalid_utf8():\n+    raw = b\"line\\r\\n\\x00<script>alert(1)</script>\\xff\"\n+    blob = c._bytes_blob(raw)\n+    assert blob[\"encoding\"] == \"base64\"\n+    assert blob[\"byte_length\"] == len(raw)\n+    assert blob[\"sha256\"] == hashlib.sha256(raw).hexdigest()\n+    assert c._decode_blob(blob) == raw\n+    assert \"<script>\" in blob[\"text\"]  # display text may replace invalid bytes\n+\n+\n+def test_append_evidence_is_idempotent_and_hash_chained(evidence_store):\n+    first = asyncio.run(c.append_evidence(1, \"epoch.started\", {\n+        \"summary\": \"start\", \"boundary_ms\": 1,\n+    }))\n+    again = asyncio.run(c.append_evidence(1, \"epoch.started\", {\n+        \"summary\": \"start\", \"boundary_ms\": 1,\n+    }))\n+    assert first.event_id == again.event_id\n+    second = asyncio.run(c.append_evidence(1, \"git.discovery_completed\", {\n+        \"summary\": \"done\", \"snapshot_id\": \"abc\",\n+    }))\n+    assert second.previous_event_sha256 == first.event_id.split(\"_\", 1)[-1]\n+    events = [e for e in c.store.read() if isinstance(e, c.Evidence)]\n+    assert len(events) == 2\n+\n+\n+def test_public_repo_row_strips_credentials():\n+    row = c._public_repo_row({\n+        \"id\": \"x\",\n+        \"url\": \"https://x-access-token:secret@github.com/org/repo.git\",\n+        \"refs\": [\"refs/heads/main\"],\n+    })\n+    assert \"secret\" not in row[\"url\"]\n+    assert \"github.com/org/repo.git\" in row[\"url\"]\n+\n+\n+def test_html_evidence_pages_escape_and_link(evidence_store):\n+    patch = b\"@@\\n+<script>evil()</script>\\n\"\n+    commit_id = c.commit_id_for_oid(\"sha1:\" + \"a\" * 40)\n+    asyncio.run(c.append_evidence(3, \"git.commit\", {\n+        \"commit_id\": commit_id,\n+        \"oid\": \"sha1:\" + \"a\" * 40,\n+        \"contributor\": \"alice\",\n+        \"message\": c._bytes_blob(\"msg <b>x</b>\"),\n+        \"patch\": c._bytes_blob(patch),\n+        \"summary\": \"commit\",\n+    }))\n+    cmp_id = c.comparison_id_for({\"x\": 1})\n+    asyncio.run(c.append_evidence(3, \"comparison.input\", {\n+        \"comparison_id\": cmp_id,\n+        \"summary\": \"cmp\",\n+        \"prompt\": c._bytes_blob(\"prompt <img>\"),\n+        \"side_a\": {\"contributor\": \"alice\", \"commit_ids\": [commit_id]},\n+        \"side_b\": {\"contributor\": \"bob\", \"commit_ids\": []},\n+    }))\n+    commit_html = asyncio.run(c.commit_detail(commit_id)).body.decode()\n+    assert \"<script>evil()\" not in commit_html\n+    assert \"&lt;script&gt;evil()\" in commit_html\n+    assert f\"/commits/{commit_id}/patch\" in commit_html\n+    epoch_html = asyncio.run(c.epoch_detail(3)).body.decode()\n+    assert f\"/commits/{commit_id}\" in epoch_html\n+    assert f\"/comparisons/{cmp_id}\" in epoch_html\n+    patch_resp = asyncio.run(c.commit_patch_download(commit_id))\n+    assert patch_resp.body == patch\n+    assert patch_resp.headers[\"content-disposition\"].startswith(\"attachment\")\n+\n+\n+def test_legacy_epoch_projects_from_gitdiscovery_without_evidence(evidence_store):\n+    oid = \"sha1:\" + \"b\" * 40\n+    discovery = c.GitDiscovery(\n+        schema_version=1,\n+        epoch=3,\n+        snapshot_id=\"legacy-snap\",\n+        timestamp_ms=1,\n+        config_digest=\"d\",\n+        initial_snapshot=True,\n+        configuration={\"repositories\": [], \"contributors\": {}},\n+        repositories=[],\n+        observations=[{\n+            \"oid\": oid,\n+            \"eligible\": False,\n+            \"exclusion_reason\": \"before_genesis\",\n+            \"first_sources\": [],\n+        }, {\n+            \"oid\": \"sha1:\" + \"c\" * 40,\n+            \"eligible\": True,\n+            \"exclusion_reason\": None,\n+            \"first_sources\": [],\n+        }],\n+        commits=[{\n+            \"oid\": \"sha1:\" + \"c\" * 40,\n+            \"contributor\": \"tommy-mor\",\n+            \"message\": \"eligible\",\n+            \"patch\": \"diff --git a/x b/x\\n\",\n+        }],\n+    )\n+    emission = c.Emission(\n+        epoch=3,\n+        timestamp_ms=2,\n+        pool_before=\"1\",\n+        total_emitted=\"0.1\",\n+        pool_after=\"0.9\",\n+        decay_rate=\"0.1\",\n+        distributions={\"tommy-mor\": \"0.1\"},\n+        ranking={\"tommy-mor\": \"1\"},\n+        models_used=[],\n+        discovery_snapshot_id=\"legacy-snap\",\n+    )\n+    asyncio.run(c.store.append(discovery))\n+    asyncio.run(c.store.append(emission))\n+    html = asyncio.run(c.epoch_detail(3)).body.decode()\n+    assert \"legacy\" in html.lower()\n+    assert \"Single-contributor\" in html or \"no LLM\" in html\n+    excluded_id = c.commit_id_for_oid(oid)\n+    excluded_html = asyncio.run(c.commit_detail(excluded_id)).body.decode()\n+    assert \"legacy evidence unavailable\" in excluded_html.lower()\n+\n+\n+def test_ranking_resume_skips_duplicate_provider_calls(evidence_store, monkeypatch):\n+    calls = {\"n\": 0}\n+\n+    async def models(n=3):\n+        return [\"mock/a\", \"mock/b\", \"mock/c\"]\n+\n+    async def compare(model_id, side_a, side_b, **kwargs):\n+        calls[\"n\"] += 1\n+        # Persist judgment the real path would write.\n+        if kwargs.get(\"persist\"):\n+            attempt_id = c.attempt_id_for(kwargs[\"comparison_id\"], model_id, 1)\n+            await c.append_evidence(kwargs[\"epoch\"], \"llm.judgment\", {\n+                \"judgment_id\": c.judgment_id_for({\n+                    \"attempt_id\": attempt_id,\n+                    \"comparison_id\": kwargs[\"comparison_id\"],\n+                    \"model_id\": model_id,\n+                    \"winner\": \"A\",\n+                    \"ratio\": \"2:1\",\n+                    \"explanation\": \"ok\",\n+                }),\n+                \"attempt_id\": attempt_id,\n+                \"comparison_id\": kwargs[\"comparison_id\"],\n+                \"model_id\": model_id,\n+                \"winner\": \"A\",\n+                \"ratio\": \"2:1\",\n+                \"explanation\": \"ok\",\n+                \"summary\": \"ok\",\n+            })\n+        return {\"winner\": \"A\", \"ratio\": \"2:1\", \"explanation\": \"ok\"}\n+\n+    monkeypatch.setattr(c, \"fetch_top_models\", models)\n+    monkeypatch.setattr(c, \"llm_pairwise_compare\", compare)\n+    monkeypatch.setattr(c, \"OPENROUTER_API_KEY\", \"k\")\n+    commits = [\n+        {\n+            \"contributor\": \"alice\",\n+            \"oid\": \"sha1:\" + \"a\" * 40,\n+            \"message\": \"a\",\n+            \"patch\": \"pa\",\n+        },\n+        {\n+            \"contributor\": \"bob\",\n+            \"oid\": \"sha1:\" + \"b\" * 40,\n+            \"message\": \"b\",\n+            \"patch\": \"pb\",\n+        },\n+    ]\n+    asyncio.run(c.rank_commits(commits, epoch=7))\n+    first_calls = calls[\"n\"]\n+    assert first_calls >= 3\n+    asyncio.run(c.rank_commits(commits, epoch=7))\n+    assert calls[\"n\"] == first_calls\n+\n+\n+def test_epochs_index_lists_epochs(evidence_store):\n+    asyncio.run(c.store.append(c.Emission(\n+        epoch=3,\n+        timestamp_ms=1,\n+        pool_before=\"1\",\n+        total_emitted=\"0\",\n+        pool_after=\"1\",\n+        decay_rate=\"0\",\n+        distributions={},\n+        ranking={},\n+        models_used=[],\n+    )))\n+    html = asyncio.run(c.epochs_index()).body.decode()\n+    assert \"/epochs/3\" in html\n+\n+\n+def test_api_ledger_remains_a_list(evidence_store):\n+    asyncio.run(c.append_evidence(1, \"epoch.started\", {\"summary\": \"x\", \"boundary_ms\": 1}))\n+    rows = asyncio.run(c.get_ledger())\n+    assert isinstance(rows, list)\n+    assert rows[0][\"type\"] == \"evidence\"\ndiff --git a/tests/test_git_discovery.py b/tests/test_git_discovery.py\nindex 5a9e167e16ad2ffb25988af85820f6f19e8910cd..00d26bfa85737b178c8822804e278211974e0efe 100644\n--- a/tests/test_git_discovery.py\n+++ b/tests/test_git_discovery.py\n@@ -397,8 +397,8 @@ def test_empty_epoch_records_zero_emission_without_burning_pool(\n             observations=[], commits=[], snapshot_id=\"empty-snapshot\"\n         )\n \n-    async def rank(_commits):\n-        return {}, []\n+    async def rank(_commits, *, epoch=-1):\n+        return {}, [], {\"ranking_run_id\": \"\", \"ranking_event_id\": \"\"}\n \n     monkeypatch.setattr(c, \"discover_repositories\", discover)\n     monkeypatch.setattr(c, \"rank_commits\", rank)\n@@ -420,11 +420,11 @@ def test_emission_distribution_sums_exactly_to_total(\n             snapshot_id=\"ranked-snapshot\",\n         )\n \n-    async def rank(_commits):\n+    async def rank(_commits, *, epoch=-1):\n         return {\n             \"alice\": c.Decimal(\"0.33333333333333333333333333333333333333333333333333\"),\n             \"bob\": c.Decimal(\"0.66666666666666666666666666666666666666666666666667\"),\n-        }, [\"model\"]\n+        }, [\"model\"], {\"ranking_run_id\": \"r\", \"ranking_event_id\": \"e\"}\n \n     monkeypatch.setattr(c, \"discover_repositories\", discover)\n     monkeypatch.setattr(c, \"rank_commits\", rank)\n@@ -435,27 +435,32 @@ def test_emission_distribution_sums_exactly_to_total(\n \n \n def test_single_contributor_ranking_is_total_and_uses_no_pairwise_votes(\n-    monkeypatch,\n+    discovery_config, monkeypatch,\n ):\n+    monkeypatch.setattr(c, \"store\", c.JsonlStore(discovery_config / \"ledger.jsonl\"))\n+\n     async def models(n=3):\n         return []\n \n     monkeypatch.setattr(c, \"fetch_top_models\", models)\n-    ranking, used = asyncio.run(c.rank_commits([{\n+    ranking, used, info = asyncio.run(c.rank_commits([{\n         \"contributor\": \"alice\",\n         \"oid\": \"sha1:\" + \"a\" * 40,\n         \"message\": \"one contribution\",\n         \"patch\": \"patch\",\n-    }]))\n+    }], epoch=0))\n     assert ranking == {\"alice\": c.Decimal(\"1\")}\n     assert used == []\n+    assert info[\"ranking_event_id\"]\n \n \n-def test_any_council_failure_aborts_ranking(monkeypatch):\n+def test_any_council_failure_aborts_ranking(discovery_config, monkeypatch):\n+    monkeypatch.setattr(c, \"store\", c.JsonlStore(discovery_config / \"ledger.jsonl\"))\n+\n     async def models(n=3):\n         return [\"broken\"]\n \n-    async def compare(*_args):\n+    async def compare(*_args, **_kwargs):\n         raise RuntimeError(\"model unavailable\")\n \n     monkeypatch.setattr(c, \"fetch_top_models\", models)\n@@ -471,7 +476,7 @@ def test_any_council_failure_aborts_ranking(monkeypatch):\n         for contributor, char in [(\"alice\", \"a\"), (\"bob\", \"b\")]\n     ]\n     with pytest.raises(RuntimeError, match=\"council model failed\"):\n-        asyncio.run(c.rank_commits(commits))\n+        asyncio.run(c.rank_commits(commits, epoch=0))\n \n \n def test_contested_ranking_requires_openrouter_key(monkeypatch):\n\n\nSide B — contributor: tommy-mor\nSide B — commit message:\n[d2c766e1] cleanup\n\nSide B — unified diff (full patch):\ndiff --git a/ideas/parser.tdsl b/ideas/parser.tdsl\ndeleted file mode 100644\nindex 03ba9563ea8c73b7411cd1aa42dda9c7c313cd39..0000000000000000000000000000000000000000\n--- a/ideas/parser.tdsl\n+++ /dev/null\n@@ -1,32 +0,0 @@\n-The parser is a series of edges/transitions, for example:\n-r -> reddit.com/ \n-where -> means that all of\n-  r->reddit.com/\n-  re->reddit.com/\n-  red->reddit.com/\n-  redd->reddit.com/\n-  reddi->reddit.com/\n-  reddit->reddit.com/\n-  reddit.->reddit.com/\n-  reddit.c->reddit.com/\n-  reddit.co->reddit.com/\n-  reddit.com->reddt.com/\n-  are defined as autocomplete suggestions\n-\n-re -> reddit.com/\n-reddit.com/ -> {show infographic explaining that u (sort user posts) and r (sort subreddit posts)} -> reddit.com/r/\n-reddit.com/r/ -> reddit.com/r/{randomly chose sub from list}\n-reddit.com/r/{sub} -> {show subrdedit view} -> reddit.com/r/{sub}/\n-reddit.com/r/{sub}/ -> {show infographic or something} -> reddit.com/r/{sub}/comments/{randomly chose comment from sql}\n-\n-\n-h->https:// (show supported domains)\n-\n-// the edges are composable such that this is possible, while reusing the above reddit code.\n-https://r->https://reddit.com/\n-https://w->https://www.\n-https://www.r->https://www.reddit.com/\n-\n-\n-// and i also want to have commands after you press space, like\n-reddit.com/r/programming !vote(reddit.comment{t3_123, t4_4444})%                                                                                                                                                \ndiff --git a/ideas/url.tdsl b/ideas/url.tdsl\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..d2397548d6ab2b8ca6af7a69782b809271536e9f\n--- /dev/null\n+++ b/ideas/url.tdsl\n@@ -0,0 +1,4 @@\n+ets zoom in on the data model. i want to import reddit data using the reddit api. i also want to import, eventually, every object on the internet.\n+i want to be able to paste in a reddit url like\n+https://old.reddit.com/r/AmItheAsshole/comments/1trnvdl/aita_for_cancelling_the_camping_trip_last_minute/\n+and see the breadcrumbs (every segment of the url seperated by /) and click on each segment. as i click down, i want the children of that url to be visible and sorted. like the comments view of that one thread is visible with the full url, then i navigate to just r/amitheasshole, and i see every child of that node, whcih is all posts from that sub. then i nav to /r/ and i see all subs, sorted against eachother. etc. and to have this apply to every url on the intrenet eventually, but first work really well for reddit, with official reddit api support for importing data cleanly.\n\\ No newline at end of file\ndiff --git a/legacy/bundle.js b/legacy/bundle.js\ndeleted file mode 100644\nindex 8d316f9a57cc7c379fe4bd8e42e092c7eac5d265..0000000000000000000000000000000000000000\n--- a/legacy/bundle.js\n+++ /dev/null\n@@ -1,52 +0,0 @@\n-/**\n- * Slug web UI: only plumbing — fetch/eval/SSE. No product UI logic here.\n- */\n-(function () {\n-  function evalJs(js) {\n-    if (js && String(js).trim()) {\n-      eval(js);\n-    }\n-  }\n-\n-  // Theme cookie sync (runs before paint; full reload if localStorage disagrees with cookie)\n-\n-  function initSlugUi() {\n-    // POST forms → eval response (except theme + full-navigation forms)\n-    document.addEventListener('submit', async function (e) {\n-      var f = e.target;\n-      if (!f || f.tagName !== 'FORM') return;\n-      if ((f.method || 'get').toLowerCase() !== 'post') return;\n-      if (f.id === 'slug-theme-form') return;\n-      if (f.getAttribute('data-navigate') === 'full') return;\n-      e.preventDefault();\n-      var resp = await fetch(f.action, {\n-        method: 'POST',\n-        body: new URLSearchParams(new FormData(f)),\n-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n-        credentials: 'same-origin',\n-      });\n-      evalJs(await resp.text());\n-    });\n-\n-    // SSE: server-pushed JS\n-    function connectSSE() {\n-      var ssePath = window.location.pathname + window.location.search;\n-      var es = new EventSource('/sse?path=' + encodeURIComponent(ssePath));\n-      es.onmessage = function (e) {\n-        evalJs(e.data);\n-      };\n-      es.onerror = function () {\n-        es.close();\n-        setTimeout(connectSSE, 3000);\n-      };\n-    }\n-    connectSSE();\n-  }\n-\n-  if (document.readyState === 'loading') {\n-    document.addEventListener('DOMContentLoaded', initSlugUi);\n-  } else {\n-    initSlugUi();\n-  }\n-})();\n-\ndiff --git a/legacy/clj-test.sh b/legacy/clj-test.sh\ndeleted file mode 100755\nindex b62a49b98ed60a65a46807b7ad80fa3142f14952..0000000000000000000000000000000000000000\n--- a/legacy/clj-test.sh\n+++ /dev/null\n@@ -1,5 +0,0 @@\n-#!/usr/bin/env bash\n-set -euo pipefail\n-cd \"$(dirname \"$0\")/..\"\n-mkdir -p target\n-exec clojure -M:kaocha\ndiff --git a/legacy/event_log.rs b/legacy/event_log.rs\ndeleted file mode 100644\nindex eaae0d495e43a45d6590603892265a62cc92906e..0000000000000000000000000000000000000000\n--- a/legacy/event_log.rs\n+++ /dev/null\n@@ -1,83 +0,0 @@\n-use std::path::{Path, PathBuf};\n-\n-use tokio::{\n-    fs::{self, OpenOptions},\n-    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},\n-};\n-\n-use crate::events::Event;\n-\n-#[derive(Debug, thiserror::Error)]\n-pub enum EventLogError {\n-    #[error(\"io error: {0}\")]\n-    Io(#[from] std::io::Error),\n-    #[error(\"json error: {0}\")]\n-    Json(#[from] serde_json::Error),\n-}\n-\n-#[derive(Debug, Clone)]\n-pub struct EventLog {\n-    path: PathBuf,\n-}\n-\n-impl EventLog {\n-    pub fn new(path: impl Into<PathBuf>) -> Self {\n-        Self { path: path.into() }\n-    }\n-\n-    pub fn path(&self) -> &Path {\n-        &self.path\n-    }\n-\n-    pub async fn ensure_parent_dir(&self) -> Result<(), EventLogError> {\n-        if let Some(parent) = self.path.parent() {\n-            fs::create_dir_all(parent).await?;\n-        }\n-        Ok(())\n-    }\n-\n-    pub async fn append(&self, event: &Event) -> Result<(), EventLogError> {\n-        self.ensure_parent_dir().await?;\n-        let mut f: tokio::fs::File = OpenOptions::new()\n-            .create(true)\n-            .append(true)\n-            .open(&self.path)\n-            .await?;\n-\n-        let mut line = serde_json::to_string(event)?;\n-        line.push('\\n');\n-        f.write_all(line.as_bytes()).await?;\n-        f.flush().await?;\n-        Ok(())\n-    }\n-\n-    /// Load events from JSONL. Corrupt lines are skipped and returned as `(line_no, line)`.\n-    pub async fn load_all(&self) -> Result<(Vec<Event>, Vec<(usize, String)>), EventLogError> {\n-        if !fs::try_exists(&self.path).await? {\n-            return Ok((vec![], vec![]));\n-        }\n-\n-        let f = fs::File::open(&self.path).await?;\n-        let mut reader = BufReader::new(f).lines();\n-\n-        let mut events = Vec::new();\n-        let mut bad_lines = Vec::new();\n-\n-        let mut line_no: usize = 0;\n-        while let Some(line) = reader.next_line().await? {\n-            line_no += 1;\n-            let trimmed = line.trim();\n-            if trimmed.is_empty() {\n-                continue;\n-            }\n-            match serde_json::from_str::<Event>(trimmed) {\n-                Ok(ev) => events.push(ev),\n-                Err(_) => bad_lines.push((line_no, line)),\n-            }\n-        }\n-\n-        Ok((events, bad_lines))\n-    }\n-}\n-\n-\ndiff --git a/legacy/forms.rs b/legacy/forms.rs\ndeleted file mode 100644\nindex d509fd889fde3fed2662ce0a39006b7a51ae762a..0000000000000000000000000000000000000000\n--- a/legacy/forms.rs\n+++ /dev/null\n@@ -1,145 +0,0 @@\n-tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒  cat server/src/form_template.rs\n-//! Plan2-style JSON templates with `{\"$form\": \"field_name\"}` holes, filled from\n-//! `application/x-www-form-urlencoded` (or any `String` → `String` map) **before**\n-//! deserializing into a typed struct.\n-//!\n-//! # Wire format\n-//!\n-//! Templates are **compact JSON** (`serde_json::to_string`): one line, no pretty\n-//! printing, strings escaped per JSON rules (`\\\"`, `\\n`, etc.). Embed that string\n-//! in HTML attributes or text nodes with normal HTML escaping (e.g. maud), not\n-//! bespoke encodings.\n-//!\n-//! # Power vs flat hidden fields\n-//!\n-//! A form is always a string→string map. You can fake depth with dotted keys (`a.b.c`),\n-//! but one structured blob (`__rpc__` = compact JSON) gives you nested objects,\n-//! arrays, and optional fields without inventing a new naming scheme each time.\n-//!\n-//! # Security\n-//!\n-//! Substitution runs **before** `serde` into your command type. It does not fix\n-//! authorization: if the client can replace the hidden `__rpc__` value, they can\n-//! change the command shape unless you validate (signed blob, server-side session\n-//! context, or treat the blob as hints only). Same threat model as any hidden field.\n-\n-use serde::Serialize;\n-use serde_json::Value;\n-use std::collections::HashMap;\n-\n-/// Serialize a value to compact JSON for a hidden `__rpc__` (or similar) field.\n-pub fn template_json_compact<T: Serialize>(v: &T) -> serde_json::Result<String> {\n-    serde_json::to_string(v)\n-}\n-\n-/// Recursively walk the JSON AST and replace `{\"$form\": \"key\"}` with the submitted\n-/// string for `key` (empty if missing). Other keys are unchanged.\n-pub fn substitute_form_vars(val: &mut Value, form_data: &HashMap<String, String>) {\n-    match val {\n-        Value::Object(map) => {\n-            if map.len() == 1 {\n-                if let Some(Value::String(field_name)) = map.get(\"$form\") {\n-                    let submitted = form_data\n-                        .get(field_name.as_str())\n-                        .map(|s| s.as_str())\n-                        .unwrap_or(\"\");\n-                    *val = Value::String(submitted.to_string());\n-                    return;\n-                }\n-            }\n-            for v in map.values_mut() {\n-                substitute_form_vars(v, form_data);\n-            }\n-        }\n-        Value::Array(arr) => {\n-            for v in arr.iter_mut() {\n-                substitute_form_vars(v, form_data);\n-            }\n-        }\n-        _ => {}\n-    }\n-}\n-\n-/// Parse JSON, apply [`substitute_form_vars`], return the mutated value.\n-pub fn fill_template_from_form(\n-    template_json: &str,\n-    form_data: &HashMap<String, String>,\n-) -> Result<Value, serde_json::Error> {\n-    let mut v: Value = serde_json::from_str(template_json)?;\n-    substitute_form_vars(&mut v, form_data);\n-    Ok(v)\n-}\n-\n-#[cfg(test)]\n-mod tests {\n-    use super::*;\n-    use serde::Deserialize;\n-\n-    #[derive(Debug, Deserialize, PartialEq, Eq)]\n-    struct Demo {\n-        room: String,\n-        thread_tag: String,\n-        nested: Nested,\n-    }\n-\n-    #[derive(Debug, Deserialize, PartialEq, Eq)]\n-    struct Nested {\n-        text: String,\n-    }\n-\n-    #[test]\n-    fn holes_become_strings() {\n-        let json = r#\"{\n-            \"room\": \"public\",\n-            \"thread_tag\": {\"$form\": \"tag\"},\n-            \"nested\": {\"text\": {\"$form\": \"body\"}}\n-        }\"#;\n-        let mut form = HashMap::new();\n-        form.insert(\"tag\".into(), \"foo\".into());\n-        form.insert(\"body\".into(), \"hello\\nworld\".into());\n-\n-        let v = fill_template_from_form(json, &form).unwrap();\n-        let d: Demo = serde_json::from_value(v).unwrap();\n-        assert_eq!(\n-            d,\n-            Demo {\n-                room: \"public\".into(),\n-                thread_tag: \"foo\".into(),\n-                nested: Nested {\n-                    text: \"hello\\nworld\".into(),\n-                },\n-            }\n-        );\n-    }\n-\n-    #[test]\n-    fn missing_form_key_is_empty_string() {\n-        let json = r#\"{\"x\": {\"$form\": \"nope\"}}\"#;\n-        let mut form = HashMap::new();\n-        form.insert(\"other\".into(), \"y\".into());\n-        let v = fill_template_from_form(json, &form).unwrap();\n-        assert_eq!(v[\"x\"], \"\");\n-    }\n-\n-    #[test]\n-    fn array_of_holes() {\n-        let json = r#\"{\"items\": [{\"$form\": \"a\"}, {\"$form\": \"b\"}]}\"#;\n-        let mut form = HashMap::new();\n-        form.insert(\"a\".into(), \"1\".into());\n-        form.insert(\"b\".into(), \"2\".into());\n-        let v = fill_template_from_form(json, &form).unwrap();\n-        assert_eq!(v[\"items\"], serde_json::json!([\"1\", \"2\"]));\n-    }\n-\n-    #[test]\n-    fn template_json_compact_escapes_and_single_line() {\n-        let s = template_json_compact(&serde_json::json!({\n-            \"x\": \"quote\\\"and\\nnewline\"\n-        }))\n-        .unwrap();\n-        assert!(!s.contains('\\n'));\n-        assert!(s.contains(\"\\\\\\\"\") || s.contains(\"\\\\n\"));\n-    }\n-}\n-tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒  \n-\ndiff --git a/legacy/mod.rs b/legacy/mod.rs\ndeleted file mode 100644\nindex b1dfe895515a1ba94304c52ac4ea82ff6bb84c16..0000000000000000000000000000000000000000\n--- a/legacy/mod.rs\n+++ /dev/null\n@@ -1,929 +0,0 @@\n-use axum::{\n-    body::Body,\n-    extract::Path,\n-    http::{header, HeaderValue, StatusCode, Uri},\n-    response::{IntoResponse, Response},\n-    Form,\n-};\n-use axum_extra::extract::cookie::CookieJar;\n-use maud::{html, Markup, DOCTYPE};\n-use serde::Deserialize;\n-use std::collections::{HashMap, HashSet};\n-\n-mod auth;\n-mod breadcrumb_path;\n-mod editor;\n-mod forum;\n-mod garden;\n-pub mod routing;\n-mod search;\n-pub mod ui_action;\n-use breadcrumb_path::{ExternalOntologyPath, OntologyPath};\n-\n-pub use auth::{\n-    auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment,\n-    choose_username_page,\n-};\n-pub use editor::{editor_check, editor_page};\n-pub use forum::{\n-    home, room_page, room_thread_post_view, room_thread_view, thread_feed_html,\n-    thread_feed_html_for_room, thread_feed_region_markup, thread_post_view, thread_view, ThreadNav,\n-};\n-\n-pub use forum::user_profile_page;\n-pub(crate) use forum::{\n-    fragment_new_thread_slot, login_to_post_hint_markup, room_members_section_markup,\n-    thread_ui_collapse_redacted_post, thread_ui_copy_thread, thread_ui_expand_post_full, thread_ui_expand_redacted_post,\n-    user_can_post_room, user_can_view_room,\n-};\n-pub(crate) use garden::{\n-    encode_pin_cookie_value, external_resolver_status_markup, vote_compare_post_success_js,\n-    GARDEN_PIN_COOKIE,\n-};\n-pub use garden::{\n-    external_garden_index, external_ontology_path, garden_index, ontology_path,\n-    room_external_garden_index, room_external_ontology_path, room_garden_index, room_ontology_path,\n-    room_vote_compare_page, vote_compare_page,\n-};\n-pub use routing::RouteContext;\n-pub use search::{search_page, search_results_fragment};\n-pub use ui_action::{parse_html_ui_from_form, HtmlUiAction, HtmlUiParseError, UI_RPC_FIELD};\n-\n-/// Public profile URL path for a stored username (no `@`).\n-pub(crate) fn profile_href(username: &str) -> String {\n-    format!(\"/u/{username}\")\n-}\n-\n-/// Cookie name for UI theme (must match document.cookie migration in [`layout`]).\n-pub const SLUG_THEME_COOKIE: &str = \"slug-theme\";\n-\n-/// Normalize a requested theme id to a known stylesheet key.\n-pub fn normalize_theme(raw: &str) -> &'static str {\n-    match raw {\n-        \"retro\" => \"retro\",\n-        \"retro_craft\" => \"retro_craft\",\n-        _ => \"default\",\n-    }\n-}\n-\n-/// Resolved theme for rendering and cookie re-issue.\n-pub fn theme_from_jar(jar: &CookieJar) -> &'static str {\n-    jar.get(SLUG_THEME_COOKIE)\n-        .map(|c| normalize_theme(c.value()))\n-        .unwrap_or(\"default\")\n-}\n-\n-/// `Path` + optional `?query` for round-tripping after `POST /theme`.\n-pub fn theme_next_from_uri(uri: &Uri) -> String {\n-    uri.path_and_query()\n-        .map(|pq| pq.as_str().to_string())\n-        .filter(|s| !s.is_empty())\n-        .unwrap_or_else(|| \"/\".to_string())\n-}\n-\n-/// `Set-Cookie` for a validated theme (ASCII cookie value).\n-pub fn theme_cookie_header_value(theme: &str) -> HeaderValue {\n-    let t = normalize_theme(theme);\n-    let s = format!(\"{SLUG_THEME_COOKIE}={t}; Path=/; SameSite=Lax; Max-Age=31536000\");\n-    HeaderValue::from_str(&s).expect(\"theme cookie must be ASCII\")\n-}\n-\n-/// Re-issue theme cookie on responses that also set `slug_session`, so login does not drop theme.\n-pub fn theme_cookie_header_from_jar(jar: &CookieJar) -> Option<HeaderValue> {\n-    let c = jar.get(SLUG_THEME_COOKIE)?;\n-    Some(theme_cookie_header_value(c.value()))\n-}\n-\n-fn sanitize_theme_next(next: Option<&str>) -> String {\n-    let s = next.unwrap_or(\"/\").trim();\n-    if s.starts_with('/') && !s.starts_with(\"//\") && s.len() < 8192 {\n-        s.to_string()\n-    } else {\n-        \"/\".to_string()\n-    }\n-}\n-\n-#[derive(Debug, Deserialize)]\n-pub struct ThemeForm {\n-    theme: String,\n-    next: Option<String>,\n-}\n-\n-/// `POST /theme` — set theme cookie and redirect back (full navigation, no fetch).\n-pub async fn post_theme(Form(form): Form<ThemeForm>) -> impl IntoResponse {\n-    let theme = normalize_theme(&form.theme);\n-    let next = sanitize_theme_next(form.next.as_deref());\n-    let loc =\n-        HeaderValue::try_from(next.as_str()).unwrap_or_else(|_| HeaderValue::from_static(\"/\"));\n-    Response::builder()\n-        .status(StatusCode::SEE_OTHER)\n-        .header(header::LOCATION, loc)\n-        .header(header::SET_COOKIE, theme_cookie_header_value(theme))\n-        .body(Body::empty())\n-        .expect(\"theme redirect response\")\n-}\n-\n-// Embed CSS and shared UI script at compile time\n-const THEME_DEFAULT_CSS: &str = include_str!(\"../../static/theme_default.css\");\n-const THEME_RETRO_CSS: &str = include_str!(\"../../static/theme_retro.css\");\n-const THEME_RETRO_CRAFT_CSS: &str = include_str!(\"../../static/theme_retro_craft.css\");\n-const SLUG_UI_JS: &str = include_str!(\"../../static/slug_ui.js\");\n-\n-pub async fn serve_static(Path(filename): Path<String>) -> impl IntoResponse {\n-    if filename == \"slug_ui.js\" {\n-        return Response::builder()\n-            .status(StatusCode::OK)\n-            .header(header::CONTENT_TYPE, \"text/javascript; charset=utf-8\")\n-            .header(header::CACHE_CONTROL, \"public, max-age=3600\")\n-            .body(SLUG_UI_JS.to_string())\n-            .unwrap()\n-            .into_response();\n-    }\n-\n-    let theme = filename\n-        .strip_prefix(\"theme_\")\n-        .and_then(|s| s.strip_suffix(\".css\"));\n-\n-    let css = match theme {\n-        Some(\"default\") => THEME_DEFAULT_CSS,\n-        Some(\"retro\") => THEME_RETRO_CSS,\n-        Some(\"retro_craft\") => THEME_RETRO_CRAFT_CSS,\n-        _ => return (StatusCode::NOT_FOUND, \"static file not found\").into_response(),\n-    };\n-\n-    Response::builder()\n-        .status(StatusCode::OK)\n-        .header(header::CONTENT_TYPE, \"text/css; charset=utf-8\")\n-        .header(header::CACHE_CONTROL, \"public, max-age=3600\")\n-        .body(css.to_string())\n-        .unwrap()\n-        .into_response()\n-}\n-\n-pub(crate) fn js_string_literal(s: &str) -> String {\n-    serde_json::to_string(s).expect(\"javascript string escaping\")\n-}\n-\n-/// `console.warn` as `text/javascript` — for `POST /ui` parse errors and inline morph failures.\n-pub(crate) fn ui_js_warn(msg: &str) -> Response {\n-    let js = format!(\"console.warn({});\", js_string_literal(msg));\n-    Response::builder()\n-        .status(StatusCode::OK)\n-        .header(header::CONTENT_TYPE, \"text/javascript; charset=utf-8\")\n-        .body(Body::from(js))\n-        .unwrap()\n-}\n-\n-pub(crate) struct JsBuilder {\n-    snippets: Vec<String>,\n-}\n-\n-pub(crate) struct JsQueryBuilder {\n-    builder: JsBuilder,\n-    expr: String,\n-}\n-\n-impl JsBuilder {\n-    pub(crate) fn new() -> Self {\n-        Self {\n-            snippets: Vec::new(),\n-        }\n-    }\n-\n-    pub(crate) fn morph_selector(self, selector: &str, markup: Markup) -> Self {\n-        self.morph_expr(\n-            &format!(\"document.querySelector({})\", js_string_literal(selector)),\n-            markup,\n-            None,\n-        )\n-    }\n-\n-    /// Morph **children** of `selector` so the outer element (e.g. `#new-thread-ui-slot`) keeps its `id`.\n-    pub(crate) fn morph_inner_selector(self, selector: &str, markup: Markup) -> Self {\n-        self.qs(selector).morph_inner(markup)\n-    }\n-\n-    pub(crate) fn morph_expr(\n-        mut self,\n-        expr: &str,\n-        markup: Markup,\n-        morph_style: Option<&str>,\n-    ) -> Self {\n-        let html = js_string_literal(&markup.into_string());\n-        let opts = morph_style\n-            .map(|style| format!(\", {{morphStyle: {}}}\", js_string_literal(style)))\n-            .unwrap_or_default();\n-        self.snippets.push(format!(\n-            \"var __slugEl = {expr}; if (__slugEl) {{ Idiomorph.morph(__slugEl, {html}{opts}); }}\",\n-        ));\n-        self\n-    }\n-\n-    pub(crate) fn qs(self, selector: &str) -> JsQueryBuilder {\n-        JsQueryBuilder {\n-            builder: self,\n-            expr: format!(\"document.querySelector({})\", js_string_literal(selector)),\n-        }\n-    }\n-\n-    pub(crate) fn id(self, id: &str) -> JsQueryBuilder {\n-        self.qs(&format!(\"#{id}\"))\n-    }\n-\n-    pub(crate) fn if_current_path_matches(\n-        mut self,\n-        path: &str,\n-        f: impl FnOnce(JsBuilder) -> JsBuilder,\n-    ) -> Self {\n-        let inner = f(JsBuilder::new()).build();\n-        self.snippets.push(format!(\n-            \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0) {{ {inner} }}\",\n-            path = js_string_literal(path),\n-        ));\n-        self\n-    }\n-\n-    pub(crate) fn if_current_path_not_matches(\n-        mut self,\n-        path: &str,\n-        f: impl FnOnce(JsBuilder) -> JsBuilder,\n-    ) -> Self {\n-        let inner = f(JsBuilder::new()).build();\n-        self.snippets.push(format!(\n-            \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (!(__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0)) {{ {inner} }}\",\n-            path = js_string_literal(path),\n-        ));\n-        self\n-    }\n-\n-    pub(crate) fn redirect(mut self, to: &str) -> Self {\n-        self.snippets\n-            .push(format!(\"window.location = {};\", js_string_literal(to)));\n-        self\n-    }\n-\n-    pub(crate) fn clipboard_write_text_and_label_btn(\n-        mut self,\n-        text: &str,\n-        btn_id: &str,\n-        copied_label: &str,\n-    ) -> Self {\n-        self.snippets.push(format!(\n-            \"navigator.clipboard.writeText({text}).then(function(){{ var __slugCopyBtn = document.getElementById({btn_id}); if (__slugCopyBtn) {{ __slugCopyBtn.textContent = {label}; }} }}).catch(function(__slugErr){{ console.warn(__slugErr); }});\",\n-            text = js_string_literal(text),\n-            btn_id = js_string_literal(btn_id),\n-            label = js_string_literal(copied_label),\n-        ));\n-        self\n-    }\n-\n-    /// Focus first matching element (e.g. after morphing open a compose form).\n-    pub(crate) fn focus_selector(mut self, selector: &str) -> Self {\n-        self.snippets.push(format!(\n-            \"var __slugF = document.querySelector({}); if (__slugF && __slugF.focus) {{ __slugF.focus(); }}\",\n-            js_string_literal(selector),\n-        ));\n-        self\n-    }\n-\n-    pub(crate) fn build(self) -> String {\n-        self.snippets.join(\" \")\n-    }\n-\n-    pub(crate) fn into_response(self) -> Response {\n-        Response::builder()\n-            .status(StatusCode::OK)\n-            .header(header::CONTENT_TYPE, \"text/javascript; charset=utf-8\")\n-            .body(Body::from(self.build()))\n-            .unwrap()\n-    }\n-}\n-\n-impl JsQueryBuilder {\n-    pub(crate) fn morph(mut self, markup: Markup) -> JsBuilder {\n-        let html = js_string_literal(&markup.into_string());\n-        self.builder.snippets.push(format!(\n-            \"var __slugTarget = {expr}; if (__slugTarget) {{ Idiomorph.morph(__slugTarget, {html}); }}\",\n-            expr = self.expr,\n-        ));\n-        self.builder\n-    }\n-\n-    pub(crate) fn morph_inner(mut self, markup: Markup) -> JsBuilder {\n-        let html = js_string_literal(&markup.into_string());\n-        self.builder.snippets.push(format!(\n-            \"var __slugTarget = {expr}; if (__slugTarget) {{ Idiomorph.morph(__slugTarget, {html}, {{morphStyle: 'innerHTML'}}); }}\",\n-            expr = self.expr,\n-        ));\n-        self.builder\n-    }\n-\n-    pub(crate) fn reset(mut self) -> JsBuilder {\n-        self.builder.snippets.push(format!(\n-            \"var __slugTarget = {expr}; if (__slugTarget) {{ __slugTarget.reset(); }}\",\n-            expr = self.expr,\n-        ));\n-        self.builder\n-    }\n-}\n-\n-#[allow(clippy::too_many_arguments)]\n-pub(super) fn layout(\n-    title: &str,\n-    view: &str,\n-    body: Markup,\n-    views: Option<u64>,\n-    theme: &str,\n-    theme_next: &str,\n-    garden_room_wire: Option<&str>,\n-    garden_path_prefix: Option<&str>,\n-) -> Markup {\n-    layout_embed_controls(\n-        title,\n-        view,\n-        body,\n-        views,\n-        theme,\n-        theme_next,\n-        garden_room_wire,\n-        garden_path_prefix,\n-        true,\n-    )\n-}\n-\n-/// Minimal document shell: no bottom controls, no garden HUD data attributes (`data-garden-room` /\n-/// `data-garden-prefix` empty). For routes that own the full viewport (e.g. vote compare).\n-pub(super) fn layout_full_bleed_chromeless(\n-    title: &str,\n-    view: &str,\n-    body: Markup,\n-    views: Option<u64>,\n-    theme: &str,\n-    theme_next: &str,\n-) -> Markup {\n-    layout_embed_controls(\n-        title, view, body, views, theme, theme_next, None, None, false,\n-    )\n-}\n-\n-#[allow(clippy::too_many_arguments)]\n-fn layout_embed_controls(\n-    title: &str,\n-    view: &str,\n-    body: Markup,\n-    views: Option<u64>,\n-    theme: &str,\n-    theme_next: &str,\n-    garden_room_wire: Option<&str>,\n-    garden_path_prefix: Option<&str>,\n-    show_controls: bool,\n-) -> Markup {\n-    let theme = normalize_theme(theme);\n-    let css_href = format!(\"/static/theme_{theme}.css\");\n-    html! {\n-        (DOCTYPE)\n-        html {\n-            head {\n-                meta charset=\"utf-8\";\n-                meta name=\"viewport\" content=\"width=device-width, initial-scale=1\";\n-                title { (title) }\n-                link rel=\"stylesheet\" href=(css_href) id=\"theme-stylesheet\";\n-                script src=\"https://unpkg.com/idiomorph@0.3.0/dist/idiomorph.min.js\" {}\n-            }\n-            body class=(view)\n-                data-garden-room=(garden_room_wire.unwrap_or(\"\"))\n-                data-garden-prefix=(garden_path_prefix.unwrap_or(\"\")) {\n-                @if let Some(n) = views {\n-                    span class=\"view-meta muted\" { (n) \" views\" }\n-                }\n-                div id=\"errors\" {}\n-                (body)\n-                @if show_controls {\n-                div id=\"controls\" {\n-                    a href=\"https://github.com/sortersocial/slug\" id=\"src-link\" { \"src\" }\n-                    div id=\"spread-control\" {\n-                        span { \"spread\" }\n-                        input type=\"range\" id=\"spread-slider\" min=\"0\" max=\"1\" step=\"0.05\" value=\"1\";\n-                    }\n-                    @if let (Some(gr), Some(ref gpx)) = (garden_room_wire, garden_path_prefix) {\n-                        @if !gr.is_empty() {\n-                            div id=\"slug-pin-hud\" class=\"slug-pin-hud\" data-garden-prefix=(gpx) {}\n-                        }\n-                    }\n-                    a id=\"search-btn\" href=\"/search\" { \"search\" }\n-                    form id=\"slug-theme-form\" method=\"post\" action=\"/theme\" {\n-                        input type=\"hidden\" name=\"next\" value=(theme_next);\n-                        select id=\"theme-select\" name=\"theme\" onchange=\"this.form.submit()\" aria-label=\"Theme\" {\n-                            @for (val, label) in [(\"default\", \"default\"), (\"retro\", \"retro\"), (\"retro_craft\", \"craft\")] {\n-                                @if theme == val {\n-                                    option value=(val) selected { (label) }\n-                                } @else {\n-                                    option value=(val) { (label) }\n-                                }\n-                            }\n-                        }\n-                    }\n-                }\n-                }\n-                script src=\"/static/slug_ui.js\" {}\n-            }\n-        }\n-    }\n-}\n-\n-pub(super) fn now_ms() -> i64 {\n-    let t = std::time::SystemTime::now()\n-        .duration_since(std::time::UNIX_EPOCH)\n-        .unwrap_or_default();\n-    t.as_millis() as i64\n-}\n-\n-pub(super) fn ratio_pct(left: i32, right: i32) -> f64 {\n-    let l = (left.max(0)) as f64;\n-    let r = (right.max(0)) as f64;\n-    let denom = l + r;\n-    if denom <= 0.0 {\n-        return 50.0;\n-    }\n-    (l / denom) * 100.0\n-}\n-\n-/// Render a single breadcrumb segment with `/` separator.\n-pub(super) fn bc_segment(label: &str, href: &str, is_current: bool) -> Markup {\n-    html! {\n-        span class=\"bc-sep\" { \" / \" }\n-        @if is_current {\n-            a href=(href) class=\"bc-current\" { (label) }\n-        } @else {\n-            a href=(href) { (label) }\n-        }\n-    }\n-}\n-\n-/// Breadcrumb for external ontology `/-/https://…`\n-fn bc_path_external(path: &ExternalOntologyPath) -> Markup {\n-    html! {\n-        a href=\"/\" { \"slug.social\" }\n-        (bc_segment(\"-\", \"/-\", path.is_root()))\n-        @for (i, id) in path.breadcrumb_chain().iter().enumerate() {\n-            @let disp = id.display_path();\n-            @let tail = disp.strip_prefix(\"-/\").unwrap_or(disp.as_str());\n-            @let href = format!(\"/-/{}\", tail);\n-            @let is_last = i + 1 == path.breadcrumb_chain().len();\n-            (bc_segment(id.last_segment(), &href, is_last))\n-        }\n-    }\n-}\n-\n-/// Breadcrumb for any ontology path segment, e.g. \"parables\" or \"parables/counting-the-cost\".\n-fn bc_path(path: &OntologyPath) -> Markup {\n-    html! {\n-        a href=(path.slug_root_href()) { \"slug.social\" }\n-        (bc_segment(\"~\", \"/~\", path.is_root()))\n-        @for (i, seg) in path.segments().iter().enumerate() {\n-            @let href = format!(\"/~/{}\", path.segments()[..=i].join(\"/\"));\n-            @let is_last = i == path.segments().len() - 1;\n-            (bc_segment(seg, &href, is_last))\n-        }\n-    }\n-}\n-\n-/// Render the thread path breadcrumb: `slug.social / #tag` or `… / #tag / post #N` on a single post.\n-/// Root link toggles to `/~` only at thread-root (`/`).\n-pub(super) fn bc_threads(thread_tag: Option<&str>, focused_post: Option<usize>) -> Markup {\n-    let root_href = if thread_tag.is_some() { \"/\" } else { \"/~\" };\n-    let root_is_current = thread_tag.is_none();\n-    html! {\n-        @if root_is_current {\n-            a href=(root_href) class=\"bc-current\" { \"slug.social\" }\n-        } @else {\n-            a href=(root_href) { \"slug.social\" }\n-        }\n-        @if let Some(tag) = thread_tag {\n-            @if let Some(idx) = focused_post {\n-                (bc_segment(&format!(\"#{tag}\"), &format!(\"/t/{tag}\"), false))\n-                (bc_segment(&format!(\"post #{idx}\"), &format!(\"/t/{tag}/{idx}\"), true))\n-            } @else {\n-                (bc_segment(&format!(\"#{tag}\"), &format!(\"/t/{tag}\"), true))\n-            }\n-        }\n-    }\n-}\n-\n-/// Short display label for a stored agent id (`uuid:rig:model`, no `@`).\n-pub(super) fn actor_label(agent_naked: &str) -> String {\n-    let a = agent_naked.trim();\n-    let parts: Vec<&str> = a.split(':').collect();\n-    if parts.len() >= 3 {\n-        let rig = parts[1].trim();\n-        let model = parts[2].trim();\n-        // X actors: show @handle instead of uuid hash.\n-        if rig == \"x.com\" {\n-            return format!(\"@{model}\");\n-        }\n-        let uuid = parts[0].trim();\n-        let uuid8 = uuid.chars().take(8).collect::<String>();\n-        if !uuid8.is_empty() && !rig.is_empty() && !model.is_empty() {\n-            return format!(\"{uuid8}:{rig}:{model}\");\n-        }\n-    }\n-    a.to_string()\n-}\n-\n-/// HTML attribution only: human `@name`, or agent `@@uuid8:rig:model` when a delegate is present.\n-pub(super) fn authorship_address(principal: &str, delegate: &Option<String>) -> String {\n-    match delegate {\n-        Some(d) => format!(\"@@{}\", actor_label(d)),\n-        None => format!(\"@{principal}\"),\n-    }\n-}\n-\n-/// Escape HTML special chars for safe injection.\n-fn escape_html(s: &str) -> String {\n-    let mut out = String::with_capacity(s.len());\n-    for c in s.chars() {\n-        match c {\n-            '&' => out.push_str(\"&amp;\"),\n-            '<' => out.push_str(\"&lt;\"),\n-            '>' => out.push_str(\"&gt;\"),\n-            '\"' => out.push_str(\"&quot;\"),\n-            _ => out.push(c),\n-        }\n-    }\n-    out\n-}\n-\n-/// Max characters from an item body placed in a `title` tooltip (native hover).\n-const ITEM_LINK_TITLE_MAX_CHARS: usize = 500;\n-\n-fn collapse_whitespace_for_title(s: &str) -> String {\n-    let mut out = String::with_capacity(s.len().min(ITEM_LINK_TITLE_MAX_CHARS + 8));\n-    let mut last_was_space = true;\n-    for c in s.chars() {\n-        if c.is_whitespace() {\n-            if !last_was_space {\n-                out.push(' ');\n-                last_was_space = true;\n-            }\n-        } else {\n-            out.push(c);\n-            last_was_space = false;\n-        }\n-    }\n-    out.trim().to_string()\n-}\n-\n-fn item_body_title_snippet(body: &str) -> Option<String> {\n-    let s = collapse_whitespace_for_title(body);\n-    if s.is_empty() {\n-        return None;\n-    }\n-    let truncated: String = s.chars().take(ITEM_LINK_TITLE_MAX_CHARS).collect();\n-    let ellipsis = if s.chars().count() > ITEM_LINK_TITLE_MAX_CHARS {\n-        \"…\"\n-    } else {\n-        \"\"\n-    };\n-    Some(format!(\"{truncated}{ellipsis}\"))\n-}\n-\n-fn garden_href_for_item_ref(\n-    raw_ref: &str,\n-    garden_prefix: &str,\n-) -> Option<(crate::path_types::ItemId, String)> {\n-    let key = slug_types::canonicalize_item(raw_ref);\n-    let id = crate::path_types::ItemId::parse(&key)?;\n-    let href = if let Some(tail) = id.tilde_tail() {\n-        if tail.is_empty() {\n-            garden_prefix.trim_end_matches('/').to_string()\n-        } else {\n-            format!(\"{}/{}\", garden_prefix.trim_end_matches('/'), tail)\n-        }\n-    } else if id.as_str().starts_with(\"https://\") || id.as_str().starts_with(\"http://\") {\n-        let display = id.display_path();\n-        let rest = display.strip_prefix(\"-/\").unwrap_or(display.as_str());\n-        let ext_prefix = format!(\"{}-\", garden_prefix.trim_end_matches('~'));\n-        format!(\"{ext_prefix}/{rest}\")\n-    } else {\n-        return None;\n-    };\n-    Some((id, href))\n-}\n-\n-fn push_item_ref_anchor(\n-    out: &mut String,\n-    raw_ref: &str,\n-    garden_prefix: &str,\n-    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n-) -> bool {\n-    let Some((id, href)) = garden_href_for_item_ref(raw_ref, garden_prefix) else {\n-        return false;\n-    };\n-    out.push_str(r#\"<a href=\"\"#);\n-    out.push_str(&escape_html(&href));\n-    out.push('\"');\n-    out.push_str(r#\" class=\"pre-link\"\"#);\n-    if let Some(bodies) = item_bodies {\n-        if let Some(body) = bodies.get(&id) {\n-            if let Some(snippet) = item_body_title_snippet(body) {\n-                out.push_str(r#\" title=\"\"#);\n-                out.push_str(&escape_html(&snippet));\n-                out.push('\"');\n-            }\n-        }\n-    }\n-    out.push('>');\n-    out.push_str(&escape_html(raw_ref));\n-    out.push_str(\"</a>\");\n-    true\n-}\n-\n-/// Replace item refs in raw prose with clickable garden links.\n-///\n-/// When `item_bodies` is set, matching ontology items get a `title` attribute with a truncated\n-/// body preview for native browser tooltips (forum posts, item pages).\n-pub(super) fn linkify_slugs_with_prefix(\n-    raw: &str,\n-    garden_prefix: &str,\n-    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n-) -> String {\n-    let mut out = String::with_capacity(raw.len() + 64);\n-    for token in crate::dsl::tokenize_prose_item_refs(raw) {\n-        match token {\n-            crate::dsl::ProseToken::Text(text) => out.push_str(&escape_html(&text)),\n-            crate::dsl::ProseToken::ItemRef(raw_ref) => {\n-                if !push_item_ref_anchor(&mut out, &raw_ref, garden_prefix, item_bodies) {\n-                    out.push_str(&escape_html(&raw_ref));\n-                }\n-            }\n-        }\n-    }\n-    out\n-}\n-\n-#[derive(Clone)]\n-struct EmbedFrame {\n-    src: String,\n-    title: String,\n-    provider_class: &'static str,\n-}\n-\n-fn clean_media_id(s: &str) -> String {\n-    s.chars()\n-        .take_while(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_')\n-        .collect()\n-}\n-\n-fn query_param(url: &str, name: &str) -> Option<String> {\n-    let q = url.split_once('?')?.1;\n-    for pair in q.split('&') {\n-        let (k, v) = pair.split_once('=').unwrap_or((pair, \"\"));\n-        if k == name {\n-            return Some(v.to_string());\n-        }\n-    }\n-    None\n-}\n-\n-fn spotify_embed_src(url: &str) -> Option<EmbedFrame> {\n-    let rest = url\n-        .strip_prefix(\"https://\")\n-        .or_else(|| url.strip_prefix(\"http://\"))?;\n-    let (host, tail) = rest.split_once('/').unwrap_or((rest, \"\"));\n-    let host = host.to_lowercase();\n-    if !(host == \"open.spotify.com\" || host == \"www.open.spotify.com\") {\n-        return None;\n-    }\n-    let path = tail\n-        .split('#')\n-        .next()\n-        .unwrap_or(tail)\n-        .split('?')\n-        .next()\n-        .unwrap_or(tail);\n-    let mut segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();\n-    if segs.first().is_some_and(|s| s.starts_with(\"intl-\")) {\n-        segs.remove(0);\n-    }\n-    if segs.len() < 2 {\n-        return None;\n-    }\n-    let kind = segs[0];\n-    let id = clean_media_id(segs[1]);\n-    if id.is_empty() {\n-        return None;\n-    }\n-    let allowed = matches!(kind, \"track\" | \"album\" | \"playlist\" | \"episode\" | \"show\");\n-    if !allowed {\n-        return None;\n-    }\n-    Some(EmbedFrame {\n-        src: format!(\"https://open.spotify.com/embed/{kind}/{id}\"),\n-        title: format!(\"Spotify {kind}\"),\n-        provider_class: \"embed-spotify\",\n-    })\n-}\n-\n-fn youtube_embed_src(url: &str) -> Option<EmbedFrame> {\n-    let rest = url\n-        .strip_prefix(\"https://\")\n-        .or_else(|| url.strip_prefix(\"http://\"))?;\n-    let (host, tail) = rest.split_once('/').unwrap_or((rest, \"\"));\n-    let host = host.to_lowercase();\n-\n-    let video_id = if host == \"youtu.be\" || host == \"www.youtu.be\" {\n-        clean_media_id(\n-            tail.split(['?', '#'])\n-                .next()\n-                .unwrap_or(tail)\n-                .trim_matches('/'),\n-        )\n-    } else if matches!(\n-        host.as_str(),\n-        \"youtube.com\" | \"www.youtube.com\" | \"m.youtube.com\" | \"music.youtube.com\"\n-    ) {\n-        let path = format!(\"/{}\", tail.split('#').next().unwrap_or(tail));\n-        if path.starts_with(\"/watch\") {\n-            clean_media_id(&query_param(url, \"v\")?)\n-        } else if let Some(id) = path.strip_prefix(\"/shorts/\") {\n-            clean_media_id(id.split(['?', '/']).next().unwrap_or(id))\n-        } else if let Some(id) = path.strip_prefix(\"/embed/\") {\n-            clean_media_id(id.split(['?', '/']).next().unwrap_or(id))\n-        } else {\n-            String::new()\n-        }\n-    } else {\n-        String::new()\n-    };\n-\n-    if video_id.is_empty() {\n-        return None;\n-    }\n-    Some(EmbedFrame {\n-        src: format!(\"https://www.youtube.com/embed/{video_id}\"),\n-        title: \"YouTube video\".to_string(),\n-        provider_class: \"embed-youtube\",\n-    })\n-}\n-\n-fn extract_embed_frames(raw: &str) -> Vec<EmbedFrame> {\n-    let mut out = Vec::new();\n-    let mut seen = HashSet::new();\n-    for token in raw.split_whitespace() {\n-        let token = token\n-            .trim_matches(|c: char| c == '(' || c == '[' || c == '{' || c == '\"' || c == '\\'')\n-            .trim_end_matches(|c: char| \".,;:!?)]}\\\"'\".contains(c));\n-        if !(token.starts_with(\"https://\") || token.starts_with(\"http://\")) {\n-            continue;\n-        }\n-        let embed = spotify_embed_src(token).or_else(|| youtube_embed_src(token));\n-        if let Some(frame) = embed {\n-            if seen.insert(frame.src.clone()) {\n-                out.push(frame);\n-            }\n-        }\n-    }\n-    out\n-}\n-\n-pub(super) fn render_linkified_with_embeds_in_scope(\n-    raw: &str,\n-    garden_prefix: &str,\n-    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n-) -> Markup {\n-    let embeds = extract_embed_frames(raw);\n-    html! {\n-        pre { (maud::PreEscaped(linkify_slugs_with_prefix(raw, garden_prefix, item_bodies))) }\n-        @if !embeds.is_empty() {\n-            div class=\"rich-embeds\" {\n-                @for e in embeds {\n-                    div class=(format!(\"rich-embed {}\", e.provider_class)) {\n-                        iframe\n-                            src=(e.src)\n-                            title=(e.title)\n-                            loading=\"lazy\"\n-                            allow=\"autoplay; clipboard-write; encrypted-media; fullscreen; picture-in-picture; web-share\"\n-                            referrerpolicy=\"strict-origin-when-cross-origin\"\n-                            allowfullscreen {}\n-                    }\n-                }\n-            }\n-        }\n-    }\n-}\n-\n-/// Item page / thread body: resolver-specific rich HTML, else linkified `<pre>` + media embeds.\n-pub(super) fn render_item_body_in_scope(\n-    raw: &str,\n-    garden_prefix: &str,\n-    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n-) -> Markup {\n-    if let Some(m) = crate::resolvers::try_render_resolver_item_body(raw) {\n-        return html! {\n-            div class=\"item-body-rich\" { (m) }\n-        };\n-    }\n-    render_linkified_with_embeds_in_scope(raw, garden_prefix, item_bodies)\n-}\n-\n-/// CLI strings are embedded in a single-quoted JS literal; they must never need escaping.\n-fn assert_cli_panel_cmd_js_single_quote_safe(s: &str) {\n-    assert!(\n-        !s.contains('\\\\') && !s.contains('\\'') && !s.contains('\\n') && !s.contains('\\r'),\n-        \"cli_panel cmd must not contain `\\\\`, `'`, or newlines (got {s:?})\"\n-    );\n-}\n-\n-/// Small CLI hint panel: one border and title; each line is hover-highlighted and copies on click.\n-pub(super) fn cli_panel<I: AsRef<str>>(cmds: &[I]) -> Markup {\n-    if cmds.is_empty() {\n-        return html! {};\n-    }\n-    for cmd in cmds {\n-        assert_cli_panel_cmd_js_single_quote_safe(cmd.as_ref());\n-    }\n-    html! {\n-        div class=\"cli-panel\" {\n-            span class=\"cli-panel-label muted\" { \"cli\" }\n-            div class=\"cli-panel-cmds\" {\n-                @for cmd in cmds {\n-                    @let s = cmd.as_ref();\n-                    button type=\"button\" class=\"cli-panel-row\" title=\"Copy command\" onclick=(format!(\n-                        r#\"navigator.clipboard.writeText('{}');\"#,\n-                        s\n-                    )) {\n-                        code class=\"cli-panel-cmd\" { (s) }\n-                    }\n-                }\n-            }\n-        }\n-    }\n-}\n-\n-/// Age bucket for recency coloring of thread entries.\n-pub(super) fn recency_class(now_ms: i64, ts_ms: i64) -> &'static str {\n-    let age_ms = now_ms.saturating_sub(ts_ms);\n-    let age_secs = age_ms / 1000;\n-    if age_secs < 3600 {\n-        \"age-fresh\" // < 1 hour\n-    } else if age_secs < 86400 {\n-        \"age-recent\" // < 1 day\n-    } else if age_secs < 86400 * 7 {\n-        \"age-week\" // < 1 week\n-    } else {\n-        \"age-old\" // >= 1 week\n-    }\n-}\n-\n-#[cfg(test)]\n-mod linkify_title_tests {\n-    use super::*;\n-    use crate::path_types::ItemId;\n-    use std::collections::HashMap;\n-\n-    #[test]\n-    fn tilde_link_gets_title_from_item_bodies() {\n-        let mut bodies = HashMap::new();\n-        let key = ItemId::parse(&slug_types::canonicalize_item(\"~/foo/bar\")).unwrap();\n-        bodies.insert(key, \"Hello  world\\nline\".to_string());\n-        let html = linkify_slugs_with_prefix(\"see ~/foo/bar ok\", \"/r/x/~\", Some(&bodies));\n-        assert!(html.contains(\"title=\\\"Hello world line\\\"\"));\n-        assert!(html.contains(\"href=\\\"/r/x/~/foo/bar\\\"\"));\n-    }\n-\n-    #[test]\n-    fn raw_url_links_to_public_external_garden_page() {\n-        let html = linkify_slugs_with_prefix(\"see https://example.com/z.\", \"/~\", None);\n-        assert!(html.contains(\n-            r#\"<a href=\"/-/https://example.com/z\" class=\"pre-link\">https://example.com/z</a>.\"#\n-        ));\n-    }\n-\n-    #[test]\n-    fn dash_ref_links_to_room_external_garden_page_with_title() {\n-        let mut bodies = HashMap::new();\n-        let key = ItemId::parse(&slug_types::canonicalize_item(\"-/example.com/z\")).unwrap();\n-        bodies.insert(key, \"External body\\npreview\".to_string());\n-        let html =\n-            linkify_slugs_with_prefix(\"see -/example.com/z\", \"/r/9ab12cdroom/~\", Some(&bodies));\n-        assert!(html.contains(r#\"href=\"/r/9ab12cdroom/-/https://example.com/z\"\"#));\n-        assert!(html.contains(r#\"title=\"External body preview\"\"#));\n-    }\n-\n-    #[test]\n-    fn code_fence_urls_are_not_linkified() {\n-        let html = linkify_slugs_with_prefix(\n-            \"```json\\n{\\\"url\\\":\\\"https://example.com/z\\\"}\\n```\\nthen https://example.com/a\",\n-            \"/~\",\n-            None,\n-        );\n-        assert!(!html.contains(r#\"href=\"/-/https://example.com/z\"\"#));\n-        assert!(html.contains(r#\"href=\"/-/https://example.com/a\"\"#));\n-    }\n-\n-    #[test]\n-    fn no_title_when_body_missing_or_empty() {\n-        let html = linkify_slugs_with_prefix(\"x ~/a/b y\", \"/~\", Some(&HashMap::new()));\n-        assert!(!html.contains(\" title=\"));\n-    }\n-}\ndiff --git a/legacy/ranking.rs b/legacy/ranking.rs\ndeleted file mode 100644\nindex 34241cf6bf13117b3ad3262761eb7f7b48b54d80..0000000000000000000000000000000000000000\n--- a/legacy/ranking.rs\n+++ /dev/null\n@@ -1,393 +0,0 @@\n-tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒  cat server/src/ranking.rs \n-use std::collections::{HashMap, HashSet};\n-\n-use crate::path_types::ItemId;\n-use crate::reducer::GroupState;\n-\n-#[derive(Debug, Clone)]\n-pub struct RankedItem {\n-    pub item: ItemId,\n-    pub score: f64,\n-}\n-\n-/// Compute connected components over the voted-pairs graph (treated as undirected).\n-///\n-/// Returns:\n-/// - `components`: each component is a sorted list of node indices, excluding isolates.\n-/// - `isolates`: sorted list of node indices with degree 0 (no voted pairs).\n-pub fn connected_components_from_voted_pairs(\n-    n: usize,\n-    voted_pairs: impl Iterator<Item = (usize, usize)>,\n-) -> (Vec<Vec<usize>>, Vec<usize>) {\n-    let mut adj: Vec<Vec<usize>> = vec![Vec::new(); n];\n-    for (a, b) in voted_pairs {\n-        if a >= n || b >= n || a == b {\n-            continue;\n-        }\n-        adj[a].push(b);\n-        adj[b].push(a);\n-    }\n-\n-    let mut isolates: Vec<usize> = (0..n).filter(|&i| adj[i].is_empty()).collect();\n-    isolates.sort();\n-\n-    let mut seen = vec![false; n];\n-    for &i in &isolates {\n-        seen[i] = true;\n-    }\n-\n-    let mut comps: Vec<Vec<usize>> = Vec::new();\n-    for i in 0..n {\n-        if seen[i] {\n-            continue;\n-        }\n-        let mut stack = vec![i];\n-        seen[i] = true;\n-        let mut comp: Vec<usize> = Vec::new();\n-        while let Some(x) = stack.pop() {\n-            comp.push(x);\n-            for &y in &adj[x] {\n-                if !seen[y] {\n-                    seen[y] = true;\n-                    stack.push(y);\n-                }\n-            }\n-        }\n-        comp.sort();\n-        comps.push(comp);\n-    }\n-\n-    (comps, isolates)\n-}\n-\n-/// Compute rank centrality scores for a GroupState.\n-/// This matches the approach in the earlier standalone prototype but avoids dependencies by doing\n-/// an O(E) multiply per iteration.\n-pub fn compute_group_ranking(group: &mut GroupState, max_iters: usize, tol: f64) {\n-    if !group.dirty && !group.cached_scores.is_empty() {\n-        return;\n-    }\n-\n-    let n = group.idx_to_item.len();\n-    if n == 0 {\n-        group.cached_scores = vec![];\n-        group.dirty = false;\n-        return;\n-    }\n-    if n == 1 {\n-        group.cached_scores = vec![1.0];\n-        group.dirty = false;\n-        return;\n-    }\n-\n-    let scores = compute_scores_from_edges(\n-        n,\n-        group.edges.iter().map(|(&k, &w)| (k, w)),\n-        max_iters,\n-        tol,\n-    );\n-    group.cached_scores = scores;\n-    group.dirty = false;\n-}\n-\n-pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<RankedItem> {\n-    compute_group_ranking(group, max_iters, tol);\n-    let mut items: Vec<RankedItem> = group\n-        .idx_to_item\n-        .iter()\n-        .enumerate()\n-        .map(|(i, item)| RankedItem {\n-            item: item.clone(),\n-            score: *group.cached_scores.get(i).unwrap_or(&0.0),\n-        })\n-        .collect();\n-\n-    items.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));\n-    items\n-}\n-\n-fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usize), f64)>, max_iters: usize, tol: f64) -> Vec<f64> {\n-    if n == 0 {\n-        return vec![];\n-    }\n-    if n == 1 {\n-        return vec![1.0];\n-    }\n-\n-    // Collect raw edges into a map for pairwise normalization.\n-    let mut raw: HashMap<(usize, usize), f64> = HashMap::new();\n-    for ((src, dst), w) in edges {\n-        if src >= n || dst >= n || w <= 0.0 {\n-            continue;\n-        }\n-        *raw.entry((src, dst)).or_insert(0.0) += w;\n-    }\n-\n-    // Pairwise normalization: a_ij = A_ij / (A_ij + A_ji).\n-    // This ensures repeated votes on the same pair don't inflate influence\n-    // beyond what the ratio implies.\n-    let keys: Vec<(usize, usize)> = raw.keys().copied().collect();\n-    let mut normalized: HashMap<(usize, usize), f64> = HashMap::new();\n-    for (i, j) in keys {\n-        if normalized.contains_key(&(i, j)) {\n-            continue;\n-        }\n-        let w_ij = *raw.get(&(i, j)).unwrap_or(&0.0);\n-        let w_ji = *raw.get(&(j, i)).unwrap_or(&0.0);\n-        let total = w_ij + w_ji;\n-        if total <= 0.0 {\n-            continue;\n-        }\n-        normalized.insert((i, j), w_ij / total);\n-        if w_ji > 0.0 {\n-            normalized.insert((j, i), w_ji / total);\n-        }\n-    }\n-\n-    // Rank Centrality (Negahban, Oh, Shah 2012, §3.1):\n-    //   P_ij = (1/d_max) * A_ij           for i ≠ j compared\n-    //   P_ii = 1 - (1/d_max) * Σ_k A_ik\n-    // where d_i is the *degree* (number of distinct neighbors compared) and\n-    // d_max = max_i d_i. Using the unweighted degree — not the sum of\n-    // pairwise-normalized weights — is what guarantees aperiodicity: it\n-    // forces P_ii > 0 for every non-maximum-degree node, and for max-degree\n-    // nodes whenever any neighbor weight is below 1 (i.e. not a unanimous\n-    // loss). Without this, regular comparison graphs (e.g. a pure star at\n-    // ratio 2:1) produce a bipartite chain that oscillates instead of\n-    // converging — see issue #146.\n-    let mut out_edges: Vec<Vec<(usize, f64)>> = vec![Vec::new(); n];\n-    let mut neighbors: Vec<HashSet<usize>> = vec![HashSet::new(); n];\n-\n-    for ((src, dst), w) in &normalized {\n-        out_edges[*src].push((*dst, *w));\n-        neighbors[*src].insert(*dst);\n-        neighbors[*dst].insert(*src);\n-    }\n-\n-    let weight_sum: Vec<f64> = out_edges\n-        .iter()\n-        .map(|es| es.iter().map(|(_, w)| *w).sum())\n-        .collect();\n-    let d_max = neighbors.iter().map(|s| s.len()).max().unwrap_or(0);\n-    if d_max == 0 {\n-        return vec![1.0 / n as f64; n];\n-    }\n-    let d_max_f = d_max as f64;\n-\n-    let mut scores = vec![1.0 / n as f64; n];\n-    let mut next = vec![0.0f64; n];\n-\n-    for _ in 0..max_iters {\n-        next.fill(0.0);\n-        for i in 0..n {\n-            let stay_prob = (d_max_f - weight_sum[i]) / d_max_f;\n-            next[i] += scores[i] * stay_prob;\n-\n-            if out_edges[i].is_empty() {\n-                continue;\n-            }\n-            for &(dst, w) in &out_edges[i] {\n-                next[dst] += scores[i] * (w / d_max_f);\n-            }\n-        }\n-\n-        let diff: f64 = scores\n-            .iter()\n-            .zip(next.iter())\n-            .map(|(a, b)| (a - b).abs())\n-            .sum();\n-\n-        scores.clone_from_slice(&next);\n-        if diff < tol {\n-            break;\n-        }\n-    }\n-\n-    let sum: f64 = scores.iter().sum();\n-    if sum.is_finite() && sum > 0.0 {\n-        for s in &mut scores {\n-            *s /= sum;\n-        }\n-    }\n-    scores\n-}\n-\n-/// Rank-centrality within a subset of items (an induced subgraph), using the group's aggregated edges.\n-///\n-/// `idxs` are indices into `group.idx_to_item`. The returned items use the original item names.\n-pub fn ranked_items_subset(group: &GroupState, idxs: &[usize], max_iters: usize, tol: f64) -> Vec<RankedItem> {\n-    if idxs.is_empty() {\n-        return vec![];\n-    }\n-\n-    // Map original idx -> compact idx [0..m)\n-    let mut map: HashMap<usize, usize> = HashMap::with_capacity(idxs.len());\n-    for (j, &i) in idxs.iter().enumerate() {\n-        map.insert(i, j);\n-    }\n-\n-    let edges_iter = group.edges.iter().filter_map(|(&(src, dst), &w)| {\n-        let s = *map.get(&src)?;\n-        let d = *map.get(&dst)?;\n-        Some(((s, d), w))\n-    });\n-\n-    let scores = compute_scores_from_edges(idxs.len(), edges_iter, max_iters, tol);\n-\n-    // Filter out entries where idx_to_item doesn't have the slot (shouldn't happen, but be safe).\n-    let mut items: Vec<RankedItem> = idxs\n-        .iter()\n-        .enumerate()\n-        .filter_map(|(j, &orig)| {\n-            let item = group.idx_to_item.get(orig)?.clone();\n-            Some(RankedItem { item, score: *scores.get(j).unwrap_or(&0.0) })\n-        })\n-        .collect();\n-\n-    items.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));\n-    items\n-}\n-\n-pub fn group_summary_scores(\n-    group: &mut GroupState,\n-    max_iters: usize,\n-    tol: f64,\n-) -> HashMap<ItemId, f64> {\n-    ranked_items(group, max_iters, tol)\n-        .into_iter()\n-        .map(|r| (r.item, r.score))\n-        .collect()\n-}\n-\n-#[cfg(test)]\n-mod tests {\n-    use super::*;\n-    use crate::reducer::VoteData;\n-\n-    fn mk_group() -> GroupState {\n-        GroupState::new()\n-    }\n-\n-    fn vote(ts: i64, a: &str, b: &str, l: i32, r: i32) -> VoteData {\n-        use crate::path_types::ItemId;\n-        VoteData {\n-            ts,\n-            a: ItemId::parse(a).unwrap(),\n-            b: ItemId::parse(b).unwrap(),\n-            ratio_left: l,\n-            ratio_right: r,\n-            body: \"because\".to_string(),\n-            principal: \"test\".to_string(),\n-            delegate: Some(\"00000000-0000-0000-0000-000000000000:test:local/test\".to_string()),\n-            thread_tag: \"untagged\".to_string(),\n-        }\n-    }\n-\n-    /// Regression for issue #146: pure forward star at default `>` ratio (2:1).\n-    /// Under the old (sum-of-weights) divisor every node had P_ii = 0 and the\n-    /// chain was bipartite; power iteration oscillated and returned the\n-    /// uniform initial distribution after an even number of steps. Using the\n-    /// paper's degree-based d_max gives every node a positive self-loop and\n-    /// the chain converges to the correct stationary distribution.\n-    #[test]\n-    fn star_topology_winner_at_top_via_subset() {\n-        let mut g = mk_group();\n-        g.apply_vote(vote(1, \"zebra\", \"alpha\", 2, 1));\n-        g.apply_vote(vote(2, \"zebra\", \"beta\", 2, 1));\n-\n-        let mut items: Vec<(usize, String)> = g\n-            .idx_to_item\n-            .iter()\n-            .enumerate()\n-            .map(|(i, it)| (i, it.as_str().to_string()))\n-            .collect();\n-        items.sort_by(|a, b| a.1.cmp(&b.1));\n-        let idxs: Vec<usize> = items.iter().map(|(i, _)| *i).collect();\n-\n-        let ranked = ranked_items_subset(&g, &idxs, 10000, 1e-8);\n-        for r in &ranked {\n-            eprintln!(\"{}: {}\", r.item.as_str(), r.score);\n-        }\n-        assert_eq!(\n-            ranked[0].item.as_str(),\n-            \"https://slug.social/zebra\",\n-            \"zebra won both votes and should rank #1\"\n-        );\n-    }\n-\n-    #[test]\n-    fn group_ranking_cache_dirty_flow() {\n-        let mut g = mk_group();\n-        assert!(g.dirty);\n-\n-        g.apply_vote(vote(1, \"a\", \"b\", 3, 1));\n-        assert!(g.dirty);\n-        assert!(g.cached_scores.is_empty());\n-\n-        compute_group_ranking(&mut g, 10000, 1e-8);\n-        assert!(!g.dirty);\n-        assert_eq!(g.cached_scores.len(), g.idx_to_item.len());\n-\n-        // Recomputing when not dirty should be a no-op.\n-        let before = g.cached_scores.clone();\n-        compute_group_ranking(&mut g, 10000, 1e-8);\n-        assert_eq!(before, g.cached_scores);\n-    }\n-\n-    #[test]\n-    fn connected_components_split_disconnected_pairs() {\n-        let mut g = mk_group();\n-        // Two disconnected edges: (a,b) and (c,d)\n-        g.apply_vote(vote(1, \"a\", \"b\", 3, 1));\n-        g.apply_vote(vote(2, \"c\", \"d\", 3, 1));\n-\n-        let n = g.idx_to_item.len();\n-        let (mut comps, isolates) =\n-            connected_components_from_voted_pairs(n, g.voted_pairs.iter().copied());\n-        assert!(isolates.is_empty());\n-        // Order-independent: sort components by their item names for stable assert.\n-        comps.sort_by_key(|c| {\n-            c.iter()\n-                .map(|&i| g.idx_to_item[i].clone())\n-                .collect::<Vec<_>>()\n-        });\n-        assert_eq!(comps.len(), 2);\n-        let comp0 = comps[0]\n-            .iter()\n-            .map(|&i| g.idx_to_item[i].as_str())\n-            .collect::<Vec<_>>();\n-        let comp1 = comps[1]\n-            .iter()\n-            .map(|&i| g.idx_to_item[i].as_str())\n-            .collect::<Vec<_>>();\n-        assert_eq!(comp0, vec![\"https://slug.social/a\", \"https://slug.social/b\"]);\n-        assert_eq!(comp1, vec![\"https://slug.social/c\", \"https://slug.social/d\"]);\n-    }\n-\n-    #[test]\n-    fn subset_ranking_ranks_within_component_only() {\n-        let mut g = mk_group();\n-        g.apply_vote(vote(1, \"a\", \"b\", 3, 1)); // a > b\n-        g.apply_vote(vote(2, \"c\", \"d\", 1, 4)); // d > c\n-\n-        let (comps, _) =\n-            connected_components_from_voted_pairs(g.idx_to_item.len(), g.voted_pairs.iter().copied());\n-        assert_eq!(comps.len(), 2);\n-\n-        // Rank each component and ensure winner is first within that component.\n-        for comp in comps {\n-            let ranked = ranked_items_subset(&g, &comp, 10000, 1e-8);\n-            assert_eq!(ranked.len(), 2);\n-            let names = ranked.iter().map(|r| r.item.as_str()).collect::<Vec<_>>();\n-            if names.contains(&\"https://slug.social/a\") {\n-                assert_eq!(names[0], \"https://slug.social/a\");\n-            } else {\n-                assert_eq!(names[0], \"https://slug.social/d\");\n-            }\n-        }\n-    }\n-}\n-\n-\n-tommy@Tommys-Laptop:~/programming/slug-star/slug|main ⇒  \n-\ndiff --git a/legacy/reddit.rs b/legacy/reddit.rs\ndeleted file mode 100644\nindex da27f6f76482dd27d44cad9d7b844972bf042e64..0000000000000000000000000000000000000000\n--- a/legacy/reddit.rs\n+++ /dev/null\n@@ -1,420 +0,0 @@\n-use governor::{Quota, RateLimiter, Jitter};\n-use nonzero_ext::nonzero;\n-use reqwest::{Client, StatusCode};\n-use serde::{Deserialize, Serialize};\n-use std::sync::Arc;\n-use std::time::Duration;\n-use anyhow::{Result, Context, anyhow};\n-\n-/// Reddit API client with built-in rate limiting\n-pub struct RedditClient {\n-    client: Client,\n-    limiter: Arc<governor::DefaultDirectRateLimiter>,\n-    user_agent: String,\n-}\n-\n-impl RedditClient {\n-    /// Create a new Reddit client with rate limiting\n-    /// Reddit API allows 60 requests per minute for OAuth2 authenticated apps\n-    /// We'll be conservative and use 50 requests per minute\n-    pub fn new() -> Self {\n-        // Create rate limiter: 50 requests per minute\n-        let quota = Quota::per_minute(nonzero!(50u32));\n-        let limiter = Arc::new(RateLimiter::direct(quota));\n-        \n-        // Create HTTP client with timeout\n-        let client = Client::builder()\n-            .timeout(Duration::from_secs(30))\n-            .build()\n-            .expect(\"Failed to create HTTP client\");\n-        \n-        // Reddit requires a unique user agent\n-        let user_agent = format!(\n-            \"rust:sorter:v{} (by /u/hourLong_arnould)\",\n-            env!(\"CARGO_PKG_VERSION\")\n-        );\n-        \n-        Self {\n-            client,\n-            limiter,\n-            user_agent,\n-        }\n-    }\n-    \n-    /// Fetch hot posts from a subreddit\n-    pub async fn get_subreddit_hot(&self, subreddit: &str, limit: usize) -> Result<RedditListingResponse> {\n-        // Wait for rate limiter\n-        self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;\n-        \n-        let url = format!(\"https://www.reddit.com/r/{}/hot.json?limit={}\", subreddit, limit);\n-        \n-        let response = self.client\n-            .get(&url)\n-            .header(\"User-Agent\", &self.user_agent)\n-            .send()\n-            .await\n-            .context(\"Failed to send request to Reddit\")?;\n-        \n-        self.handle_response(response).await\n-    }\n-    \n-    /// Fetch top posts from a subreddit\n-    pub async fn get_subreddit_top(&self, subreddit: &str, limit: usize, time_period: &str) -> Result<RedditListingResponse> {\n-        self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;\n-        \n-        let url = format!(\n-            \"https://www.reddit.com/r/{}/top.json?limit={}&t={}\",\n-            subreddit, limit, time_period\n-        );\n-        \n-        let response = self.client\n-            .get(&url)\n-            .header(\"User-Agent\", &self.user_agent)\n-            .send()\n-            .await\n-            .context(\"Failed to send request to Reddit\")?;\n-        \n-        self.handle_response(response).await\n-    }\n-    \n-    /// Fetch new posts from a subreddit\n-    pub async fn get_subreddit_new(&self, subreddit: &str, limit: usize) -> Result<RedditListingResponse> {\n-        self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;\n-        \n-        let url = format!(\"https://www.reddit.com/r/{}/new.json?limit={}\", subreddit, limit);\n-        \n-        let response = self.client\n-            .get(&url)\n-            .header(\"User-Agent\", &self.user_agent)\n-            .send()\n-            .await\n-            .context(\"Failed to send request to Reddit\")?;\n-        \n-        self.handle_response(response).await\n-    }\n-    \n-    /// Fetch a specific post and its comments\n-    pub async fn get_post(&self, subreddit: &str, post_id: &str) -> Result<Vec<RedditListingResponse>> {\n-        self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;\n-        \n-        let url = format!(\n-            \"https://www.reddit.com/r/{}/comments/{}.json\",\n-            subreddit, post_id\n-        );\n-        \n-        let response = self.client\n-            .get(&url)\n-            .header(\"User-Agent\", &self.user_agent)\n-            .send()\n-            .await\n-            .context(\"Failed to send request to Reddit\")?;\n-        \n-        match response.status() {\n-            StatusCode::OK => {\n-                let listings: Vec<RedditListingResponse> = response\n-                    .json()\n-                    .await\n-                    .context(\"Failed to parse Reddit response\")?;\n-                Ok(listings)\n-            }\n-            StatusCode::TOO_MANY_REQUESTS => {\n-                Err(anyhow!(\"Reddit rate limit exceeded. Please try again later.\"))\n-            }\n-            StatusCode::NOT_FOUND => {\n-                Err(anyhow!(\"Post not found: r/{}/comments/{}\", subreddit, post_id))\n-            }\n-            status => {\n-                Err(anyhow!(\"Reddit API error: {}\", status))\n-            }\n-        }\n-    }\n-    \n-    /// Fetch user profile (posts and comments)\n-    pub async fn get_user_profile(&self, username: &str, content_type: &str, limit: usize) -> Result<RedditListingResponse> {\n-        self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;\n-        \n-        let url = format!(\n-            \"https://www.reddit.com/user/{}/{}.json?limit={}\",\n-            username, content_type, limit\n-        );\n-        \n-        let response = self.client\n-            .get(&url)\n-            .header(\"User-Agent\", &self.user_agent)\n-            .send()\n-            .await\n-            .context(\"Failed to send request to Reddit\")?;\n-        \n-        self.handle_response(response).await\n-    }\n-    \n-    /// Handle Reddit API response with proper error checking\n-    async fn handle_response(&self, response: reqwest::Response) -> Result<RedditListingResponse> {\n-        match response.status() {\n-            StatusCode::OK => {\n-                let listing: RedditListingResponse = response\n-                    .json()\n-                    .await\n-                    .context(\"Failed to parse Reddit response\")?;\n-                Ok(listing)\n-            }\n-            StatusCode::TOO_MANY_REQUESTS => {\n-                Err(anyhow!(\"Reddit rate limit exceeded. Please try again later.\"))\n-            }\n-            StatusCode::NOT_FOUND => {\n-                Err(anyhow!(\"Reddit resource not found\"))\n-            }\n-            StatusCode::FORBIDDEN => {\n-                Err(anyhow!(\"Access forbidden. The subreddit may be private.\"))\n-            }\n-            status => {\n-                Err(anyhow!(\"Reddit API error: {}\", status))\n-            }\n-        }\n-    }\n-}\n-\n-// Reddit API response types\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-pub struct RedditListingResponse {\n-    pub kind: String,\n-    pub data: RedditListingData,\n-}\n-\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-pub struct RedditListingData {\n-    #[serde(skip_serializing_if = \"Option::is_none\")]\n-    pub after: Option<String>,\n-    #[serde(skip_serializing_if = \"Option::is_none\")]\n-    pub before: Option<String>,\n-    pub children: Vec<RedditThing>,\n-    #[serde(skip_serializing_if = \"Option::is_none\")]\n-    pub modhash: Option<String>,\n-}\n-\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-pub struct RedditThing {\n-    pub kind: String,\n-    pub data: RedditThingData,\n-}\n-\n-/// Reddit's \"Thing\" data can be either a post, comment, or other types\n-/// We use untagged enum to handle different data structures\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-#[serde(untagged)]\n-pub enum RedditThingData {\n-    Post(RedditPost),\n-    Comment(RedditComment),\n-    // For things we don't care about yet (like \"more\" comments)\n-    Other(serde_json::Value),\n-}\n-\n-/// Reddit post data with serde handling all the parsing\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-pub struct RedditPost {\n-    pub id: String,\n-    pub name: String, // Full name (t3_xxx)\n-    #[serde(default = \"default_untitled\")]\n-    pub title: String,\n-    #[serde(default = \"default_deleted_user\")]\n-    pub author: String,\n-    pub subreddit: String,\n-    #[serde(default)]\n-    pub url: String,\n-    #[serde(default)]\n-    pub permalink: String,\n-    #[serde(default, deserialize_with = \"deserialize_selftext\")]\n-    pub selftext: Option<String>,\n-    #[serde(default)]\n-    pub score: i64,\n-    #[serde(default)]\n-    pub num_comments: i64,\n-    #[serde(default)]\n-    pub created_utc: f64,\n-    #[serde(default, deserialize_with = \"deserialize_thumbnail\")]\n-    pub thumbnail: Option<String>,\n-    #[serde(default)]\n-    pub is_video: bool,\n-    #[serde(default)]\n-    pub is_self: bool,\n-    // Additional useful fields\n-    #[serde(default)]\n-    pub ups: i64,\n-    #[serde(default)]\n-    pub downs: i64,\n-    #[serde(default)]\n-    pub upvote_ratio: f64,\n-    #[serde(default)]\n-    pub over_18: bool,\n-    #[serde(default)]\n-    pub spoiler: bool,\n-    #[serde(default)]\n-    pub stickied: bool,\n-    #[serde(default)]\n-    pub locked: bool,\n-    #[serde(default)]\n-    pub distinguished: Option<String>,\n-}\n-\n-/// Reddit comment data\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-pub struct RedditComment {\n-    pub id: String,\n-    pub name: String, // Full name (t1_xxx)\n-    #[serde(default = \"default_deleted_user\")]\n-    pub author: String,\n-    #[serde(default)]\n-    pub body: String,\n-    #[serde(default)]\n-    pub score: i64,\n-    #[serde(default)]\n-    pub created_utc: f64,\n-    #[serde(default)]\n-    pub parent_id: String,\n-    #[serde(default)]\n-    pub permalink: String,\n-    #[serde(default)]\n-    pub depth: i32,\n-    // Additional useful fields\n-    #[serde(default)]\n-    pub ups: i64,\n-    #[serde(default)]\n-    pub downs: i64,\n-    #[serde(default)]\n-    pub edited: RedditEditStatus,\n-    #[serde(default)]\n-    pub stickied: bool,\n-    #[serde(default)]\n-    pub distinguished: Option<String>,\n-    #[serde(default)]\n-    pub is_submitter: bool,\n-    #[serde(default)]\n-    pub collapsed: bool,\n-    #[serde(default)]\n-    pub controversiality: i32,\n-}\n-\n-/// Reddit's edit status - can be false or a timestamp\n-#[derive(Debug, Clone, Serialize, Deserialize)]\n-#[serde(untagged)]\n-pub enum RedditEditStatus {\n-    NotEdited(bool),\n-    EditedAt(f64),\n-}\n-\n-impl Default for RedditEditStatus {\n-    fn default() -> Self {\n-        RedditEditStatus::NotEdited(false)\n-    }\n-}\n-\n-// Helper functions for serde defaults\n-fn default_untitled() -> String {\n-    \"Untitled\".to_string()\n-}\n-\n-fn default_deleted_user() -> String {\n-    \"[deleted]\".to_string()\n-}\n-\n-// Custom deserializer for selftext (empty strings should be None)\n-fn deserialize_selftext<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>\n-where\n-    D: serde::Deserializer<'de>,\n-{\n-    let s: Option<String> = Option::deserialize(deserializer)?;\n-    Ok(s.filter(|text| !text.is_empty()))\n-}\n-\n-// Custom deserializer for thumbnail (filter out \"self\", \"default\", empty)\n-fn deserialize_thumbnail<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>\n-where\n-    D: serde::Deserializer<'de>,\n-{\n-    let s: Option<String> = Option::deserialize(deserializer)?;\n-    Ok(s.filter(|thumb| {\n-        !thumb.is_empty() && thumb != \"self\" && thumb != \"default\" && thumb != \"nsfw\" && thumb != \"spoiler\"\n-    }))\n-}\n-\n-// Helper methods for extracting typed data from Things\n-impl RedditThing {\n-    /// Try to get this Thing as a Post\n-    pub fn as_post(&self) -> Option<&RedditPost> {\n-        if self.kind != \"t3\" {\n-            return None;\n-        }\n-        match &self.data {\n-            RedditThingData::Post(post) => Some(post),\n-            _ => None,\n-        }\n-    }\n-    \n-    /// Try to get this Thing as a Comment\n-    pub fn as_comment(&self) -> Option<&RedditComment> {\n-        if self.kind != \"t1\" {\n-            return None;\n-        }\n-        match &self.data {\n-            RedditThingData::Comment(comment) => Some(comment),\n-            _ => None,\n-        }\n-    }\n-    \n-    /// Check if this is a \"more comments\" indicator\n-    pub fn is_more_comments(&self) -> bool {\n-        self.kind == \"more\"\n-    }\n-}\n-\n-// Helper methods for working with listing responses\n-impl RedditListingResponse {\n-    /// Extract all posts from this listing\n-    pub fn get_posts(&self) -> Vec<&RedditPost> {\n-        self.data.children.iter()\n-            .filter_map(|thing| thing.as_post())\n-            .collect()\n-    }\n-    \n-    /// Extract all comments from this listing\n-    pub fn get_comments(&self) -> Vec<&RedditComment> {\n-        self.data.children.iter()\n-            .filter_map(|thing| thing.as_comment())\n-            .collect()\n-    }\n-    \n-    /// Extract posts as owned values\n-    pub fn into_posts(self) -> Vec<RedditPost> {\n-        self.data.children.into_iter()\n-            .filter_map(|thing| {\n-                if thing.kind == \"t3\" {\n-                    match thing.data {\n-                        RedditThingData::Post(post) => Some(post),\n-                        _ => None,\n-                    }\n-                } else {\n-                    None\n-                }\n-            })\n-            .collect()\n-    }\n-    \n-    /// Extract comments as owned values\n-    pub fn into_comments(self) -> Vec<RedditComment> {\n-        self.data.children.into_iter()\n-            .filter_map(|thing| {\n-                if thing.kind == \"t1\" {\n-                    match thing.data {\n-                        RedditThingData::Comment(comment) => Some(comment),\n-                        _ => None,\n-                    }\n-                } else {\n-                    None\n-                }\n-            })\n-            .collect()\n-    }\n-}\n-\n-\n-\ndiff --git a/legacy/reducer.rs b/legacy/reducer.rs\ndeleted file mode 100644\nindex 1ba8030feaf783b066b2e0bba4d2d05659c992f4..0000000000000000000000000000000000000000\n--- a/legacy/reducer.rs\n+++ /dev/null\n@@ -1,845 +0,0 @@\n-use std::collections::{HashMap, HashSet, VecDeque};\n-\n-use serde::{Deserialize, Serialize};\n-\n-use crate::canonical_path::canonicalize_tag;\n-use crate::dsl;\n-use crate::events::{Event, Ingest, ThreadCapability};\n-use crate::path_types::ItemId;\n-\n-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\n-pub enum ScopeId {\n-    Public,\n-    Room(String),\n-}\n-\n-/// Wire `room` field → content scope (`\"public\"` → [`ScopeId::Public`]).\n-pub fn scope_from_room_wire(room: &str) -> ScopeId {\n-    let r = room.trim();\n-    if r.is_empty() || r == \"public\" {\n-        ScopeId::Public\n-    } else {\n-        ScopeId::Room(r.to_string())\n-    }\n-}\n-\n-/// Parsed vote data (internal representation).\n-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\n-pub struct VoteData {\n-    pub ts: i64,\n-    pub a: ItemId,\n-    pub b: ItemId,\n-    pub ratio_left: i32,\n-    pub ratio_right: i32,\n-    pub body: String,\n-    pub principal: String,\n-    pub delegate: Option<String>,\n-    /// Forum channel where this vote was cast (tag only, not room id).\n-    pub thread_tag: String,\n-}\n-\n-#[derive(Debug, Clone)]\n-pub struct GroupState {\n-    pub item_to_idx: HashMap<ItemId, usize>,\n-    pub idx_to_item: Vec<ItemId>,\n-\n-    /// Aggregated directed edge weights: (src_idx, dst_idx) -> weight.\n-    pub edges: HashMap<(usize, usize), f64>,\n-\n-    /// Unordered pairs that have at least one vote recorded between them (i<j).\n-    pub voted_pairs: HashSet<(usize, usize)>,\n-    pub dirty: bool,\n-    pub cached_scores: Vec<f64>,\n-    pub recent_votes: VecDeque<VoteData>,\n-}\n-\n-impl Default for GroupState {\n-    fn default() -> Self {\n-        Self::new()\n-    }\n-}\n-\n-impl GroupState {\n-    pub fn new() -> Self {\n-        Self {\n-            item_to_idx: HashMap::new(),\n-            idx_to_item: Vec::new(),\n-            edges: HashMap::new(),\n-            voted_pairs: HashSet::new(),\n-            dirty: true,\n-            cached_scores: Vec::new(),\n-            recent_votes: VecDeque::with_capacity(200),\n-        }\n-    }\n-\n-    fn ensure_item(&mut self, item: &ItemId) -> usize {\n-        if let Some(&idx) = self.item_to_idx.get(item) {\n-            return idx;\n-        }\n-        let idx = self.idx_to_item.len();\n-        self.idx_to_item.push(item.clone());\n-        self.item_to_idx.insert(item.clone(), idx);\n-        self.dirty = true;\n-        idx\n-    }\n-\n-    /// Public test helper: insert an item into the group without a vote (for unit tests).\n-    pub fn ensure_item_pub(&mut self, item: &str) -> usize {\n-        if let Some(canon) = ItemId::parse(item) {\n-            self.ensure_item(&canon)\n-        } else {\n-            // Fallback: treat as raw storage string\n-            let canon = ItemId::opaque(item.to_string());\n-            self.ensure_item(&canon)\n-        }\n-    }\n-\n-    fn add_edge_weight(&mut self, src: usize, dst: usize, w: f64) {\n-        if w <= 0.0 {\n-            return;\n-        }\n-        *self.edges.entry((src, dst)).or_insert(0.0) += w;\n-        self.dirty = true;\n-    }\n-\n-    pub fn apply_vote(&mut self, mut vote: VoteData) {\n-        vote.a = ItemId::parse(vote.a.as_str()).unwrap_or_else(|| vote.a.clone());\n-        vote.b = ItemId::parse(vote.b.as_str()).unwrap_or_else(|| vote.b.clone());\n-        vote.thread_tag = canonicalize_tag(&vote.thread_tag);\n-        if vote.ratio_left < 0 {\n-            vote.ratio_left = 0;\n-        }\n-        if vote.ratio_right < 0 {\n-            vote.ratio_right = 0;\n-        }\n-        let a_idx = self.ensure_item(&vote.a);\n-        let b_idx = self.ensure_item(&vote.b);\n-\n-        let (i, j) = if a_idx < b_idx { (a_idx, b_idx) } else { (b_idx, a_idx) };\n-        self.voted_pairs.insert((i, j));\n-\n-        let w_a = vote.ratio_left as f64;\n-        let w_b = vote.ratio_right as f64;\n-\n-        self.add_edge_weight(b_idx, a_idx, w_a);\n-        self.add_edge_weight(a_idx, b_idx, w_b);\n-\n-        self.recent_votes.push_front(vote);\n-        while self.recent_votes.len() > 200 {\n-            self.recent_votes.pop_back();\n-        }\n-    }\n-}\n-\n-/// Compact rank-history entry stored per item in the ledger.\n-/// `caused_by` is resolved lazily at query time from `ingests_by_id`.\n-#[derive(Debug, Clone)]\n-pub struct RankHistoryEntry {\n-    pub ts: i64,\n-    pub scope_rank: usize,\n-    pub scope_rank_delta: i32,\n-    pub scope_total: usize,\n-    pub global_rank: usize,\n-    pub global_rank_delta: i32,\n-    pub global_total: usize,\n-    pub score: f64,\n-    pub thread: String,\n-    pub post_id: String,\n-}\n-\n-/// Invite link materialized from log events [`crate::events::InviteMinted`] /\n-/// [`crate::events::InviteRedeemed`] when those are replayed.\n-///\n-/// **`RoomMintInvite` today** stores tokens only in [`crate::state::AppState::invites`] (RAM);\n-/// they are not appended to the JSONL log, so they disappear on restart. This struct is for\n-/// replay and any future persisted-mint path, not for the current ephemeral RPC mint.\n-#[derive(Debug, Clone)]\n-pub struct ActiveInviteState {\n-    pub room_id: String,\n-    pub capabilities: HashSet<ThreadCapability>,\n-    pub inviter: String,\n-    pub uses_remaining: u32,\n-    pub expires_ts_ms: Option<i64>,\n-}\n-\n-#[derive(Clone, Debug)]\n-pub enum RoomTimelineKind {\n-    RoomCreated {\n-        owner: String,\n-        slug: String,\n-    },\n-    RoomDeleted {\n-        deleted_by: String,\n-    },\n-    GrantAdded {\n-        username: String,\n-        granted_by: String,\n-        capabilities: Vec<ThreadCapability>,\n-    },\n-    GrantRevoked {\n-        username: String,\n-        revoked_by: String,\n-        capabilities: Vec<ThreadCapability>,\n-    },\n-}\n-\n-#[derive(Clone, Debug)]\n-pub struct RoomTimelineEntry {\n-    pub ts: i64,\n-    pub kind: RoomTimelineKind,\n-}\n-\n-#[derive(Debug, Clone)]\n-#[derive(Default)]\n-pub struct ForumThreadState {\n-    pub last_activity_ts: i64,\n-    /// Username of the most recent person who bumped this thread.\n-    pub last_actor: String,\n-}\n-\n-\n-#[derive(Debug, Clone, Default)]\n-pub struct ContentState {\n-    pub ranking_group: GroupState,\n-    pub items: HashSet<ItemId>,\n-    pub item_bodies: HashMap<ItemId, String>,\n-    /// Parent [`ItemId`] -> direct children.\n-    pub item_children: HashMap<ItemId, HashSet<ItemId>>,\n-    /// Per-item vote history (most recent first).\n-    pub item_votes: HashMap<ItemId, VecDeque<VoteData>>,\n-    /// Per-item ingest references (most recent first).\n-    pub item_snippets: HashMap<ItemId, VecDeque<String>>,\n-    /// Item path -> threads that mention or vote on this item.\n-    pub item_threads: HashMap<ItemId, HashSet<String>>,\n-    /// Per-item rank history, oldest first.\n-    pub rank_history: HashMap<ItemId, Vec<RankHistoryEntry>>,\n-}\n-\n-#[derive(Debug, Clone)]\n-pub struct ReducerState {\n-    pub content: HashMap<ScopeId, ContentState>,\n-\n-    /// (provider, provider_id) -> username\n-    pub users_by_provider: HashMap<(String, String), String>,\n-    /// token_id -> (username, salt, token_hash)\n-    pub tokens_by_id: HashMap<String, (String, String, String)>,\n-    pub agent_bindings: HashMap<String, String>,\n-\n-\n-    pub ingests_by_id: HashMap<String, Ingest>,\n-    /// (scope, thread_tag) → ingest ids, newest first.\n-    pub ingests_by_scope_thread: HashMap<(ScopeId, String), VecDeque<String>>,\n-    /// Private room ids (`shortid/slug`) known from [`RoomCreated`].\n-    pub rooms: HashSet<String>,\n-    /// (scope, thread_tag) → last activity.\n-    pub forum_threads: HashMap<(ScopeId, String), ForumThreadState>,\n-    pub actor_last_post_ts: HashMap<String, i64>,\n-\n-    /// All ingest IDs in chronological order (oldest first). Used by the feed endpoint.\n-    pub ingests_ordered: Vec<String>,\n-    /// Username → ingest ids in post order (oldest first), for profile pages.\n-    pub posts_by_actor: HashMap<String, VecDeque<String>>,\n-    /// Ingest ids removed by author redaction (content and thread body omitted; tombstone in UI).\n-    pub redacted_posts: HashSet<String>,\n-    /// Redaction event timestamp (ms) per post id.\n-    pub post_redact_ts: HashMap<String, i64>,\n-    /// room_id → username → capabilities\n-    pub grants: HashMap<String, HashMap<String, HashSet<ThreadCapability>>>,\n-    /// room_id → chronological room admin lines (for thread UI).\n-    pub room_timeline: HashMap<String, Vec<RoomTimelineEntry>>,\n-    /// Invite token → active invite (absent when fully consumed or never minted).\n-    pub invites: HashMap<String, ActiveInviteState>,\n-}\n-\n-impl ReducerState {\n-    pub fn content_for_scope(&self, scope: &ScopeId) -> Option<&ContentState> {\n-        self.content.get(scope)\n-    }\n-\n-    /// 0-based chronological index of `post_id` in `(scope, thread_tag)` (forum routes `/t/tag/N`).\n-    pub fn try_thread_post_index_chronological(\n-        &self,\n-        scope: &ScopeId,\n-        thread_tag: &str,\n-        post_id: &str,\n-    ) -> Option<usize> {\n-        let tag = canonicalize_tag(thread_tag);\n-        self.ingests_by_scope_thread\n-            .get(&(scope.clone(), tag))\n-            .and_then(|q| q.iter().rev().position(|pid| pid == post_id))\n-    }\n-\n-    pub fn thread_post_index_chronological(\n-        &self,\n-        scope: &ScopeId,\n-        thread_tag: &str,\n-        post_id: &str,\n-    ) -> usize {\n-        self.try_thread_post_index_chronological(scope, thread_tag, post_id)\n-            .expect(\n-                \"post_id must appear in ingests_by_scope_thread for this scope and thread\",\n-            )\n-    }\n-\n-    /// Ingest ids authored by `actor`, oldest first. Unfiltered; use with access checks per ingest.\n-    pub fn posts_by_actor_ids(&self, actor: &str) -> Vec<String> {\n-        self.posts_by_actor\n-            .get(actor)\n-            .map(|q| q.iter().cloned().collect())\n-            .unwrap_or_default()\n-    }\n-\n-    /// Same order as [`Self::posts_by_actor_ids`], omitting ingests in scopes the viewer cannot see.\n-    pub fn visible_posts_for_actor(&self, actor: &str, viewer: Option<&str>) -> Vec<String> {\n-        self.posts_by_actor_ids(actor)\n-            .into_iter()\n-            .filter(|id| {\n-                !self.redacted_posts.contains(id)\n-                    && self.ingests_by_id.get(id).is_some_and(|ing| {\n-                        let scope = scope_from_room_wire(&ing.room_id);\n-                        match &scope {\n-                            ScopeId::Public => true,\n-                            ScopeId::Room(rid) => {\n-                                viewer.is_some_and(|u| self.user_has_cap(rid, u, ThreadCapability::View))\n-                            }\n-                        }\n-                    })\n-            })\n-            .collect()\n-    }\n-\n-    pub fn user_has_cap(&self, room_id: &str, username: &str, cap: ThreadCapability) -> bool {\n-        self.grants\n-            .get(room_id)\n-            .and_then(|t| t.get(username))\n-            .map(|caps| caps.contains(&cap))\n-            .unwrap_or(false)\n-    }\n-\n-    /// Invite link is present, not expired, and has uses left.\n-    pub fn invite_token_active(&self, token: &str, now_ms: i64) -> Option<&ActiveInviteState> {\n-        let inv = self.invites.get(token)?;\n-        if inv.uses_remaining == 0 {\n-            return None;\n-        }\n-        if let Some(exp) = inv.expires_ts_ms {\n-            if now_ms > exp {\n-                return None;\n-            }\n-        }\n-        Some(inv)\n-    }\n-\n-    pub fn content_for_scope_mut(&mut self, scope: ScopeId) -> &mut ContentState {\n-        self.content.entry(scope).or_default()\n-    }\n-\n-    pub fn public(&self) -> &ContentState {\n-        self.content.get(&ScopeId::Public).expect(\"public scope missing\")\n-    }\n-\n-    /// Register parent→child edges for the full ancestor chain.\n-    /// For `a/b/c/d` this creates: `a/b/c→d`, `a/b→a/b/c`, `a→a/b`, `\"\"→a`.\n-    /// Stops early when an intermediate is already registered (its ancestors must be too).\n-    /// @e2bdefa9-a6fa-4725-b0a2-c0b09d95bb20:claudecode:anthropic/claude-opus-4\n-    fn add_child_edge(content: &mut ContentState, item: &ItemId) {\n-        let mut child = item.clone();\n-        loop {\n-            let Some(parent) = child.parent() else { break };\n-            let is_new = content\n-                .item_children\n-                .entry(parent.clone())\n-                .or_default()\n-                .insert(child);\n-            if !is_new { break; }\n-            child = parent;\n-        }\n-    }\n-\n-    /// Resolve an item path as a first-class [`ItemId`].\n-    fn normalize_item(item: &str) -> Option<ItemId> {\n-        ItemId::parse(item)\n-    }\n-\n-    /// 1-indexed rank of `item` within its connected component in the parent scope.\n-    /// 0 if the item has no votes connecting it to siblings (unranked).\n-    fn scope_rank_of(\n-        group: &GroupState,\n-        item: &ItemId,\n-        item_children: &HashMap<ItemId, HashSet<ItemId>>,\n-    ) -> usize {\n-        let scope = match item.parent() {\n-            Some(p) => p,\n-            None => return 0,\n-        };\n-        let children = match item_children.get(&scope) {\n-            None => return 0,\n-            Some(c) => c,\n-        };\n-        let &item_global_idx = match group.item_to_idx.get(item) {\n-            None => return 0,\n-            Some(i) => i,\n-        };\n-        // Map scope children to compact local indices.\n-        let sibling_idxs: Vec<usize> = children.iter()\n-            .filter_map(|c| group.item_to_idx.get(c).copied())\n-            .collect();\n-        let global_to_local: HashMap<usize, usize> = sibling_idxs.iter()\n-            .enumerate().map(|(l, &g)| (g, l)).collect();\n-        let item_local = match global_to_local.get(&item_global_idx) {\n-            None => return 0,\n-            Some(&l) => l,\n-        };\n-        // Connected components within scope.\n-        let (comps, _) = crate::ranking::connected_components_from_voted_pairs(\n-            sibling_idxs.len(),\n-            group.voted_pairs.iter().filter_map(|(a, b)| {\n-                Some((global_to_local.get(a).copied()?, global_to_local.get(b).copied()?))\n-            }),\n-        );\n-        // Find the component containing this item.\n-        let comp_local = match comps.iter().find(|c| c.contains(&item_local)) {\n-            None => return 0,\n-            Some(c) => c,\n-        };\n-        let comp_global: Vec<usize> = comp_local.iter()\n-            .filter_map(|&l| sibling_idxs.get(l).copied())\n-            .collect();\n-        let ranked = crate::ranking::ranked_items_subset(group, &comp_global, 10000, 1e-8);\n-        ranked.iter().position(|r| &r.item == item).map(|i| i + 1).unwrap_or(0)\n-    }\n-\n-    /// 1-indexed position of `item` in the component-aware global flat list.\n-    /// Components sorted largest-first; items ranked within each component.\n-    /// 0 if the item is not in the ranking group.\n-    fn global_rank_of(group: &GroupState, item: &ItemId) -> usize {\n-        if !group.item_to_idx.contains_key(item) {\n-            return 0;\n-        }\n-        let n = group.idx_to_item.len();\n-        let (mut comps, _) = crate::ranking::connected_components_from_voted_pairs(\n-            n, group.voted_pairs.iter().copied(),\n-        );\n-        comps.sort_by_key(|b| std::cmp::Reverse(b.len()));\n-        let mut pos = 1usize;\n-        for comp in &comps {\n-            let ranked = crate::ranking::ranked_items_subset(group, comp, 10000, 1e-8);\n-            for r in &ranked {\n-                if &r.item == item {\n-                    return pos;\n-                }\n-                pos += 1;\n-            }\n-        }\n-        0\n-    }\n-\n-    /// Apply one ingest's DSL effects to `content` (votes, items, snippets, rank history).\n-    fn apply_ingest_to_content(content: &mut ContentState, ing: &Ingest) -> Result<(), ()> {\n-        let doc = dsl::parse_full(&ing.raw).map_err(|_| ())?;\n-        let canonical_thread = canonicalize_tag(&ing.thread_tag);\n-\n-        let voted_items: Vec<ItemId> = doc\n-            .statements\n-            .iter()\n-            .filter_map(|s| {\n-                if let dsl::Stmt::Vote { item1, item2, .. } = s {\n-                    Some([item1, item2])\n-                } else {\n-                    None\n-                }\n-            })\n-            .flat_map(|pair| pair.into_iter())\n-            .filter_map(|raw| Self::normalize_item(raw))\n-            .collect::<HashSet<_>>()\n-            .into_iter()\n-            .collect();\n-\n-        let principal = ing.principal.clone();\n-        let delegate = ing.delegate.clone();\n-\n-        let before: HashMap<ItemId, (usize, usize)> = if !voted_items.is_empty() {\n-            crate::ranking::compute_group_ranking(&mut content.ranking_group, 10000, 1e-8);\n-            voted_items\n-                .iter()\n-                .map(|it| {\n-                    (\n-                        it.clone(),\n-                        (\n-                            Self::scope_rank_of(&content.ranking_group, it, &content.item_children),\n-                            Self::global_rank_of(&content.ranking_group, it),\n-                        ),\n-                    )\n-                })\n-                .collect()\n-        } else {\n-            HashMap::new()\n-        };\n-\n-        let mut ingest_items: HashSet<ItemId> = HashSet::new();\n-\n-        for stmt in doc.statements {\n-            match stmt {\n-                dsl::Stmt::Item { title, body } => {\n-                    let Some(item) = Self::normalize_item(&title) else {\n-                        continue;\n-                    };\n-                    nav!(content.items, set_elem(item.clone()));\n-                    ingest_items.insert(item.clone());\n-                    Self::add_child_edge(content, &item);\n-\n-                    if let Some(body_text) = body {\n-                        if !body_text.trim().is_empty() {\n-                            nav!(content.item_bodies, keypath(item.clone()), setval(body_text));\n-                        }\n-                    }\n-                }\n-                dsl::Stmt::Vote {\n-                    item1,\n-                    item2,\n-                    ratio_left,\n-                    ratio_right,\n-                    explanation,\n-                } => {\n-                    let Some(item_a) = Self::normalize_item(&item1) else {\n-                        continue;\n-                    };\n-                    let Some(item_b) = Self::normalize_item(&item2) else {\n-                        continue;\n-                    };\n-\n-                    let vote = VoteData {\n-                        ts: ing.ts,\n-                        a: item_a.clone(),\n-                        b: item_b.clone(),\n-                        ratio_left,\n-                        ratio_right,\n-                        body: explanation,\n-                        principal: principal.clone(),\n-                        delegate: delegate.clone(),\n-                        thread_tag: canonical_thread.clone(),\n-                    };\n-\n-                    ingest_items.insert(item_a.clone());\n-                    ingest_items.insert(item_b.clone());\n-\n-                    nav!(content.items, set_elem(item_a.clone()));\n-                    nav!(content.items, set_elem(item_b.clone()));\n-                    Self::add_child_edge(content, &item_a);\n-                    Self::add_child_edge(content, &item_b);\n-\n-                    content.ranking_group.apply_vote(vote.clone());\n-\n-                    for it in [&item_a, &item_b] {\n-                        nav!(content.item_votes, keypath(it.clone()), push_front(vote.clone()));\n-                    }\n-                }\n-                dsl::Stmt::Prose { .. } => {}\n-            }\n-        }\n-\n-        for item in ingest_items.iter() {\n-            nav!(content.item_snippets, keypath(item.clone()), push_front(ing.id.clone()));\n-        }\n-\n-        for item in ingest_items.iter() {\n-            nav!(\n-                content.item_threads,\n-                keypath(item.clone()),\n-                set_elem(canonical_thread.clone())\n-            );\n-        }\n-\n-        if !voted_items.is_empty() {\n-            crate::ranking::compute_group_ranking(&mut content.ranking_group, 10000, 1e-8);\n-            let thread = canonical_thread.clone();\n-            for item in &voted_items {\n-                let after_scope = Self::scope_rank_of(&content.ranking_group, item, &content.item_children);\n-                let after_global = Self::global_rank_of(&content.ranking_group, item);\n-                let score = content\n-                    .ranking_group\n-                    .item_to_idx\n-                    .get(item)\n-                    .and_then(|&i| content.ranking_group.cached_scores.get(i))\n-                    .copied()\n-                    .unwrap_or(0.0);\n-                let (before_scope, before_global) = before.get(item).copied().unwrap_or((0, 0));\n-                let prev = content.rank_history.get(item).and_then(|v| v.last());\n-                let scope_delta = if prev.is_none() {\n-                    0\n-                } else {\n-                    after_scope as i32 - before_scope as i32\n-                };\n-                let global_delta = if prev.is_none() {\n-                    0\n-                } else {\n-                    after_global as i32 - before_global as i32\n-                };\n-                let scope_total = item\n-                    .parent()\n-                    .and_then(|p| content.item_children.get(&p))\n-                    .map(|s| s.len())\n-                    .unwrap_or(0);\n-                let global_total = content.ranking_group.idx_to_item.len();\n-                content.rank_history.entry(item.clone()).or_default().push(RankHistoryEntry {\n-                    ts: ing.ts,\n-                    scope_rank: after_scope,\n-                    scope_rank_delta: scope_delta,\n-                    scope_total,\n-                    global_rank: after_global,\n-                    global_rank_delta: global_delta,\n-                    global_total,\n-                    score,\n-                    thread: thread.clone(),\n-                    post_id: ing.id.clone(),\n-                });\n-            }\n-        }\n-\n-        Ok(())\n-    }\n-\n-    fn rebuild_scope_content(&mut self, scope: ScopeId) {\n-        let mut cs = ContentState::default();\n-        for id in &self.ingests_ordered {\n-            if self.redacted_posts.contains(id) {\n-                continue;\n-            }\n-            let Some(ing) = self.ingests_by_id.get(id) else {\n-                continue;\n-            };\n-            if scope_from_room_wire(&ing.room_id) != scope {\n-                continue;\n-            }\n-            let _ = Self::apply_ingest_to_content(&mut cs, ing);\n-        }\n-        self.content.insert(scope, cs);\n-        // `ingests_by_scope_thread` is intentionally not rebuilt: tombstoned ids stay in the deque so\n-        // per-post URLs and chronological indices remain stable; only projected garden state resets.\n-    }\n-\n-    /// Drop all reducer state keyed by a private room id (forum, garden scope, invites, grants).\n-    fn purge_private_room(&mut self, room_id: &str) {\n-        let scope = ScopeId::Room(room_id.to_string());\n-        self.rooms.remove(room_id);\n-        self.grants.remove(room_id);\n-        self.room_timeline.remove(room_id);\n-        self.invites.retain(|_, inv| inv.room_id != room_id);\n-        self.content.remove(&scope);\n-        self.forum_threads.retain(|(s, _), _| s != &scope);\n-        self.ingests_by_scope_thread.retain(|(s, _), _| s != &scope);\n-\n-        let mut to_drop: Vec<String> = self\n-            .ingests_by_id\n-            .iter()\n-            .filter(|(_, ing)| ing.room_id.trim() == room_id)\n-            .map(|(id, _)| id.clone())\n-            .collect();\n-        to_drop.sort();\n-        to_drop.dedup();\n-        for id in to_drop {\n-            if let Some(ing) = self.ingests_by_id.remove(&id) {\n-                self.posts_by_actor\n-                    .entry(ing.principal)\n-                    .and_modify(|q| {\n-                        q.retain(|x| x != &id);\n-                    });\n-            }\n-            self.ingests_ordered.retain(|x| x != &id);\n-            self.redacted_posts.remove(&id);\n-            self.post_redact_ts.remove(&id);\n-        }\n-    }\n-\n-    pub fn apply_event(&mut self, event: Event) {\n-        match event {\n-            Event::UserRegistered(ur) => {\n-                self.users_by_provider.insert(\n-                    (ur.provider.to_lowercase(), ur.provider_id.clone()),\n-                    ur.username,\n-                );\n-            }\n-            Event::TokenIssued(ti) => {\n-                self.tokens_by_id.insert(\n-                    ti.token_id.clone(),\n-                    (ti.username, ti.salt.clone(), ti.token_hash.clone()),\n-                );\n-            }\n-            Event::AgentBound(ab) => {\n-                if ab.agent.is_empty() {\n-                    return;\n-                }\n-                self.agent_bindings.insert(ab.agent, ab.username);\n-            }\n-            Event::RoomCreated(rc) => {\n-                self.rooms.insert(rc.room_id.clone());\n-                self.room_timeline\n-                    .entry(rc.room_id.clone())\n-                    .or_default()\n-                    .push(RoomTimelineEntry {\n-                        ts: rc.ts,\n-                        kind: RoomTimelineKind::RoomCreated {\n-                            owner: rc.owner.clone(),\n-                            slug: rc.slug.clone(),\n-                        },\n-                    });\n-            }\n-            Event::RoomDeleted(rd) => {\n-                let room_id = rd.room_id.clone();\n-                if self.rooms.contains(&room_id) {\n-                    self.room_timeline\n-                        .entry(room_id.clone())\n-                        .or_default()\n-                        .push(RoomTimelineEntry {\n-                            ts: rd.ts,\n-                            kind: RoomTimelineKind::RoomDeleted {\n-                                deleted_by: rd.deleted_by.clone(),\n-                            },\n-                        });\n-                }\n-                self.purge_private_room(&room_id);\n-            }\n-            Event::Ingest(mut ing) => {\n-                ing.thread_tag = canonicalize_tag(&ing.thread_tag);\n-                let room_key = ing.room_id.trim().to_string();\n-                let scope = scope_from_room_wire(&room_key);\n-                let canonical_thread = ing.thread_tag.clone();\n-                let scope_thread_key = (scope.clone(), canonical_thread.clone());\n-\n-                {\n-                    let content = self.content_for_scope_mut(scope.clone());\n-                    if Self::apply_ingest_to_content(content, &ing).is_err() {\n-                        eprintln!(\n-                            \"WARNING: Skipping malformed ingest event {}: parse failed\",\n-                            ing.id\n-                        );\n-                        return;\n-                    }\n-                }\n-\n-                self.ingests_by_id.insert(ing.id.clone(), ing.clone());\n-\n-                let ft = self.forum_threads.entry(scope_thread_key.clone()).or_default();\n-                let prev_ts = ft.last_activity_ts;\n-                if ing.ts > prev_ts {\n-                    ft.last_activity_ts = ing.ts;\n-                    ft.last_actor = ing.principal.clone();\n-                }\n-\n-                nav!(self.ingests_by_scope_thread, keypath(scope_thread_key), push_front(ing.id.clone()));\n-\n-                nav!(self.ingests_ordered, push_back(ing.id.clone()));\n-\n-                nav!(self.posts_by_actor, keypath(ing.principal.clone()), push_back(ing.id.clone()));\n-\n-                nav!(self.actor_last_post_ts, keypath(ing.principal.clone()), setval(ing.ts));\n-            }\n-            Event::PostRedacted(pr) => {\n-                self.redacted_posts.insert(pr.post_id.clone());\n-                self.post_redact_ts.insert(pr.post_id.clone(), pr.ts);\n-                let Some(ing) = self.ingests_by_id.get(&pr.post_id).cloned() else {\n-                    return;\n-                };\n-                let scope = scope_from_room_wire(ing.room_id.trim());\n-                // Rebuilds garden projection only; `ingests_by_scope_thread` is left as-is — see `rebuild_scope_content`.\n-                self.rebuild_scope_content(scope);\n-            }\n-            Event::GrantAdded(ga) => {\n-                let room_id = ga.room_id.clone();\n-                let caps = self.grants\n-                    .entry(ga.room_id)\n-                    .or_default()\n-                    .entry(ga.username.clone())\n-                    .or_default();\n-                for cap in ga.capabilities.iter().copied() {\n-                    caps.insert(cap);\n-                }\n-                self.room_timeline\n-                    .entry(room_id)\n-                    .or_default()\n-                    .push(RoomTimelineEntry {\n-                        ts: ga.ts,\n-                        kind: RoomTimelineKind::GrantAdded {\n-                            username: ga.username.clone(),\n-                            granted_by: ga.granted_by.clone(),\n-                            capabilities: ga.capabilities.clone(),\n-                        },\n-                    });\n-            }\n-            Event::GrantRevoked(gr) => {\n-                let room_id = gr.room_id.clone();\n-                if let Some(room_grants) = self.grants.get_mut(&gr.room_id) {\n-                    let username = gr.username.clone();\n-                    if let Some(caps) = room_grants.get_mut(&username) {\n-                        for cap in &gr.capabilities {\n-                            caps.remove(cap);\n-                        }\n-                        if caps.is_empty() {\n-                            room_grants.remove(&username);\n-                        }\n-                    }\n-                    if room_grants.is_empty() {\n-                        self.grants.remove(&gr.room_id);\n-                    }\n-                }\n-                self.room_timeline\n-                    .entry(room_id)\n-                    .or_default()\n-                    .push(RoomTimelineEntry {\n-                        ts: gr.ts,\n-                        kind: RoomTimelineKind::GrantRevoked {\n-                            username: gr.username.clone(),\n-                            revoked_by: gr.revoked_by.clone(),\n-                            capabilities: gr.capabilities.clone(),\n-                        },\n-                    });\n-            }\n-            Event::InviteMinted(im) => {\n-                self.invites.insert(\n-                    im.token.clone(),\n-                    ActiveInviteState {\n-                        room_id: im.room_id.clone(),\n-                        capabilities: im.capabilities.iter().copied().collect(),\n-                        inviter: im.inviter.clone(),\n-                        uses_remaining: im.max_uses,\n-                        expires_ts_ms: im.expires_ts_ms,\n-                    },\n-                );\n-            }\n-            Event::InviteRedeemed(ir) => {\n-                if let Some(inv) = self.invites.get_mut(&ir.token) {\n-                    inv.uses_remaining = inv.uses_remaining.saturating_sub(1);\n-                    if inv.uses_remaining == 0 {\n-                        self.invites.remove(&ir.token);\n-                    }\n-                }\n-            }\n-        }\n-    }\n-}\n-\n-impl Default for ReducerState {\n-    fn default() -> Self {\n-        let mut content = HashMap::new();\n-        content.insert(ScopeId::Public, ContentState::default());\n-        Self {\n-            content,\n-            users_by_provider: HashMap::new(),\n-            tokens_by_id: HashMap::new(),\n-            agent_bindings: HashMap::new(),\n-            ingests_by_id: HashMap::new(),\n-            ingests_by_scope_thread: HashMap::new(),\n-            rooms: HashSet::new(),\n-            forum_threads: HashMap::new(),\n-            actor_last_post_ts: HashMap::new(),\n-            ingests_ordered: Vec::new(),\n-            posts_by_actor: HashMap::new(),\n-            redacted_posts: HashSet::new(),\n-            post_redact_ts: HashMap::new(),\n-            grants: HashMap::new(),\n-            room_timeline: HashMap::new(),\n-            invites: HashMap::new(),\n-        }\n-    }\n-}\n-\ndiff --git a/legacy/ui_action.rs b/legacy/ui_action.rs\ndeleted file mode 100644\nindex 5e4131dd346a6f80bfe091a9b0cf7902721bc47f..0000000000000000000000000000000000000000\n--- a/legacy/ui_action.rs\n+++ /dev/null\n@@ -1,270 +0,0 @@\n-//! Browser-only UI commands: JSON in hidden `__rpc__` plus hole fill ([`crate::form_template`]).\n-//! Not part of [`slug_types::RpcCommand`] (CLI / JSON API).\n-\n-use crate::form_template::fill_template_from_form;\n-use serde::{Deserialize, Serialize};\n-use serde_json::Value;\n-use std::collections::HashMap;\n-use thiserror::Error;\n-\n-/// Form field name for the compact JSON template (possibly with `{\"$form\":\"…\"}` holes).\n-pub const UI_RPC_FIELD: &str = \"__rpc__\";\n-\n-fn default_ui_form_action() -> String {\n-    \"/ui\".to_string()\n-}\n-\n-/// HTML form / fetch `POST /ui` payload after template fill and deserialization.\n-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\n-#[serde(tag = \"action\", rename_all = \"snake_case\")]\n-pub enum HtmlUiAction {\n-    /// Forum ingest via `POST /ui`.\n-    PostIngest {\n-        room: String,\n-        thread_tag: String,\n-        text: String,\n-        #[serde(default)]\n-        error_target: Option<String>,\n-        #[serde(default)]\n-        form_id: Option<String>,\n-    },\n-    /// DSL check / validation via `POST /ui`.\n-    CheckIngest {\n-        room: String,\n-        thread_tag: String,\n-        text: String,\n-        #[serde(default)]\n-        error_target: Option<String>,\n-        #[serde(default)]\n-        form_id: Option<String>,\n-    },\n-    /// Post a pairwise vote from `/vote` (browser compose).\n-    VoteComparePost {\n-        room: String,\n-        thread_tag: String,\n-        left_item: String,\n-        right_item: String,\n-        /// From form fields (string); parsed server-side.\n-        ratio_left: String,\n-        ratio_right: String,\n-        explanation: String,\n-        /// Same-origin path after successful post (JS redirect).\n-        next: String,\n-        /// Pool parent item path, if the vote was initiated from a pool URL.\n-        #[serde(default)]\n-        pool: Option<String>,\n-        #[serde(default = \"default_ui_form_action\")]\n-        form_action: String,\n-    },\n-    /// Set or clear the garden HUD pin cookie (`slug_garden_pin`). Response is **`303` + `Set-Cookie`** when submitted as a full-navigation form (`data-navigate=\"full\"`), matching `POST /theme`.\n-    SetGardenPin {\n-        #[serde(default)]\n-        clear: bool,\n-        #[serde(default)]\n-        room_wire: String,\n-        #[serde(default)]\n-        item_storage: Option<String>,\n-        next: String,\n-        /// Must equal the form `action` (usually `/ui`). Used to reject forged requests that POST to another path.\n-        #[serde(default = \"default_ui_form_action\")]\n-        form_action: String,\n-    },\n-    /// Resolve children or siblings for an external garden item.\n-    ResolveExternal {\n-        room_wire: String,\n-        item_storage: String,\n-        mode: String,\n-        next: String,\n-        #[serde(default = \"default_ui_form_action\")]\n-        form_action: String,\n-    },\n-    /// Author redacts own post via `POST /ui`.\n-    RedactPost { post_id: String },\n-    /// Morph `#room-members-section` — members list open or collapsed (server-rendered).\n-    SetRoomMembersExpanded {\n-        room_wire: String,\n-        #[serde(default)]\n-        expanded: bool,\n-    },\n-    /// Delete the private room (Manage only); redirects to `/` on success.\n-    DeleteRoom { room: String },\n-    /// Morph `#new-thread-ui-slot` inner — compose open or collapsed (`room_wire: \"public\"` for home).\n-    SetNewThreadComposeExpanded {\n-        room_wire: String,\n-        #[serde(default)]\n-        expanded: bool,\n-    },\n-    /// Replace a truncated post card with the full body (same thread index).\n-    ExpandPostFull {\n-        room: String,\n-        thread_tag: String,\n-        post_index: usize,\n-    },\n-    /// Expand a redacted/tombstone post to show stripped body (author view).\n-    ExpandRedactedPost {\n-        room: String,\n-        thread_tag: String,\n-        post_index: usize,\n-    },\n-    /// Collapse an expanded redacted post back to the tombstone card.\n-    CollapseRedactedPost {\n-        room: String,\n-        thread_tag: String,\n-        post_index: usize,\n-    },\n-    /// Copy full thread text (CLI `forum show` format) to the clipboard.\n-    CopyThread {\n-        room: String,\n-        thread_tag: String,\n-        copy_btn_id: String,\n-    },\n-}\n-\n-#[derive(Debug, Error)]\n-pub enum HtmlUiParseError {\n-    #[error(\"missing __rpc__ field\")]\n-    MissingRpc,\n-    #[error(\"invalid template json: {0}\")]\n-    Template(serde_json::Error),\n-    #[error(\"invalid ui action: {0}\")]\n-    Action(serde_json::Error),\n-}\n-\n-/// Parse `__rpc__` JSON, apply `$form` holes from the rest of the form map, deserialize.\n-pub fn parse_html_ui_from_form(\n-    form: &HashMap<String, String>,\n-) -> Result<HtmlUiAction, HtmlUiParseError> {\n-    let template = form.get(UI_RPC_FIELD).ok_or(HtmlUiParseError::MissingRpc)?;\n-    let mut hole_map = form.clone();\n-    hole_map.remove(UI_RPC_FIELD);\n-    let v: Value =\n-        fill_template_from_form(template, &hole_map).map_err(HtmlUiParseError::Template)?;\n-    serde_json::from_value(v).map_err(HtmlUiParseError::Action)\n-}\n-\n-#[cfg(test)]\n-mod tests {\n-    use super::*;\n-\n-    #[test]\n-    fn round_trip_post_ingest_with_holes() {\n-        let template = serde_json::json!({\n-            \"action\": \"post_ingest\",\n-            \"room\": \"public\",\n-            \"thread_tag\": {\"$form\": \"thread_tag\"},\n-            \"text\": {\"$form\": \"text\"},\n-            \"error_target\": \"e\",\n-            \"form_id\": \"f\",\n-        });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        form.insert(\"thread_tag\".into(), \"x\".into());\n-        form.insert(\"text\".into(), \"body\".into());\n-\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(\n-            a,\n-            HtmlUiAction::PostIngest {\n-                room: \"public\".into(),\n-                thread_tag: \"x\".into(),\n-                text: \"body\".into(),\n-                error_target: Some(\"e\".into()),\n-                form_id: Some(\"f\".into()),\n-            }\n-        );\n-    }\n-\n-    #[test]\n-    fn expand_post_full_round_trip() {\n-        let template = serde_json::json!({\n-            \"action\": \"expand_post_full\",\n-            \"room\": \"public\",\n-            \"thread_tag\": \"demo\",\n-            \"post_index\": 3,\n-        });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(\n-            a,\n-            HtmlUiAction::ExpandPostFull {\n-                room: \"public\".into(),\n-                thread_tag: \"demo\".into(),\n-                post_index: 3,\n-            }\n-        );\n-    }\n-\n-    #[test]\n-    fn set_room_members_expanded_defaults_false() {\n-        let template = serde_json::json!({\n-            \"action\": \"set_room_members_expanded\",\n-            \"room_wire\": \"ab/cd\",\n-        });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(\n-            a,\n-            HtmlUiAction::SetRoomMembersExpanded {\n-                room_wire: \"ab/cd\".into(),\n-                expanded: false,\n-            }\n-        );\n-    }\n-\n-    #[test]\n-    fn copy_thread_round_trip() {\n-        let template = serde_json::json!({\n-            \"action\": \"copy_thread\",\n-            \"room\": \"public\",\n-            \"thread_tag\": \"demo\",\n-            \"copy_btn_id\": \"thread-copy-top\",\n-        });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(\n-            a,\n-            HtmlUiAction::CopyThread {\n-                room: \"public\".into(),\n-                thread_tag: \"demo\".into(),\n-                copy_btn_id: \"thread-copy-top\".into(),\n-            }\n-        );\n-    }\n-\n-    #[test]\n-    fn set_new_thread_compose_expanded_true() {\n-        let template = serde_json::json!({\n-            \"action\": \"set_new_thread_compose_expanded\",\n-            \"room_wire\": \"ab/cd\",\n-            \"expanded\": true,\n-        });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(\n-            a,\n-            HtmlUiAction::SetNewThreadComposeExpanded {\n-                room_wire: \"ab/cd\".into(),\n-                expanded: true,\n-            }\n-        );\n-    }\n-}\ndiff --git a/legacy/views.rs b/legacy/views.rs\ndeleted file mode 100644\nindex d4f0ffc49475f014698b4da0de6f476884430813..0000000000000000000000000000000000000000\n--- a/legacy/views.rs\n+++ /dev/null\n@@ -1,63 +0,0 @@\n-use std::{\n-    collections::HashMap,\n-    sync::{Arc, Mutex},\n-};\n-use tokio::sync::mpsc;\n-\n-type CountMap = Arc<Mutex<HashMap<String, u64>>>;\n-\n-#[derive(Clone)]\n-pub struct ViewStore {\n-    counts: CountMap,\n-    flush_tx: mpsc::Sender<()>,\n-}\n-\n-impl ViewStore {\n-    pub fn new(json_path: &str) -> Self {\n-        // Load existing counts from disk on startup (best-effort)\n-        let initial: HashMap<String, u64> = std::fs::read_to_string(json_path)\n-            .ok()\n-            .and_then(|s| serde_json::from_str(&s).ok())\n-            .unwrap_or_default();\n-\n-        let counts: CountMap = Arc::new(Mutex::new(initial));\n-        let (flush_tx, mut flush_rx) = mpsc::channel::<()>(64);\n-        let path = json_path.to_string();\n-\n-        let counts_for_writer = counts.clone();\n-        tokio::spawn(async move {\n-            while flush_rx.recv().await.is_some() {\n-                while flush_rx.try_recv().is_ok() {}\n-\n-                let snapshot: HashMap<String, u64> = {\n-                    counts_for_writer.lock().unwrap().clone()\n-                };\n-\n-                let path = path.clone();\n-                let _ = tokio::task::spawn_blocking(move || {\n-                    if let Ok(json) = serde_json::to_string(&snapshot) {\n-                        let tmp = format!(\"{path}.tmp\");\n-                        if std::fs::write(&tmp, &json).is_ok() {\n-                            let _ = std::fs::rename(&tmp, &path);\n-                        }\n-                    }\n-                })\n-                .await;\n-            }\n-        });\n-\n-        Self { counts, flush_tx }\n-    }\n-\n-    pub fn increment(&self, path: String) {\n-        {\n-            let mut map = self.counts.lock().unwrap();\n-            *map.entry(path).or_insert(0) += 1;\n-        }\n-        let _ = self.flush_tx.try_send(());\n-    }\n-\n-    pub fn get_views(&self, path: &str) -> u64 {\n-        self.counts.lock().unwrap().get(path).copied().unwrap_or(0)\n-    }\n-}\ndiff --git a/legacy/vote.rs b/legacy/vote.rs\ndeleted file mode 100644\nindex d0ec78cd675eae284d056fb3b8eaf5cc853d6263..0000000000000000000000000000000000000000\n--- a/legacy/vote.rs\n+++ /dev/null\n@@ -1,580 +0,0 @@\n-use axum::{\n-    extract::{Path, Query, State},\n-    http::{HeaderMap, StatusCode, Uri},\n-    response::{Html, IntoResponse},\n-};\n-use axum_extra::extract::cookie::CookieJar;\n-use maud::html;\n-use serde::Deserialize;\n-use serde_json::json;\n-use std::collections::{HashMap, HashSet};\n-\n-use crate::{\n-    api::optional_principal,\n-    canonical_path::canonicalize_tag,\n-    form_template::template_json_compact,\n-    html::{\n-        forum::ThreadNav,\n-        layout_full_bleed_chromeless,\n-        ratio_pct, render_item_body_in_scope,\n-        theme_from_jar, theme_next_from_uri,\n-        user_can_post_room,\n-        ui_action::UI_RPC_FIELD,\n-        JsBuilder,\n-    },\n-    middleware::canonical_view_url,\n-    path_types::ItemId,\n-    reducer::{ContentState, ScopeId},\n-    scope_rank::suggest_next_pair_in_pool,\n-    state::AppState,\n-};\n-\n-use super::{\n-    access::{content_for_garden_view, room_not_found_page, room_scope_has_garden_content, user_can_view_room},\n-    item::{item_display_path, login_href_with_next},\n-};\n-\n-fn pick_autothread_for_vote_pair(content: &ContentState, a: &ItemId, b: &ItemId) -> String {\n-    let cands: HashSet<String> = content\n-        .item_threads\n-        .get(a)\n-        .into_iter()\n-        .chain(content.item_threads.get(b))\n-        .flat_map(|s| s.iter().cloned())\n-        .collect();\n-    if cands.is_empty() {\n-        return \"vote\".to_string();\n-    }\n-    let mut v: Vec<String> = cands.into_iter().collect();\n-    v.sort();\n-    canonicalize_tag(&v[0])\n-}\n-\n-/// Canonical unordered pair: lexicographic by storage string (stable edge identity).\n-pub(super) fn canonical_edge_items(a: &ItemId, b: &ItemId) -> (ItemId, ItemId) {\n-    let ac = a.clone().normalized_storage();\n-    let bc = b.clone().normalized_storage();\n-    if ac.as_str() <= bc.as_str() {\n-        (ac, bc)\n-    } else {\n-        (bc, ac)\n-    }\n-}\n-\n-/// All votes whose endpoints are exactly this unordered pair (unsorted).\n-pub(super) fn edge_vote_entries_for_pair(\n-    content: &ContentState,\n-    a: &ItemId,\n-    b: &ItemId,\n-) -> Vec<crate::reducer::VoteData> {\n-    let (lo, hi) = canonical_edge_items(a, b);\n-    let lo_s = lo.as_str();\n-    let hi_s = hi.as_str();\n-    content\n-        .item_votes\n-        .get(&lo)\n-        .into_iter()\n-        .flat_map(|q| q.iter())\n-        .filter(|v| {\n-            (v.a.as_str() == lo_s && v.b.as_str() == hi_s)\n-                || (v.a.as_str() == hi_s && v.b.as_str() == lo_s)\n-        })\n-        .cloned()\n-        .collect()\n-}\n-\n-pub(super) fn ratios_for_compare_page(\n-    v: &crate::reducer::VoteData,\n-    page_left: &ItemId,\n-    page_right: &ItemId,\n-) -> (i32, i32) {\n-    let pl = page_left.as_str();\n-    let pr = page_right.as_str();\n-    match (v.a.as_str(), v.b.as_str()) {\n-        (a, b) if a == pl && b == pr => (v.ratio_left, v.ratio_right),\n-        (a, b) if a == pr && b == pl => (v.ratio_right, v.ratio_left),\n-        _ => (v.ratio_left, v.ratio_right),\n-    }\n-}\n-\n-fn left_share_normalized(ratio_left: i32, ratio_right: i32) -> f64 {\n-    let l = ratio_left.max(0) as f64;\n-    let r = ratio_right.max(0) as f64;\n-    let sum = l + r;\n-    if sum <= 0.0 {\n-        0.5\n-    } else {\n-        l / sum\n-    }\n-}\n-\n-/// Stronger preference for **`page_left` first**; ties **newer first**.\n-pub(super) fn sort_votes_for_compare_display(\n-    mut votes: Vec<crate::reducer::VoteData>,\n-    page_left: &ItemId,\n-    page_right: &ItemId,\n-) -> Vec<crate::reducer::VoteData> {\n-    votes.sort_by(|va, vb| {\n-        let (ratio_left_a, ratio_right_a) = ratios_for_compare_page(va, page_left, page_right);\n-        let (ratio_left_b, ratio_right_b) = ratios_for_compare_page(vb, page_left, page_right);\n-        let sa = left_share_normalized(ratio_left_a, ratio_right_a);\n-        let sb = left_share_normalized(ratio_left_b, ratio_right_b);\n-        match sb.partial_cmp(&sa).unwrap_or(std::cmp::Ordering::Equal) {\n-            std::cmp::Ordering::Equal => vb.ts.cmp(&va.ts),\n-            o => o,\n-        }\n-    });\n-    votes\n-}\n-\n-/// Number of vote ingests recorded for this unordered pair in `content` (same scope as ranking).\n-pub(super) fn edge_vote_count_for_pair(content: &ContentState, a: &ItemId, b: &ItemId) -> usize {\n-    let (lo, hi) = canonical_edge_items(a, b);\n-    let lo_s = lo.as_str();\n-    let hi_s = hi.as_str();\n-    content\n-        .item_votes\n-        .get(&lo)\n-        .into_iter()\n-        .flat_map(|q| q.iter())\n-        .filter(|v| {\n-            (v.a.as_str() == lo_s && v.b.as_str() == hi_s)\n-                || (v.a.as_str() == hi_s && v.b.as_str() == lo_s)\n-        })\n-        .count()\n-}\n-\n-fn vote_thread_tags_for_pair(content: &ContentState, a: &ItemId, b: &ItemId) -> Vec<String> {\n-    let set: HashSet<String> = content\n-        .item_threads\n-        .get(a)\n-        .into_iter()\n-        .chain(content.item_threads.get(b))\n-        .flat_map(|s| s.iter().cloned())\n-        .collect();\n-    let mut v: Vec<String> = set.into_iter().collect();\n-    v.sort();\n-    v.into_iter().map(|t| canonicalize_tag(&t)).collect()\n-}\n-\n-fn vote_edge_history_markup(content: &ContentState, left: &ItemId, right: &ItemId) -> maud::Markup {\n-    let votes = edge_vote_entries_for_pair(content, left, right);\n-    let votes = sort_votes_for_compare_display(votes, left, right);\n-    let legend_left = item_display_path(left.as_str());\n-    let legend_right = item_display_path(right.as_str());\n-    html! {\n-        @if votes.is_empty() {\n-            p class=\"muted vote-edge-empty\" { \"no votes on this pair in this scope yet\" }\n-        } @else {\n-            h3 class=\"vote-edge-history-title\" {\n-                \"votes on this edge\"\n-                span class=\"vote-edge-history-axis muted\" { \" · \" (legend_left) \" : \" (legend_right) }\n-            }\n-            ul class=\"vote-edge-history\" {\n-                @for v in &votes {\n-                    @let (r_left, r_right) = ratios_for_compare_page(v, left, right);\n-                    @let pct = ratio_pct(r_left, r_right);\n-                    @let row_tip = format!(\n-                        \"{}:{} counts toward {} (left of bar) vs {} (right of bar); #{} · @{}\",\n-                        r_left,\n-                        r_right,\n-                        legend_left,\n-                        legend_right,\n-                        v.thread_tag,\n-                        v.principal,\n-                    );\n-                    li class=\"vote-edge-history-row\" title=(row_tip) {\n-                        div class=\"vote-edge-meta\" {\n-                            span class=\"vote-edge-ratio\" { (format!(\"{}:{}\", r_left, r_right)) }\n-                            span class=\"muted\" { \" · #\" (v.thread_tag) \" · @\" (v.principal) }\n-                        }\n-                        div class=\"ratio-bar vote-edge-bar\" aria-hidden=\"true\" {\n-                            div class=\"ratio-left\" style={(format!(\"width: {:.3}%;\", pct))} {}\n-                            div class=\"ratio-right\" style={(format!(\"width: {:.3}%;\", 100.0 - pct))} {}\n-                        }\n-                        @if !v.body.trim().is_empty() {\n-                            div class=\"vote-edge-reason muted\" { (v.body.trim()) }\n-                        }\n-                    }\n-                }\n-            }\n-        }\n-    }\n-}\n-\n-/// After a successful vote post: refresh edge history (no in-page preview card).\n-#[allow(clippy::too_many_arguments)]\n-pub(crate) async fn vote_compare_post_success_js(\n-    state: &AppState,\n-    nav: &ThreadNav,\n-    _room_wire: &str,\n-    _thread_tag: &str,\n-    left: &ItemId,\n-    right: &ItemId,\n-    pool: Option<&ItemId>,\n-    _post_id: &str,\n-    _post_idx: Option<usize>,\n-) -> String {\n-    let reduced = state.reduced.read().await;\n-    let content = content_for_garden_view(&reduced, &nav.scope());\n-    let edge_history = vote_edge_history_markup(content, left, right);\n-    let next_pair = suggest_next_vote_pair(content, left, right, pool);\n-    let nav_markup = vote_compare_nav_markup(nav, next_pair.as_ref(), pool);\n-    drop(reduced);\n-    JsBuilder::new()\n-        .morph_inner_selector(\"#vote-edge-history-region\", edge_history)\n-        .morph_selector(\".vote-compare-nav\", nav_markup)\n-        .build()\n-}\n-\n-pub(super) fn vote_compare_href(\n-    nav: &ThreadNav,\n-    left: &ItemId,\n-    right: &ItemId,\n-    thread_override: Option<&str>,\n-    pool: Option<&ItemId>,\n-) -> String {\n-    let left_dp = left.display_path();\n-    let right_dp = right.display_path();\n-    let left_q = urlencoding::encode(&left_dp);\n-    let right_q = urlencoding::encode(&right_dp);\n-    let mut base = format!(\n-        \"{}/vote?left={}&right={}\",\n-        nav.room_path_prefix_for_vote_compare(),\n-        left_q,\n-        right_q\n-    );\n-    if let Some(t) = thread_override.filter(|s| !s.is_empty()) {\n-        base = format!(\"{}&thread={}\", base, urlencoding::encode(t));\n-    }\n-    if let Some(p) = pool {\n-        let pool_dp = p.display_path();\n-        base = format!(\"{}&pool={}\", base, urlencoding::encode(&pool_dp));\n-    }\n-    base\n-}\n-\n-pub(super) fn vote_pool_href(nav: &ThreadNav, pool_item_str: &str) -> String {\n-    let display = ItemId::parse(pool_item_str)\n-        .map(|i| i.display_path())\n-        .unwrap_or_else(|| pool_item_str.to_string());\n-    format!(\n-        \"{}/vote?pool={}\",\n-        nav.room_path_prefix_for_vote_compare(),\n-        urlencoding::encode(&display)\n-    )\n-}\n-\n-fn vote_compare_nav_markup(\n-    nav: &ThreadNav,\n-    next_pair: Option<&(ItemId, ItemId)>,\n-    pool: Option<&ItemId>,\n-) -> maud::Markup {\n-    let next_pair_href = next_pair.map(|(nl, nr)| vote_compare_href(nav, nl, nr, None, pool));\n-    html! {\n-        div class=\"vote-compare-nav\" {\n-            @if let Some(href) = &next_pair_href {\n-                a class=\"vote-compare-next\" data-testid=\"vote-next-pair\" href=(href) { \"next pair\" }\n-            } @else {\n-                span class=\"vote-compare-next is-disabled\" { \"no next pair\" }\n-            }\n-        }\n-    }\n-}\n-\n-pub(super) fn suggest_next_vote_pair(\n-    content: &ContentState,\n-    current_left: &ItemId,\n-    current_right: &ItemId,\n-    pool_parent: Option<&ItemId>,\n-) -> Option<(ItemId, ItemId)> {\n-    let pool: Vec<ItemId> = if let Some(parent) = pool_parent {\n-        content\n-            .item_children\n-            .get(parent)\n-            .map(|s| s.iter().cloned().collect())\n-            .unwrap_or_default()\n-    } else if current_left.parent().as_ref().map(|p| p.as_str())\n-        == current_right.parent().as_ref().map(|p| p.as_str())\n-    {\n-        current_left\n-            .parent()\n-            .and_then(|parent| {\n-                content\n-                    .item_children\n-                    .get(&parent.normalized_storage())\n-                    .cloned()\n-            })\n-            .map(|children| children.into_iter().collect())\n-            .unwrap_or_default()\n-    } else {\n-        Vec::new()\n-    };\n-    if pool.len() < 2 {\n-        return None;\n-    }\n-    suggest_next_pair_in_pool(\n-        &content.ranking_group,\n-        &pool,\n-        Some((current_left, current_right)),\n-    )\n-}\n-\n-pub(super) fn vote_compare_item_card(\n-    nav: &ThreadNav,\n-    item: &ItemId,\n-    body: Option<&String>,\n-    side_class: &str,\n-    item_bodies: Option<&HashMap<ItemId, String>>,\n-) -> maud::Markup {\n-    html! {\n-        div class=(format!(\"vote-compare-side {side_class}\")) {\n-            a class=(format!(\"vote-compare-item {side_class}\")) href=(nav.garden_item_href(item)) {\n-                code { (item_display_path(item.as_str())) }\n-            }\n-            @if let Some(body) = body.filter(|b| !b.trim().is_empty()) {\n-                div class=\"vote-compare-item-body\" {\n-                    (render_item_body_in_scope(\n-                        body,\n-                        nav.garden_root_url(),\n-                        item_bodies,\n-                    ))\n-                }\n-            } @else {\n-                p class=\"muted vote-compare-item-body-empty\" { \"no body yet\" }\n-            }\n-        }\n-    }\n-}\n-#[derive(Debug, Deserialize)]\n-pub struct VoteCompareQuery {\n-    #[serde(default)]\n-    pub left: Option<String>,\n-    #[serde(default)]\n-    pub right: Option<String>,\n-    #[serde(default)]\n-    pub thread: Option<String>,\n-    #[serde(default)]\n-    pub pool: Option<String>,\n-}\n-\n-/// Public pairwise vote UI — `/vote?left=&right=&thread=`.\n-pub async fn vote_compare_page(\n-    State(state): State<AppState>,\n-    Query(q): Query<VoteCompareQuery>,\n-    headers: HeaderMap,\n-    jar: CookieJar,\n-    uri: Uri,\n-) -> impl IntoResponse {\n-    let nav = ThreadNav::public();\n-    vote_compare_inner(state, q, nav, headers, jar, uri).await\n-}\n-\n-pub async fn room_vote_compare_page(\n-    State(state): State<AppState>,\n-    Path(room_key): Path<String>,\n-    Query(q): Query<VoteCompareQuery>,\n-    headers: HeaderMap,\n-    jar: CookieJar,\n-    uri: Uri,\n-) -> impl IntoResponse {\n-    let Some(room_id) = slug_types::room_id_from_route_segment(&room_key) else {\n-        return (StatusCode::NOT_FOUND, \"bad room path\").into_response();\n-    };\n-    let Some(nav) = ThreadNav::from_room_id(&room_id) else {\n-        return (StatusCode::NOT_FOUND, \"bad room path\").into_response();\n-    };\n-    let reduced = state.reduced.read().await;\n-    let user = optional_principal(&headers, &jar, &reduced);\n-    if !user_can_view_room(&reduced, &room_id, user.as_deref()) {\n-        drop(reduced);\n-        return room_not_found_page(&jar, &uri).into_response();\n-    }\n-    if !room_scope_has_garden_content(&reduced, &nav) {\n-        drop(reduced);\n-        return room_not_found_page(&jar, &uri).into_response();\n-    }\n-    drop(reduced);\n-    vote_compare_inner(state, q, nav, headers, jar, uri).await\n-}\n-\n-async fn vote_compare_inner(\n-    state: AppState,\n-    q: VoteCompareQuery,\n-    nav: ThreadNav,\n-    headers: HeaderMap,\n-    jar: CookieJar,\n-    uri: Uri,\n-) -> axum::response::Response {\n-    let pool_id: Option<ItemId> = match q.pool.as_deref() {\n-        Some(p) => match ItemId::parse(p.trim()) {\n-            Some(i) => Some(i.normalized_storage()),\n-            None => return (StatusCode::BAD_REQUEST, \"bad pool item\").into_response(),\n-        },\n-        None => None,\n-    };\n-\n-    let (left, right) = match (q.left.as_deref(), q.right.as_deref()) {\n-        (Some(l), Some(r)) => {\n-            let left = match ItemId::parse(l.trim()) {\n-                Some(i) => i.normalized_storage(),\n-                None => return (StatusCode::NOT_FOUND, \"bad left item\").into_response(),\n-            };\n-            let right = match ItemId::parse(r.trim()) {\n-                Some(i) => i.normalized_storage(),\n-                None => return (StatusCode::NOT_FOUND, \"bad right item\").into_response(),\n-            };\n-            if left == right {\n-                return (StatusCode::BAD_REQUEST, \"items must differ\").into_response();\n-            }\n-            (left, right)\n-        }\n-        (None, None) => {\n-            let Some(pool) = pool_id.as_ref() else {\n-                return (StatusCode::BAD_REQUEST, \"provide left+right or pool\").into_response();\n-            };\n-            let reduced = state.reduced.read().await;\n-            let content = content_for_garden_view(&reduced, &nav.scope());\n-            let children: Vec<ItemId> = content\n-                .item_children\n-                .get(pool)\n-                .map(|s| s.iter().cloned().collect())\n-                .unwrap_or_default();\n-            if children.len() < 2 {\n-                drop(reduced);\n-                return (StatusCode::BAD_REQUEST, \"pool has fewer than 2 children to compare\").into_response();\n-            }\n-            let pair = suggest_next_pair_in_pool(&content.ranking_group, &children, None);\n-            drop(reduced);\n-            match pair {\n-                Some(p) => p,\n-                None => return (StatusCode::BAD_REQUEST, \"no pairs available in pool\").into_response(),\n-            }\n-        }\n-        _ => return (StatusCode::BAD_REQUEST, \"provide both left and right, or just pool\").into_response(),\n-    };\n-\n-    let reduced = state.reduced.read().await;\n-    let content = content_for_garden_view(&reduced, &nav.scope());\n-    let viewer = optional_principal(&headers, &jar, &reduced);\n-    let can_post = match &nav.scope() {\n-        ScopeId::Public => viewer.is_some(),\n-        ScopeId::Room(rid) => viewer\n-            .as_ref()\n-            .map(|u| user_can_post_room(&reduced, rid, u))\n-            .unwrap_or(false),\n-    };\n-    let auto_thread = q\n-        .thread\n-        .as_ref()\n-        .map(|t| canonicalize_tag(t))\n-        .filter(|t| !t.is_empty())\n-        .unwrap_or_else(|| pick_autothread_for_vote_pair(content, &left, &right));\n-    let thread_tags = vote_thread_tags_for_pair(content, &left, &right);\n-    let edge_history = vote_edge_history_markup(content, &left, &right);\n-    let left_body = content.item_bodies.get(&left).cloned();\n-    let right_body = content.item_bodies.get(&right).cloned();\n-    let item_bodies_for_cards = content.item_bodies.clone();\n-    let next_pair = suggest_next_vote_pair(content, &left, &right, pool_id.as_ref());\n-    drop(reduced);\n-\n-    let title = format!(\n-        \"vote — {} vs {}\",\n-        item_display_path(left.as_str()),\n-        item_display_path(right.as_str())\n-    );\n-    let next_path = uri\n-        .path_and_query()\n-        .map(|pq| pq.as_str().to_string())\n-        .unwrap_or_else(|| \"/vote\".into());\n-\n-    let rpc_json = template_json_compact(&json!({\n-        \"action\": \"vote_compare_post\",\n-        \"room\": nav.room_wire,\n-        \"thread_tag\": {\"$form\": \"thread_tag\"},\n-        \"left_item\": left.as_str(),\n-        \"right_item\": right.as_str(),\n-        \"ratio_left\": {\"$form\": \"ratio_left\"},\n-        \"ratio_right\": {\"$form\": \"ratio_right\"},\n-        \"explanation\": {\"$form\": \"explanation\"},\n-        \"next\": next_path,\n-        \"pool\": pool_id.as_ref().map(|p| p.as_str()),\n-        \"form_action\": \"/ui\",\n-    }))\n-    .expect(\"vote compare rpc json\");\n-\n-    let body = html! {\n-    section class=\"vote-compare-shell\" {\n-        h2 { \"compare\" }\n-        div class=\"vote-compare-pair\" {\n-            (vote_compare_item_card(\n-                &nav,\n-                &left,\n-                left_body.as_ref(),\n-                \"vote-compare-left\",\n-                Some(&item_bodies_for_cards),\n-            ))\n-            span class=\"vote-compare-vs\" { \"vs\" }\n-            (vote_compare_item_card(\n-                &nav,\n-                &right,\n-                right_body.as_ref(),\n-                \"vote-compare-right\",\n-                Some(&item_bodies_for_cards),\n-            ))\n-        }\n-        (vote_compare_nav_markup(&nav, next_pair.as_ref(), pool_id.as_ref()))\n-        div id=\"vote-edge-history-region\" {\n-            (edge_history)\n-        }\n-        @if can_post {\n-            form id=\"vote-compare-form\" method=\"POST\" action=\"/ui\" {\n-                input type=\"hidden\" name=(UI_RPC_FIELD) value=(rpc_json);\n-                div class=\"vote-thread-picker\" {\n-                    label class=\"vote-thread-picker-label\" { \"thread\" }\n-                    select id=\"vote-thread-select\" name=\"thread_tag\" aria-label=\"Thread to post vote into\" {\n-                        @if thread_tags.is_empty() {\n-                            option value=\"vote\" selected { \"#vote\" }\n-                        }\n-                        @for t in &thread_tags {\n-                            @if *t == auto_thread {\n-                                option value=(t) selected { \"#\" (t) }\n-                            } @else {\n-                                option value=(t) { \"#\" (t) }\n-                            }\n-                        }\n-                    }\n-                }\n-                input type=\"hidden\" name=\"ratio_left\" id=\"vote-ratio-left\" value=\"50\";\n-                input type=\"hidden\" name=\"ratio_right\" id=\"vote-ratio-right\" value=\"50\";\n-                label class=\"vote-compare-slider-label\" {\n-                    span id=\"vote-slider-left-label\" { (item_display_path(left.as_str())) }\n-                    input type=\"range\" id=\"vote-preference-slider\" min=\"0\" max=\"100\" value=\"50\"\n-                        aria-valuemin=\"0\" aria-valuemax=\"100\";\n-                    span id=\"vote-slider-right-label\" { (item_display_path(right.as_str())) }\n-                }\n-                label class=\"vote-explain-label\" { \"reason (required)\" }\n-                textarea name=\"explanation\" id=\"vote-explain\" rows=\"5\" placeholder=\"why this split?\" required {}\n-                div id=\"vote-compare-errors\" {}\n-                p { button type=\"submit\" { \"post vote\" } }\n-            }\n-        } @else {\n-            p class=\"muted\" { a href=(login_href_with_next(&next_path)) { \"log in\" } \" to post this vote.\" }\n-        }\n-    }\n-    };\n-\n-    let url_key = canonical_view_url(&uri);\n-    let view_count = state.views.get_views(&url_key);\n-\n-    let page = layout_full_bleed_chromeless(\n-        &title,\n-        \"view-ontology view-ontology-light view-vote-compare view-vote-compare-fullscreen\",\n-        body,\n-        Some(view_count),\n-        theme_from_jar(&jar),\n-        &theme_next_from_uri(&uri),\n-    );\n-    Html(page.into_string()).into_response()\n-}\n-\n","role":"user"}],"model":"openai/gpt-chat-latest"}