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:
[9e20d06c] Add sorterc dev tool for offline DSL compile and JSONL lint.

Introduce a workspace-only binary that validates .sorter files into ranking JSON and scans events.jsonl for corrupt or unreplayable ingests.

Co-authored-by: Cursor <cursoragent@cursor.com>

Side A — unified diff (full patch):
diff --git a/Cargo.lock b/Cargo.lock
index bf8153d9c723af97122c9ffdd4a7cfe82e853bb6..a07734f089b466440c3ae6fc1087ce85fc24ce62 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1826,6 +1826,17 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "sorterc"
+version = "0.0.1"
+dependencies = [
+ "anyhow",
+ "clap",
+ "serde",
+ "serde_json",
+ "slugsocial-server",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.8"
diff --git a/Cargo.toml b/Cargo.toml
index 149cbf07901eab57c593184ff8719a75d530f1da..25337acdd61e44b20f354c78fed4a88caf896280 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["server", "cli"]
+members = ["server", "cli", "sorterc"]
 resolver = "2"
 
 
diff --git a/agents.md b/agents.md
index d8b801e454fdf37e7ac6038b91a69f83b0746d59..ce646ed3cd7123be4732dccec4a6800467e651e7 100644
--- a/agents.md
+++ b/agents.md
@@ -93,6 +93,17 @@ SLUG_GOOGLE_CLIENT_SECRET=mock
 
 After OAuth completes, the pending-session poll returns a `slug_…` bearer token for API calls.
 
+### Dev-only offline tooling
+
+**`sorterc`** — workspace binary, not published via npm. Compiles `.sorter` files and lints `events.jsonl` without a server:
+
+```
+cargo run -p sorterc -- compile path/to/doc.sorter [--base events.jsonl] [--room public] [--pretty]
+cargo run -p sorterc -- scan path/to/events.jsonl [--pretty]
+```
+
+`compile` validates DSL, simulates ingest against empty (or `--base`) reducer state, and prints JSON rankings. `scan` reports corrupt JSONL lines and ingests that fail DSL replay.
+
 ### Testing
 
 - **Rust tests:** `cargo nextest run --workspace` (163 tests; requires `cargo-nextest`)
diff --git a/server/src/lib.rs b/server/src/lib.rs
index c1d477d21aea03aff00e6f0689b0b4379d0d68d2..ad8e31099c807fb5844acb16cd5086a2f19327a7 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -10,6 +10,7 @@ pub mod form_template;
 pub mod html;
 pub mod identity;
 pub mod middleware;
+pub mod offline;
 pub mod path_types;
 pub mod ranking;
 pub mod reducer;
diff --git a/server/src/offline.rs b/server/src/offline.rs
new file mode 100644
index 0000000000000000000000000000000000000000..54ad0ded096a305ef8454ab2cdd1c3af71b14f5d
--- /dev/null
+++ b/server/src/offline.rs
@@ -0,0 +1,333 @@
+//! Offline `.sorter` compilation and JSONL diagnostics (no network, no auth).
+
+use std::collections::HashSet;
+use std::path::Path;
+
+use serde::Serialize;
+use slug_types::{CheckScopeRanking, RankComponent, RankRow, paths::GardenItemUrl};
+
+use crate::{
+    api::{resolve_item, validate_ingest_document},
+    dsl,
+    events::{Event, Ingest},
+    path_types::ItemId,
+    reducer::{ReducerState, ScopeId, scope_from_room_wire},
+    scope_rank::build_children_rankings,
+};
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CompileStats {
+    pub items: usize,
+    pub votes: usize,
+    pub prose_blocks: usize,
+}
+
+#[derive(Debug, Serialize)]
+pub struct CompileResult {
+    pub ok: bool,
+    pub threads: Vec<String>,
+    pub rankings: Vec<CheckScopeRanking>,
+    pub stats: CompileStats,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CompileError {
+    pub ok: bool,
+    pub error: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hint: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct BadJsonLine {
+    pub line: usize,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MalformedIngest {
+    pub line: usize,
+    pub id: String,
+    pub room_id: String,
+    pub thread_tag: String,
+    pub reason: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ScanResult {
+    pub ok: bool,
+    pub path: String,
+    pub total_lines: usize,
+    pub parsed_events: usize,
+    pub bad_json_lines: Vec<BadJsonLine>,
+    pub malformed_ingests: Vec<MalformedIngest>,
+    pub skipped_ingests: usize,
+}
+
+fn document_stats(doc: &dsl::Document) -> CompileStats {
+    let mut items = 0usize;
+    let mut votes = 0usize;
+    let mut prose_blocks = 0usize;
+    for stmt in &doc.statements {
+        match stmt {
+            dsl::Stmt::Item { .. } => items += 1,
+            dsl::Stmt::Vote { .. } => votes += 1,
+            dsl::Stmt::Prose { .. } => prose_blocks += 1,
+        }
+    }
+    CompileStats {
+        items,
+        votes,
+        prose_blocks,
+    }
+}
+
+fn threads_in_document(text: &str) -> Vec<String> {
+    let mut out = HashSet::new();
+    for line in text.lines() {
+        let trimmed = line.trim();
+        if !trimmed.starts_with('#') {
+            continue;
+        }
+        let rest = trimmed.trim_start_matches('#').trim();
+        if rest.is_empty() {
+            continue;
+        }
+        let tag = rest.split_whitespace().next().unwrap_or(rest);
+        let tag = tag.split(':').next().unwrap_or(tag).trim();
+        if tag.is_empty() {
+            continue;
+        }
+        out.insert(format!("#{}", crate::canonical_path::canonicalize_tag(tag)));
+    }
+    let mut tags: Vec<String> = out.into_iter().collect();
+    tags.sort();
+    tags
+}
+
+fn voted_parent_scopes(doc: &dsl::Document) -> Vec<ItemId> {
+    let mut parents = HashSet::new();
+    for stmt in &doc.statements {
+        if let dsl::Stmt::Vote { item1, item2, .. } = stmt {
+            if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
+                if let Some(p) = a.parent() {
+                    parents.insert(p);
+                }
+                if let Some(p) = b.parent() {
+                    parents.insert(p);
+                }
+            }
+        }
+    }
+    let mut out: Vec<ItemId> = parents.into_iter().collect();
+    out.sort();
+    out
+}
+
+fn rankings_for_simulated(
+    simulated: &ReducerState,
+    scope: &ScopeId,
+    room_wire: &str,
+    doc: &dsl::Document,
+) -> Vec<CheckScopeRanking> {
+    voted_parent_scopes(doc)
+        .iter()
+        .map(|parent| {
+            let scoped_content = simulated
+                .content_for_scope(&scope)
+                .unwrap_or_else(|| simulated.public());
+            let scoped = build_children_rankings(scoped_content, parent);
+            let components: Vec<RankComponent> = scoped
+                .component_rankings
+                .into_iter()
+                .map(|comp| RankComponent {
+                    pairs: comp.pairs,
+                    ranking: comp
+                        .ranked
+                        .into_iter()
+                        .map(|r| RankRow {
+                            item: GardenItemUrl::from_stored(&r.item, room_wire),
+                            score: r.score,
+                            percent: None,
+                        })
+                        .collect(),
+                })
+                .collect();
+            CheckScopeRanking {
+                parent: GardenItemUrl::from_stored(parent, room_wire).into_inner(),
+                components,
+                unranked_items: scoped
+                    .unranked_items
+                    .into_iter()
+                    .map(|it| GardenItemUrl::from_stored(&it, room_wire))
+                    .collect(),
+            }
+        })
+        .collect()
+}
+
+/// Validate and simulate one `.sorter` document against optional base reducer state.
+pub fn compile_document(
+    base: &ReducerState,
+    room: &str,
+    text: &str,
+) -> Result<CompileResult, CompileError> {
+    let room_key = room.trim();
+    let scope = scope_from_room_wire(room_key);
+    let validated = validate_ingest_document(base, text, &scope).map_err(|(_, message, hint)| {
+        CompileError {
+            ok: false,
+            error: message,
+            hint,
+        }
+    })?;
+
+    let event = Event::Ingest(Ingest {
+        ts: validated.ts,
+        id: uuid::Uuid::new_v4().to_string(),
+        raw: validated.raw_text.clone(),
+        principal: "offline".to_string(),
+        delegate: None,
+        room_id: room_key.to_string(),
+        thread_tag: "offline".to_string(),
+    });
+
+    let mut simulated = base.clone();
+    simulated.apply_event(event);
+
+    Ok(CompileResult {
+        ok: true,
+        threads: threads_in_document(text),
+        rankings: rankings_for_simulated(&simulated, &scope, room_key, &validated.doc),
+        stats: document_stats(&validated.doc),
+    })
+}
+
+fn ingest_parse_error(raw: &str) -> Option<String> {
+    dsl::parse_full(raw).err().map(|e| e.to_string())
+}
+
+fn load_events_from_jsonl(path: &Path) -> Result<(Vec<(usize, Event)>, Vec<BadJsonLine>), std::io::Error> {
+    let text = std::fs::read_to_string(path)?;
+    let mut events = Vec::new();
+    let mut bad_json_lines = Vec::new();
+    for (idx, line) in text.lines().enumerate() {
+        let line_no = idx + 1;
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        match serde_json::from_str::<Event>(trimmed) {
+            Ok(ev) => events.push((line_no, ev)),
+            Err(e) => bad_json_lines.push(BadJsonLine {
+                line: line_no,
+                message: e.to_string(),
+            }),
+        }
+    }
+    Ok((events, bad_json_lines))
+}
+
+/// Replay a JSONL event log into reducer state (same rules as server boot).
+pub fn load_reducer_from_jsonl(path: &Path) -> Result<(ReducerState, Vec<BadJsonLine>), std::io::Error> {
+    let (events, bad_json_lines) = load_events_from_jsonl(path)?;
+    let mut state = ReducerState::default();
+    for (_line_no, ev) in events {
+        state.apply_event(ev);
+    }
+    Ok((state, bad_json_lines))
+}
+
+/// Scan an events.jsonl for corrupt JSON lines and ingests that fail DSL replay.
+pub fn scan_jsonl(path: &Path) -> Result<ScanResult, std::io::Error> {
+    let text = std::fs::read_to_string(path)?;
+    let total_lines = text.lines().count();
+    let (events, bad_json_lines) = load_events_from_jsonl(path)?;
+
+    let mut malformed_ingests = Vec::new();
+    let mut skipped_ingests = 0usize;
+    let mut state = ReducerState::default();
+    let parsed_events = events.len();
+
+    for (line_no, ev) in events {
+        if let Event::Ingest(ref ing) = ev {
+            if let Some(reason) = ingest_parse_error(&ing.raw) {
+                malformed_ingests.push(MalformedIngest {
+                    line: line_no,
+                    id: ing.id.clone(),
+                    room_id: ing.room_id.clone(),
+                    thread_tag: ing.thread_tag.clone(),
+                    reason,
+                });
+            }
+            let before = state.ingests_by_id.len();
+            state.apply_event(ev);
+            if state.ingests_by_id.len() == before {
+                skipped_ingests += 1;
+            }
+        } else {
+            state.apply_event(ev);
+        }
+    }
+
+    let ok = bad_json_lines.is_empty() && malformed_ingests.is_empty() && skipped_ingests == 0;
+
+    Ok(ScanResult {
+        ok,
+        path: path.display().to_string(),
+        total_lines,
+        parsed_events,
+        bad_json_lines,
+        malformed_ingests,
+        skipped_ingests,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TUTORIAL: &str = include_str!("../tests/fixtures/tutorial.sorter");
+
+    #[test]
+    fn compile_tutorial_fixture_emits_rankings() {
+        let result = compile_document(&ReducerState::default(), "public", TUTORIAL).unwrap();
+        assert!(result.ok);
+        assert!(!result.threads.is_empty());
+        assert!(result.stats.items >= 6);
+        assert!(result.stats.votes >= 6);
+        assert!(!result.rankings.is_empty());
+    }
+
+    #[test]
+    fn compile_rejects_vote_on_missing_item() {
+        let err = compile_document(
+            &ReducerState::default(),
+            "public",
+            "{ reason }\n~/missing/a 2:1 ~/missing/b",
+        )
+        .unwrap_err();
+        assert!(!err.ok);
+        assert!(err.error.contains("undefined"));
+    }
+
+    #[test]
+    fn scan_empty_jsonl_is_ok() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("events.jsonl");
+        std::fs::write(&path, "").unwrap();
+        let report = scan_jsonl(&path).unwrap();
+        assert!(report.ok);
+        assert!(report.bad_json_lines.is_empty());
+    }
+
+    #[test]
+    fn scan_reports_bad_json_line() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("events.jsonl");
+        std::fs::write(&path, "{not json}\n").unwrap();
+        let report = scan_jsonl(&path).unwrap();
+        assert!(!report.ok);
+        assert_eq!(report.bad_json_lines.len(), 1);
+    }
+}
diff --git a/sorterc/Cargo.toml b/sorterc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92d477aff9b53291fb1a266db83065c1c800791d
--- /dev/null
+++ b/sorterc/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "sorterc"
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+publish = false
+description = "Offline .sorter compiler and events.jsonl linter (dev only)"
+
+[[bin]]
+name = "sorterc"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1"
+clap = { version = "4", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+slugsocial-server = { path = "../server" }
diff --git a/sorterc/readme.md b/sorterc/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..1ebcc3fc935541ea9e47e0458ec67a750fe19fff
--- /dev/null
+++ b/sorterc/readme.md
@@ -0,0 +1,92 @@
+# sorterc
+
+Dev-only offline tooling for the slug `.sorter` DSL and `events.jsonl` event log.
+
+`sorterc` is **not** published via npm and does not talk to slug.social. It reuses the same parser, validator, and ranking code as the server, but runs entirely on local files.
+
+## Build
+
+From the repo root:
+
+```bash
+cargo build -p sorterc
+cargo run -p sorterc -- --help
+```
+
+## Commands
+
+### `compile` — evaluate a `.sorter` document
+
+Reads a `.sorter` file (or `-` for stdin), validates the DSL, simulates one ingest against reducer state, and prints JSON rankings to stdout.
+
+```bash
+cargo run -p sorterc -- compile path/to/doc.sorter
+cargo run -p sorterc -- compile path/to/doc.sorter --pretty
+cargo run -p sorterc -- compile - --pretty                    # stdin
+cargo run -p sorterc -- compile doc.sorter --base events.jsonl  # seed garden from log
+cargo run -p sorterc -- compile doc.sorter --room public         # default room
+```
+
+**Flags**
+
+| Flag | Description |
+|------|-------------|
+| `--base PATH` | Replay an `events.jsonl` first, then compile against that garden state |
+| `--room ID` | Room wire id (`public` or private room id). Default: `public` |
+| `--pretty` | Pretty-print JSON |
+
+**Success output** (shape):
+
+```json
+{
+  "ok": true,
+  "threads": ["#my-thread"],
+  "rankings": [ … ],
+  "stats": { "items": 3, "votes": 2, "prose_blocks": 5 }
+}
+```
+
+Rankings use the same structure as the server's dry-run check: parent scope, connected components, scores, unranked items.
+
+**Error output** exits with code 1:
+
+```json
+{
+  "ok": false,
+  "error": "parse error",
+  "hint": "…"
+}
+```
+
+### `scan` — lint an `events.jsonl`
+
+Reads a JSONL event log and reports problems without starting a server.
+
+```bash
+cargo run -p sorterc -- scan events.jsonl
+cargo run -p sorterc -- scan events.jsonl --pretty
+```
+
+Reports:
+
+- **bad JSON lines** — lines that are not valid JSON
+- **malformed ingests** — ingest events whose `raw` DSL fails to parse
+- **skipped ingests** — ingests dropped during replay (same behavior as server boot)
+
+Exits 0 when clean, 1 when any issue is found.
+
+## Typical uses
+
+- Iterate on `.sorter` files in an editor and pipe through `compile` to see rankings instantly
+- Verify a downloaded or edited `events.jsonl` before uploading to Fly
+- Debug "malformed ingest" warnings from production boot logs
+- CI or pre-commit checks on fixture docs (no OAuth, no network)
+
+## What it does not do
+
+- Post to slug.social or append to a live log
+- Authenticate users or bind agents
+- Run browser/UI tests
+- Replace `slugsocial public check` for operators who want the full RPC path against a running server
+
+For live server dry-run against current garden state, use `npx slugsocial public check` or `POST /try/check` in the browser.
diff --git a/sorterc/src/main.rs b/sorterc/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..71382c180085cb0ad71043c852f8db5d3a48a284
--- /dev/null
+++ b/sorterc/src/main.rs
@@ -0,0 +1,117 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Context, Result};
+use clap::{Parser, Subcommand};
+use slugsocial_server::{
+    offline::{self, CompileError, CompileResult, ScanResult},
+    reducer::ReducerState,
+};
+
+#[derive(Parser)]
+#[command(
+    name = "sorterc",
+    about = "Offline .sorter compiler and events.jsonl linter (dev only)",
+    version
+)]
+struct Cli {
+    #[command(subcommand)]
+    cmd: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// Parse and simulate a .sorter document; emit ranking JSON to stdout.
+    Compile {
+        /// `.sorter` file, or `-` for stdin.
+        file: PathBuf,
+        /// Room wire id (`public` or private room id).
+        #[arg(long, default_value = "public")]
+        room: String,
+        /// Optional events.jsonl to replay before compiling (seed garden state).
+        #[arg(long)]
+        base: Option<PathBuf>,
+        /// Pretty-print JSON.
+        #[arg(long)]
+        pretty: bool,
+    },
+    /// Scan an events.jsonl for corrupt JSON lines and malformed ingests.
+    Scan {
+        file: PathBuf,
+        #[arg(long)]
+        pretty: bool,
+    },
+}
+
+fn read_input(path: &Path) -> Result<String> {
+    if path.as_os_str() == "-" {
+        use std::io::Read;
+        let mut buf = String::new();
+        std::io::stdin().read_to_string(&mut buf)?;
+        Ok(buf)
+    } else {
+        std::fs::read_to_string(path)
+            .with_context(|| format!("read {}", path.display()))
+    }
+}
+
+fn load_base_state(base: Option<&Path>) -> Result<ReducerState> {
+    let Some(path) = base else {
+        return Ok(ReducerState::default());
+    };
+    let (state, bad_lines) = offline::load_reducer_from_jsonl(path)
+        .with_context(|| format!("load base jsonl {}", path.display()))?;
+    if !bad_lines.is_empty() {
+        bail!(
+            "base jsonl has {} corrupt line(s); fix or omit --base",
+            bad_lines.len()
+        );
+    }
+    Ok(state)
+}
+
+fn print_json<T: serde::Serialize>(value: &T, pretty: bool) -> Result<()> {
+    if pretty {
+        println!("{}", serde_json::to_string_pretty(value)?);
+    } else {
+        println!("{}", serde_json::to_string(value)?);
+    }
+    Ok(())
+}
+
+fn run_compile(file: PathBuf, room: String, base: Option<PathBuf>, pretty: bool) -> Result<()> {
+    let text = read_input(&file)?;
+    let base_state = load_base_state(base.as_deref())?;
+    match offline::compile_document(&base_state, &room, &text) {
+        Ok(result) => {
+            print_json::<CompileResult>(&result, pretty)?;
+            Ok(())
+        }
+        Err(err) => {
+            print_json::<CompileError>(&err, pretty)?;
+            std::process::exit(1);
+        }
+    }
+}
+
+fn run_scan(file: PathBuf, pretty: bool) -> Result<()> {
+    let report = offline::scan_jsonl(&file)
+        .with_context(|| format!("scan {}", file.display()))?;
+    print_json::<ScanResult>(&report, pretty)?;
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+    match cli.cmd {
+        Command::Compile {
+            file,
+            room,
+            base,
+            pretty,
+        } => run_compile(file, room, base, pretty),
+        Command::Scan { file, pretty } => run_scan(file, pretty),
+    }
+}


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