You are a constitutional council ranking individual git commits for ownership allocation.

Compare these two commits. Decide which contributed more lasting value to the project.

Judge substance, not spectacle:
- Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise.
- Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one.
- Do not favor a side merely because its patch is longer or noisier.
- Weight what the change does for the project, not the contributor's name.

Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."}
The explanation must cite concrete differences in the patches (1-3 sentences).

Side A — contributor: tommy-mor
Side A — commit message:
[07715165] nice

Side A — unified diff (full patch):
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index c3c62a76f424010d77a6090c84dd0b82098f573e..da2536112faea313352624cf2ce0ddd0ab3377c1 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -6,7 +6,7 @@ use axum::{
 use std::collections::HashMap;
 
 use crate::{
-    html::{demo_counter_panel, js_string_literal, ranking_panel, JsBuilder},
+    html::{js_string_literal, ranking_panel, JsBuilder},
     parser::parse_reddit_url,
     parser_render::parser_panel_morph,
     state::AppState,
@@ -35,13 +35,6 @@ pub async fn post_ui_html(
     };
 
     match action {
-        HtmlUiAction::BumpDemoCounter => {
-            let count = state.bump_demo_counter().await;
-            let panel = demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref());
-            JsBuilder::new()
-                .morph_selector("#demo-counter-panel", panel)
-                .into_response()
-        }
         HtmlUiAction::RecordVote {
             a,
             b,
@@ -54,8 +47,8 @@ pub async fn post_ui_html(
             {
                 return ui_js_warn(&e).into_response();
             }
-            let mut group = state.group.write().await;
-            let panel = ranking_panel(&mut group);
+            let group = state.group.read().await;
+            let panel = ranking_panel(&group);
             JsBuilder::new()
                 .morph_selector("#ranking-panel", panel)
                 .into_response()
@@ -87,20 +80,6 @@ mod tests {
         assert!(matches!(err, HtmlUiParseError::MissingRpc));
     }
 
-    #[test]
-    fn bump_action_deserializes() {
-        let template = serde_json::json!({ "action": "bump_demo_counter" });
-        let mut form = HashMap::new();
-        form.insert(
-            UI_RPC_FIELD.to_string(),
-            serde_json::to_string(&template).unwrap(),
-        );
-        assert_eq!(
-            parse_html_ui_from_form(&form).unwrap(),
-            HtmlUiAction::BumpDemoCounter
-        );
-    }
-
     #[test]
     fn record_vote_action_deserializes() {
         let template = serde_json::json!({
diff --git a/server/src/events.rs b/server/src/events.rs
index b969242534e184d4f0a689543a479670b08a18df..eff80aef0257f706d2341f666e63d6a3d921bf6e 100644
--- a/server/src/events.rs
+++ b/server/src/events.rs
@@ -5,8 +5,6 @@ use serde::{Deserialize, Serialize};
 pub enum Event {
     /// Page view recorded (path → counter in views.json).
     ViewRecorded { path: String, ts: i64 },
-    /// Demo counter bump from `POST /ui` (persisted in the single JSONL log).
-    DemoCounterBumped { ts: i64, value: u64 },
     /// Pairwise comparison vote (replayed into [`crate::reducer::GroupState`] on boot).
     VoteRecorded {
         ts: i64,
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index 5b1d0b5a887d89e7e80796aa7a6c8ed5baaf2782..d69ed962b5c8625bc83c933b1825f2cc1d0868e2 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -13,7 +13,7 @@ use crate::{
     form_template::template_json_compact,
     parser_action::ParserAction,
     parser_render::parser_panel,
-    ranking::ranked_items,
+    ranking::ranked_items_cached,
     reducer::GroupState,
     state::AppState,
     ui_action::UI_RPC_FIELD,
@@ -199,10 +199,8 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)
     }
 }
 
-pub fn ranking_panel(group: &mut GroupState) -> Markup {
-    const MAX_ITERS: usize = 10_000;
-    const TOL: f64 = 1e-8;
-    let items = ranked_items(group, MAX_ITERS, TOL);
+pub fn ranking_panel(group: &GroupState) -> Markup {
+    let items = ranked_items_cached(group);
     html! {
         section id="ranking-panel" class="demo-panel" {
             h2 { "Ranking" }
@@ -260,35 +258,6 @@ pub fn vote_panel() -> Markup {
 }
 
 
-pub fn demo_counter_panel(count: u64, event_log_path: &str) -> Markup {
-    let rpc = template_json_compact(&serde_json::json!({ "action": "bump_demo_counter" }))
-        .expect("rpc json");
-    html! {
-        section id="demo-counter-panel" class="demo-panel" {
-            h1 { "sorter2" }
-            p class="muted" {
-                "Pairwise ranking scaffold — votes persist to JSONL and replay on boot."
-            }
-            p class="demo-count" {
-                strong { "Counter: " }
-                span id="demo-count-value" { (count) }
-            }
-            p class="muted small" {
-                "Event log: " code { (event_log_path) }
-            }
-            form method="post" action="/ui" id="demo-bump-form" {
-                input type="hidden" name=(UI_RPC_FIELD) value=(rpc);
-                button type="submit" class="btn-primary" { "Bump (POST /ui → eval JS)" }
-            }
-            p class="muted small" {
-                "Uses hidden "
-                code { "__rpc__" }
-                " JSON + Idiomorph morph — no full page reload."
-            }
-        }
-    }
-}
-
 pub async fn home(
     State(state): State<AppState>,
     jar: CookieJar,
@@ -297,16 +266,15 @@ pub async fn home(
     let path = uri.path().to_string();
     state.views.increment(path.clone());
     let views = state.views.get_views(&path);
-    let count = *state.demo_counter.read().await;
     let theme = theme_from_jar(&jar);
     let theme_next = theme_next_from_uri(&uri);
-    let mut group = state.group.write().await;
+    let group = state.group.read().await;
     let empty_action = ParserAction::suggest(String::new(), None);
     let body = html! {
+        h1 { "sorter2" }
         (parser_panel("", &empty_action))
         (vote_panel())
-        (ranking_panel(&mut group))
-        (demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref()))
+        (ranking_panel(&group))
     };
     layout("sorter2", body, views, theme, &theme_next)
 }
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 6716c5b282e7980a7a0f03d63ad8b25eda61cc55..fa423640d598f4ba97a5885d228e78d7b97f7a22 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -9,6 +9,7 @@ pub mod parser_render;
 pub mod path_types;
 pub mod ranking;
 pub mod reducer;
+pub mod settlement;
 pub mod state;
 pub mod ui_action;
 pub mod views;
diff --git a/server/src/ranking.rs b/server/src/ranking.rs
index 89d3280126a8d8f841721ce8cb63ff735d68752a..2d706762792ba9239bb3f1c2e4974a2fde908013 100644
--- a/server/src/ranking.rs
+++ b/server/src/ranking.rs
@@ -91,6 +91,11 @@ pub fn compute_group_ranking(group: &mut GroupState, max_iters: usize, tol: f64)
 
 pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<RankedItem> {
     compute_group_ranking(group, max_iters, tol);
+    ranked_items_cached(group)
+}
+
+/// Read cached scores without recomputing (HTTP fast path).
+pub fn ranked_items_cached(group: &GroupState) -> Vec<RankedItem> {
     let mut items: Vec<RankedItem> = group
         .idx_to_item
         .iter()
@@ -105,7 +110,12 @@ pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<R
     items
 }
 
-fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usize), f64)>, max_iters: usize, tol: f64) -> Vec<f64> {
+pub fn compute_scores_from_edges(
+    n: usize,
+    edges: impl Iterator<Item = ((usize, usize), f64)>,
+    max_iters: usize,
+    tol: f64,
+) -> Vec<f64> {
     if n == 0 {
         return vec![];
     }
diff --git a/server/src/settlement.rs b/server/src/settlement.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f722ceaea62cda22c28ab71551f259fbf049b81
--- /dev/null
+++ b/server/src/settlement.rs
@@ -0,0 +1,114 @@
+use std::sync::Arc;
+
+use tokio::sync::{mpsc, oneshot, RwLock};
+
+use crate::{
+    event_log::EventLog,
+    events::Event,
+    ranking::compute_scores_from_edges,
+    reducer::{GroupState, VoteData},
+};
+
+const MAX_ITERS: usize = 10_000;
+const TOL: f64 = 1e-8;
+
+pub struct SettlementCommand {
+    pub vote: VoteData,
+    pub event: Event,
+    pub reply: oneshot::Sender<Result<(), String>>,
+}
+
+#[derive(Clone)]
+pub struct SettlementClient {
+    tx: mpsc::Sender<SettlementCommand>,
+}
+
+impl SettlementClient {
+    pub fn spawn(group: Arc<RwLock<GroupState>>, event_log: Arc<EventLog>) -> Self {
+        let (tx, rx) = mpsc::channel(64);
+        tokio::spawn(settlement_worker(rx, group, event_log));
+        Self { tx }
+    }
+
+    pub async fn record_vote(&self, vote: VoteData, event: Event) -> Result<(), String> {
+        let (reply, rx) = oneshot::channel();
+        self.tx
+            .send(SettlementCommand {
+                vote,
+                event,
+                reply,
+            })
+            .await
+            .map_err(|_| "settlement worker stopped".to_string())?;
+        rx.await
+            .map_err(|_| "settlement worker stopped".to_string())?
+    }
+}
+
+async fn settlement_worker(
+    mut rx: mpsc::Receiver<SettlementCommand>,
+    group: Arc<RwLock<GroupState>>,
+    event_log: Arc<EventLog>,
+) {
+    while let Some(first) = rx.recv().await {
+        let mut batch = vec![first];
+        while let Ok(more) = rx.try_recv() {
+            batch.push(more);
+        }
+
+        let mut disk_err: Option<String> = None;
+        for cmd in &batch {
+            if let Err(e) = event_log.append(&cmd.event).await {
+                disk_err = Some(e.to_string());
+                break;
+            }
+        }
+
+        if let Some(err) = disk_err {
+            for cmd in batch {
+                let _ = cmd.reply.send(Err(err.clone()));
+            }
+            continue;
+        }
+
+        let (edges, n) = {
+            let mut w = group.write().await;
+            for cmd in &batch {
+                w.apply_vote(cmd.vote.clone());
+            }
+            (w.edges.clone(), w.idx_to_item.len())
+        };
+
+        let new_scores = compute_scores_from_edges(
+            n,
+            edges.iter().map(|(&k, &v)| (k, v)),
+            MAX_ITERS,
+            TOL,
+        );
+
+        {
+            let mut w = group.write().await;
+            w.cached_scores = new_scores;
+            w.dirty = false;
+        }
+
+        for cmd in batch {
+            let _ = cmd.reply.send(Ok(()));
+        }
+    }
+}
+
+/// Compute ranking cache from current in-memory edges (startup replay only).
+pub fn warm_ranking_cache(group: &mut GroupState) {
+    if !group.dirty {
+        return;
+    }
+    let n = group.idx_to_item.len();
+    group.cached_scores = compute_scores_from_edges(
+        n,
+        group.edges.iter().map(|(&k, &v)| (k, v)),
+        MAX_ITERS,
+        TOL,
+    );
+    group.dirty = false;
+}
diff --git a/server/src/state.rs b/server/src/state.rs
index 8ec9902e2ecc31cf8208f7ad6365891dc5537eed..1922541a4064c2de1df2d993a461cae783320e05 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -6,6 +6,7 @@ use crate::{
     event_log::EventLog,
     events::Event,
     reducer::{GroupState, VoteData},
+    settlement::{warm_ranking_cache, SettlementClient},
     views::ViewStore,
 };
 
@@ -38,8 +39,8 @@ pub struct AppState {
     pub cfg: Arc<AppConfig>,
     pub event_log: Arc<EventLog>,
     pub views: ViewStore,
-    pub demo_counter: Arc<RwLock<u64>>,
     pub group: Arc<RwLock<GroupState>>,
+    settlement: SettlementClient,
 }
 
 impl AppState {
@@ -48,14 +49,10 @@ impl AppState {
         let views_path = format!("{}/views.json", cfg.data_dir);
         let views = ViewStore::new(&views_path);
 
-        let mut demo_counter: u64 = 0;
         let mut group = GroupState::new();
         if let Ok((events, _)) = event_log.load_all().await {
             for ev in events {
                 match ev {
-                    Event::DemoCounterBumped { value, .. } => {
-                        demo_counter = demo_counter.max(value);
-                    }
                     Event::VoteRecorded {
                         ts,
                         a,
@@ -74,30 +71,20 @@ impl AppState {
             }
         }
 
+        warm_ranking_cache(&mut group);
+
+        let group = Arc::new(RwLock::new(group));
+        let settlement = SettlementClient::spawn(group.clone(), event_log.clone());
+
         Self {
             cfg: Arc::new(cfg),
             event_log,
             views,
-            demo_counter: Arc::new(RwLock::new(demo_counter)),
-            group: Arc::new(RwLock::new(group)),
+            group,
+            settlement,
         }
     }
 
-    pub async fn bump_demo_counter(&self) -> u64 {
-        let mut guard = self.demo_counter.write().await;
-        *guard += 1;
-        let value = *guard;
-        drop(guard);
-
-        let ts = crate::html::now_ms();
-        let _ = self
-            .event_log
-            .append(&Event::DemoCounterBumped { ts, value })
-            .await;
-
-        value
-    }
-
     pub async fn record_vote(
         &self,
         a: &str,
@@ -109,23 +96,14 @@ impl AppState {
         let vote = VoteData::from_recorded(ts, a, b, ratio_left, ratio_right)
             .ok_or_else(|| "invalid vote: need two distinct non-empty items".to_string())?;
 
-        {
-            let mut group = self.group.write().await;
-            group.apply_vote(vote.clone());
-        }
-
-        let _ = self
-            .event_log
-            .append(&Event::VoteRecorded {
-                ts,
-                a: vote.a.as_str().to_string(),
-                b: vote.b.as_str().to_string(),
-                ratio_left: vote.ratio_left,
-                ratio_right: vote.ratio_right,
-            })
-            .await
-            .map_err(|e| e.to_string())?;
+        let event = Event::VoteRecorded {
+            ts,
+            a: vote.a.as_str().to_string(),
+            b: vote.b.as_str().to_string(),
+            ratio_left: vote.ratio_left,
+            ratio_right: vote.ratio_right,
+        };
 
-        Ok(())
+        self.settlement.record_vote(vote, event).await
     }
 }
diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs
index 1d488e1ad1d8fd81bd9d016d69255adfe9b22fc8..5d94c84113607b3bcd8d31d03ef5b8e1b87b67a7 100644
--- a/server/src/ui_action.rs
+++ b/server/src/ui_action.rs
@@ -12,8 +12,6 @@ pub const UI_RPC_FIELD: &str = "__rpc__";
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(tag = "action", rename_all = "snake_case")]
 pub enum HtmlUiAction {
-    /// Demo: morph `#demo-counter-panel` after bumping the persisted counter.
-    BumpDemoCounter,
     /// Record a pairwise vote and morph `#ranking-panel`.
     RecordVote {
         a: String,
@@ -52,18 +50,6 @@ pub fn parse_html_ui_from_form(
 mod tests {
     use super::*;
 
-    #[test]
-    fn bump_demo_counter_round_trip() {
-        let template = serde_json::json!({ "action": "bump_demo_counter" });
-        let mut form = HashMap::new();
-        form.insert(
-            UI_RPC_FIELD.to_string(),
-            serde_json::to_string(&template).unwrap(),
-        );
-        let a = parse_html_ui_from_form(&form).unwrap();
-        assert_eq!(a, HtmlUiAction::BumpDemoCounter);
-    }
-
     #[test]
     fn record_vote_round_trip_with_form_holes() {
         let template = serde_json::json!({
diff --git a/server/tests/integration_health.rs b/server/tests/integration_health.rs
index 8a58bc14aac68c779e7ce4ffa57d27b3220e9953..1d816e008b9bf629967e3b3c786c41afefc284e3 100644
--- a/server/tests/integration_health.rs
+++ b/server/tests/integration_health.rs
@@ -38,7 +38,7 @@ async fn healthz_ok() {
 }
 
 #[tokio::test]
-async fn home_has_demo_panel() {
+async fn home_has_main_panels() {
     let (addr, _tmp) = start_test_server().await;
     let client = reqwest::Client::new();
     let html = client
diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs
index bee79407dec120699a083f1a75adf9291e207fc7..7ede46d681fefbe25b1d98fc33520a185515eb1c 100644
--- a/server/tests/integration_ui.rs
+++ b/server/tests/integration_ui.rs
@@ -25,33 +25,6 @@ async fn start_test_server() -> (SocketAddr, TempDir) {
     (addr, tmp)
 }
 
-#[tokio::test]
-async fn post_ui_bump_returns_javascript_morph() {
-    let (addr, tmp) = start_test_server().await;
-    let rpc = serde_json::json!({ "action": "bump_demo_counter" }).to_string();
-    let mut form = HashMap::new();
-    form.insert(UI_RPC_FIELD.to_string(), rpc);
-
-    let client = reqwest::Client::new();
-    let body = client
-        .post(format!("http://{addr}/ui"))
-        .form(&form)
-        .send()
-        .await
-        .unwrap()
-        .text()
-        .await
-        .unwrap();
-
-    assert!(body.contains("Idiomorph.morph"));
-    assert!(body.contains("demo-counter-panel"));
-    assert!(body.contains("Counter:"));
-
-    let log_path = tmp.path().join("events.jsonl");
-    let log = std::fs::read_to_string(log_path).unwrap();
-    assert!(log.contains("demo_counter_bumped"));
-}
-
 #[tokio::test]
 async fn post_ui_record_vote_morphs_ranking_and_persists() {
     let (addr, tmp) = start_test_server().await;
@@ -90,8 +63,8 @@ async fn post_ui_record_vote_morphs_ranking_and_persists() {
         port: 0,
     };
     let state = create_app_state(cfg).await;
-    let mut group = state.group.write().await;
-    let ranked = sorter2_server::ranking::ranked_items(&mut group, 10_000, 1e-8);
+    let group = state.group.read().await;
+    let ranked = sorter2_server::ranking::ranked_items_cached(&group);
     assert_eq!(ranked.len(), 2);
     assert_eq!(ranked[0].item.as_str(), "alpha");
 }
diff --git a/test/smoke.clj b/test/smoke.clj
index b332324743b58baf3fe96d7477353749f137feae..11887c48282088e140d823a88ba616f6325835b3 100644
--- a/test/smoke.clj
+++ b/test/smoke.clj
@@ -26,7 +26,7 @@
             false))))))
 
 (deftest http-smoke-against-running-server
-  (testing "build, start, healthz, home contains RPC demo"
+  (testing "build, start, healthz, home contains main panels"
     (let [root (repo-root)
           data-dir (.getAbsolutePath (doto (io/file (System/getProperty "java.io.tmpdir")
                                                    (str "sorter2-smoke-" (System/currentTimeMillis)))


Side B — contributor: tommy-mor
Side B — commit message:
[c59951f5] fixed canonical item paths business

Side B — unified diff (full patch):
diff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs
index 12ad2c84faf2fbb693015d4552e45b5c54d587b9..c8a3937923161a6ff248bd77e87eff0dc6fe9ab0 100644
--- a/server/src/html/breadcrumb_path.rs
+++ b/server/src/html/breadcrumb_path.rs
@@ -1,4 +1,4 @@
-use crate::path_types::CanonicalItemUrl;
+use crate::path_types::{tilde_http_path_to_canonical, CanonicalItemUrl};
 
 /// Semantic view of an ontology path for rendering and routing decisions.
 pub(super) struct OntologyPath {
@@ -11,16 +11,7 @@ impl OntologyPath {
     /// Path is the `*path` segment from `/~/*path` (e.g. `topic/a`). Always treat it as under `~/`
     /// so it canonicalizes to `https://slug.social/~/…`, not the non-tilde site path.
     pub(super) fn from_input(path: &str) -> Self {
-        let p = path.trim_start_matches('/');
-        let raw = if p.starts_with("http://") || p.starts_with("https://") {
-            p.to_string()
-        } else if p.is_empty() {
-            "~/".to_string()
-        } else {
-            format!("~/{}", p)
-        };
-        let canonical = CanonicalItemUrl::parse(&raw)
-            .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap());
+        let canonical = tilde_http_path_to_canonical(path);
         Self::from_canonical(canonical)
     }
 
@@ -37,7 +28,7 @@ impl OntologyPath {
     }
 
     pub(super) fn root() -> Self {
-        Self::from_canonical(CanonicalItemUrl::parse("~/").unwrap())
+        Self::from_canonical(CanonicalItemUrl::ontology_root())
     }
 
     pub(super) fn is_root(&self) -> bool {
diff --git a/server/src/html/garden.rs b/server/src/html/garden.rs
index d58d9b46f575eb6b7e4971086b07dda75ca2f645..319feb15a6b68d2b5df98b4289fedbc9bdd048d3 100644
--- a/server/src/html/garden.rs
+++ b/server/src/html/garden.rs
@@ -459,6 +459,8 @@ struct ItemPageViewModel {
     item: String,
     body: Option<String>,
     sibling_rank: Option<SiblingRank>,
+    /// False at the tilde ontology root (`~/`): sibling-rank footnote does not apply.
+    item_has_parent: bool,
     child_rankings: ChildrenRankings,
     rank_history: Vec<RankHistoryEntryView>,
     /// Forum threads that mention or vote on this item.
@@ -470,11 +472,12 @@ fn build_sibling_rank(
     scope: &ScopeId,
     item: &CanonicalItemUrl,
 ) -> Option<SiblingRank> {
+    let item = item.clone().normalized_storage();
     let content = reduced
         .content_for_scope(scope)
         .unwrap_or_else(|| reduced.public());
     let group = &content.ranking_group;
-    let parent = item.parent()?;
+    let parent = item.parent()?.normalized_storage();
     let siblings: Vec<CanonicalItemUrl> = content
         .item_children
         .get(&parent)
@@ -492,7 +495,7 @@ fn build_sibling_rank(
     if scoped_idxs.is_empty() {
         return None;
     }
-    let current_idx = *group.item_to_idx.get(item)?;
+    let current_idx = *group.item_to_idx.get(&item)?;
     if !scoped_idxs.contains(&current_idx) {
         return None;
     }
@@ -520,7 +523,7 @@ fn build_sibling_rank(
         .filter_map(|li| local_to_global.get(*li).copied())
         .collect();
     let ranked = ranked_items_subset(group, &comp_global, 10000, 1e-8);
-    let position = ranked.iter().position(|r| &r.item == item)? + 1;
+    let position = ranked.iter().position(|r| r.item == item)? + 1;
     Some(SiblingRank {
         position,
         component_size: ranked.len(),
@@ -597,7 +600,9 @@ fn build_item_page_view_model(
         .content_for_scope(scope)
         .unwrap_or_else(|| reduced.public());
     let item_key = CanonicalItemUrl::parse(item)
-        .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap());
+        .unwrap_or_else(|| CanonicalItemUrl::parse("~/").unwrap())
+        .normalized_storage();
+    let item_has_parent = item_key.parent().is_some();
     let child_rankings = build_children_rankings(content, &item_key);
 
     let rank_history = build_rank_history(reduced, scope, item_key.as_str());
@@ -617,6 +622,7 @@ fn build_item_page_view_model(
             .cloned()
             .or_else(|| reduced.public().item_bodies.get(&item_key).cloned()),
         sibling_rank: build_sibling_rank(reduced, scope, &item_key),
+        item_has_parent,
         child_rankings,
         rank_history,
         threads,
@@ -652,7 +658,7 @@ async fn render_scope_view(
                             (format!("#{} of {}", rank.position, rank.component_size))
                         }
                         span class="muted" { (format!("({} siblings)", rank.sibling_total)) }
-                    } @else {
+                    } @else if model.item_has_parent {
                         span class="muted" { "unranked among siblings" }
                     }
                 }
@@ -815,6 +821,18 @@ mod tests {
         }));
     }
 
+    fn apply_ingest_room(state: &mut ReducerState, ts: i64, room_id: &str, raw: &str) {
+        state.apply_event(Event::Ingest(Ingest {
+            ts,
+            id: format!("ing-{ts}"),
+            raw: raw.to_string(),
+            principal: "testuser".to_string(),
+            delegate: Some("00000000-0000-0000-0000-000000000000:test:local/test".to_string()),
+            room_id: room_id.to_string(),
+            thread_tag: String::new(),
+        }));
+    }
+
     #[test]
     fn item_page_model_includes_body_and_unranked_without_votes() {
         let mut reduced = ReducerState::default();
@@ -885,4 +903,85 @@ mod tests {
                 || model.child_rankings.unranked_items.contains(&CanonicalItemUrl("https://slug.social/~/topic/kid2".to_string()))
         );
     }
+
+    #[test]
+    fn item_page_room_scope_root_lists_top_level_children() {
+        let mut reduced = ReducerState::default();
+        apply_ingest_room(
+            &mut reduced,
+            1,
+            "9ab12cd/my-room",
+            "@00000000-0000-0000-0000-000000000000:test:local/test\n~/t1 {a}\n~/t2 {b}\n",
+        );
+        use crate::path_types::CanonicalItemUrl;
+        let root = CanonicalItemUrl::ontology_root();
+        let model = build_item_page_view_model(
+            &reduced,
+            &ScopeId::Room("9ab12cd/my-room".to_string()),
+            root.as_str(),
+        );
+        assert!(!model.item_has_parent);
+        assert_eq!(model.child_rankings.unranked_items.len(), 2);
+        let set: std::collections::HashSet<&str> = model
+            .child_rankings
+            .unranked_items
+            .iter()
+            .map(|u| u.as_str())
+            .collect();
+        assert!(set.contains("https://slug.social/~/t1"));
+        assert!(set.contains("https://slug.social/~/t2"));
+    }
+
+    /// Top-level `~/a` vs `~/b` votes form one ranked component under the ontology root.
+    #[test]
+    fn item_page_room_scope_root_shows_ranked_child_group() {
+        let mut reduced = ReducerState::default();
+        apply_ingest_room(
+            &mut reduced,
+            1,
+            "9ab12cd/my-room",
+            "@00000000-0000-0000-0000-000000000000:test:local/test\n\
+             ~/a {a}\n~/b {b}\n~/a 2:1 ~/b {because}\n",
+        );
+        use crate::path_types::CanonicalItemUrl;
+        let root = CanonicalItemUrl::ontology_root();
+        let model = build_item_page_view_model(
+            &reduced,
+            &ScopeId::Room("9ab12cd/my-room".to_string()),
+            root.as_str(),
+        );
+        assert_eq!(model.child_rankings.component_rankings.len(), 1);
+        assert_eq!(model.child_rankings.component_rankings[0].pairs, 1);
+        let names: Vec<&str> = model.child_rankings.component_rankings[0]
+            .ranked
+            .iter()
+            .map(|r| r.item.as_str())
+            .collect();
+        assert_eq!(
+            names,
+            vec!["https://slug.social/~/a", "https://slug.social/~/b"]
+        );
+        assert!(model.child_rankings.unranked_items.is_empty());
+    }
+
+    /// Legacy `https://slug.social/~/` spelling still resolves children under the real root key.
+    #[test]
+    fn item_page_model_normalizes_legacy_tilde_root_storage_url() {
+        let mut reduced = ReducerState::default();
+        apply_ingest(
+            &mut reduced,
+            1,
+            "@00000000-0000-0000-0000-000000000000:test:local/test\n~/x {x}\n",
+        );
+        let model = build_item_page_view_model(
+            &reduced,
+            &ScopeId::Public,
+            "https://slug.social/~/",
+        );
+        assert_eq!(model.child_rankings.unranked_items.len(), 1);
+        assert_eq!(
+            model.child_rankings.unranked_items[0].as_str(),
+            "https://slug.social/~/x"
+        );
+    }
 }
diff --git a/server/src/path_types.rs b/server/src/path_types.rs
index 4c8075bbd488f1b9a5eda9e03ced83f6238c6d5e..361a9d446c9043cbdea5f060db2e8633c2fd9bf9 100644
--- a/server/src/path_types.rs
+++ b/server/src/path_types.rs
@@ -1,3 +1,5 @@
 //! Re-exports — implementations live in `slug-types` (`paths` module).
 
-pub use slug_types::paths::{CanonicalItemUrl, RelativePath, TildePath};
+pub use slug_types::paths::{
+    tilde_http_path_to_canonical, CanonicalItemUrl, RelativePath, TildeHttpPathTail, TildePath,
+};
diff --git a/server/src/scope_rank.rs b/server/src/scope_rank.rs
index dc640848232b7e79142bfeeea3003c9023f84854..d656b2f0a0a3623ca6b234b746beaaca8ae6017d 100644
--- a/server/src/scope_rank.rs
+++ b/server/src/scope_rank.rs
@@ -149,9 +149,10 @@ pub fn build_rankings_for_item_set(content: &ContentState, items_in_scope: &[Can
 /// Build connected-component rankings for direct children of parent_scope.
 /// Matches the HTML garden view: multiple components, isolates, no-vote items.
 pub fn build_children_rankings(content: &ContentState, parent: &CanonicalItemUrl) -> ChildrenRankings {
+    let parent = parent.clone().normalized_storage();
     let items: Vec<CanonicalItemUrl> = content
         .item_children
-        .get(parent)
+        .get(&parent)
         .map(|s| s.iter().cloned().collect())
         .unwrap_or_default();
     build_rankings_for_item_set(content, &items)
diff --git a/server/tests/integration.rs b/server/tests/integration.rs
index f9c218378f6a173e56ae1cec797b3c492986eac0..d4c5bfe9c6f1c71dc61878bd8c5e729b1b7c69ef 100644
--- a/server/tests/integration.rs
+++ b/server/tests/integration.rs
@@ -704,6 +704,62 @@ async fn test_private_room_post_links_use_private_garden_routes() {
     assert!(garden_body.contains(&format!("/r/{room_short}/{room_slug}/t/garden-thread")));
 }
 
+#[tokio::test]
+async fn test_private_room_garden_root_lists_top_level_tilde_children() {
+    let (addr, _tmp, _log, _handle) = create_test_server().await;
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+    let bearer = test_bearer();
+
+    let create = rpc_batch(
+        &client,
+        addr,
+        Some(&bearer),
+        serde_json::json!([{
+            "RoomCreate": { "slug": "garden-root-list" }
+        }]),
+    )
+    .await;
+    let room_id = create["results"][0]["result"]["RoomCreated"]["room_id"]
+        .as_str()
+        .unwrap()
+        .to_string();
+    let (room_short, room_slug) = room_id.split_once('/').unwrap();
+
+    let rpc = ui_post_ingest_rpc(
+        &room_id,
+        "ing",
+        "~/test1 {wow}\n~/test2 {wow2}\n~/test1 2:1 ~/test2 {because}\n",
+    );
+    let post = client
+        .post(format!("http://{addr}/ui"))
+        .header("Authorization", format!("Bearer {bearer}"))
+        .form(&[("__rpc__", rpc.as_str())])
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(post.status(), reqwest::StatusCode::OK);
+
+    let root_page = client
+        .get(format!("http://{addr}/r/{room_short}/{room_slug}/~"))
+        .header("Authorization", format!("Bearer {bearer}"))
+        .send()
+        .await
+        .unwrap();
+    assert!(root_page.status().is_success());
+    let body = root_page.text().await.unwrap();
+    assert!(
+        body.contains("ranked child groups"),
+        "expected garden child panel: {}",
+        body.len()
+    );
+    assert!(body.contains("~/test1"));
+    assert!(body.contains("~/test2"));
+    assert!(body.contains("ordering 1"));
+}
+
 #[tokio::test]
 async fn test_post_check_returns_targeted_js_error_for_missing_thread_tag() {
     let (addr, _tmp, _log, _handle) = create_test_server().await;
diff --git a/test/browser_public_garden.clj b/test/browser_public_garden.clj
new file mode 100644
index 0000000000000000000000000000000000000000..7bea08e1cf2c8f5b1a94b0640a46e9ba5607b19b
--- /dev/null
+++ b/test/browser_public_garden.clj
@@ -0,0 +1,100 @@
+(ns test.browser-public-garden
+  "Regression: ingest ontology items in the public room via RPC, then open /~ in the browser
+   and assert ranked + unranked paths appear (HTML garden index — not JSON API)."
+  (:require [babashka.fs :as fs]
+            [cheshire.core :as json]
+            [clojure.string :as str]
+            [clojure.test :refer [deftest is]]
+            [com.blockether.spel.core :as core]
+            [com.blockether.spel.locator :as locator]
+            [com.blockether.spel.page :as page]
+            [test.common :as common]
+            [test.oauth :as oauth]))
+
+(defn- wait-for-text [pg selector expected timeout-ms]
+  (let [deadline (+ (System/currentTimeMillis) timeout-ms)]
+    (loop []
+      (let [text (locator/text-content (page/locator pg selector))]
+        (if (and (string? text) (str/includes? text expected))
+          true
+          (if (< (System/currentTimeMillis) deadline)
+            (do (Thread/sleep 200) (recur))
+            false))))))
+
+(defn public-garden-flow! []
+  (println "\n━━━ browser public room garden index (RPC seed + GET /~) ━━━\n")
+
+  (common/letlocals
+   (bind build (common/run-cargo-build-release! ["slugsocial-server"]))
+   (is (zero? (:exit build)) "cargo build succeeds")
+   (bind server-bin "target/release/slugsocial-server")
+
+   (bind tmp-dir (str (fs/create-temp-dir {:prefix "slug-browser-pub-garden-"})))
+   (bind slug-port (common/pick-port))
+   (bind google-port (common/pick-port))
+   (bind base-url (str "http://127.0.0.1:" slug-port))
+   (bind google-url (str "http://127.0.0.1:" google-port))
+
+   (bind !server (atom nil))
+   (bind !google (atom nil))
+   (bind server-env (common/slug-server-env tmp-dir base-url google-url slug-port))
+   (try
+     (reset! !google (oauth/start-mock-google google-port
+                                              :google-users ["google-user-alice"]))
+     (reset! !server (common/start-server server-bin server-env))
+     (is (common/wait-for-server base-url 10000) "server responds to /healthz")
+
+     (let [alice-token (oauth/fetch-bearer-token! base-url :username "alice")
+           thread-tag "browser-pub-garden"
+           ;; Ranked pair at root + one isolate so both panels are exercised.
+           raw (str "# " thread-tag "\n\n"
+                    "~/br-pub-a {alpha}\n"
+                    "~/br-pub-b {beta}\n"
+                    "~/br-pub-c {gamma}\n"
+                    "~/br-pub-a 2:1 ~/br-pub-b {browser regression vote}\n")
+           post-resp (oauth/http-post-json
+                      (str base-url "/api/v0/rpc")
+                      [{"Post" {"room" "public"
+                                "thread_tag" thread-tag
+                                "text" raw
+                                "return_rank_diff" false}}]
+                      :headers {"Authorization" (str "Bearer " alice-token)})
+           post-json (json/parse-string (:body post-resp) false)
+           _ (is (true? (get-in post-json ["results" 0 "ok"])) "seed public post via rpc")
+           rank-resp (oauth/http-post-json
+                      (str base-url "/api/v0/rpc")
+                      [{"GetGardenRank" {"room" "public"
+                                         "parent_path" "~"
+                                         "depth" 1}}])
+           rank-json (json/parse-string (:body rank-resp) false)
+           _ (is (true? (get-in rank-json ["results" 0 "ok"])) "GetGardenRank ok")
+           comps (get-in rank-json ["results" 0 "result" "GardenRank" "components"])
+           _ (is (pos? (count comps)) "rank API reports at least one component")]
+       (core/with-playwright [pw]
+         (core/with-browser [browser (core/launch-chromium pw {:headless true :channel "chrome"})]
+           (core/with-context [ctx (core/new-context browser)]
+             (core/with-page [pg (core/new-page-from-context ctx)]
+               (page/navigate pg (str base-url "/login"))
+               (is (wait-for-text pg "body" "@alice" 15000) "alice session after login")
+               (page/navigate pg (str base-url "/~"))
+               (is (wait-for-text pg "body" "paths" 15000) "public garden index shows paths heading")
+               (is (wait-for-text pg "body" "ordering" 10000)
+                   "ranked child group meta visible")
+               (is (wait-for-text pg "body" "~/br-pub-a" 10000) "ranked list shows ~/br-pub-a")
+               (is (wait-for-text pg "body" "~/br-pub-b" 10000) "ranked list shows ~/br-pub-b")
+               (is (wait-for-text pg "body" "unranked" 10000) "unranked section present")
+               (is (wait-for-text pg "body" "~/br-pub-c" 10000)
+                   "unranked list shows ~/br-pub-c"))))))
+
+     (finally
+       (when-some [s @!server] (common/kill-server s))
+       (when-some [g @!google] ((:stop-fn g)))
+       (fs/delete-tree tmp-dir)))
+
+   nil))
+
+(defn public-garden-browser-test [& _args]
+  (public-garden-flow!))
+
+(deftest browser-public-garden-index-check
+  (public-garden-flow!))
diff --git a/tests.edn b/tests.edn
index 56fdfa4f29383ad305fd8068783e4efe2ed334a0..6e96432ba766461b4233c75dc48db2633483e5e0 100644
--- a/tests.edn
+++ b/tests.edn
@@ -16,7 +16,8 @@
    :ns-patterns ["^test\\.browser-sse$"
                  "^test\\.browser-ui-morph$"
                  "^test\\.browser-post-redact$"
-                 "^test\\.browser-room-delete$"]
+                 "^test\\.browser-room-delete$"
+                 "^test\\.browser-public-garden$"]
    :kaocha.filter/skip-meta [:skip]
    :parallel? false}]
  :plugins [:kaocha.plugin/junit-xml]
diff --git a/types/src/lib.rs b/types/src/lib.rs
index 8cea90238ef6207d65ecdb2903b8958fafb213d2..edbb923e4d7d41ad82dfc254c3bd697562383527 100644
--- a/types/src/lib.rs
+++ b/types/src/lib.rs
@@ -4,8 +4,9 @@ pub mod paths;
 pub mod timeago;
 
 pub use paths::{
-    canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments, CanonicalItemUrl,
-    ForumThreadUrl, GardenItemUrl, RelativePath, TildeOntologyPath, TildePath,
+    canonicalize_item, canonicalize_tag, item_parent_path, item_path_segments, normalize_slug_ontology_storage_url,
+    CanonicalItemUrl, ForumThreadUrl, GardenItemUrl, RelativePath, SLUG_TILDE_ONTOLOGY_ROOT,
+    TildeHttpPathTail, TildeOntologyPath, TildePath, tilde_http_path_to_canonical,
 };
 
 /// Max characters returned for a garden item body unless `full=true` / `--full` (API + CLI).
diff --git a/types/src/paths.rs b/types/src/paths.rs
index 668323ed777f360f2838a0dfe6eae68905d1183b..8971f599a7ebcf399f60c306d35ee28d0f581194 100644
--- a/types/src/paths.rs
+++ b/types/src/paths.rs
@@ -1,5 +1,13 @@
 //! Canonical paths, storage ids, and JSON href newtypes. All normalization and
 //! room-aware URL rules for items live here.
+//!
+//! ## String kinds (parse in this module only)
+//!
+//! - **[`canonicalize_item`] / [`CanonicalItemUrl`]** — graph storage key and DSL form; tilde
+//!   ontology root is always [`SLUG_TILDE_ONTOLOGY_ROOT`] (no `…/~/` trailing slash only).
+//! - **[`TildeHttpPathTail`]** — capture from `GET /~/*path` or `…/r/…/~/…` (the `*path` segment).
+//! - **`-/…` wire form** — external items; see [`canonicalize_item`] dash branch.
+//! - **[`GardenItemUrl`], [`ForumThreadUrl`]** — JSON / browser href surfaces.
 
 use std::borrow::Borrow;
 use std::fmt;
@@ -7,6 +15,23 @@ use std::ops::Deref;
 
 use serde::{Deserialize, Serialize};
 
+// ---------------------------------------------------------------------------
+// Slug tilde ontology (single storage form for `~/`)
+// ---------------------------------------------------------------------------
+
+/// Canonical absolute URL for the tilde ontology **root** (`~/` in UI). Used as the
+/// `item_children` parent key for top-level items and must match [`CanonicalItemUrl::ontology_root`].
+pub const SLUG_TILDE_ONTOLOGY_ROOT: &str = "https://slug.social/~";
+
+/// Collapse legacy or parser variants of the ontology root to [`SLUG_TILDE_ONTOLOGY_ROOT`].
+pub fn normalize_slug_ontology_storage_url(s: &str) -> String {
+    if s == "https://slug.social/~/" {
+        SLUG_TILDE_ONTOLOGY_ROOT.to_string()
+    } else {
+        s.to_string()
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Normalization (moved from server `canonical_path`)
 // ---------------------------------------------------------------------------
@@ -89,6 +114,9 @@ pub fn canonicalize_item(input: &str) -> String {
         .join("/");
 
     if is_tilde {
+        if tail.is_empty() {
+            return SLUG_TILDE_ONTOLOGY_ROOT.to_string();
+        }
         format!("https://slug.social/~/{}", tail)
     } else if tail.is_empty() {
         "https://slug.social".to_string()
@@ -173,7 +201,7 @@ impl CanonicalItemUrl {
         if c.is_empty() {
             None
         } else {
-            Some(Self(c))
+            Some(Self(normalize_slug_ontology_storage_url(&c)))
         }
     }
 
@@ -181,8 +209,19 @@ impl CanonicalItemUrl {
         &self.0
     }
 
+    /// Collapses legacy slug ontology root spellings so [`HashMap`] keys match the reducer graph.
+    pub fn normalized_storage(self) -> Self {
+        Self(normalize_slug_ontology_storage_url(self.as_str()))
+    }
+
     pub fn tilde_tail(&self) -> Option<&str> {
-        self.0.strip_prefix("https://slug.social/~/")
+        if let Some(tail) = self.0.strip_prefix("https://slug.social/~/") {
+            return Some(tail);
+        }
+        if self.0 == SLUG_TILDE_ONTOLOGY_ROOT || self.0 == "https://slug.social/~/" {
+            return Some("");
+        }
+        None
     }
 
     pub fn last_segment(&self) -> &str {
@@ -193,7 +232,7 @@ impl CanonicalItemUrl {
     }
 
     pub fn ontology_root() -> Self {
-        Self("https://slug.social/~".to_string())
+        Self(SLUG_TILDE_ONTOLOGY_ROOT.to_string())
     }
 
     pub fn parent(&self) -> Option<Self> {
@@ -234,9 +273,13 @@ impl CanonicalItemUrl {
 
     /// `-/` representation for external `https://…` items, `~/…` for slug ontology, else unchanged.
     pub fn display_path(&self) -> String {
-        if let Some(tail) = self.0.strip_prefix("https://slug.social/~/") {
-            format!("~/{}", tail)
-        } else if let Some(tail) = self.0.strip_prefix("https://") {
+        if let Some(tail) = self.tilde_tail() {
+            if tail.is_empty() {
+                return "~/".to_string();
+            }
+            return format!("~/{}", tail);
+        }
+        if let Some(tail) = self.0.strip_prefix("https://") {
             if tail.starts_with("slug.social") {
                 self.0.clone()
             } else {
@@ -276,6 +319,37 @@ impl CanonicalItemUrl {
     }
 }
 
+/// HTTP route capture: path segment after `~/` in `GET /~/*path` or `…/r/…/~/…` (empty = ontology root).
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TildeHttpPathTail(pub String);
+
+impl TildeHttpPathTail {
+    pub fn new(path_segment: &str) -> Self {
+        Self(path_segment.trim_start_matches('/').to_string())
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    pub fn to_canonical(&self) -> CanonicalItemUrl {
+        tilde_http_path_to_canonical(self.as_str())
+    }
+}
+
+/// Map the router's tilde tail (e.g. `topic/a`, or empty for root) to a [`CanonicalItemUrl`].
+pub fn tilde_http_path_to_canonical(path_segment: &str) -> CanonicalItemUrl {
+    let p = path_segment.trim_start_matches('/');
+    let raw = if p.starts_with("http://") || p.starts_with("https://") {
+        p.to_string()
+    } else if p.is_empty() {
+        "~/".to_string()
+    } else {
+        format!("~/{}", p)
+    };
+    CanonicalItemUrl::parse(&raw).unwrap_or_else(|| CanonicalItemUrl::ontology_root())
+}
+
 impl fmt::Display for CanonicalItemUrl {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
@@ -557,6 +631,44 @@ mod tests {
     fn canonical_parent_root_is_none() {
         let root = CanonicalItemUrl::parse("~/").unwrap();
         assert!(root.parent().is_none());
+        assert_eq!(root.as_str(), SLUG_TILDE_ONTOLOGY_ROOT);
+        assert_eq!(root, CanonicalItemUrl::ontology_root());
+    }
+
+    #[test]
+    fn tilde_ontology_root_unifies_forms() {
+        assert_eq!(canonicalize_item("~/"), SLUG_TILDE_ONTOLOGY_ROOT);
+        assert_eq!(
+            normalize_slug_ontology_storage_url("https://slug.social/~/"),
+            SLUG_TILDE_ONTOLOGY_ROOT.to_string()
+        );
+        assert_eq!(
+            CanonicalItemUrl::parse("https://slug.social/~/")
+                .unwrap()
+                .as_str(),
+            SLUG_TILDE_ONTOLOGY_ROOT
+        );
+        let legacy = CanonicalItemUrl("https://slug.social/~/".to_string());
+        assert_eq!(legacy.normalized_storage().as_str(), SLUG_TILDE_ONTOLOGY_ROOT);
+    }
+
+    #[test]
+    fn tilde_http_path_tail_maps_router_segment() {
+        assert_eq!(
+            TildeHttpPathTail::new("").to_canonical(),
+            CanonicalItemUrl::ontology_root()
+        );
+        assert_eq!(
+            tilde_http_path_to_canonical("topic/x").as_str(),
+            "https://slug.social/~/topic/x"
+        );
+    }
+
+    #[test]
+    fn display_path_slug_ontology_root() {
+        let r = CanonicalItemUrl::ontology_root();
+        assert_eq!(r.display_path(), "~/");
+        assert_eq!(r.tilde_tail(), Some(""));
     }
 
     #[test]