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:
[62d18183] room create path

Side A — unified diff (full patch):
diff --git a/cli/GUIDE.sorter b/cli/GUIDE.sorter
index dcb06a46045564f8f6f6acffbda6f88644d453cc..9828cba4d9c17b7cce3de597d8724609b2b2adbe 100644
--- a/cli/GUIDE.sorter
+++ b/cli/GUIDE.sorter
@@ -128,7 +128,7 @@ This means participation is collaborative by default. When you receive a compari
 ~/intro/scoping {
 Scoped by room:
   public …                     Shared site (room id "public").
-  private <ROOM_ID> …          Private room (e.g. abc12xy/my-project from RoomCreate over RPC).
+  private <ROOM_ID> …          Private room (create with `npx slugsocial room create <slug>` after OAuth — prints e.g. abc12xy/my-project).
 
 Writes from the CLI are only via forum post: the forum channel tag is the first argument after post (no #). Humans post through the website; CLI requires --delegate (agent identity).
 
@@ -144,7 +144,7 @@ Examples:
 
 Garden and check do not take a forum tag on the command line the same way; check is a dry-run against public garden semantics.
 
-Global (no room prefix): identity, whoami, feed, search, healthz.
+Global (no room prefix): room, identity, whoami, feed, search, healthz.
 }
 
 ~/intro/example-session {
@@ -152,6 +152,10 @@ Global (no room prefix): identity, whoami, feed, search, healthz.
 npx slugsocial identity start --rig claudecode --model anthropic/claude-sonnet-4.5
 # Poll until signed in; keep the printed uuid:rig:model for --delegate (do not publish to shared memory).
 
+# Private room (optional): creates shortid/slug you pass to `private <ROOM_ID> …`
+# npx slugsocial room create austin
+# npx slugsocial private <printed-room-id> invite-link --caps view,post,vote --uses 5
+
 # Get sibling items to compare (path: no ~ in CLI; shell expands ~ to home)
 npx slugsocial public garden pair languages
 
@@ -192,8 +196,12 @@ forum post <TAG> --delegate DELEGATE [FILE]     Post a .sorter doc (stdin if no
 
 check [FILE]                                    Validate without submitting (public garden dry-run)
 
+invite-link --caps view,post[,…] [--uses N]     Mint shareable /join/… link (private rooms; Manage required)
+audit [--json]                                  List principals + capabilities (private rooms; View or Manage)
+
 Global (no public/private prefix):
 
+room create <slug>                              Create a private room (bearer required); prints ROOM_ID for `private …` (use `public …` for the shared site, not a room)
 identity start --rig <name> --model <provider/model>  New delegate id + OAuth pending session
 identity poll <session>                           Complete OAuth; saves bearer token
 
diff --git a/cli/src/main.rs b/cli/src/main.rs
index 8eda9f485bd1f7392f1e34be27176c21e20354eb..5b1a5845e90bfea9bd9a1e1af5744e97e566b5ae 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -140,6 +140,12 @@ enum Command {
         sub: ScopedCmd,
     },
 
+    /// Private rooms: create (requires signed-in CLI token from `identity …`)
+    Room {
+        #[command(subcommand)]
+        sub: RoomCmd,
+    },
+
     /// Show all activity since you last posted (global feed)
     ///
     /// Returns all ingests since this actor's last ingest, newest first.
@@ -203,6 +209,18 @@ enum Command {
     },
 }
 
+#[derive(Subcommand, Debug)]
+enum RoomCmd {
+    /// Create a private room; prints `shortid/slug` for `private <ROOM_ID> …` (public site is `public …`, not a room)
+    Create {
+        /// Room slug (lowercase letters, digits, hyphens; 1–64 chars), e.g. `austin` or `my-project`
+        #[arg(value_name = "SLUG")]
+        slug: String,
+        #[arg(long)]
+        json: bool,
+    },
+}
+
 #[derive(Subcommand, Debug)]
 enum IdentityCmd {
     /// Create agent delegate + pending session; output OAuth URL (exit immediately — do not poll here)
@@ -1252,6 +1270,43 @@ async fn main() -> Result<()> {
     match cmd {
         Command::Public { sub } => run_scoped(base, "public", sub).await?,
         Command::Private { room, sub } => run_scoped(base, &room, sub).await?,
+        Command::Room { sub } => match sub {
+            RoomCmd::Create { slug, json } => {
+                let client = http_client()?;
+                let bearer = effective_bearer().ok_or_else(|| {
+                    anyhow!(
+                        "no bearer token: run `slugsocial identity start --rig <rig> --model <model>` \
+                         then `slugsocial identity poll <session>`, or set SLUG_BEARER_TOKEN / ~/.config/slugsocial/token"
+                    )
+                })?;
+                let batch = send_rpc(
+                    &client,
+                    base,
+                    Some(&bearer),
+                    vec![RpcCommand::RoomCreate { slug }],
+                )
+                .await?;
+                match rpc_line_ok(&batch.results[0])? {
+                    RpcResult::RoomCreated { room_id } => {
+                        if json {
+                            println!(
+                                "{}",
+                                serde_json::to_string_pretty(&serde_json::json!({
+                                    "ok": true,
+                                    "room_id": room_id,
+                                }))?
+                            );
+                        } else {
+                            println!("{room_id}");
+                            println!();
+                            println!("Next: npx slugsocial private {room_id} forum post <TAG> --delegate '…' …");
+                            println!("      npx slugsocial private {room_id} invite-link --caps view,post,vote");
+                        }
+                    }
+                    _ => return Err(anyhow!("unexpected RPC result")),
+                }
+            }
+        },
 
         Command::Healthz { json } => {
             let client = http_client()?;
diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs
index f6bbc3df71909a2da7403cd46fe4ea6ca130c692..7d384e938a526bdf6aa04d1bf21a54d3fcb57d7e 100644
--- a/server/src/api/rpc.rs
+++ b/server/src/api/rpc.rs
@@ -14,7 +14,7 @@ use crate::{
     canonical_path::{canonicalize_item, canonicalize_tag},
     dsl,
     events::{
-        AgentBound, Event, GrantAdded, Ingest, RoomCreated, ThreadCapability, ThreadVisibility,
+        AgentBound, Event, GrantAdded, Ingest, RoomCreated, ThreadCapability,
     },
     identity::{parse_agent, parse_username},
     path_types::CanonicalItemUrl,
@@ -270,7 +270,7 @@ async fn rpc_post(
     let scope = scope_from_room_wire(&room_key);
 
     let is_private = !matches!(scope, ScopeId::Public);
-    if is_private && !reduced.rooms.contains_key(&room_key) {
+    if is_private && !reduced.rooms.contains(&room_key) {
         drop(reduced);
         return Err(("unknown room".into(), Some(format!("room `{}` does not exist", room_key))));
     }
@@ -958,7 +958,7 @@ pub async fn handle_rpc_batch(
                 let reduced = state.reduced.read().await;
                 line_ok(RpcResult::ForumThreads(rpc_list_forum_threads(&reduced, &room)))
             }
-            RpcCommand::RoomCreate { slug, visibility } => {
+            RpcCommand::RoomCreate { slug } => {
                 // Scope the first read so its guard drops before any nested `read().await` / `write().await`.
                 // A guard from `match verify(..., &*state.reduced.read().await)` would otherwise live for the
                 // whole `match` and deadlock here (tokio::sync::RwLock is not reentrant).
@@ -975,53 +975,42 @@ pub async fn handle_rpc_batch(
                         } else if !slug.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') {
                             line_err("slug must be lowercase alphanumeric with hyphens", None)
                         } else {
-                            match visibility.as_deref().unwrap_or("private") {
-                                "private" | "public" => {
-                                    let vis = if visibility.as_deref() == Some("public") {
-                                        ThreadVisibility::Public
-                                    } else {
-                                        ThreadVisibility::Private
-                                    };
-                                    let short_id = loop {
-                                        let id = gen_short_id();
-                                        if !state.reduced.read().await.rooms.contains_key(&format!("{id}/{slug}")) {
-                                            break id;
-                                        }
-                                    };
-                                    let room_id = format!("{short_id}/{slug}");
-                                    let ts = now_ms();
-                                    let tc_ev = Event::RoomCreated(RoomCreated {
-                                        ts,
-                                        room_id: room_id.clone(),
-                                        slug: slug.clone(),
-                                        owner: principal.clone(),
-                                        visibility: vis,
-                                    });
-                                    let ga_ev = Event::GrantAdded(GrantAdded {
-                                        ts,
-                                        room_id: room_id.clone(),
-                                        username: principal.clone(),
-                                        capabilities: vec![
-                                            ThreadCapability::View,
-                                            ThreadCapability::Post,
-                                            ThreadCapability::Vote,
-                                            ThreadCapability::AddItem,
-                                            ThreadCapability::Manage,
-                                        ],
-                                        granted_by: principal.clone(),
-                                    });
-                                    if let Err(e) = state.event_log.append(&tc_ev).await {
-                                        line_err(format!("{e}"), None)
-                                    } else if let Err(e) = state.event_log.append(&ga_ev).await {
-                                        line_err(format!("{e}"), None)
-                                    } else {
-                                        let mut r = state.reduced.write().await;
-                                        r.apply_event(tc_ev);
-                                        r.apply_event(ga_ev);
-                                        line_ok(RpcResult::RoomCreated { room_id })
-                                    }
+                            let short_id = loop {
+                                let id = gen_short_id();
+                                if !state.reduced.read().await.rooms.contains(&format!("{id}/{slug}")) {
+                                    break id;
                                 }
-                                other => line_err(format!("unknown visibility: {other}"), None),
+                            };
+                            let room_id = format!("{short_id}/{slug}");
+                            let ts = now_ms();
+                            let tc_ev = Event::RoomCreated(RoomCreated {
+                                ts,
+                                room_id: room_id.clone(),
+                                slug: slug.clone(),
+                                owner: principal.clone(),
+                            });
+                            let ga_ev = Event::GrantAdded(GrantAdded {
+                                ts,
+                                room_id: room_id.clone(),
+                                username: principal.clone(),
+                                capabilities: vec![
+                                    ThreadCapability::View,
+                                    ThreadCapability::Post,
+                                    ThreadCapability::Vote,
+                                    ThreadCapability::AddItem,
+                                    ThreadCapability::Manage,
+                                ],
+                                granted_by: principal.clone(),
+                            });
+                            if let Err(e) = state.event_log.append(&tc_ev).await {
+                                line_err(format!("{e}"), None)
+                            } else if let Err(e) = state.event_log.append(&ga_ev).await {
+                                line_err(format!("{e}"), None)
+                            } else {
+                                let mut r = state.reduced.write().await;
+                                r.apply_event(tc_ev);
+                                r.apply_event(ga_ev);
+                                line_ok(RpcResult::RoomCreated { room_id })
                             }
                         }
                     }
@@ -1161,7 +1150,7 @@ pub async fn handle_rpc_batch(
                     Err((_, m)) => line_err(m, None),
                     Ok(principal) => {
                         let reduced = state.reduced.read().await;
-                        if !reduced.rooms.contains_key(&room) {
+                        if !reduced.rooms.contains(&room) {
                             line_err("unknown room", None)
                         } else {
                             let can_audit = reduced.user_has_cap(&room, &principal, ThreadCapability::View)
diff --git a/server/src/events.rs b/server/src/events.rs
index 9e60f2c218f5c871a93e855e415dd984e3a017c5..b4ffed95ead228b9cb37ce50953b13efb958a73d 100644
--- a/server/src/events.rs
+++ b/server/src/events.rs
@@ -1,12 +1,5 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum ThreadVisibility {
-    Public,
-    Private,
-}
-
 #[derive(Debug, Clone, Copy, Hash, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 pub enum ThreadCapability {
@@ -57,13 +50,13 @@ pub struct AgentBound {
     pub username: String,
 }
 
+/// Private space keyed as `shortid/slug`.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct RoomCreated {
     pub ts: i64,
     pub room_id: String,
     pub slug: String,
     pub owner: String,
-    pub visibility: ThreadVisibility,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
diff --git a/server/src/html/search.rs b/server/src/html/search.rs
index 9353cf229fbbd2cfbab5b89ba63ebe192042c91f..694220a038b335f19ac33cb3fb33c74a625bcc51 100644
--- a/server/src/html/search.rs
+++ b/server/src/html/search.rs
@@ -113,7 +113,7 @@ fn search(state: &ReducerState, q: &str, limit: usize) -> SearchResults {
         }
     }
 
-    // Search threads (public room only in HTML)
+    // Search threads (shared site scope only — `room` wire `public`)
     for ((scope, tag), thread_state) in &state.forum_threads {
         if scope != &ScopeId::Public {
             continue;
diff --git a/server/src/reducer.rs b/server/src/reducer.rs
index 5190d0a7ee3d545a786a68fef483322aafdce7f9..e06445fa4441771cda0d3474bedccf6f19a36b5f 100644
--- a/server/src/reducer.rs
+++ b/server/src/reducer.rs
@@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use serde::{Deserialize, Serialize};
 
 use crate::canonical_path::canonicalize_tag;
-use crate::events::{Event, Ingest, ThreadCapability, ThreadVisibility};
+use crate::events::{Event, Ingest, ThreadCapability};
 use crate::path_types::CanonicalItemUrl;
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
@@ -151,11 +151,6 @@ pub struct RankHistoryEntry {
     pub post_id: String,
 }
 
-#[derive(Debug, Clone)]
-pub struct RoomState {
-    pub visibility: crate::events::ThreadVisibility,
-}
-
 /// Durable invite link state (from [`crate::events::InviteMinted`] / [`crate::events::InviteRedeemed`]).
 #[derive(Debug, Clone)]
 pub struct ActiveInviteState {
@@ -171,7 +166,6 @@ pub enum RoomTimelineKind {
     RoomCreated {
         owner: String,
         slug: String,
-        visibility: ThreadVisibility,
     },
     GrantAdded {
         username: String,
@@ -235,8 +229,8 @@ pub struct ReducerState {
     pub ingests_by_id: HashMap<String, Ingest>,
     /// (scope, thread_tag) → ingest ids, newest first.
     pub ingests_by_scope_thread: HashMap<(ScopeId, String), VecDeque<String>>,
-    /// Private (or public) room registry: room_id → visibility from [`RoomCreated`].
-    pub rooms: HashMap<String, RoomState>,
+    /// Private room ids (`shortid/slug`) known from [`RoomCreated`].
+    pub rooms: HashSet<String>,
     /// (scope, thread_tag) → last activity.
     pub forum_threads: HashMap<(ScopeId, String), ForumThreadState>,
     pub actor_last_post_ts: HashMap<String, i64>,
@@ -403,12 +397,7 @@ impl ReducerState {
                 self.agent_bindings.insert(ab.agent, ab.username);
             }
             Event::RoomCreated(rc) => {
-                self.rooms.insert(
-                    rc.room_id.clone(),
-                    RoomState {
-                        visibility: rc.visibility,
-                    },
-                );
+                self.rooms.insert(rc.room_id.clone());
                 self.room_timeline
                     .entry(rc.room_id.clone())
                     .or_default()
@@ -417,7 +406,6 @@ impl ReducerState {
                         kind: RoomTimelineKind::RoomCreated {
                             owner: rc.owner.clone(),
                             slug: rc.slug.clone(),
-                            visibility: rc.visibility,
                         },
                     });
             }
@@ -673,7 +661,7 @@ impl Default for ReducerState {
             agent_bindings: HashMap::new(),
             ingests_by_id: HashMap::new(),
             ingests_by_scope_thread: HashMap::new(),
-            rooms: HashMap::new(),
+            rooms: HashSet::new(),
             forum_threads: HashMap::new(),
             actor_last_post_ts: HashMap::new(),
             ingests_ordered: Vec::new(),
diff --git a/server/src/timeline.rs b/server/src/timeline.rs
index 251158943ab36d3015268e35f6bdd01c3f42ab3b..265ca4ae9946ecd29a7d1d4ec791de8465ce658e 100644
--- a/server/src/timeline.rs
+++ b/server/src/timeline.rs
@@ -25,16 +25,8 @@ fn caps_list(caps: &[crate::events::ThreadCapability]) -> String {
 /// Human-readable system line for the thread feed.
 pub fn format_room_timeline_entry(e: &RoomTimelineEntry) -> String {
     match &e.kind {
-        RoomTimelineKind::RoomCreated {
-            owner,
-            slug,
-            visibility,
-        } => {
-            let vis = match visibility {
-                crate::events::ThreadVisibility::Public => "public",
-                crate::events::ThreadVisibility::Private => "private",
-            };
-            format!("@{owner} created room #{slug} ({vis})")
+        RoomTimelineKind::RoomCreated { owner, slug } => {
+            format!("@{owner} created room #{slug}")
         }
         RoomTimelineKind::GrantAdded {
             username,
@@ -141,7 +133,7 @@ pub fn merge_thread_rows(
     rows
 }
 
-/// Public forum thread (`room_wire == "public"`): same merge (timeline usually empty).
+/// Shared-site thread view (`room_wire == "public"` on the wire). Same merge as private rooms; private-room timeline is unused here.
 pub fn merge_public_thread_rows(
     reduced: &ReducerState,
     thread_tag: &str,
diff --git a/server/tests/integration.rs b/server/tests/integration.rs
index b930120da09fe7d307f0411b84fb639fb8bd0b15..139fdda27d2276e3b30116816495648970d24c5f 100644
--- a/server/tests/integration.rs
+++ b/server/tests/integration.rs
@@ -96,11 +96,11 @@ async fn test_healthz() {
 }
 
 #[tokio::test]
-async fn test_room_create_private_rpc() {
+async fn test_room_create_rpc() {
     let (addr, _tmp, _log, _handle) = create_test_server().await;
     let client = reqwest::Client::new();
     let batch = serde_json::json!([{
-        "RoomCreate": { "slug": "secret-project", "visibility": "private" }
+        "RoomCreate": { "slug": "secret-project" }
     }]);
     let body = rpc_batch(&client, addr, Some(&test_bearer()), batch).await;
     let line = &body["results"][0];
diff --git a/test/grants.bb b/test/grants.bb
index 4ded5ce92576cdea653cce0ba8a751be4374731a..697e7d91545dd3ee96efde07fc8c3cf90f1a8056 100644
--- a/test/grants.bb
+++ b/test/grants.bb
@@ -82,7 +82,7 @@
            ;; Alice creates a private room.
            _ (println "\nalice creates private room…")
            create (rpc-batch! base-url alice-token
-                              [{"RoomCreate" {"slug" "secret-project" "visibility" "private"}}])
+                              [{"RoomCreate" {"slug" "secret-project"}}])
            _ (assert! (= 200 (:status create)) "room create HTTP 200")
            _ (assert! (rpc-line-ok? (:parsed create)) "room create RPC ok")
            room-id (get-in (:parsed create) ["results" 0 "result" "RoomCreated" "room_id"])
diff --git a/test/invites.bb b/test/invites.bb
index f72b1e630a6856174cdef11eb977e2f81b16e551..ca0fd6c858400671452c4ec59c490d05101dd0e4 100644
--- a/test/invites.bb
+++ b/test/invites.bb
@@ -86,7 +86,7 @@
 
            _ (println "\nalice creates private room…")
            create (rpc-batch! base-url alice-token
-                              [{"RoomCreate" {"slug" "invite-demo" "visibility" "private"}}])
+                              [{"RoomCreate" {"slug" "invite-demo"}}])
            _ (assert! (= 200 (:status create)) "room create HTTP 200")
            _ (assert! (rpc-line-ok? (:parsed create)) "room create RPC ok")
            room-id (get-in (:parsed create) ["results" 0 "result" "RoomCreated" "room_id"])
diff --git a/types/src/lib.rs b/types/src/lib.rs
index 98c66a00fd27803ef6f75b5ac478ff2eb762d771..bb8586f1734f77d95598a9294bdb0de2d55bf715 100644
--- a/types/src/lib.rs
+++ b/types/src/lib.rs
@@ -319,8 +319,6 @@ pub enum RpcCommand {
     },
     RoomCreate {
         slug: String,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        visibility: Option<String>,
     },
     RoomGrant {
         room: String,


Side B — contributor: tommy-mor
Side B — commit message:
[674964ef] refactor: Deref for href newtypes, CanonicalItemUrl through resolve_item

- Implement Deref<Target=str> for GardenItemUrl, ForumThreadUrl, TildeOntologyPath
- resolve_item returns CanonicalItemUrl; validate uses HashSet<CanonicalItemUrl>
- compute_scope_rank_changes keys are CanonicalItemUrl; pair RPC uses Vec pool
- pick_random_distinct_canonical; connectivity stats on &[CanonicalItemUrl]
- Global rank unranked uses stored ids before GardenItemUrl mapping

Made-with: Cursor

Side B — unified diff (full patch):
diff --git a/server/src/api/helpers.rs b/server/src/api/helpers.rs
index 03b3e77911ccd662bec8635345dafe2593cf242e..1b291db83df7364a026f2e147e0a29a70a399371 100644
--- a/server/src/api/helpers.rs
+++ b/server/src/api/helpers.rs
@@ -30,13 +30,13 @@ pub fn now_ms() -> i64 {
     t.as_millis() as i64
 }
 
-/// Resolve an item path as a first-class canonical path.
-pub fn resolve_item(item: &str) -> Result<String, String> {
+/// Resolve DSL/user input to a stored canonical item id.
+pub fn resolve_item(item: &str) -> Result<CanonicalItemUrl, String> {
     let canonical = canonicalize_item(item);
     if canonical.is_empty() {
         return Err(format!("empty item path: `{}`", item));
     }
-    Ok(canonical)
+    Ok(CanonicalItemUrl(canonical))
 }
 
 pub fn parse_parent_specs(parent: Option<&String>) -> Vec<String> {
@@ -94,7 +94,7 @@ pub fn paginate_rankings(
     (out_components, out_unranked)
 }
 
-pub fn pick_random_distinct(items: &[String]) -> Option<(String, String)> {
+pub fn pick_random_distinct_canonical(items: &[CanonicalItemUrl]) -> Option<(CanonicalItemUrl, CanonicalItemUrl)> {
     use rand::seq::SliceRandom;
     if items.len() < 2 {
         return None;
@@ -123,15 +123,12 @@ pub fn is_pair_voted(group: &crate::reducer::GroupState, a: &str, b: &str) -> bo
     group.voted_pairs.contains(&(i, j))
 }
 
-pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[String]) -> ConnectivityStats {
+pub fn compute_connectivity_stats(group: &crate::reducer::GroupState, pool: &[CanonicalItemUrl]) -> ConnectivityStats {
     let n = pool.len();
 
     let global_idxs: Vec<Option<usize>> = pool
         .iter()
-        .map(|it| {
-            let key = CanonicalItemUrl(it.clone());
-            group.item_to_idx.get(&key).copied()
-        })
+        .map(|it| group.item_to_idx.get(it).copied())
         .collect();
     let present: Vec<usize> = global_idxs.iter().filter_map(|x| *x).collect();
 
diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs
index cf22cb0129366c3aed031bc86f3197a4321cb806..a10ce662105cff8fad949c6b83f7035ce79bed18 100644
--- a/server/src/api/mod.rs
+++ b/server/src/api/mod.rs
@@ -24,7 +24,7 @@ pub use auth::{
 
 pub use helpers::{
     api_error, compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings,
-    parse_parent_specs, pick_random_distinct, resolve_item, sha256_hex, vote_touches_path,
+    parse_parent_specs, pick_random_distinct_canonical, resolve_item, sha256_hex, vote_touches_path,
 };
 
 pub use rpc::handle_rpc_batch;
diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs
index 5f7d50188f1381267402f2e57e671234ef5db2fd..de0955d0887d32740e1fd18365205c5bdb53c247 100644
--- a/server/src/api/rpc.rs
+++ b/server/src/api/rpc.rs
@@ -29,7 +29,7 @@ use crate::{
 use super::auth::verify_bearer_principal;
 use super::helpers::{
     compute_connectivity_stats, is_pair_voted, now_ms, paginate_rankings, parse_parent_specs,
-    pick_random_distinct, resolve_item, vote_touches_path,
+    pick_random_distinct_canonical, resolve_item, vote_touches_path,
 };
 use super::validate::{normalize_room_and_thread, validate_ingest_document};
 
@@ -146,21 +146,21 @@ fn authorize_room_read(reduced: &ReducerState, headers: &HeaderMap, room: &str)
 }
 
 fn compute_scope_rank_changes(
-    parent: &str,
+    parent: &CanonicalItemUrl,
     before: &crate::scope_rank::ChildrenRankings,
     after: &crate::scope_rank::ChildrenRankings,
     room_wire: &str,
 ) -> Option<ScopeRankChanges> {
-    fn build_positions(rankings: &crate::scope_rank::ChildrenRankings) -> HashMap<String, Option<RankPosition>> {
+    fn build_positions(rankings: &crate::scope_rank::ChildrenRankings) -> HashMap<CanonicalItemUrl, Option<RankPosition>> {
         let mut map = HashMap::new();
         for comp in &rankings.component_rankings {
             let total = comp.ranked.len();
             for (i, item) in comp.ranked.iter().enumerate() {
-                map.insert(item.item.as_str().to_string(), Some(RankPosition { rank: i + 1, of: total }));
+                map.insert(item.item.clone(), Some(RankPosition { rank: i + 1, of: total }));
             }
         }
         for item in &rankings.unranked_items {
-            map.insert(item.as_str().to_string(), None);
+            map.insert(item.clone(), None);
         }
         map
     }
@@ -168,7 +168,7 @@ fn compute_scope_rank_changes(
     let before_pos = build_positions(before);
     let after_pos = build_positions(after);
 
-    let all_items: std::collections::BTreeSet<String> = before_pos.keys().cloned()
+    let all_items: std::collections::BTreeSet<CanonicalItemUrl> = before_pos.keys().cloned()
         .chain(after_pos.keys().cloned())
         .collect();
 
@@ -184,7 +184,7 @@ fn compute_scope_rank_changes(
         };
         if changed {
             changes.push(RankChange {
-                item: GardenItemUrl::from_storage_str(&item, room_wire),
+                item: GardenItemUrl::from_stored(&item, room_wire),
                 before: b,
                 after: a,
             });
@@ -203,11 +203,7 @@ fn compute_scope_rank_changes(
     });
 
     Some(ScopeRankChanges {
-        parent: if parent.is_empty() {
-            "/".to_string()
-        } else {
-            GardenItemUrl::from_storage_str(parent, room_wire).into_inner()
-        },
+        parent: GardenItemUrl::from_stored(parent, room_wire).into_inner(),
         changes,
     })
 }
@@ -473,8 +469,8 @@ async fn rpc_post(
         for s in &v.doc.statements {
             if let dsl::Stmt::Vote { item1, item2, .. } = s {
                 if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
-                    if let Some(p) = CanonicalItemUrl::parse(&a).and_then(|c| c.parent()) { parents.insert(p); }
-                    if let Some(p) = CanonicalItemUrl::parse(&b).and_then(|c| c.parent()) { parents.insert(p); }
+                    if let Some(p) = a.parent() { parents.insert(p); }
+                    if let Some(p) = b.parent() { parents.insert(p); }
                 }
             }
         }
@@ -525,7 +521,7 @@ async fn rpc_post(
             .filter_map(|p| {
                 let before = pre_rankings.get(p)?;
                 let after = crate::scope_rank::build_children_rankings(content, p);
-                compute_scope_rank_changes(p.as_str(), before, &after, &room_key)
+                compute_scope_rank_changes(p, before, &after, &room_key)
             })
             .collect();
         if v.is_empty() { None } else { Some(v) }
@@ -638,8 +634,8 @@ async fn rpc_check(
         for s in &v.doc.statements {
             if let dsl::Stmt::Vote { item1, item2, .. } = s {
                 if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
-                    if let Some(p) = CanonicalItemUrl::parse(&a).and_then(|c| c.parent()) { parents.insert(p); }
-                    if let Some(p) = CanonicalItemUrl::parse(&b).and_then(|c| c.parent()) { parents.insert(p); }
+                    if let Some(p) = a.parent() { parents.insert(p); }
+                    if let Some(p) = b.parent() { parents.insert(p); }
                 }
             }
         }
@@ -961,7 +957,7 @@ fn rpc_search(reduced: &ReducerState, q: &str, limit: usize, principal: Option<&
 async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Result<RpcResult, RpcErr> {
     let scope = scope_from_room_wire(&room);
     let reduced_arc = state.reduced.clone();
-    let pool: Vec<String> = {
+    let pool: Vec<CanonicalItemUrl> = {
         let reduced = reduced_arc.read().await;
         let content = content_for_room(&reduced, &room);
         let tmp = if parent_path.trim().is_empty() {
@@ -970,12 +966,11 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re
             Some(parent_path.clone())
         };
         let specs = parse_parent_specs(tmp.as_ref());
-        let raw_pool: Vec<CanonicalItemUrl> = if specs.is_empty() {
+        if specs.is_empty() {
             content.ranking_group.idx_to_item.clone()
         } else {
             crate::scope_rank::resolve_scope(content, &specs)
-        };
-        raw_pool.into_iter().map(|it| it.0).collect()
+        }
     };
     if pool.len() < 2 {
         return Err((
@@ -983,31 +978,30 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re
             Some("add items via ingest".into()),
         ));
     }
-    let selected: Option<(String, String)> = {
+    let selected: Option<(CanonicalItemUrl, CanonicalItemUrl)> = {
         let mut reduced = reduced_arc.write().await;
         let content = reduced.content.entry(scope.clone()).or_default();
         let group = &mut content.ranking_group;
         if group.idx_to_item.is_empty() {
-            pick_random_distinct(&pool)
+            pick_random_distinct_canonical(&pool)
         } else {
             let mut rng = rand::thread_rng();
-            let idxs: Vec<usize> = pool.iter()
-                .filter_map(|it| {
-                    let key = CanonicalItemUrl(it.clone());
-                    group.item_to_idx.get(&key).copied()
-                })
+            let idxs: Vec<usize> = pool
+                .iter()
+                .filter_map(|it| group.item_to_idx.get(it).copied())
                 .collect();
             let ranked = ranked_items_subset(group, &idxs, 10000, 1e-8);
-            let ranked_set: HashSet<String> = ranked.iter().map(|r| r.item.as_str().to_string()).collect();
-            let unsorted: Vec<String> = pool.iter()
+            let ranked_set: HashSet<CanonicalItemUrl> = ranked.iter().map(|r| r.item.clone()).collect();
+            let unsorted: Vec<CanonicalItemUrl> = pool
+                .iter()
                 .filter(|it| !ranked_set.contains(*it))
                 .cloned()
                 .collect();
-            let mut pick: Option<(String, String)> = None;
+            let mut pick: Option<(CanonicalItemUrl, CanonicalItemUrl)> = None;
             if !unsorted.is_empty() {
                 if let Some(left) = unsorted.choose(&mut rng).cloned() {
-                    let mut candidates: Vec<String> = if !ranked.is_empty() {
-                        ranked.iter().map(|r| r.item.as_str().to_string()).collect()
+                    let mut candidates: Vec<CanonicalItemUrl> = if !ranked.is_empty() {
+                        ranked.iter().map(|r| r.item.clone()).collect()
                     } else {
                         pool.clone()
                     };
@@ -1021,21 +1015,21 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re
                     let a = ranked[i].item.as_str();
                     let b = ranked[i + 1].item.as_str();
                     if a != b && !is_pair_voted(group, a, b) {
-                        pick = Some((a.to_string(), b.to_string()));
+                        pick = Some((ranked[i].item.clone(), ranked[i + 1].item.clone()));
                         break;
                     }
                 }
                 if pick.is_none() {
                     for _ in 0..64 {
                         let (Some(a), Some(b)) = (pool.choose(&mut rng).cloned(), pool.choose(&mut rng).cloned()) else { break; };
-                        if a != b && !is_pair_voted(group, &a, &b) {
+                        if a != b && !is_pair_voted(group, a.as_str(), b.as_str()) {
                             pick = Some((a, b));
                             break;
                         }
                     }
                 }
             }
-            pick.or_else(|| pick_random_distinct(&pool))
+            pick.or_else(|| pick_random_distinct_canonical(&pool))
         }
     };
     let Some((left, right)) = selected else {
@@ -1043,8 +1037,8 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re
     };
     let reduced = reduced_arc.read().await;
     let content = content_for_room(&reduced, &room);
-    let left_key = CanonicalItemUrl(left.clone());
-    let right_key = CanonicalItemUrl(right.clone());
+    let left_key = left.clone();
+    let right_key = right.clone();
     let lb = content.item_bodies.get(&left_key).cloned();
     let rb = content.item_bodies.get(&right_key).cloned();
     let th: Vec<String> = content
@@ -1058,8 +1052,8 @@ async fn rpc_get_pair(state: &AppState, room: String, parent_path: String) -> Re
         .collect();
     let cs = compute_connectivity_stats(&content.ranking_group, &pool);
     Ok(RpcResult::Pair(PairResponse {
-        left: GardenItemUrl::from_storage_str(&left, &room),
-        right: GardenItemUrl::from_storage_str(&right, &room),
+        left: GardenItemUrl::from_stored(&left, &room),
+        right: GardenItemUrl::from_stored(&right, &room),
         left_body: lb,
         right_body: rb,
         threads: th,
@@ -1554,7 +1548,7 @@ pub async fn handle_rpc_batch(
                     for r in items {
                         let pct = want_percent.then(|| ((r.score - bot) / range * 100.0).clamp(0.0, 100.0));
                         ranked.push(RankRow {
-                            item: GardenItemUrl::from_storage_str(r.item.as_str(), &room),
+                            item: GardenItemUrl::from_stored(&r.item, &room),
                             score: r.score,
                             percent: pct,
                         });
@@ -1562,11 +1556,11 @@ pub async fn handle_rpc_batch(
                 }
 
                 let ranked_total = ranked.len();
-                let mut unranked: Vec<String> = content
+                let mut unranked: Vec<CanonicalItemUrl> = content
                     .items
                     .iter()
                     .filter(|it| !group.item_to_idx.contains_key(*it))
-                    .map(|it| it.as_str().to_string())
+                    .cloned()
                     .collect();
                 unranked.sort();
                 let unranked_total = unranked.len();
@@ -1574,7 +1568,7 @@ pub async fn handle_rpc_batch(
                 let page: Vec<RankRow> = ranked
                     .into_iter()
                     .chain(unranked.into_iter().map(|it| RankRow {
-                        item: GardenItemUrl::from_storage_str(&it, &room),
+                        item: GardenItemUrl::from_stored(&it, &room),
                         score: 0.0,
                         percent: want_percent.then_some(0.0),
                     }))
@@ -1722,7 +1716,7 @@ pub async fn handle_rpc_batch(
                     .filter(|p| !parents.contains(p.as_str()))
                     .map(|p| GardenItemUrl::from_stored(p, &room))
                     .collect();
-                paths.sort_by(|a, b| a.as_str().cmp(b.as_str()));
+                paths.sort();
                 line_ok(RpcResult::Leaves(LeavesResponse { paths }))
                 }
             },
diff --git a/server/src/api/validate.rs b/server/src/api/validate.rs
index a51c783ee9785569b5a44c0b1572471fe00d174b..3c7aa80fd485cf247231fe5c5c7e6fea62f22534 100644
--- a/server/src/api/validate.rs
+++ b/server/src/api/validate.rs
@@ -52,7 +52,7 @@ pub fn validate_ingest_document(
     };
 
     let ts = super::helpers::now_ms();
-    let mut defined_in_doc: HashSet<String> = HashSet::new();
+    let mut defined_in_doc: HashSet<CanonicalItemUrl> = HashSet::new();
 
     for s in &doc.statements {
         match s {
@@ -66,14 +66,14 @@ pub fn validate_ingest_document(
                 let Some(body_text) = body else {
                     return Err((
                         StatusCode::BAD_REQUEST,
-                        format!("item missing body: {}", GardenItemUrl::from_storage_str(&item, room_wire)),
+                        format!("item missing body: {}", GardenItemUrl::from_stored(&item, room_wire)),
                         Some("items must be declared with bodies, e.g. `~/path/item { ... }`".to_string()),
                     ));
                 };
                 if body_text.trim().is_empty() {
                     return Err((
                         StatusCode::BAD_REQUEST,
-                        format!("item body is empty: {}", GardenItemUrl::from_storage_str(&item, room_wire)),
+                        format!("item body is empty: {}", GardenItemUrl::from_stored(&item, room_wire)),
                         Some("write at least one sentence inside `{ ... }`".to_string()),
                     ));
                 }
@@ -102,11 +102,8 @@ pub fn validate_ingest_document(
                 };
                 let missing: Vec<String> = [&a, &b]
                     .into_iter()
-                    .filter(|it| {
-                        let key = CanonicalItemUrl((*it).clone());
-                        !defined_in_doc.contains(*it) && !item_exists(&key)
-                    })
-                    .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner())
+                    .filter(|it| !defined_in_doc.contains(*it) && !item_exists(it))
+                    .map(|it| GardenItemUrl::from_stored(it, room_wire).into_inner())
                     .collect();
                 if !missing.is_empty() {
                     return Err((
@@ -120,11 +117,8 @@ pub fn validate_ingest_document(
                 }
                 let missing_body: Vec<String> = [&a, &b]
                     .into_iter()
-                    .filter(|it| {
-                        let key = CanonicalItemUrl((*it).clone());
-                        !defined_in_doc.contains(*it) && !body_exists(&key)
-                    })
-                    .map(|it| GardenItemUrl::from_storage_str(it, room_wire).into_inner())
+                    .filter(|it| !defined_in_doc.contains(*it) && !body_exists(it))
+                    .map(|it| GardenItemUrl::from_stored(it, room_wire).into_inner())
                     .collect();
                 if !missing_body.is_empty() {
                     return Err((
diff --git a/server/src/html/editor.rs b/server/src/html/editor.rs
index ecdd226b1b17d5f11d1b79f99add5759ef918281..26d648d7c8d6e5d53ce5ed7a051b44856fca2fcf 100644
--- a/server/src/html/editor.rs
+++ b/server/src/html/editor.rs
@@ -130,8 +130,8 @@ pub async fn editor_check(
                 for s in &v.doc.statements {
                     if let crate::dsl::Stmt::Vote { item1, item2, .. } = s {
                         if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
-                            if let Some(p) = crate::path_types::CanonicalItemUrl::parse(&a).and_then(|c| c.parent()) { parents.insert(p); }
-                            if let Some(p) = crate::path_types::CanonicalItemUrl::parse(&b).and_then(|c| c.parent()) { parents.insert(p); }
+                            if let Some(p) = a.parent() { parents.insert(p); }
+                            if let Some(p) = b.parent() { parents.insert(p); }
                         }
                     }
                 }
diff --git a/types/src/paths.rs b/types/src/paths.rs
index 2950a7502255927583fbacdfd2adb700f0b0c221..839684dfa0ecdd6c2572e2d8132ecee4d5c41bf8 100644
--- a/types/src/paths.rs
+++ b/types/src/paths.rs
@@ -3,6 +3,7 @@
 
 use std::borrow::Borrow;
 use std::fmt;
+use std::ops::Deref;
 
 use serde::{Deserialize, Serialize};
 
@@ -319,6 +320,14 @@ impl fmt::Display for GardenItemUrl {
     }
 }
 
+impl Deref for GardenItemUrl {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 fn garden_href_string(item: &str, room_wire: &str) -> String {
     let room = room_wire.trim();
     if room.is_empty() || room == "public" {
@@ -386,6 +395,14 @@ impl fmt::Display for ForumThreadUrl {
     }
 }
 
+impl Deref for ForumThreadUrl {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 /// `~/a/b` style path for list UIs (paths index `path` field).
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(transparent)]
@@ -412,6 +429,14 @@ impl fmt::Display for TildeOntologyPath {
     }
 }
 
+impl Deref for TildeOntologyPath {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -452,6 +477,13 @@ mod tests {
         assert_eq!(c.tilde_segments(), Vec::<&str>::new());
     }
 
+    #[test]
+    fn garden_item_url_deref_to_str() {
+        let g = GardenItemUrl::from_storage_str("https://slug.social/~/x", "public");
+        let s: &str = &*g;
+        assert_eq!(s, "https://slug.social/~/x");
+    }
+
     #[test]
     fn garden_public_passthrough_https() {
         let u = "https://slug.social/~/a/b";