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:
[2bc302c3] refactor

Side A — unified diff (full patch):
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index 06001212820101e0cc953d3687dea64f85e60787..d2f9769108def7ca2c5857aec8b4319426188a66 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -47,7 +47,7 @@ pub async fn post_ui_html(
             ratio_left,
             ratio_right,
             scope,
-            next,
+            vote_compare,
         } => {
             let parent = parent_from_scope(&scope);
             if let Err(e) = state
@@ -57,14 +57,12 @@ pub async fn post_ui_html(
                 return ui_js_warn(&e).into_response();
             }
             let tree = state.tree.read().await;
-            if !next.trim().is_empty() {
+            if vote_compare {
+                let left = parse_item_param(&a);
+                let right = parse_item_param(&b);
+                let morph = crate::html::vote::vote_recorded_morph(&tree, &parent, &left, &right);
                 drop(tree);
-                return JsBuilder::new()
-                    .raw(&format!(
-                        "window.location.href={};",
-                        js_string_literal(next.trim())
-                    ))
-                    .into_response();
+                return morph.into_response();
             }
             let empty = crate::reducer::NodeState::default();
             let node = tree.get(&parent).unwrap_or(&empty);
@@ -137,7 +135,7 @@ mod tests {
                 ratio_left: 3,
                 ratio_right: 1,
                 scope: String::new(),
-                next: String::new(),
+                vote_compare: false,
             }
         );
     }
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index 61cdbc094819ddedb755572c59456ec0d6617619..cd578a5fea46a9a1d49e238d08a80c2caf18708d 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -65,6 +65,15 @@ impl JsBuilder {
         self
     }
 
+    pub(crate) fn morph_inner_selector(mut self, selector: &str, markup: Markup) -> Self {
+        let html = js_string_literal(&markup.into_string());
+        self.snippets.push(format!(
+            "var __el = document.querySelector({sel}); if (__el) {{ Idiomorph.morph(__el, {html}, {{ morphStyle: 'innerHTML' }}); }}",
+            sel = js_string_literal(selector),
+        ));
+        self
+    }
+
     pub(crate) fn raw(mut self, js: &str) -> Self {
         if !js.is_empty() {
             self.snippets.push(js.to_string());
diff --git a/server/src/html/vote.rs b/server/src/html/vote.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89ed621ad861214e147add2062224fc4137ff8ad
--- /dev/null
+++ b/server/src/html/vote.rs
@@ -0,0 +1,306 @@
+//! Pairwise vote UI — `/vote?parent=` with optional `left` / `right`.
+
+use axum::{
+    extract::{Query, State},
+    response::{Html, IntoResponse},
+};
+use maud::{html, Markup};
+use serde::Deserialize;
+
+use crate::{
+    form_template::template_json_compact,
+    html::JsBuilder,
+    pair::{children_of, resolve_pair, suggest_next_pair_in_pool},
+    path_types::ItemId,
+    reducer::{GlobalTree, GroupState, NodeState, VoteData},
+    state::{parse_item_param, AppState},
+    ui_action::UI_RPC_FIELD,
+};
+
+use super::{breadcrumb_path, item_href, layout};
+
+#[derive(Debug, Deserialize)]
+pub struct VoteQuery {
+    pub parent: String,
+    #[serde(default)]
+    pub left: Option<String>,
+    #[serde(default)]
+    pub right: Option<String>,
+}
+
+pub fn vote_href(parent: &ItemId) -> String {
+    format!(
+        "/vote?parent={}",
+        urlencoding::encode(parent.as_str())
+    )
+}
+
+fn vote_compare_href(parent: &ItemId, left: &ItemId, right: &ItemId) -> String {
+    format!(
+        "/vote?parent={}&left={}&right={}",
+        urlencoding::encode(parent.as_str()),
+        urlencoding::encode(left.as_str()),
+        urlencoding::encode(right.as_str()),
+    )
+}
+
+fn display_label(id: &ItemId) -> String {
+    id.segments()
+        .last()
+        .map_or("item".into(), |v| v.to_string())
+}
+
+fn child_title(tree: &GlobalTree, id: &ItemId) -> String {
+    tree.get(id)
+        .and_then(|n| n.data.as_ref())
+        .map(|d| d.title.clone())
+        .unwrap_or_else(|| display_label(id))
+}
+
+fn ratio_pct(ratio_left: i32, ratio_right: i32) -> f64 {
+    let l = ratio_left.max(0) as f64;
+    let r = ratio_right.max(0) as f64;
+    let sum = l + r;
+    if sum <= 0.0 {
+        50.0
+    } else {
+        (l / sum) * 100.0
+    }
+}
+
+fn ratios_for_page(v: &VoteData, page_left: &ItemId, page_right: &ItemId) -> (i32, i32) {
+    match (v.a.as_str(), v.b.as_str()) {
+        (a, b) if a == page_left.as_str() && b == page_right.as_str() => {
+            (v.ratio_left, v.ratio_right)
+        }
+        (a, b) if a == page_right.as_str() && b == page_left.as_str() => {
+            (v.ratio_right, v.ratio_left)
+        }
+        _ => (v.ratio_left, v.ratio_right),
+    }
+}
+
+fn edge_votes(group: &GroupState, left: &ItemId, right: &ItemId) -> Vec<VoteData> {
+    group
+        .recent_votes
+        .iter()
+        .filter(|v| {
+            (v.a.as_str() == left.as_str() && v.b.as_str() == right.as_str())
+                || (v.a.as_str() == right.as_str() && v.b.as_str() == left.as_str())
+        })
+        .cloned()
+        .collect()
+}
+
+fn vote_edge_history(tree: &GlobalTree, group: &GroupState, left: &ItemId, right: &ItemId) -> Markup {
+    let mut votes = edge_votes(group, left, right);
+    votes.sort_by(|a, b| b.ts.cmp(&a.ts));
+    let legend_left = child_title(tree, left);
+    let legend_right = child_title(tree, right);
+    html! {
+        @if votes.is_empty() {
+            p class="muted vote-edge-empty" { "no votes on this pair yet" }
+        } @else {
+            h3 class="vote-edge-history-title" {
+                "votes on this pair"
+                span class="vote-edge-history-axis muted" { " · " (legend_left) " : " (legend_right) }
+            }
+            ul class="vote-edge-history" {
+                @for v in &votes {
+                    @let (r_left, r_right) = ratios_for_page(v, left, right);
+                    @let pct = ratio_pct(r_left, r_right);
+                    li class="vote-edge-history-row" {
+                        div class="vote-edge-meta" {
+                            span class="vote-edge-ratio" { (format!("{}:{}", r_left, r_right)) }
+                        }
+                        div class="ratio-bar vote-edge-bar" aria-hidden="true" {
+                            div class="ratio-left" style={(format!("width: {:.3}%;", pct))} {}
+                            div class="ratio-right" style={(format!("width: {:.3}%;", 100.0 - pct))} {}
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn vote_back_nav(parent: &ItemId) -> Markup {
+    html! {
+        div class="vote-compare-nav" {
+            a class="vote-compare-back muted" href=(item_href(parent)) { "← back to " (display_label(parent)) }
+        }
+    }
+}
+
+fn vote_compare_actions(parent: &ItemId, next: Option<&(ItemId, ItemId)>) -> Markup {
+    let next_href = next.map(|(l, r)| vote_compare_href(parent, l, r));
+    html! {
+        div id="vote-compare-actions" class="vote-compare-actions" {
+            button type="submit" class="btn-primary" data-testid="vote-post" { "post vote" }
+            @if let Some(href) = &next_href {
+                a class="btn-secondary vote-compare-next" data-testid="vote-next-pair" href=(href) { "next pair" }
+            } @else {
+                span class="btn-secondary vote-compare-next is-disabled" { "no next pair" }
+            }
+        }
+    }
+}
+
+/// After recording a vote on the compare page: refresh edge history and next-pair link.
+pub(crate) fn vote_recorded_morph(
+    tree: &GlobalTree,
+    parent: &ItemId,
+    left: &ItemId,
+    right: &ItemId,
+) -> JsBuilder {
+    let pool = children_of(tree, parent);
+    let empty = NodeState::default();
+    let group = tree
+        .get(parent)
+        .unwrap_or(&empty)
+        .local_ranking
+        .clone();
+    let edge_history = vote_edge_history(tree, &group, left, right);
+    let next_pair = suggest_next(&group, left, right, &pool);
+    let actions = vote_compare_actions(parent, next_pair.as_ref());
+    JsBuilder::new()
+        .morph_inner_selector("#vote-edge-history-region", edge_history)
+        .morph_selector("#vote-compare-actions", actions)
+}
+
+fn vote_compare_item_card(tree: &GlobalTree, item: &ItemId, side_class: &str) -> Markup {
+    let href = item_href(item);
+    let title = child_title(tree, item);
+    html! {
+        div class=(format!("vote-compare-side {side_class}")) {
+            a class=(format!("vote-compare-item {side_class}")) href=(href) {
+                @if let Some(row) = crate::render::reddit::child_row_markup(tree, item, &href) {
+                    (row)
+                } @else {
+                    strong { (title) }
+                }
+            }
+            @if let Some(node) = tree.get(item) {
+                @if crate::render::reddit::is_reddit_post(item) {
+                    @if let Some(data) = &node.data {
+                        @if let Some(src) = data.image_url.as_ref().or(data.thumb_url.as_ref()) {
+                            figure class="vote-compare-figure" {
+                                img class="vote-compare-image" src=(src) alt="" loading="lazy";
+                            }
+                        }
+                        @if let Some(author) = &data.author {
+                            p class="muted small" { "by " (author) }
+                        }
+                    }
+                } @else if let Some(data) = &node.data {
+                    @if let Some(body) = &data.body_html {
+                        div class="vote-compare-item-body" {
+                            (maud::PreEscaped(body))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+fn suggest_next(group: &GroupState, left: &ItemId, right: &ItemId, pool: &[ItemId]) -> Option<(ItemId, ItemId)> {
+    suggest_next_pair_in_pool(group, pool, Some((left, right)))
+}
+
+pub async fn vote_page(
+    State(state): State<AppState>,
+    Query(q): Query<VoteQuery>,
+) -> impl IntoResponse {
+    let parent = parse_item_param(&q.parent);
+    let left_param = q.left.as_deref().map(parse_item_param);
+    let right_param = q.right.as_deref().map(parse_item_param);
+
+    let tree = state.tree.read().await;
+    let empty = NodeState::default();
+    let parent_node = tree.get(&parent).unwrap_or(&empty);
+
+    let (left, right) = match resolve_pair(
+        &tree,
+        &parent,
+        left_param.as_ref(),
+        right_param.as_ref(),
+    ) {
+        Ok(p) => p,
+        Err(e) => {
+            let (msg, status) = e.status_message();
+            return (status, msg).into_response();
+        }
+    };
+
+    let pool = children_of(&tree, &parent);
+    let group = &parent_node.local_ranking;
+    let next_pair = suggest_next(group, &left, &right, &pool);
+    let edge_history = vote_edge_history(&tree, group, &left, &right);
+
+    let rpc_json = template_json_compact(&serde_json::json!({
+        "action": "record_vote",
+        "a": left.as_str(),
+        "b": right.as_str(),
+        "ratio_left": {"$form:i32": "ratio_left"},
+        "ratio_right": {"$form:i32": "ratio_right"},
+        "scope": parent.as_str(),
+        "vote_compare": true,
+    }))
+    .expect("vote rpc json");
+
+    let title = format!(
+        "vote — {} vs {}",
+        child_title(&tree, &left),
+        child_title(&tree, &right)
+    );
+
+    let body = html! {
+        section class="vote-compare-shell" {
+            h1 { "compare" }
+            (breadcrumb_path(&parent))
+            p class="muted vote-compare-scope" {
+                "ranking children of "
+                a href=(item_href(&parent)) { (child_title(&tree, &parent)) }
+            }
+            div class="vote-compare-pair" {
+                (vote_compare_item_card(&tree, &left, "vote-compare-left"))
+                span class="vote-compare-vs" { "vs" }
+                (vote_compare_item_card(&tree, &right, "vote-compare-right"))
+            }
+            (vote_back_nav(&parent))
+            div id="vote-edge-history-region" {
+                (edge_history)
+            }
+            form id="vote-compare-form" method="POST" action="/ui" {
+                input type="hidden" name=(UI_RPC_FIELD) value=(rpc_json);
+                input type="hidden" name="ratio_left" id="vote-ratio-left" value="50";
+                input type="hidden" name="ratio_right" id="vote-ratio-right" value="50";
+                label class="vote-compare-slider-label" {
+                    span id="vote-slider-left-label" { (child_title(&tree, &left)) }
+                    input type="range" id="vote-preference-slider" min="0" max="100" value="50"
+                        aria-valuemin="0" aria-valuemax="100";
+                    span id="vote-slider-right-label" { (child_title(&tree, &right)) }
+                }
+                (vote_compare_actions(&parent, next_pair.as_ref()))
+            }
+        }
+    };
+
+    drop(tree);
+
+    let path = format!("/vote?parent={}", urlencoding::encode(parent.as_str()));
+    state.views.increment(path.clone());
+    let views = state.views.get_views(&path);
+
+    Html(
+        layout(
+            &title,
+            body,
+            views,
+        )
+        .into_string(),
+    )
+    .into_response()
+}
diff --git a/server/src/pair.rs b/server/src/pair.rs
new file mode 100644
index 0000000000000000000000000000000000000000..606ffa51038a57ffacf335aa48bdb1185f8483fb
--- /dev/null
+++ b/server/src/pair.rs
@@ -0,0 +1,340 @@
+//! Pick two children of a parent scope for pairwise voting.
+//!
+//! Pair selection prefers **bridge** votes — comparisons between items in
+//! different connected components of the voted-pairs graph — so the pool
+//! merges into one ranking group before refining within it.
+
+use rand::seq::SliceRandom;
+use std::collections::{HashMap, HashSet};
+
+use crate::{
+    path_types::ItemId,
+    ranking::connected_components_from_voted_pairs,
+    reducer::{GlobalTree, GroupState},
+};
+
+fn pairs_match(a: &ItemId, b: &ItemId, x: &ItemId, y: &ItemId) -> bool {
+    (a == x && b == y) || (a == y && b == x)
+}
+
+fn pair_is_voted(group: &GroupState, a: &ItemId, b: &ItemId) -> bool {
+    let Some(&ai) = group.item_to_idx.get(a) else {
+        return false;
+    };
+    let Some(&bi) = group.item_to_idx.get(b) else {
+        return false;
+    };
+    let (i, j) = if ai < bi { (ai, bi) } else { (bi, ai) };
+    group.voted_pairs.contains(&(i, j))
+}
+
+/// Component id per pool item: voted-pairs graph components plus one id per
+/// never-voted child.
+fn component_ids(group: &GroupState, pool: &[ItemId]) -> HashMap<ItemId, usize> {
+    let n = group.idx_to_item.len();
+    let (comps, isolates) =
+        connected_components_from_voted_pairs(n, group.voted_pairs.iter().copied());
+
+    let mut out: HashMap<ItemId, usize> = HashMap::new();
+    for (comp_idx, comp) in comps.iter().enumerate() {
+        for &idx in comp {
+            if idx < n {
+                out.insert(group.idx_to_item[idx].clone(), comp_idx);
+            }
+        }
+    }
+    let mut next = comps.len();
+    for &idx in &isolates {
+        if idx < n {
+            out.insert(group.idx_to_item[idx].clone(), next);
+            next += 1;
+        }
+    }
+    for item in pool {
+        out.entry(item.clone()).or_insert_with(|| {
+            let id = next;
+            next += 1;
+            id
+        });
+    }
+    out
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum PairPriority {
+    /// Unvoted edge between two components — grows the ranking group.
+    BridgeUnvoted = 0,
+    /// Unvoted edge inside one component — refines order.
+    WithinUnvoted = 1,
+    /// Re-vote across components (rare once merged).
+    BridgeVoted = 2,
+    /// Re-vote within a component.
+    WithinVoted = 3,
+}
+
+fn pair_priority(
+    group: &GroupState,
+    components: &HashMap<ItemId, usize>,
+    a: &ItemId,
+    b: &ItemId,
+) -> PairPriority {
+    let voted = pair_is_voted(group, a, b);
+    let bridge = components.get(a) != components.get(b);
+    match (bridge, voted) {
+        (true, false) => PairPriority::BridgeUnvoted,
+        (false, false) => PairPriority::WithinUnvoted,
+        (true, true) => PairPriority::BridgeVoted,
+        (false, true) => PairPriority::WithinVoted,
+    }
+}
+
+/// All unordered pairs from `pool`, optionally skipping `exclude`.
+fn candidate_pairs(
+    pool: &[ItemId],
+    exclude: Option<(&ItemId, &ItemId)>,
+) -> Vec<(ItemId, ItemId)> {
+    let mut out = Vec::new();
+    for i in 0..pool.len() {
+        for j in (i + 1)..pool.len() {
+            let a = &pool[i];
+            let b = &pool[j];
+            if a == b {
+                continue;
+            }
+            if exclude.is_some_and(|(x, y)| pairs_match(a, b, x, y)) {
+                continue;
+            }
+            out.push((a.clone(), b.clone()));
+        }
+    }
+    out
+}
+
+/// Pick the next pair to vote on within `pool`.
+///
+/// 1. Prefer unvoted **bridge** pairs (connect separate ranking components).
+/// 2. Then unvoted within-component pairs (refinement).
+/// 3. Then already-voted pairs (re-compare).
+pub fn suggest_next_pair_in_pool(
+    group: &GroupState,
+    pool: &[ItemId],
+    exclude: Option<(&ItemId, &ItemId)>,
+) -> Option<(ItemId, ItemId)> {
+    let candidates = candidate_pairs(pool, exclude);
+    if candidates.is_empty() {
+        return None;
+    }
+    let components = component_ids(group, pool);
+    let best = candidates
+        .iter()
+        .map(|(a, b)| (pair_priority(group, &components, a, b), (a, b)))
+        .min_by_key(|(p, _)| *p)?
+        .0;
+    let best_pairs: Vec<(ItemId, ItemId)> = candidates
+        .into_iter()
+        .filter(|(a, b)| pair_priority(group, &components, a, b) == best)
+        .collect();
+    best_pairs.choose(&mut rand::thread_rng()).cloned()
+}
+
+/// Random distinct pair from `children` (legacy pair.rs behavior).
+pub fn random_pair(children: &[ItemId]) -> Option<(ItemId, ItemId)> {
+    if children.len() < 2 {
+        return None;
+    }
+    let left = children.choose(&mut rand::thread_rng())?;
+    let mut right = children.choose(&mut rand::thread_rng())?;
+    let mut guard = 0;
+    while left == right && guard < 32 {
+        right = children.choose(&mut rand::thread_rng())?;
+        guard += 1;
+    }
+    if left == right {
+        return None;
+    }
+    Some((left.clone(), right.clone()))
+}
+
+/// Sorted children of `parent` from the global tree.
+pub fn children_of(tree: &GlobalTree, parent: &ItemId) -> Vec<ItemId> {
+    let Some(node) = tree.get(parent) else {
+        return Vec::new();
+    };
+    let mut children: Vec<ItemId> = node.children.iter().cloned().collect();
+    children.sort_by(|a, b| a.as_str().cmp(b.as_str()));
+    children
+}
+
+/// Resolve a pair to compare under `parent`.
+pub fn resolve_pair(
+    tree: &GlobalTree,
+    parent: &ItemId,
+    left: Option<&ItemId>,
+    right: Option<&ItemId>,
+) -> Result<(ItemId, ItemId), PairError> {
+    let children = children_of(tree, parent);
+    if children.len() < 2 {
+        return Err(PairError::TooFewChildren);
+    }
+    let child_set: HashSet<_> = children.iter().collect();
+
+    match (left, right) {
+        (Some(l), Some(r)) => {
+            if l == r {
+                return Err(PairError::SameItem);
+            }
+            if !child_set.contains(l) || !child_set.contains(r) {
+                return Err(PairError::NotChild);
+            }
+            Ok((l.clone(), r.clone()))
+        }
+        (None, None) => {
+            let group = tree
+                .get(parent)
+                .map(|n| &n.local_ranking)
+                .cloned()
+                .unwrap_or_default();
+            suggest_next_pair_in_pool(&group, &children, None).ok_or(PairError::NoPair)
+        }
+        _ => Err(PairError::IncompletePair),
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PairError {
+    TooFewChildren,
+    SameItem,
+    NotChild,
+    IncompletePair,
+    NoPair,
+}
+
+impl PairError {
+    pub fn status_message(&self) -> (&'static str, axum::http::StatusCode) {
+        match self {
+            Self::TooFewChildren => (
+                "parent needs at least 2 children to vote",
+                axum::http::StatusCode::BAD_REQUEST,
+            ),
+            Self::SameItem => (
+                "left and right must differ",
+                axum::http::StatusCode::BAD_REQUEST,
+            ),
+            Self::NotChild => (
+                "left and right must be children of parent",
+                axum::http::StatusCode::BAD_REQUEST,
+            ),
+            Self::IncompletePair => (
+                "provide both left and right, or neither",
+                axum::http::StatusCode::BAD_REQUEST,
+            ),
+            Self::NoPair => (
+                "no pair available",
+                axum::http::StatusCode::BAD_REQUEST,
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::reducer::{GlobalTree, VoteData};
+
+    fn seed_children(parent: &ItemId, ids: &[&str]) -> GlobalTree {
+        let mut tree = GlobalTree::new();
+        tree.ensure_path(parent);
+        for id in ids {
+            let child = ItemId::parse(id).unwrap();
+            tree.ensure_path(&child);
+            if let Some(p) = tree.nodes.get_mut(parent) {
+                p.children.insert(child);
+            }
+        }
+        tree
+    }
+
+    fn pair_set(pair: &(ItemId, ItemId)) -> HashSet<&str> {
+        [pair.0.as_str(), pair.1.as_str()].into_iter().collect()
+    }
+
+    #[test]
+    fn suggest_prefers_unvoted_pair() {
+        let parent = ItemId::parse("reddit.com/r/rust").unwrap();
+        let mut tree = seed_children(
+            &parent,
+            &[
+                "reddit.com/r/rust/a",
+                "reddit.com/r/rust/b",
+                "reddit.com/r/rust/c",
+            ],
+        );
+        let vote =
+            VoteData::from_recorded(1, "reddit.com/r/rust/a", "reddit.com/r/rust/b", 2, 1).unwrap();
+        tree.apply_vote(&parent, vote);
+        let group = tree.get(&parent).unwrap().local_ranking.clone();
+        let pool = children_of(&tree, &parent);
+        let (l, r) = suggest_next_pair_in_pool(&group, &pool, None).unwrap();
+        let voted_ab = (l.as_str() == "reddit.com/r/rust/a" && r.as_str() == "reddit.com/r/rust/b")
+            || (l.as_str() == "reddit.com/r/rust/b" && r.as_str() == "reddit.com/r/rust/a");
+        assert!(!voted_ab);
+    }
+
+    #[test]
+    fn suggest_bridges_separate_components() {
+        let parent = ItemId::parse("reddit.com/r/rust").unwrap();
+        let mut tree = seed_children(
+            &parent,
+            &[
+                "reddit.com/r/rust/a",
+                "reddit.com/r/rust/b",
+                "reddit.com/r/rust/c",
+                "reddit.com/r/rust/d",
+            ],
+        );
+        let ab = VoteData::from_recorded(1, "reddit.com/r/rust/a", "reddit.com/r/rust/b", 2, 1).unwrap();
+        let cd = VoteData::from_recorded(2, "reddit.com/r/rust/c", "reddit.com/r/rust/d", 2, 1).unwrap();
+        tree.apply_vote(&parent, ab);
+        tree.apply_vote(&parent, cd);
+        let group = tree.get(&parent).unwrap().local_ranking.clone();
+        let pool = children_of(&tree, &parent);
+        let pair = suggest_next_pair_in_pool(&group, &pool, None).unwrap();
+        let chosen = pair_set(&pair);
+        let from_ab = chosen.contains("reddit.com/r/rust/a") || chosen.contains("reddit.com/r/rust/b");
+        let from_cd = chosen.contains("reddit.com/r/rust/c") || chosen.contains("reddit.com/r/rust/d");
+        assert!(from_ab && from_cd, "expected bridge pair, got {:?}", chosen);
+    }
+
+    #[test]
+    fn suggest_connects_isolate_to_existing_component() {
+        let parent = ItemId::parse("reddit.com/r/rust").unwrap();
+        let mut tree = seed_children(
+            &parent,
+            &[
+                "reddit.com/r/rust/a",
+                "reddit.com/r/rust/b",
+                "reddit.com/r/rust/c",
+            ],
+        );
+        let ab = VoteData::from_recorded(1, "reddit.com/r/rust/a", "reddit.com/r/rust/b", 2, 1).unwrap();
+        tree.apply_vote(&parent, ab);
+        let group = tree.get(&parent).unwrap().local_ranking.clone();
+        let pool = children_of(&tree, &parent);
+        let pair = suggest_next_pair_in_pool(&group, &pool, None).unwrap();
+        let chosen = pair_set(&pair);
+        assert!(chosen.contains("reddit.com/r/rust/c"));
+        assert!(chosen.contains("reddit.com/r/rust/a") || chosen.contains("reddit.com/r/rust/b"));
+    }
+
+    #[test]
+    fn resolve_pair_picks_from_pool() {
+        let parent = ItemId::parse("reddit.com/r/rust").unwrap();
+        let tree = seed_children(&parent, &["reddit.com/r/rust/a", "reddit.com/r/rust/b"]);
+        let pair = resolve_pair(&tree, &parent, None, None).unwrap();
+        let pool: HashSet<_> = ["reddit.com/r/rust/a", "reddit.com/r/rust/b"]
+            .into_iter()
+            .collect();
+        assert!(pool.contains(pair.0.as_str()));
+        assert!(pool.contains(pair.1.as_str()));
+    }
+}
diff --git a/server/src/path_types.rs b/server/src/path_types.rs
index 12dce9888f5cd4e1a0974d12d6468368d0f775b9..a0d1a028b8bd3c5d1c714dea3ec597d1ac39e1bc 100644
--- a/server/src/path_types.rs
+++ b/server/src/path_types.rs
@@ -40,6 +40,22 @@ impl ItemId {
         Self::canonicalize(raw_url).map(Self)
     }
 
+    /// Normalize strings from forms, events, and Reddit imports into the same
+    /// stored id shape (e.g. drop post title slug after comment id).
+    pub fn from_storage(s: &str) -> Option<Self> {
+        let t = s.trim();
+        if t.is_empty() {
+            return None;
+        }
+        if t.contains("://") || t.starts_with("r/") {
+            return Self::from_url(t).or_else(|| Self::parse(t));
+        }
+        if t.starts_with("reddit.com/") && t.contains("/comments/") {
+            return Self::from_url(t).or_else(|| Self::parse(t));
+        }
+        Self::parse(t).or_else(|| Self::from_url(t))
+    }
+
     /// Map legacy scope keys (`""`, `"rust"`) to fractal parent nodes.
     pub fn from_legacy_scope(raw: &str) -> Self {
         let s = raw.trim();
@@ -324,6 +340,12 @@ mod tests {
         assert_eq!(id.as_str(), "reddit.com/r/amitheasshole");
     }
 
+    #[test]
+    fn from_storage_strips_post_title_slug() {
+        let id = ItemId::from_storage("reddit.com/r/rust/comments/aaa/announcing_rust_199").unwrap();
+        assert_eq!(id.as_str(), "reddit.com/r/rust/comments/aaa");
+    }
+
     #[test]
     fn from_browse_uri_strips_prefix() {
         let id = ItemId::from_browse_uri("/~/https://reddit.com/r/rust").unwrap();
diff --git a/server/src/reddit.rs b/server/src/reddit.rs
index 1168ec2afc77c092514eec91b513bac301cbe225..626454e5a2f638734193b5190a2beea286af85b6 100644
--- a/server/src/reddit.rs
+++ b/server/src/reddit.rs
@@ -567,7 +567,7 @@ fn parse_children(_parent: &ItemId, payload: &Value) -> Vec<(ItemId, Value)> {
             _ => continue,
         };
         let path = format!("reddit.com{}", permalink.trim_end_matches('/'));
-        if let Some(id) = ItemId::parse(&path) {
+        if let Some(id) = ItemId::from_storage(&path) {
             out.push((id, child.clone()));
         }
     }
diff --git a/server/src/reducer.rs b/server/src/reducer.rs
index 336e78b77d3ab59361b89af5c9868e13da4ac962..fc23f41137d7df33997afe19c533505c250cc305 100644
--- a/server/src/reducer.rs
+++ b/server/src/reducer.rs
@@ -28,8 +28,8 @@ impl VoteData {
         ratio_left: i32,
         ratio_right: i32,
     ) -> Option<Self> {
-        let a = ItemId::parse(a)?;
-        let b = ItemId::parse(b)?;
+        let a = ItemId::from_storage(a)?;
+        let b = ItemId::from_storage(b)?;
         if a == b {
             return None;
         }
@@ -85,8 +85,8 @@ impl GroupState {
     }
 
     pub fn apply_vote(&mut self, mut vote: VoteData) {
-        vote.a = ItemId::parse(vote.a.as_str()).unwrap_or_else(|| vote.a.clone());
-        vote.b = ItemId::parse(vote.b.as_str()).unwrap_or_else(|| vote.b.clone());
+        vote.a = ItemId::from_storage(vote.a.as_str()).unwrap_or(vote.a.clone());
+        vote.b = ItemId::from_storage(vote.b.as_str()).unwrap_or(vote.b.clone());
         if vote.ratio_left < 0 {
             vote.ratio_left = 0;
         }
diff --git a/server/src/state.rs b/server/src/state.rs
index d238701208a1c708b94a778a6a2e1891a678ecbc..4c3008e73cc74d8483a2064a0a280e73d82a01ec 100644
--- a/server/src/state.rs
+++ b/server/src/state.rs
@@ -18,7 +18,7 @@ pub fn parse_item_param(raw: &str) -> ItemId {
     if s.is_empty() {
         return ItemId::root();
     }
-    ItemId::from_url(s).or_else(|| ItemId::parse(s)).unwrap_or_else(|| ItemId::opaque(s))
+    ItemId::from_storage(s).unwrap_or_else(|| ItemId::opaque(s))
 }
 
 /// Legacy: normalize raw ranking subject into a scope key for old event replay.
diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs
index 53581e1362bfcc5dfb4ae3069c41ea6f7be41437..237411a689fb10ad1b7022ea66aee1969c7507ec 100644
--- a/server/src/ui_action.rs
+++ b/server/src/ui_action.rs
@@ -31,9 +31,9 @@ pub enum HtmlUiAction {
         /// Parent node [`ItemId`] string; empty = tree root.
         #[serde(default)]
         scope: String,
-        /// After vote, navigate here (vote compare page).
+        /// Posted from `/vote` compare UI — morph edge history in place.
         #[serde(default)]
-        next: String,
+        vote_compare: bool,
     },
     /// Parse pasted Reddit URL/path; redirect to subreddit ranking on success.
     ParseQuery {
@@ -98,7 +98,7 @@ mod tests {
                 ratio_left: 60,
                 ratio_right: 40,
                 scope: "parent".into(),
-                next: String::new(),
+                vote_compare: false,
             }
         );
     }
@@ -129,7 +129,7 @@ mod tests {
                 ratio_left: 2,
                 ratio_right: 1,
                 scope: "amitheasshole".into(),
-                next: String::new(),
+                vote_compare: false,
             }
         );
     }
@@ -156,7 +156,7 @@ mod tests {
                 ratio_left: 2,
                 ratio_right: 1,
                 scope: String::new(),
-                next: String::new(),
+                vote_compare: false,
             }
         );
     }
diff --git a/server/static/sorter.css b/server/static/sorter.css
index 3c2cec5cb5094013387147c621d75bd341bc06cc..b95718ce463b200a5667d3014dac2119836a0bef 100644
--- a/server/static/sorter.css
+++ b/server/static/sorter.css
@@ -289,11 +289,27 @@ h1 {
 }
 
 .vote-compare-nav {
+  margin: 1rem 0 0.5rem;
+}
+
+.vote-compare-actions {
   display: flex;
-  justify-content: space-between;
+  flex-wrap: wrap;
   align-items: center;
-  gap: 1rem;
-  margin: 1rem 0;
+  gap: 0.75rem;
+  margin-top: 0.5rem;
+}
+
+.vote-compare-actions .btn-secondary {
+  margin-top: 0;
+  display: inline-block;
+  text-decoration: none;
+  line-height: 1.4;
+}
+
+.vote-compare-actions .vote-compare-next.is-disabled {
+  opacity: 0.6;
+  cursor: default;
 }
 
 .vote-compare-next {
diff --git a/server/static/sorter_ui.js b/server/static/sorter_ui.js
index c8d7c3ef2413399ced7898a7edb3e7a2c8e16163..ab15d27f508cc6f5fbca9d8926fd0ca26d64857b 100644
--- a/server/static/sorter_ui.js
+++ b/server/static/sorter_ui.js
@@ -104,11 +104,10 @@
       if (f.getAttribute('data-navigate') === 'full') return;
       e.preventDefault();
       await postUiForm(f);
-      if (f.id === 'vote-form' || f.id === 'vote-compare-form') {
+      if (f.id === 'vote-form') {
         f.reset();
-        var slider = f.querySelector('#vote-preference-slider');
-        if (slider) slider.value = '50';
-        initVoteSlider();
+        var firstField = f.querySelector('input[type="text"]');
+        if (firstField) firstField.focus();
       }
     });
   }
diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs
index df7d9ab357531c5146d0b326c149fdaa6b531a4a..56d2db313b313ffce07eff38a8ccdaa2fbb9498f 100644
--- a/server/tests/integration_ui.rs
+++ b/server/tests/integration_ui.rs
@@ -25,6 +25,53 @@ async fn start_test_server() -> (SocketAddr, TempDir) {
     (addr, tmp)
 }
 
+#[tokio::test]
+async fn post_ui_vote_compare_morphs_edge_history() {
+    let (addr, _tmp) = start_test_server().await;
+    let parent = "reddit.com/r/rust";
+    let a = "reddit.com/r/rust/comments/aaa/announcing_rust_199";
+    let b = "reddit.com/r/rust/comments/bbb/what_are_you_working_on";
+
+    let rpc = serde_json::json!({
+        "action": "record_vote",
+        "a": a,
+        "b": b,
+        "ratio_left": {"$form:i32": "ratio_left"},
+        "ratio_right": {"$form:i32": "ratio_right"},
+        "scope": parent,
+        "vote_compare": true,
+    })
+    .to_string();
+    let mut form = HashMap::new();
+    form.insert(UI_RPC_FIELD.to_string(), rpc);
+    form.insert("ratio_left".into(), "70".into());
+    form.insert("ratio_right".into(), "30".into());
+
+    let client = reqwest::Client::new();
+    let body = client
+        .post(format!("http://{addr}/ui"))
+        .form(&form)
+        .send()
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+
+    assert!(
+        body.contains("vote-edge-history"),
+        "expected edge history morph, got: {body}"
+    );
+    assert!(
+        body.contains("70:30"),
+        "expected recorded ratio in morph, got: {body}"
+    );
+    assert!(
+        !body.contains("no votes on this pair yet"),
+        "should not show empty edge history after vote, got: {body}"
+    );
+}
+
 #[tokio::test]
 async fn post_ui_record_vote_morphs_ranking_and_persists() {
     let (addr, tmp) = start_test_server().await;
diff --git a/test/reddit_import.clj b/test/reddit_import.clj
index 45a2a19f20799d77e84d8aa64735ab5e7e45f97c..b476488526252c13fd73bdda76e5201678e4a714 100644
--- a/test/reddit_import.clj
+++ b/test/reddit_import.clj
@@ -2,9 +2,8 @@
   (:require [babashka.process :as process]
             [clojure.java.io :as io]
             [clojure.string :as str]
-            [clojure.test :refer [deftest is testing]])
-  (:import [com.sun.net.httpserver HttpServer HttpHandler HttpExchange]
-           [java.net InetSocketAddress]))
+            [clojure.test :refer [deftest is testing]]
+            [test.support.mock-reddit :as mock-reddit]))
 
 (defn- repo-root []
   (.getCanonicalPath (io/file (System/getProperty "user.dir"))))
@@ -13,29 +12,6 @@
   (with-open [s (java.net.ServerSocket. 0)]
     (.getLocalPort s)))
 
-(defn- start-mock-reddit [port fixtures-dir]
-  (let [about (.getBytes (slurp (io/file fixtures-dir "r_rust_about.json")) "UTF-8")
-        listing (.getBytes (slurp (io/file fixtures-dir "r_rust_listing.json")) "UTF-8")
-        server (HttpServer/create (InetSocketAddress. "127.0.0.1" port) 0)
-        handler
-        (proxy [HttpHandler] []
-          (handle [^HttpExchange exchange]
-            ;; Route by path: `/r/<sub>/about.json` is the subreddit entity,
-            ;; `/r/<sub>.json` is the children listing.
-            (let [path (.getPath (.getRequestURI exchange))
-                  body (if (str/includes? path "/about")
-                         about
-                         listing)]
-              (.sendResponseHeaders exchange 200 (alength body))
-              (let [out (.getResponseBody exchange)]
-                (.write out body)
-                (.close out)))))]
-    (.createContext server "/" handler)
-    (.setExecutor server nil)
-    (.start server)
-    (fn stop []
-      (.stop server 0))))
-
 (defn- wait-health [base-url ms]
   (let [deadline (+ (System/currentTimeMillis) ms)
         url (str base-url "/healthz")]
@@ -100,7 +76,7 @@
 (deftest reddit-fetch-via-mock-api
   (testing "Fetch more queues import; event log stores full payload; page shows title"
     (let [root (repo-root)
-          fixtures (str root "/test/fixtures/reddit")
+          fixtures (mock-reddit/fixtures-dir root)
           data-dir (.getAbsolutePath
                     (doto (io/file (System/getProperty "java.io.tmpdir")
                                    (str "sorter2-reddit-" (System/currentTimeMillis)))
@@ -110,7 +86,7 @@
           reddit-base (str "http://127.0.0.1:" reddit-port)
           app-base (str "http://127.0.0.1:" app-port)
           bin (str root "/target/release/sorter2-server")
-          stop-mock (start-mock-reddit reddit-port fixtures)]
+          stop-mock (mock-reddit/start-mock-reddit reddit-port fixtures)]
       (try
         (is (zero? (:exit (process/shell {:dir root}
                                          "cargo" "build" "--release" "--package" "sorter2-server")))
diff --git a/test/support/mock_reddit.clj b/test/support/mock_reddit.clj
new file mode 100644
index 0000000000000000000000000000000000000000..5efa92db3e1f79b8f423a2f1adcbda959123c1ad
--- /dev/null
+++ b/test/support/mock_reddit.clj
@@ -0,0 +1,35 @@
+(ns test.support.mock-reddit
+  "In-process HTTP stub for Reddit API fixtures (`test/fixtures/reddit/`)."
+  (:require [clojure.java.io :as io]
+            [clojure.string :as str])
+  (:import [com.sun.net.httpserver HttpServer HttpHandler HttpExchange]
+           [java.net InetSocketAddress]))
+
+(defn fixtures-dir
+  ([] (fixtures-dir (System/getProperty "user.dir")))
+  ([root] (str root "/test/fixtures/reddit")))
+
+(defn start-mock-reddit
+  "Start a mock Reddit API on `port`. Returns a zero-arg `stop` function."
+  ([port] (start-mock-reddit port (fixtures-dir)))
+  ([port dir]
+   (let [about (.getBytes (slurp (io/file dir "r_rust_about.json")) "UTF-8")
+         listing (.getBytes (slurp (io/file dir "r_rust_listing.json")) "UTF-8")
+         server (HttpServer/create (InetSocketAddress. "127.0.0.1" port) 0)
+         handler
+         (proxy [HttpHandler] []
+           (handle [^HttpExchange exchange]
+             ;; `/r/<sub>/about.json` → subreddit entity; `/r/<sub>.json` → listing.
+             (let [path (.getPath (.getRequestURI exchange))
+                   body (if (str/includes? path "/about")
+                          about
+                          listing)]
+               (.sendResponseHeaders exchange 200 (alength body))
+               (let [out (.getResponseBody exchange)]
+                 (.write out body)
+                 (.close out)))))]
+     (.createContext server "/" handler)
+     (.setExecutor server nil)
+     (.start server)
+     (fn stop []
+       (.stop server 0)))))
diff --git a/test/vote_compare.clj b/test/vote_compare.clj
new file mode 100644
index 0000000000000000000000000000000000000000..fbc00281e466a1ba0833193c7b96fa30aeb45a5c
--- /dev/null
+++ b/test/vote_compare.clj
@@ -0,0 +1,101 @@
+(ns test.vote-compare
+  (:require [babashka.process :as process]
+            [clojure.java.io :as io]
+            [clojure.string :as str]
+            [clojure.test :refer [deftest is testing]]
+            [com.blockether.spel.core :as core]
+            [com.blockether.spel.locator :as loc]
+            [com.blockether.spel.page :as page]
+            [test.support.mock-reddit :as mock-reddit])
+  (:import [java.net URLEncoder]))
+
+(defn- repo-root []
+  (.getCanonicalPath (io/file (System/getProperty "user.dir"))))
+
+(defn- pick-port []
+  (with-open [s (java.net.ServerSocket. 0)]
+    (.getLocalPort s)))
+
+(defn- wait-health [base-url ms]
+  (let [deadline (+ (System/currentTimeMillis) ms)
+        url (str base-url "/healthz")]
+    (loop []
+      (let [resp (try
+                   (process/shell {:out :string :err :string}
+                                  "curl" "-sf" url)
+                   (catch Exception _ nil))]
+        (if (and resp (zero? (:exit resp)) (= "ok" (str/trim (:out resp ""))))
+          true
+          (if (< (System/currentTimeMillis) deadline)
+            (do (Thread/sleep 200) (recur))
+            false))))))
+
+(defn- curl-fetch-children [base item]
+  (process/shell {:out :string :err :string}
+                 "curl" "-sfN" "--max-time" "20"
+                 "-X" "POST" (str base "/ui")
+                 "--data-urlencode"
+                 (str "__rpc__={\"action\":\"fetch_entity\",\"item\":\"" item
+                      "\",\"kind\":\"children\"}")))
+
+(defn- vote-page-url [base parent]
+  (str base "/vote?parent="
+       (URLEncoder/encode parent "UTF-8")))
+
+(deftest vote-compare-shows-recorded-vote-after-post
+  (testing "post vote on /vote morphs edge history (mock Reddit children seeded)"
+    (let [root (repo-root)
+          fixtures (mock-reddit/fixtures-dir root)
+          data-dir (.getAbsolutePath
+                    (doto (io/file (System/getProperty "java.io.tmpdir")
+                                   (str "sorter2-vote-" (System/currentTimeMillis)))
+                      (.mkdirs)))
+          reddit-port (pick-port)
+          app-port (pick-port)
+          reddit-base (str "http://127.0.0.1:" reddit-port)
+          app-base (str "http://127.0.0.1:" app-port)
+          bin (str root "/target/release/sorter2-server")
+          stop-mock (mock-reddit/start-mock-reddit reddit-port fixtures)]
+      (try
+        (is (zero? (:exit (process/shell {:dir root}
+                                         "cargo" "build" "--release" "--package" "sorter2-server")))
+            "release build succeeds")
+        (let [proc (process/process {:dir root
+                                     :env (into (into {} (System/getenv))
+                                                {"SORTER2_SKIP_DOTENV" "1"
+                                                 "SORTER2_DATA_DIR" data-dir
+                                                 "SORTER2_EVENT_LOG" (str data-dir "/events.jsonl")
+                                                 "PORT" (str app-port)
+                                                 "REDDIT_API_BASE" reddit-base
+                                                 "REDDIT_OAUTH_BASE" reddit-base
+                                                 "REDDIT_CLIENT_ID" ""
+                                                 "REDDIT_CLIENT_SECRET" ""
+                                                 "REDDIT_APP_ID" ""
+                                                 "REDDIT_APP_SECRET" ""})
+                                     :out :string
+                                     :err :string}
+                                    bin)]
+          (try
+            (is (wait-health app-base 20000) "app healthz")
+            (let [fetch (curl-fetch-children app-base "reddit.com/r/rust")]
+              (is (zero? (:exit fetch)) "fetch posts via mock Reddit")
+              (is (str/includes? (:out fetch) "Idiomorph.morph")))
+            (core/with-testing-page [pg]
+              (page/navigate pg (vote-page-url app-base "reddit.com/r/rust"))
+              (page/wait-for-selector pg "#vote-compare-form")
+              (let [before (loc/text-content (page/locator pg "#vote-edge-history-region"))]
+                (is (str/includes? before "no votes on this pair yet")
+                    "empty edge history before first vote"))
+              (loc/click (page/get-by-test-id pg "vote-post"))
+              (page/wait-for-selector pg ".vote-edge-history-title")
+              (let [after (loc/text-content (page/locator pg "#vote-edge-history-region"))]
+                (is (str/includes? after "votes on this pair")
+                    "shows edge history title after vote")
+                (is (str/includes? after "50:50")
+                    "shows submitted ratio after vote")
+                (is (not (str/includes? after "no votes on this pair yet"))
+                    "does not revert to empty edge history")))
+            (finally
+              (process/destroy proc))))
+        (finally
+          (stop-mock))))))


Side B — contributor: tommy-mor
Side B — commit message:
[529cc941] Replace autocomplete parser with paste-and-go navigate.

The keystroke transition graph was unreliable; a textarea plus Go button now parses pasted Reddit URLs and redirects to the subreddit ranking scope.

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

Side B — unified diff (full patch):
diff --git a/AGENTS.md b/AGENTS.md
index 77f2e31d4e860a92a77255ca5106c8b6c4510ee7..36ee4c0ec700bffbe226ee775ba9cf59cf35c770 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,7 +11,6 @@ Single Rust web app **`sorter2-server`**: pairwise voting, rank-centrality ranki
 - **Rust 1.88+** is required (some transitive crates need a recent Cargo). The image may ship older `/usr/local/cargo` (1.83); use **rustup** and `rustup default 1.88.0` before building.
 - **System packages** for builds: `pkg-config`, `libssl-dev` (for `reqwest` / OpenSSL in integration tests and release builds).
 - **Clojure CLI 1.12.0.1530** (optional but used in CI): install from https://clojure.org/guides/install_clojure — needed for `./scripts/clj-test.sh` / Kaocha tests.
-- **Playwright browser** for the spel browser test (`test/parser_race.clj`): install once with `clojure -M -e "(com.microsoft.playwright.CLI/main (into-array String [\"install\" \"chromium\" \"--with-deps\"]))"`. The browser binary is cached under `~/.cache/ms-playwright`.
 
 ### Commands (see also `TEST.sh`)
 
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index 1339048c955c0a3eb5120381aaf031424cbed540..c4ab9d65c7b3cd42a5b4d093ba429993c101e9a8 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -8,7 +8,7 @@ use std::collections::HashMap;
 use crate::{
     html::{js_string_literal, ranking_panel, JsBuilder},
     parser::parse_reddit_url,
-    parser_render::parser_panel_morph,
+    parser_render::navigate_panel,
     state::AppState,
     ui_action::{parse_html_ui_from_form, HtmlUiAction},
 };
@@ -57,18 +57,23 @@ pub async fn post_ui_html(
                 .morph_selector("#ranking-panel", panel)
                 .into_response()
         }
-        HtmlUiAction::ParseQuery { query } => {
-            let action = parse_reddit_url(&query);
-            let panel = parser_panel_morph(&query, &action);
-            let mut js = JsBuilder::new().morph_selector("#parser-panel", panel);
-            if let Some(comp) = action.primary_completion() {
-                js = js.raw(&format!(
-                    "var __pi=document.getElementById('parser-input'); if(__pi){{__pi.dataset.completion={};}}",
-                    js_string_literal(comp)
-                ));
+        HtmlUiAction::ParseQuery { query } => match parse_reddit_url(&query) {
+            Ok(subreddit) => {
+                let dest = format!("/?sub={subreddit}");
+                JsBuilder::new()
+                    .raw(&format!(
+                        "window.location.href={};",
+                        js_string_literal(&dest)
+                    ))
+                    .into_response()
             }
-            js.into_response()
-        }
+            Err(message) => {
+                let panel = navigate_panel(&query, Some(&message));
+                JsBuilder::new()
+                    .morph_selector("#parser-panel", panel)
+                    .into_response()
+            }
+        },
     }
 }
 
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index 94a5cfb561d1c8464bd2782f7ffd4e0965ccf95d..9650d333d29c4ac94ceb407aee3ee00399c7f40b 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -11,8 +11,7 @@ use serde::Deserialize;
 
 use crate::{
     form_template::template_json_compact,
-    parser_action::ParserAction,
-    parser_render::parser_panel,
+    parser_render::navigate_panel,
     ranking::{top_bottom, RankedItem},
     reducer::GroupState,
     state::{normalize_scope, AppState},
@@ -336,10 +335,9 @@ pub async fn home(
     let empty = GroupState::new();
     let group = groups.get(&scope).unwrap_or(&empty);
 
-    let empty_action = ParserAction::suggest(String::new(), None);
     let body = html! {
         h1 { "sorter2" }
-        (parser_panel("", &empty_action))
+        (navigate_panel("", None))
         (vote_panel(&scope))
         (ranking_panel(&scope, group))
     };
diff --git a/server/src/lib.rs b/server/src/lib.rs
index fa423640d598f4ba97a5885d228e78d7b97f7a22..de8bca48cbf689cad22337883e7791966e7c4919 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -4,7 +4,6 @@ pub mod events;
 pub mod form_template;
 pub mod html;
 pub mod parser;
-pub mod parser_action;
 pub mod parser_render;
 pub mod path_types;
 pub mod ranking;
diff --git a/server/src/parser.rs b/server/src/parser.rs
index ea437c4434045b44cba04a2b3416df850db518e7..50571a59f0d3ece1e2538f88e00ef46ec40ea545 100644
--- a/server/src/parser.rs
+++ b/server/src/parser.rs
@@ -1,1811 +1,87 @@
-use std::collections::HashMap;
-use std::sync::OnceLock;
+//! Extract a subreddit name from a pasted Reddit URL or path.
 
-use crate::parser_action::{GuideOption, ParserAction, ScrollingSuggestion, Suggestion};
-
-// --- Core Abstractions ---
-
-/// Unique identifier for nodes in the graph
-type NodeId = &'static str;
-
-/// Pattern matching for edges
-#[derive(Debug, Clone)]
-pub enum EdgePattern {
-    /// Matches exact literal string
-    Literal(&'static str),
-    
-    /// Matches any prefix of a string and suggests the full string
-    /// e.g., PrefixOf("reddit.com") matches "r", "re", "red", "reddit", "reddit.com"
-    PrefixOf(&'static str),
-    
-    /// Captures a variable segment (e.g., subreddit name, username)
-    Variable(&'static str),
-    
-    /// Matches any string (wildcard)
-    Any,
-}
-
-impl EdgePattern {
-    /// Try to match this pattern against input, return (consumed_chars, captured_value)
-    fn matches(&self, input: &str) -> Option<(usize, Option<String>)> {
-        match self {
-            EdgePattern::Literal(lit) => {
-                if input.starts_with(lit) {
-                    Some((lit.len(), None))
-                } else {
-                    None
-                }
-            }
-            EdgePattern::PrefixOf(target) => {
-                // Check if input is a prefix of target
-                if target.starts_with(input) && !input.is_empty() {
-                    // It's a valid prefix
-                    Some((input.len(), None))
-                } else if input.starts_with(target) {
-                    // Full match
-                    Some((target.len(), None))
-                } else {
-                    None
-                }
-            }
-            EdgePattern::Variable(var_name) => {
-                // Consume until next '/' or end of string
-                let end = input.find('/').unwrap_or(input.len());
-                if end > 0 {
-                    let captured = input[..end].to_string();
-                    // Validate based on variable type
-                    if is_valid_variable(var_name, &captured) {
-                        Some((end, Some(captured)))
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            }
-            EdgePattern::Any => {
-                // Match everything until next '/' or end
-                let end = input.find('/').unwrap_or(input.len());
-                if end > 0 {
-                    Some((end, Some(input[..end].to_string())))
-                } else {
-                    None
-                }
-            }
-        }
-    }
-    
-    /// Get the completion suggestion for this pattern
-    fn completion(&self, partial: &str) -> Option<String> {
-        match self {
-            EdgePattern::PrefixOf(target) => {
-                if target.starts_with(partial) && partial != *target {
-                    Some(target.to_string())
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
+pub fn parse_reddit_url(query: &str) -> Result<String, String> {
+    let q = query.trim();
+    if q.is_empty() {
+        return Err("Paste a Reddit URL or r/subreddit path".into());
     }
-}
 
-/// Edge in the graph
-pub struct Edge {
-    pattern: EdgePattern,
-    target: NodeId,
-    /// Optional description for autocomplete
-    description: Option<&'static str>,
-}
-
-/// Handler function for generating UI actions (Send + Sync so the graph can live in `OnceLock`).
-type Handler = Box<dyn Fn(&str, &str, &HashMap<String, String>) -> ParserAction + Send + Sync>;
-
-/// Node in the graph
-pub struct Node {
-    #[allow(dead_code)]
-    id: NodeId,
-    edges: Vec<Edge>,
-    handler: Option<Handler>,
-}
-
-/// The composable parser graph (immutable after `build`).
-pub struct Graph {
-    nodes: HashMap<NodeId, Node>,
-    root: NodeId,
-}
-
-// --- Graph Builder (Fluent API) ---
-
-pub struct GraphBuilder {
-    nodes: HashMap<NodeId, Node>,
-    current_node: Option<NodeId>,
-    root: NodeId,
-}
-
-impl GraphBuilder {
-    pub fn new() -> Self {
-        let mut nodes = HashMap::new();
-        nodes.insert(
-            "root",
-            Node {
-                id: "root",
-                edges: Vec::new(),
-                handler: None,
-            },
-        );
-
-        GraphBuilder {
-            nodes,
-            current_node: Some("root"),
-            root: "root",
-        }
+    if let Some(sub) = subreddit_after_prefix(q, "r/") {
+        return Ok(sub);
     }
 
-    /// Select a node to add edges to
-    pub fn at(mut self, node_id: NodeId) -> Self {
-        self.nodes.entry(node_id).or_insert_with(|| Node {
-            id: node_id,
-            edges: Vec::new(),
-            handler: None,
-        });
-        self.current_node = Some(node_id);
-        self
+    if let Some(sub) = subreddit_from_path_segment(q, "/r/") {
+        return Ok(sub);
     }
-    
-    /// Add an edge from the current node
-    pub fn edge(self, pattern: EdgePattern, target: NodeId) -> Self {
-        self.edge_with_desc(pattern, target, None)
-    }
-    
-    /// Add an edge with description
-    pub fn edge_with_desc(
-        mut self,
-        pattern: EdgePattern,
-        target: NodeId,
-        desc: Option<&'static str>,
-    ) -> Self {
-        let current = self.current_node.expect("No current node selected");
-
-        self.nodes.entry(target).or_insert_with(|| Node {
-            id: target,
-            edges: Vec::new(),
-            handler: None,
-        });
-
-        if let Some(node) = self.nodes.get_mut(current) {
-            node.edges.push(Edge {
-                pattern,
-                target,
-                description: desc,
-            });
-        }
 
-        self
-    }
-
-    /// Set handler for current node
-    pub fn handler<F>(mut self, handler: F) -> Self
-    where
-        F: Fn(&str, &str, &HashMap<String, String>) -> ParserAction + Send + Sync + 'static,
-    {
-        let current = self.current_node.expect("No current node selected");
-        if let Some(node) = self.nodes.get_mut(current) {
-            node.handler = Some(Box::new(handler));
-        }
-        self
-    }
-    
-    /// Build the final graph
-    pub fn build(self) -> Graph {
-        Graph {
-            nodes: self.nodes,
-            root: self.root,
-        }
-    }
+    Err("Could not find a subreddit in that URL".into())
 }
 
-// --- Parser Implementation ---
-
-impl Graph {
-    pub fn parse(&self, input: &str) -> ParserAction {
-        let normalized = input.trim().to_lowercase();
-        let mut state = ParserState {
-            input: &normalized,
-            cursor: 0,
-            current_node_id: self.root,
-            context: HashMap::new(),
-            original_query: input.to_string(),
-            current_prefix: String::new(),
-        };
-        
-        self.parse_recursive(&mut state)
-    }
-    
-    fn parse_recursive(&self, state: &mut ParserState) -> ParserAction {
-        let node = self
-            .nodes
-            .get(state.current_node_id)
-            .expect("Node not found in graph");
-
-        // If we've consumed all input, check for handler or suggestions
-        if state.cursor >= state.input.len() {
-            if let Some(handler) = &node.handler {
-                return handler(&state.original_query, &state.current_prefix, &state.context);
-            }
-
-            // No handler, try to suggest based on available edges
-            return self.suggest_from_edges(node, state);
-        }
-
-        let remaining = &state.input[state.cursor..];
-
-        // Try to match each edge
-        for edge in &node.edges {
-            if let Some((consumed, captured)) = edge.pattern.matches(remaining) {
-                // Save state for potential backtracking
-                let saved_cursor = state.cursor;
-                let saved_node = state.current_node_id;
-                let saved_prefix = state.current_prefix.clone();
-                
-                // Update state
-                state.cursor += consumed;
-                state.current_node_id = edge.target;
-                state.current_prefix.push_str(&remaining[..consumed]);
-                
-                // Store captured variable if any
-                if let Some(value) = captured {
-                    if let EdgePattern::Variable(var_name) = &edge.pattern {
-                        state.context.insert(var_name.to_string(), value);
-                    }
-                }
-                
-                // Check if this is a partial match that needs completion
-                if state.cursor == state.input.len() {
-                    if let Some(completion_suffix) = edge.pattern.completion(remaining) {
-                        // Use the current_prefix plus the completion suffix
-                        let full_completion = format!("{}{}", 
-                            state.current_prefix, 
-                            completion_suffix.strip_prefix(remaining).unwrap_or(&completion_suffix)
-                        );
-                        return ParserAction::suggest(
-                            state.original_query.clone(),
-                            Some(Suggestion {
-                                text: full_completion.clone(),
-                                completion: full_completion,
-                                description: edge.description.map(|d| d.to_string()),
-                                score: 1.0,
-                            })
-                        );
-                    }
-                }
-                
-                // Continue parsing from the target node
-                let result = self.parse_recursive(state);
-                
-                // If we got a valid response, return it
-                if !matches!(result, ParserAction::ShowError(_)) {
-                    return result;
-                }
-                
-                // Otherwise, restore state and try next edge
-                state.cursor = saved_cursor;
-                state.current_node_id = saved_node;
-                state.current_prefix = saved_prefix;
-            }
-        }
-        
-        // No edges matched - try to provide suggestions
-        self.suggest_from_edges(node, state)
-    }
-    
-    fn suggest_from_edges(&self, node: &Node, state: &ParserState) -> ParserAction {
-        let remaining = &state.input[state.cursor..];
-        
-        // Find edges that could match with more input
-        for edge in &node.edges {
-            match &edge.pattern {
-                EdgePattern::PrefixOf(target) => {
-                    if target.starts_with(remaining) && !remaining.is_empty() {
-                        // Use current_prefix instead of rebuilding from input
-                        let full_completion = format!("{}{}", state.current_prefix, target);
-                        return ParserAction::suggest(
-                            state.original_query.clone(),
-                            Some(Suggestion {
-                                text: full_completion.clone(),
-                                completion: full_completion,
-                                description: edge.description.map(|d| d.to_string()),
-                                score: 1.0,
-                            })
-                        );
-                    }
-                }
-                EdgePattern::Literal(lit) => {
-                    if lit.starts_with(remaining) && !remaining.is_empty() {
-                        let full_completion = format!("{}{}", state.current_prefix, lit);
-                        return ParserAction::suggest(
-                            state.original_query.clone(),
-                            Some(Suggestion {
-                                text: full_completion.clone(),
-                                completion: full_completion,
-                                description: edge.description.map(|d| d.to_string()),
-                                score: 1.0,
-                            })
-                        );
-                    }
-                }
-                _ => {}
-            }
-        }
-        
-        ParserAction::error(
-            "InvalidPath".to_string(),
-            format!("'{}' doesn't match any known pattern", state.original_query)
-        )
-    }
+fn subreddit_after_prefix(text: &str, prefix: &str) -> Option<String> {
+    let rest = text.strip_prefix(prefix)?;
+    let sub = rest.split(['/', '?', '#']).next()?.trim();
+    valid_subreddit(sub)
 }
 
-struct ParserState<'a> {
-    input: &'a str,
-    cursor: usize,
-    current_node_id: NodeId,
-    context: HashMap<String, String>,
-    original_query: String,
-    current_prefix: String,
+fn subreddit_from_path_segment(text: &str, needle: &str) -> Option<String> {
+    let idx = text.find(needle)?;
+    let rest = &text[idx + needle.len()..];
+    let sub = rest.split(['/', '?', '#']).next()?.trim();
+    valid_subreddit(sub)
 }
 
-// --- Helper Functions ---
-
-fn is_valid_variable(var_name: &str, value: &str) -> bool {
-    match var_name {
-        "subreddit" => {
-            !value.is_empty() && 
-            value.len() <= 21 && 
-            value.chars().all(|c| c.is_alphanumeric() || c == '_')
-        }
-        "username" => {
-            !value.is_empty() && 
-            value.len() <= 20 && 
-            value.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-')
-        }
-        "post_id" => {
-            !value.is_empty() && 
-            value.len() <= 10 && 
-            value.chars().all(|c| c.is_alphanumeric())
-        }
-        _ => true, // Allow any value for unknown variables
+fn valid_subreddit(name: &str) -> Option<String> {
+    if name.is_empty() {
+        return None;
+    }
+    if name
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '_')
+    {
+        Some(name.to_ascii_lowercase())
+    } else {
+        None
     }
-}
-
-// --- Define the Reddit Graph ---
-
-pub fn build_reddit_graph() -> Graph {
-    GraphBuilder::new()
-        // === ROOT LEVEL: Direct aliases and domain/protocol patterns ===
-        .at("root")
-            // Direct aliases to subreddit and user selection
-            .edge_with_desc(
-                EdgePattern::PrefixOf("r/"),
-                "subreddit_selection",
-                Some("Browse subreddits (e.g., r/programming)")
-            )
-            .edge_with_desc(
-                EdgePattern::PrefixOf("u/"),
-                "user_selection",
-                Some("Browse users (e.g., u/spez)")
-            )
-            
-            // Reddit shortcuts - one pattern handles ALL prefixes!
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"), 
-                "reddit_domain",
-                Some("Go to Reddit")
-            )
-            
-            // Protocol patterns - "h" can suggest "https://"
-            .edge_with_desc(
-                EdgePattern::PrefixOf("https://"),
-                "https_protocol",
-                Some("HTTPS protocol")
-            )
-            .edge_with_desc(
-                EdgePattern::PrefixOf("http://"),
-                "http_protocol", 
-                Some("HTTP protocol")
-            )
-            .edge_with_desc(
-                EdgePattern::PrefixOf("www."),
-                "www_prefix",
-                Some("World Wide Web")
-            )
-        
-
-        
-        // === HTTPS PROTOCOL: Can go to any domain ===
-        .at("https_protocol")
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"),
-                "reddit_domain",
-                Some("Reddit (HTTPS)")
-            )
-            .edge_with_desc(
-                EdgePattern::PrefixOf("www."),
-                "https_www",
-                Some("WWW prefix")
-            )
-        
-        // === HTTP PROTOCOL: Similar to HTTPS ===
-        .at("http_protocol")
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"),
-                "reddit_domain",
-                Some("Reddit (HTTP)")
-            )
-            .edge_with_desc(
-                EdgePattern::PrefixOf("www."),
-                "http_www",
-                Some("WWW prefix")
-            )
-        
-        // === HTTPS + WWW ===
-        .at("https_www")
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"),
-                "reddit_domain",
-                Some("Reddit")
-            )
-        
-        // === HTTP + WWW ===
-        .at("http_www")
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"),
-                "reddit_domain",
-                Some("Reddit")
-            )
-        
-        // === WWW PREFIX (without protocol) ===
-        .at("www_prefix")
-            .edge_with_desc(
-                EdgePattern::PrefixOf("reddit.com"),
-                "reddit_domain",
-                Some("Reddit")
-            )
-        
-        // === REDDIT DOMAIN: Expect "/" ===
-        .at("reddit_domain")
-            .edge(EdgePattern::Literal("/"), "reddit_root")
-            .handler(|query, prefix, _ctx| {
-                // If someone just types "reddit.com" (or with protocol) without slash
-                // Suggest adding the slash using the current prefix
-                let completion = format!("{}/", prefix);
-                
-                ParserAction::suggest(
-                    query.to_string(),
-                    Some(Suggestion {
-                        text: completion.clone(),
-                        completion,
-                        description: Some("Continue to Reddit homepage".to_string()),
-                        score: 1.0,
-                    })
-                )
-            })
-        
-        // === REDDIT ROOT: The main Reddit navigation ===
-        .at("reddit_root")
-            .edge(EdgePattern::Literal("r/"), "subreddit_selection")
-            .edge(EdgePattern::Literal("u/"), "user_selection")
-            .handler(|query, prefix, _ctx| {
-                ParserAction::multiple(vec![
-                    ParserAction::scrolling_suggestions(
-                        query.to_string(),
-                        vec![
-                            ScrollingSuggestion {
-                                completion: format!("{}r/", prefix),
-                            },
-                            ScrollingSuggestion {
-                                completion: format!("{}u/", prefix),
-                            },
-                        ],
-                        1400, // 1.4 second interval (slower)
-                        true  // loop through
-                    ),
-                    ParserAction::guide(
-                        query.to_string(),
-                        "Welcome to Sorter for Reddit".to_string(),
-                        "Where would you like to start?".to_string(),
-                        vec![
-                            GuideOption { 
-                                key: "r".to_string(), 
-                                label: "Sort a Subreddit".to_string(), 
-                                description: "Find the best posts in a community.".to_string(), 
-                                completion: format!("{}r/", prefix)
-                            },
-                            GuideOption { 
-                                key: "u".to_string(), 
-                                label: "Sort User Content".to_string(), 
-                                description: "Explore and rank a user's posts and comments.".to_string(), 
-                                completion: format!("{}u/", prefix)
-                            },
-                        ]
-                    ),
-                ])
-            })
-        
-
-        
-        // === SUBREDDIT SELECTION: THE UNIFIED NODE ===
-        // This node is now reached from `r/` OR `reddit.com/r/`
-        .at("subreddit_selection")
-            .edge(EdgePattern::Variable("subreddit"), "subreddit_page")
-            .handler(|query, prefix, _ctx| {
-                ParserAction::multiple(vec![
-                    ParserAction::scrolling_suggestions(
-                        query.to_string(),
-                        vec![
-                            ScrollingSuggestion {
-                                completion: format!("{}programming", prefix),
-                            },
-                            ScrollingSuggestion {
-                                completion: format!("{}askreddit", prefix),
-                            },
-                            ScrollingSuggestion {
-                                completion: format!("{}aww", prefix),
-                            },
-                            ScrollingSuggestion {
-                                completion: format!("{}rust", prefix),
-                            },
-                            ScrollingSuggestion {
-                                completion: format!("{}webdev", prefix),
-                            },
-                        ],
-                        1600, // 1.6 second interval (slower)
-                        true  // loop through
-                    ),
-                    // Live DB-backed suggestions for subreddits as the user types
-                    ParserAction::SuggestSubredditsFromDb { partial: query.to_string(), prefix: prefix.to_string() }
-                ])
-            })
-        
-        // === Specific subreddit page ===
-        .at("subreddit_page")
-            .edge(EdgePattern::Literal("/"), "subreddit_slash")
-            .handler(|_query, prefix, ctx| {
-                // Use the new unified subreddit resolution logic
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::ResolveAndDisplaySubreddit {
-                    subreddit,
-                    prefix: prefix.to_string(),
-                }
-            })
-        
-        .at("subreddit_slash")
-            .edge(EdgePattern::Literal("hot"), "subreddit_hot")
-            .edge(EdgePattern::Literal("top"), "subreddit_top")
-            .edge(EdgePattern::Literal("new"), "subreddit_new")
-            .edge(EdgePattern::Literal("comments"), "subreddit_comments")
-            .handler(|query, prefix, ctx| {
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::guide(
-                    query.to_string(), 
-                    format!("What to sort in r/{}?", subreddit), 
-                    "Choose a category to begin sorting.".to_string(), 
-                    vec![
-                        GuideOption { 
-                            key: "hot".to_string(), 
-                            label: "Hot Posts".to_string(), 
-                            description: "Import and sort posts currently on the front page.".to_string(), 
-                            completion: format!("{}hot", prefix) 
-                        },
-                        GuideOption { 
-                            key: "top".to_string(), 
-                            label: "Top Posts".to_string(), 
-                            description: "Import and sort the highest-rated posts.".to_string(), 
-                            completion: format!("{}top", prefix) 
-                        },
-                        GuideOption { 
-                            key: "new".to_string(), 
-                            label: "New Posts".to_string(), 
-                            description: "Import and sort the newest posts.".to_string(), 
-                            completion: format!("{}new", prefix) 
-                        },
-                        GuideOption { 
-                            key: "comments".to_string(), 
-                            label: "All Comments".to_string(), 
-                            description: "Find the best comment across all imported threads.".to_string(), 
-                            completion: format!("{}comments/", prefix) 
-                        },
-                    ]
-                )
-            })
-        
-
-        
-        .at("user_selection")
-            .edge(EdgePattern::Variable("username"), "user_profile")
-            .handler(|query, prefix, _ctx| {
-                ParserAction::guide(
-                    query.to_string(),
-                    "User Profile Sorting".to_string(),
-                    "Enter a Reddit username to sort their content.".to_string(),
-                    vec![
-                        GuideOption {
-                            key: "popular".to_string(),
-                            label: "Popular Users".to_string(),
-                            description: "Browse well-known Reddit users.".to_string(),
-                            completion: prefix.to_string(),
-                        },
-                    ]
-                )
-            })
-        
-        // === Subreddit sort types ===
-        .at("subreddit_hot")
-            .handler(|_query, _prefix, ctx| {
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::RenderEntityView {
-                    ns: "reddit.subreddit".to_string(),
-                    pk: subreddit,
-                }
-            })
-        
-        .at("subreddit_top")
-            .handler(|_query, _prefix, ctx| {
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::RenderEntityView {
-                    ns: "reddit.subreddit".to_string(),
-                    pk: subreddit,
-                }
-            })
-        
-        .at("subreddit_new")
-            .handler(|_query, _prefix, ctx| {
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::RenderEntityView {
-                    ns: "reddit.subreddit".to_string(),
-                    pk: subreddit,
-                }
-            })
-        
-        .at("subreddit_comments")
-            .handler(|_query, _prefix, ctx| {
-                let subreddit = ctx.get("subreddit").cloned().unwrap_or_default();
-                ParserAction::RenderEntityView {
-                    ns: "reddit.subreddit".to_string(),
-                    pk: subreddit,
-                }
-            })
-        
-        // === User profile ===
-        .at("user_profile")
-            .handler(|_query, _prefix, ctx| {
-                let username = ctx.get("username").cloned().unwrap_or_default();
-                ParserAction::RenderEntityView {
-                    ns: "reddit.user".to_string(),
-                    pk: username,
-                }
-            })
-        
-        // === Build the graph ===
-        .build()
-}
-
-// --- Public API ---
-
-static REDDIT_GRAPH: OnceLock<Graph> = OnceLock::new();
-
-fn reddit_graph() -> &'static Graph {
-    REDDIT_GRAPH.get_or_init(build_reddit_graph)
-}
-
-/// Parse a query string and return a UI action
-pub fn parse_reddit_url(query: &str) -> ParserAction {
-    reddit_graph().parse(query)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    /// Represents a keystroke action
-    #[derive(Debug, Clone, PartialEq)]
-    enum KeyAction {
-        Type(String),  // Type characters
-        Tab,           // Press tab (accept completion)
-
-    }
-
-    /// Expected state after a keystroke
-    #[derive(Debug, Clone)]
-    enum ExpectedAction {
-        Suggestion { completion: String },
-        ScrollingSuggestions { completions: Vec<String> },
-        Guide { title_contains: String },
-
-        RenderSubreddit { subreddit: String, sort: Option<String> },
-        RenderSubredditComments { subreddit: String },
-        RenderUser { username: String },
-        ResolveSubreddit { subreddit: String, prefix: String },  // New unified subreddit resolution
-        Error { error_type: String },
-        Multiple { expected_actions: Vec<ExpectedAction> },  // Multiple responses with specific expectations
-        MultipleAny,  // Multiple responses (any sub-actions - legacy)
-        DbSuggestions { partial: String, prefix: String },  // Database-backed suggestions
-
-    }
-
-    impl ExpectedAction {
-        fn matches(&self, action: &ParserAction) -> bool {
-            match (self, action) {
-                (ExpectedAction::Suggestion { completion }, ParserAction::ShowSuggestions(data)) => {
-                    data.suggestion.as_ref()
-                        .map(|s| s.completion == *completion)
-                        .unwrap_or(false)
-                }
-                (ExpectedAction::ScrollingSuggestions { completions }, ParserAction::ShowScrollingSuggestions { suggestions, .. }) => {
-                    let actual_completions: Vec<String> = suggestions.iter().map(|s| s.completion.clone()).collect();
-                    *completions == actual_completions
-                }
-                (ExpectedAction::Guide { title_contains }, ParserAction::ShowStaticGuide { title, .. }) => {
-                    title.contains(title_contains)
-                }
-                (ExpectedAction::RenderSubreddit { subreddit, sort: _ }, 
-                 ParserAction::RenderEntityView { ns, pk }) => {
-                    ns == "reddit.subreddit" && pk == subreddit
-                }
-                (ExpectedAction::RenderSubredditComments { subreddit }, 
-                 ParserAction::RenderEntityView { ns, pk }) => {
-                    ns == "reddit.subreddit" && pk == subreddit
-                }
-                (ExpectedAction::RenderUser { username }, ParserAction::RenderEntityView { ns, pk }) => {
-                    ns == "reddit.user" && pk == username
-                }
-                (ExpectedAction::ResolveSubreddit { subreddit, prefix }, 
-                 ParserAction::ResolveAndDisplaySubreddit { subreddit: s, prefix: p }) => {
-                    s == subreddit && p == prefix
-                }
-                (ExpectedAction::Error { error_type }, ParserAction::ShowError(data)) => {
-                    data.error_type == *error_type
-                }
-                (ExpectedAction::Multiple { expected_actions }, ParserAction::ShowMultiple { actions }) => {
-                    // Check that all expected actions are present
-                    if expected_actions.len() != actions.len() {
-                        return false;
-                    }
-                    expected_actions.iter().zip(actions.iter()).all(|(expected, actual)| {
-                        expected.matches(actual)
-                    })
-                }
-                (ExpectedAction::MultipleAny, ParserAction::ShowMultiple { .. }) => true,
-                (ExpectedAction::DbSuggestions { partial, prefix }, 
-                 ParserAction::SuggestSubredditsFromDb { partial: p, prefix: pr }) => {
-                    p == partial && pr == prefix
-                }
-
-                _ => false,
-            }
-        }
-    }
-
-    /// Test helper to simulate a sequence of keystrokes
-    fn simulate_keystrokes(actions: Vec<KeyAction>) -> Vec<(String, ParserAction)> {
-        let graph = build_reddit_graph();
-        let mut current_text = String::new();
-        let mut results = Vec::new();
-        
-        for action in actions {
-            match action {
-                KeyAction::Type(text) => {
-                    current_text.push_str(&text);
-                    let result = graph.parse(&current_text);
-                    results.push((current_text.clone(), result));
-                }
-                KeyAction::Tab => {
-                    // Tab accepts the current suggestion if there is one
-                    let result = graph.parse(&current_text);
-                    if let ParserAction::ShowSuggestions(ref data) = result {
-                        if let Some(ref suggestion) = data.suggestion {
-                            current_text = suggestion.completion.clone();
-                            let new_result = graph.parse(&current_text);
-                            results.push((current_text.clone(), new_result));
-                        }
-                    }
-                }
-
-            }
-        }
-        
-        results
-    }
-
-    /// Test a flow using declarative (KeyAction, ExpectedAction) tuples
-    fn test_flow(name: &str, flow: Vec<(KeyAction, ExpectedAction)>) {
-        let graph = build_reddit_graph();
-        let mut current_text = String::new();
-        
-        println!("\n=== Flow: {} ===", name);
-        
-        for (i, (key_action, expected)) in flow.iter().enumerate() {
-            // Perform the keystroke
-            match key_action {
-                KeyAction::Type(text) => {
-                    current_text.push_str(text);
-                }
-                KeyAction::Tab => {
-                    // Tab accepts the current suggestion
-                    let result = graph.parse(&current_text);
-                    if let ParserAction::ShowSuggestions(data) = result {
-                        if let Some(suggestion) = &data.suggestion {
-                            current_text = suggestion.completion.clone();
-                        }
-                    }
-                }
-            }
-            
-            // Check the result
-            let actual_action = graph.parse(&current_text);
-            
-            println!("  Step {}: {:?} -> '{}' -> {:?}", 
-                     i + 1, key_action, current_text, actual_action);
-            
-            assert!(
-                expected.matches(&actual_action),
-                "Flow '{}' failed at step {}\n  Expected: {:?}\n  Actual: {:?}\n  Text: '{}'",
-                name, i + 1, expected, actual_action, current_text
-            );
-        }
-        
-        println!("✓ Flow '{}' passed!", name);
-    }
-    
-    /// Legacy helper for backward compatibility (will be removed)
-    fn assert_flow(
-        name: &str,
-        actions: Vec<KeyAction>,
-        expected_checks: Vec<Box<dyn Fn(&str, &ParserAction) -> bool>>,
-    ) {
-        let results = simulate_keystrokes(actions);
-        
-        println!("\n=== Flow: {} ===", name);
-        for (i, (text, action)) in results.iter().enumerate() {
-            println!("  Step {}: '{}' -> {:?}", i + 1, text, action);
-            
-            if i < expected_checks.len() {
-                let check = &expected_checks[i];
-                assert!(
-                    check(text, action),
-                    "Flow '{}' failed at step {} with text '{}' and action {:?}",
-                    name, i + 1, text, action
-                );
-            }
-        }
-        println!("✓ Flow '{}' passed!", name);
-    }
-
-    #[test]
-    fn test_https_reddit_tab_flow() {
-        // Test: typing "https://reddit.com" and pressing tab should give "https://reddit.com/"
-        assert_flow(
-            "HTTPS Reddit with Tab",
-            vec![
-                KeyAction::Type("https://reddit.com".to_string()),
-                KeyAction::Tab,
-            ],
-            vec![
-                Box::new(|text, action| {
-                    // After typing "https://reddit.com", should get a suggestion
-                    text == "https://reddit.com" && matches!(action, ParserAction::ShowSuggestions(data) if 
-                        data.suggestion.as_ref().map(|s| s.completion == "https://reddit.com/").unwrap_or(false)
-                    )
-                }),
-                Box::new(|text, action| {
-                    // After tab, should have "https://reddit.com/" and show guide
-                    text == "https://reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_quick_subreddit_flow() {
-        // Test: "r" -> TAB -> "rust" (direct alias flow)
-        assert_flow(
-            "Quick Subreddit Access",
-            vec![
-                KeyAction::Type("r".to_string()),
-                KeyAction::Tab,
-                KeyAction::Type("rust".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    // "r" should suggest "r/"
-                    text == "r" && matches!(action, ParserAction::ShowSuggestions(data) if 
-                        data.suggestion.as_ref().map(|s| s.completion == "r/").unwrap_or(false)
-                    )
-                }),
-                Box::new(|text, action| {
-                    // After tab, should have "r/" and show subreddit selection
-                    text == "r/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-                Box::new(|text, action| {
-                    // "r/rust" should resolve the subreddit
-                    text == "r/rust" && matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } if subreddit == "rust" && prefix == "r/rust")
-                }),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_progressive_completion_flow() {
-        // Test progressive typing: "r" -> "re" -> "red" -> "redd" -> "reddit" -> TAB
-        let progressive_actions = vec![
-            KeyAction::Type("r".to_string()),
-            KeyAction::Type("e".to_string()),
-            KeyAction::Type("d".to_string()),
-            KeyAction::Type("d".to_string()),
-            KeyAction::Type("i".to_string()),
-            KeyAction::Type("t".to_string()),
-            KeyAction::Tab,
-        ];
-        
-        let results = simulate_keystrokes(progressive_actions);
-        
-        println!("\n=== Progressive Completion Flow ===");
-        for (i, (text, action)) in results.iter().enumerate() {
-            println!("  '{}' -> {:?}", text, action);
-            
-            // First step: "r" should suggest "r/"
-            if i == 0 && text == "r" {
-                match action {
-                    ParserAction::ShowSuggestions(data) => {
-                        assert_eq!(
-                            data.suggestion.as_ref().unwrap().completion,
-                            "r/",
-                            "Should suggest r/ at 'r'"
-                        );
-                    }
-                    _ => panic!("Expected suggestion at 'r'"),
-                }
-            }
-            // Other steps before tab should suggest "reddit.com"
-            else if i > 0 && i < results.len() - 1 {
-                match action {
-                    ParserAction::ShowSuggestions(data) => {
-                        assert_eq!(
-                            data.suggestion.as_ref().unwrap().completion,
-                            "reddit.com",
-                            "Should suggest reddit.com at '{}'", text
-                        );
-                    }
-                    _ => panic!("Expected suggestion at '{}'", text),
-                }
-            }
-        }
-        
-        // After tab, should have "reddit.com"
-        let (final_text, _) = results.last().unwrap();
-        assert_eq!(final_text, "reddit.com");
-        println!("✓ Progressive completion flow passed!");
-    }
-
     #[test]
-    fn test_subreddit_sort_flow() {
-        // Test navigating to a subreddit and choosing a sort option
-        assert_flow(
-            "Subreddit Sort Navigation",
-            vec![
-                KeyAction::Type("reddit.com/r/programming/hot".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    text == "reddit.com/r/programming/hot" && 
-                    matches!(action, ParserAction::RenderEntityView { ns, pk } 
-                        if ns == "reddit.subreddit" && pk == "programming")
-                }),
-            ],
-        );
+    fn parses_short_path() {
+        assert_eq!(parse_reddit_url("r/rust").unwrap(), "rust");
     }
 
     #[test]
-    fn test_user_profile_flow() {
-        // Test navigating to a user profile
-        assert_flow(
-            "User Profile Navigation",
-            vec![
-                KeyAction::Type("reddit.com/u/spez".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    text == "reddit.com/u/spez" && 
-                    matches!(action, ParserAction::RenderEntityView { ns, pk } if ns == "reddit.user" && pk == "spez")
-                }),
-            ],
-        );
+    fn parses_path_with_trailing_slash() {
+        assert_eq!(parse_reddit_url("r/rust/").unwrap(), "rust");
     }
 
     #[test]
-    fn test_alias_shortcut_flow() {
-        // Test using the "r/" shortcut - now correctly goes directly to subreddit
-        assert_flow(
-            "Alias Shortcut",
-            vec![
-                KeyAction::Type("r/".to_string()),
-                KeyAction::Type("technology".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    text == "r/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-                Box::new(|text, action| {
-                    text == "r/technology" && 
-                    matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } if subreddit == "technology" && prefix == "r/technology")
-                }),
-            ],
+    fn parses_full_url() {
+        assert_eq!(
+            parse_reddit_url("https://www.reddit.com/r/programming/hot").unwrap(),
+            "programming"
         );
     }
 
     #[test]
-    fn test_www_prefix_flow() {
-        // Test with www prefix
-        assert_flow(
-            "WWW Prefix",
-            vec![
-                KeyAction::Type("www.reddit.com".to_string()),
-                KeyAction::Tab,
-            ],
-            vec![
-                Box::new(|text, action| {
-                    // Should suggest adding slash
-                    text == "www.reddit.com" && matches!(action, ParserAction::ShowSuggestions(data) if 
-                        data.suggestion.as_ref().map(|s| s.completion == "www.reddit.com/").unwrap_or(false)
-                    )
-                }),
-                Box::new(|text, action| {
-                    // After tab, should show guide
-                    text == "www.reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-            ],
+    fn parses_url_without_scheme() {
+        assert_eq!(
+            parse_reddit_url("reddit.com/r/AskReddit").unwrap(),
+            "askreddit"
         );
     }
 
     #[test]
-    fn test_invalid_path_handling() {
-        // Test that invalid paths show errors
-        assert_flow(
-            "Invalid Path",
-            vec![
-                KeyAction::Type("reddit.com/invalid/path".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    text == "reddit.com/invalid/path" && 
-                    matches!(action, ParserAction::ShowError(_))
-                }),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_complete_user_journey() {
-        // Test a complete user journey: type partial URL, tab complete, navigate to subreddit
-        assert_flow(
-            "Complete User Journey",
-            vec![
-                KeyAction::Type("http".to_string()),
-                KeyAction::Type("s://r".to_string()),
-                KeyAction::Tab,
-                KeyAction::Type("/".to_string()),
-                KeyAction::Type("r/".to_string()),
-                KeyAction::Type("programming".to_string()),
-                KeyAction::Type("/".to_string()),
-                KeyAction::Type("top".to_string()),
-            ],
-            vec![
-                Box::new(|text, action| {
-                    // "http" should suggest "https://"
-                    text == "http" && matches!(action, ParserAction::ShowSuggestions(data) if 
-                        data.suggestion.as_ref().map(|s| s.completion == "https://").unwrap_or(false)
-                    )
-                }),
-                Box::new(|text, action| {
-                    // "https://r" should suggest "https://reddit.com"
-                    text == "https://r" && matches!(action, ParserAction::ShowSuggestions(data) if 
-                        data.suggestion.as_ref().map(|s| s.completion == "https://reddit.com").unwrap_or(false)
-                    )
-                }),
-                Box::new(|text, action| {
-                    // After tab, should have "https://reddit.com"
-                    text == "https://reddit.com" && matches!(action, ParserAction::ShowSuggestions(_))
-                }),
-                Box::new(|text, action| {
-                    // "https://reddit.com/" should show guide
-                    text == "https://reddit.com/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-                Box::new(|text, action| {
-                    // "https://reddit.com/r/" should show subreddit selection
-                    text == "https://reddit.com/r/" && matches!(action, ParserAction::ShowMultiple { .. })
-                }),
-                Box::new(|text, action| {
-                    // "https://reddit.com/r/programming" should resolve subreddit
-                    text == "https://reddit.com/r/programming" && 
-                    matches!(action, ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } 
-                        if subreddit == "programming" && prefix == "https://reddit.com/r/programming")
-                }),
-                Box::new(|text, action| {
-                    // "https://reddit.com/r/programming/" should show sort options
-                    text == "https://reddit.com/r/programming/" && 
-                    matches!(action, ParserAction::ShowStaticGuide { .. })
-                }),
-                Box::new(|text, action| {
-                    // "https://reddit.com/r/programming/top" should render entity view
-                    text == "https://reddit.com/r/programming/top" && 
-                    matches!(action, ParserAction::RenderEntityView { ns, pk } 
-                        if ns == "reddit.subreddit" && pk == "programming")
-                }),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_multiple_tab_completions() {
-        // Test multiple tab completions in sequence
-        let actions = vec![
-            KeyAction::Type("h".to_string()),
-            KeyAction::Tab,  // Complete to "https://"
-            KeyAction::Type("r".to_string()),
-            KeyAction::Tab,  // Complete to "https://reddit.com"
-            KeyAction::Type("/".to_string()),
-        ];
-        
-        let results = simulate_keystrokes(actions);
-        
-        println!("\n=== Multiple Tab Completions ===");
-        for (i, (text, _action)) in results.iter().enumerate() {
-            println!("  Step {}: '{}'", i + 1, text);
-        }
-        
-        // Verify the final state
-        assert_eq!(results[1].0, "https://");  // After first tab
-        assert_eq!(results[3].0, "https://reddit.com");  // After second tab
-        assert_eq!(results[4].0, "https://reddit.com/");  // After typing /
-        
-        println!("✓ Multiple tab completions work correctly!");
-    }
-
-    // === CONVENIENCE MACROS FOR CLEANER TESTS ===
-    
-    macro_rules! flow {
-        ($(($key:expr, $expected:expr)),* $(,)?) => {
-            vec![$(($key, $expected)),*]
-        };
-    }
-    
-    macro_rules! type_text {
-        ($text:expr) => {
-            KeyAction::Type($text.to_string())
-        };
-    }
-    
-    macro_rules! suggests {
-        ($completion:expr) => {
-            ExpectedAction::Suggestion { completion: $completion.to_string() }
-        };
-    }
-    
-    macro_rules! renders_subreddit {
-        ($subreddit:expr) => {
-            ExpectedAction::RenderSubreddit { subreddit: $subreddit.to_string(), sort: None }
-        };
-        ($subreddit:expr, $sort:expr) => {
-            ExpectedAction::RenderSubreddit { 
-                subreddit: $subreddit.to_string(), 
-                sort: Some($sort.to_string()) 
-            }
-        };
-    }
-    
-    macro_rules! renders_subreddit_comments {
-        ($subreddit:expr) => {
-            ExpectedAction::RenderSubredditComments { subreddit: $subreddit.to_string() }
-        };
-    }
-    
-    macro_rules! resolves_subreddit {
-        ($subreddit:expr, $prefix:expr) => {
-            ExpectedAction::ResolveSubreddit { 
-                subreddit: $subreddit.to_string(),
-                prefix: $prefix.to_string()
-            }
-        };
-    }
-    
-    macro_rules! shows_guide {
-        ($title_contains:expr) => {
-            ExpectedAction::Guide { title_contains: $title_contains.to_string() }
-        };
-    }
-    
-    macro_rules! multiple {
-        ($($action:expr),* $(,)?) => {
-            ExpectedAction::Multiple { expected_actions: vec![$($action),*] }
-        };
-    }
-    
-    macro_rules! scrolling_suggestions {
-        ($($completion:expr),* $(,)?) => {
-            ExpectedAction::ScrollingSuggestions { completions: vec![$($completion.to_string()),*] }
-        };
-    }
-    
-    macro_rules! db_suggestions {
-        ($partial:expr, $prefix:expr) => {
-            ExpectedAction::DbSuggestions { partial: $partial.to_string(), prefix: $prefix.to_string() }
-        };
-    }
-
-    // === NEW DECLARATIVE TESTS ===
-
-    #[test]
-    fn test_declarative_https_tab_flow() {
-        test_flow("HTTPS Tab Completion", vec![
-            (KeyAction::Type("https://reddit.com".to_string()), 
-             ExpectedAction::Suggestion { completion: "https://reddit.com/".to_string() }),
-            (KeyAction::Tab, 
-             multiple![
-                 scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"),
-                 shows_guide!("Welcome to Sorter")
-             ]),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_quick_subreddit_flow() {
-        test_flow("Quick Subreddit Flow", vec![
-            (KeyAction::Type("r".to_string()), 
-             ExpectedAction::Suggestion { completion: "r/".to_string() }),
-            (KeyAction::Tab, 
-             ExpectedAction::MultipleAny), // r/ shows subreddit selection
-            (KeyAction::Type("rust".to_string()),
-             ExpectedAction::ResolveSubreddit { subreddit: "rust".to_string(), prefix: "r/rust".to_string() }),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_complete_journey() {
-        test_flow("Complete User Journey", vec![
-            (KeyAction::Type("http".to_string()),
-             ExpectedAction::Suggestion { completion: "https://".to_string() }),
-            (KeyAction::Type("s://r".to_string()),
-             ExpectedAction::Suggestion { completion: "https://reddit.com".to_string() }),
-            (KeyAction::Tab,
-             ExpectedAction::Suggestion { completion: "https://reddit.com/".to_string() }),
-            (KeyAction::Type("/r/programming/top".to_string()),
-             ExpectedAction::RenderSubreddit { 
-                 subreddit: "programming".to_string(), 
-                 sort: Some("top".to_string()) 
-             }),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_user_profile() {
-        test_flow("User Profile Navigation", vec![
-            (KeyAction::Type("reddit.com/u/spez".to_string()),
-             ExpectedAction::RenderUser { username: "spez".to_string() }),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_error_handling() {
-        test_flow("Error Handling", vec![
-            (KeyAction::Type("reddit.com/invalid/path".to_string()),
-             ExpectedAction::Error { error_type: "InvalidPath".to_string() }),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_progressive_completion() {
-        test_flow("Progressive Completion", vec![
-            (KeyAction::Type("r".to_string()),
-             ExpectedAction::Suggestion { completion: "r/".to_string() }),
-            (KeyAction::Type("e".to_string()),
-             ExpectedAction::Suggestion { completion: "reddit.com".to_string() }),
-            (KeyAction::Type("d".to_string()),
-             ExpectedAction::Suggestion { completion: "reddit.com".to_string() }),
-            (KeyAction::Type("dit".to_string()),
-             ExpectedAction::Suggestion { completion: "reddit.com".to_string() }),
-            (KeyAction::Tab,
-             ExpectedAction::Suggestion { completion: "reddit.com/".to_string() }),
-        ]);
-    }
-
-    #[test]
-    fn test_declarative_subreddit_guide() {
-        test_flow("Subreddit Guide", vec![
-            (KeyAction::Type("reddit.com/r/programming/".to_string()),
-             ExpectedAction::Guide { title_contains: "What to sort".to_string() }),
-        ]);
-    }
-
-    #[test]
-    fn test_clean_macro_example() {
-        // This is what the tests can look like with macros!
-        test_flow("Clean Macro Example", flow![
-            (type_text!("r"), suggests!("r/")),
-            (KeyAction::Tab, ExpectedAction::MultipleAny),
-            (type_text!("rust/hot"), renders_subreddit!("rust", "hot")),
-        ]);
-    }
-
-    #[test]
-    fn test_unified_subreddit_resolution_flow() {
-        // This test demonstrates the new unified behavior:
-        // - r/programming (exact) → tries exact match first
-        // - r/pro (partial) → tries exact match, then suggestions + TAB completion
-        
-        test_flow("Unified Resolution: Exact Match", flow![
-            (type_text!("r/programming"), resolves_subreddit!("programming", "r/programming")),
-        ]);
-        
-        test_flow("Unified Resolution: Partial Match", flow![
-            (type_text!("r/pro"), resolves_subreddit!("pro", "r/pro")),
-        ]);
-        
-        // Both go through the same action type, but dispatcher handles them differently:
-        // - If "programming" exists in DB → shows EntityView immediately
-        // - If "pro" doesn't exist in DB → shows Multiple with:
-        //   1. Suggestions (for TAB completion to best match)  
-        //   2. Selection (for clickable options including import)
-    }
-
-    #[test]
-    fn test_tab_completion_workflow_unified() {
-        // This demonstrates the desired TAB completion behavior:
-        // r/pro + TAB → r/programming (if "programming" is the best DB match)
-        
-        // Note: This test shows the PARSER behavior. The actual TAB completion 
-        // happens in the frontend when it receives the Multiple response containing
-        // both Suggestions (for TAB) and Selection (for click options).
-        
-        let graph = build_reddit_graph();
-        
-        // 1. Parser generates unified action for partial input
-        match graph.parse("r/pro") {
-            ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => {
-                assert_eq!(subreddit, "pro");
-                assert_eq!(prefix, "r/pro");
-                println!("✓ Parser correctly identifies 'r/pro' as subreddit resolution");
-            }
-            _ => panic!("Expected ResolveAndDisplaySubreddit for 'r/pro'"),
-        }
-        
-        // 2. When dispatcher runs (in real app), it will return Multiple response with:
-        //    - Suggestions: { completion: "r/programming" } (for TAB)
-        //    - Selection: [ "Import r/pro", "r/programming", ... ] (for clicks)
-        
-        println!("✓ TAB completion workflow: r/pro → ResolveAndDisplaySubreddit → Multiple(Suggestions + Selection)");
-    }
-
-    #[test]
-    fn test_ultra_clean_user_journey() {
-        test_flow("Ultra Clean User Journey", flow![
-            (type_text!("h"), suggests!("https://")),
-            (type_text!("ttps://r"), suggests!("https://reddit.com")), 
-            (KeyAction::Tab, suggests!("https://reddit.com/")),
-            (type_text!("/u/spez"), ExpectedAction::RenderUser { username: "spez".to_string() }),
-        ]);
-    }
-
-    // === TESTS FROM parser.tdsl ===
-
-    #[test]
-    fn test_tdsl_basic_reddit_progression() {
-        // Tests from parser.tdsl: r -> r/, then re -> reddit.com with all intermediate steps
-        test_flow("TDSL Basic Reddit Progression", flow![
-            (type_text!("r"), suggests!("r/")),
-            (type_text!("e"), suggests!("reddit.com")),
-            (type_text!("d"), suggests!("reddit.com")),
-            (type_text!("d"), suggests!("reddit.com")),
-            (type_text!("i"), suggests!("reddit.com")),
-            (type_text!("t"), suggests!("reddit.com")),
-            (type_text!("."), suggests!("reddit.com")),
-            (type_text!("c"), suggests!("reddit.com")),
-            (type_text!("o"), suggests!("reddit.com")),
-            (KeyAction::Tab, suggests!("reddit.com/")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_reddit_com_slash_infographic() {
-        // reddit.com/ -> {show infographic explaining that u (sort user posts) and r (sort subreddit posts)}
-        test_flow("TDSL Reddit.com/ Infographic", flow![
-            (type_text!("reddit.com/"), ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_subreddit_selection() {
-        // reddit.com/r/ -> reddit.com/r/{randomly chose sub from list}
-        test_flow("TDSL Subreddit Selection", flow![
-            (type_text!("reddit.com/r/"), ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_subreddit_view() {
-        // reddit.com/r/{sub} -> {resolve subreddit (exact match or suggestions)}
-        test_flow("TDSL Subreddit View", flow![
-            (type_text!("reddit.com/r/programming"), resolves_subreddit!("programming", "reddit.com/r/programming")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_subreddit_slash_infographic() {
-        // reddit.com/r/{sub}/ -> {show infographic or something}
-        test_flow("TDSL Subreddit Slash Infographic", flow![
-            (type_text!("reddit.com/r/programming/"), shows_guide!("What to sort")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_subreddit_comments() {
-        // reddit.com/r/{sub}/comments/{randomly chose comment from sql}
-        test_flow("TDSL Subreddit Comments", flow![
-            (type_text!("reddit.com/r/programming/comments"), renders_subreddit_comments!("programming")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_h_to_https() {
-        // h->https:// (show supported domains)
-        test_flow("TDSL H to HTTPS", flow![
-            (type_text!("h"), suggests!("https://")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_composable_https_reddit() {
-        // https://r->https://reddit.com/
-        test_flow("TDSL Composable HTTPS Reddit", flow![
-            (type_text!("https://r"), suggests!("https://reddit.com")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_composable_https_www() {
-        // https://w->https://www.
-        test_flow("TDSL Composable HTTPS WWW", flow![
-            (type_text!("https://w"), suggests!("https://www.")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_composable_https_www_reddit() {
-        // https://www.r->https://www.reddit.com/
-        test_flow("TDSL Composable HTTPS WWW Reddit", flow![
-            (type_text!("https://www.r"), suggests!("https://www.reddit.com")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_full_composable_chain() {
-        // Complete chain showing composability: h -> https:// -> https://www.reddit.com
-        test_flow("TDSL Full Composable Chain Step 1", flow![
-            (type_text!("h"), suggests!("https://")),
-        ]);
-        
-        test_flow("TDSL Full Composable Chain Step 2", flow![
-            (type_text!("https://w"), suggests!("https://www.")),
-        ]);
-        
-        test_flow("TDSL Full Composable Chain Step 3", flow![
-            (type_text!("https://www.r"), suggests!("https://www.reddit.com")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_progressive_reddit_paths() {
-        // Test various reddit paths work as expected
-        test_flow("TDSL Progressive Reddit Paths", flow![
-            (type_text!("reddit.com"), suggests!("reddit.com/")),
-            (KeyAction::Tab, ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    #[test] 
-    fn test_tdsl_subreddit_sorting_options() {
-        // Test that subreddit sorting options work as described
-        test_flow("TDSL Subreddit Sorting", flow![
-            (type_text!("reddit.com/r/rust/hot"), renders_subreddit!("rust", "hot")),
-        ]);
-        
-        test_flow("TDSL Subreddit Top", flow![
-            (type_text!("reddit.com/r/rust/top"), renders_subreddit!("rust", "top")),
-        ]);
-        
-        test_flow("TDSL Subreddit New", flow![
-            (type_text!("reddit.com/r/rust/new"), renders_subreddit!("rust", "new")),
-        ]);
-    }
-
-    #[test]
-    fn test_tdsl_all_reddit_prefixes() {
-        // Test all the prefixes mentioned in parser.tdsl work
-        // "r" now suggests "r/", all others suggest "reddit.com"
-        let prefixes_to_reddit = vec!["re", "red", "redd", "reddi", "reddit", "reddit.", "reddit.c", "reddit.co"];
-        
-        // Test "r" separately since it now suggests "r/"
-        test_flow("TDSL Prefix: r", flow![
-            (type_text!("r"), suggests!("r/")),
-        ]);
-        
-        for prefix in prefixes_to_reddit {
-            test_flow(&format!("TDSL Prefix: {}", prefix), flow![
-                (type_text!(prefix), suggests!("reddit.com")),
-            ]);
-        }
-    }
-
-    #[test]
-    fn test_tdsl_protocol_combinations() {
-        // Test various protocol combinations from parser.tdsl
-        let test_cases = vec![
-            ("http://r", "http://reddit.com"),
-            ("https://r", "https://reddit.com"),
-            ("www.r", "www.reddit.com"),
-            ("https://www.r", "https://www.reddit.com"),
-            ("http://www.r", "http://www.reddit.com"),
-        ];
-        
-        for (input, expected) in test_cases {
-            test_flow(&format!("TDSL Protocol: {}", input), flow![
-                (type_text!(input), suggests!(expected)),
-            ]);
-        }
+    fn rejects_empty() {
+        assert!(parse_reddit_url("").is_err());
+        assert!(parse_reddit_url("   ").is_err());
     }
 
     #[test]
-    fn test_tdsl_edge_case_completions() {
-        // Test edge cases mentioned in parser.tdsl
-        test_flow("TDSL Reddit.com completion", flow![
-            (type_text!("reddit.com"), suggests!("reddit.com/")),
-        ]);
-        
-        // Test that typing full reddit.com suggests the slash
-        test_flow("TDSL Full domain completion", flow![
-            (type_text!("reddit.com"), suggests!("reddit.com/")),
-            (KeyAction::Tab, ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    #[test]
-    fn test_real_user_trace_2025_08_07_fixed() {
-        // Based on actual WebSocket trace from 2025-08-07T01:35:46Z
-        // This test shows the CORRECT behavior after fixing the protocol preservation bug
-        test_flow("Real User Trace: Progressive Typing with Tab Completions (Fixed)", flow![
-            // User started typing "h"
-            (type_text!("h"), suggests!("https://")),
-            
-            // User continued to "ht" 
-            (type_text!("t"), suggests!("https://")),
-            
-            // User finished typing "https://" (trace shows full protocol)
-            (type_text!("tps://"), suggests!("https://")),
-            
-            // User started typing "r" after protocol
-            (type_text!("r"), suggests!("https://reddit.com")),
-            
-            // User continued typing "re"
-            (type_text!("e"), suggests!("https://reddit.com")),
-            
-            // User typed out or completed "https://reddit.com"
-            (type_text!("ddit.com"), suggests!("https://reddit.com/")),
-            
-            // User accepted completion to "https://reddit.com/"
-            // NOW suggestions should preserve the https:// protocol
-            (KeyAction::Tab, multiple![
-                scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"),  // This is the key fix!
-                shows_guide!("Welcome to Sorter")
-            ]),
-        ]);
-    }
-
-    #[test]
-    fn test_protocol_preservation_bug_fix() {
-        // This test specifically verifies the fix for the protocol preservation bug
-        test_flow("Protocol Preservation: HTTPS Reddit Homepage", flow![
-            (type_text!("https://reddit.com/"), multiple![
-                scrolling_suggestions!("https://reddit.com/r/", "https://reddit.com/u/"),  // Should preserve https://
-                shows_guide!("Welcome to Sorter")
-            ]),
-        ]);
-        
-        // Test that subreddit selection preserves protocol
-        test_flow("Protocol Preservation: HTTPS Subreddit Selection", flow![
-            (type_text!("https://reddit.com/r/"), multiple![
-                scrolling_suggestions!("https://reddit.com/r/programming", "https://reddit.com/r/askreddit", "https://reddit.com/r/aww", "https://reddit.com/r/rust", "https://reddit.com/r/webdev"),  // Should preserve https://
-                db_suggestions!("https://reddit.com/r/", "https://reddit.com/r/")
-            ]),
-        ]);
-        
-        // Test with different protocols
-        test_flow("Protocol Preservation: HTTP", flow![
-            (type_text!("http://reddit.com/"), multiple![
-                scrolling_suggestions!("http://reddit.com/r/", "http://reddit.com/u/"),  // Should preserve http://
-                shows_guide!("Welcome to Sorter")
-            ]),
-        ]);
-        
-        test_flow("Protocol Preservation: WWW", flow![
-            (type_text!("www.reddit.com/"), multiple![
-                scrolling_suggestions!("www.reddit.com/r/", "www.reddit.com/u/"),  // Should preserve www.
-                shows_guide!("Welcome to Sorter")
-            ]),
-        ]);
-        
-        // Test that plain reddit.com still works
-        test_flow("Protocol Preservation: Plain Domain", flow![
-            (type_text!("reddit.com/"), multiple![
-                scrolling_suggestions!("reddit.com/r/", "reddit.com/u/"),  // No protocol prefix
-                shows_guide!("Welcome to Sorter")
-            ]),
-        ]);
-    }
-
-    #[test]
-    fn test_user_navigation_pattern() {
-        // Models how users actually navigate: type → tab → click suggestion → end up at destination
-        // This captures the "jump" from https://reddit.com/ to reddit.com/r/ seen in the trace
-        test_flow("User Navigation: Protocol to Domain", flow![
-            // User types and gets to homepage
-            (type_text!("https://reddit.com/"), ExpectedAction::MultipleAny),
-        ]);
-        
-        // Then they navigate (perhaps clicking a suggestion) to subreddit selection
-        test_flow("User Navigation: Click to Subreddit", flow![
-            // This is where they ended up - the suggestion in the guide probably said "reddit.com/r/"
-            (type_text!("reddit.com/r/"), ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    #[test]
-    fn test_progressive_typing_pattern() {
-        // Based on the trace pattern - users often type character by character
-        // This tests the exact sequence of suggestions they would see
-        test_flow("Progressive Typing Pattern", flow![
-            (type_text!("h"), suggests!("https://")),
-            (type_text!("t"), suggests!("https://")), // Still suggests https://
-            (type_text!("t"), suggests!("https://")), // ht -> htt, still suggests https://
-            (type_text!("p"), suggests!("https://")), // http should still suggest https://
-            (type_text!("s"), suggests!("https://")), // https should suggest https://
-            (type_text!("://"), suggests!("https://")), // Even complete protocol still suggests itself
-        ]);
-    }
-
-    #[test]  
-    fn test_tab_completion_workflow() {
-        // Test what happens when user uses tab completions strategically
-        test_flow("Strategic Tab Completion Workflow", flow![
-            // Start typing, get suggestion
-            (type_text!("h"), suggests!("https://")),
-            
-            // Accept suggestion with tab - this should move us to "https://"
-            (KeyAction::Tab, suggests!("https://")), // After tab, we're at "https://" which still suggests itself
-            
-            // Start typing reddit
-            (type_text!("r"), suggests!("https://reddit.com")),
-            
-            // Accept reddit suggestion  
-            (KeyAction::Tab, suggests!("https://reddit.com/")),
-            
-            // Accept final suggestion to get to homepage
-            (KeyAction::Tab, ExpectedAction::MultipleAny),
-        ]);
-    }
-
-    // Keep the original tests as well
-    #[test]
-    fn test_reddit_prefix_autocomplete() {
-        let graph = build_reddit_graph();
-        
-        // "r" now suggests "r/", others suggest "reddit.com"
-        match graph.parse("r") {
-            ParserAction::ShowSuggestions(data) => {
-                assert_eq!(data.suggestion.as_ref().unwrap().completion, "r/");
-                println!("✓ 'r' → r/");
-            }
-            _ => panic!("Expected suggestion for 'r'"),
-        }
-        
-        // Test other prefixes that should suggest "reddit.com"
-        let prefixes = vec!["re", "red", "redd", "reddi", "reddit", "reddit.", "reddit.c", "reddit.co"];
-        
-        for prefix in prefixes {
-            match graph.parse(prefix) {
-                ParserAction::ShowSuggestions(data) => {
-                    assert_eq!(data.suggestion.as_ref().unwrap().completion, "reddit.com");
-                    println!("✓ '{}' → reddit.com", prefix);
-                }
-                _ => panic!("Expected suggestion for '{}'", prefix),
-            }
-        }
-    }
-    
-    #[test]
-    fn test_protocol_composition() {
-        let graph = build_reddit_graph();
-        
-        // Test protocol + reddit compositions
-        let tests = vec![
-            ("https://r", "https://reddit.com"),
-            ("https://re", "https://reddit.com"),
-            ("https://reddit", "https://reddit.com"),
-            ("https://www.r", "https://www.reddit.com"),
-            ("https://www.reddit", "https://www.reddit.com"),
-            ("http://r", "http://reddit.com"),
-            ("www.r", "www.reddit.com"),
-        ];
-        
-        for (input, expected) in tests {
-            match graph.parse(input) {
-                ParserAction::ShowSuggestions(data) => {
-                    assert_eq!(data.suggestion.as_ref().unwrap().completion, expected);
-                    println!("✓ '{}' → {}", input, expected);
-                }
-                _ => panic!("Expected suggestion for '{}'", input),
-            }
-        }
-    }
-    
-    #[test]
-    fn test_alias_and_full_paths() {
-        let graph = build_reddit_graph();
-        
-        // reddit.com/ should show guide, r/ should show subreddit selection
-        match graph.parse("reddit.com/") {
-            ParserAction::ShowMultiple { actions } => {
-                let has_guide = actions.iter()
-                    .any(|a| matches!(a, ParserAction::ShowStaticGuide { .. }));
-                assert!(has_guide, "Path 'reddit.com/' should show guide");
-                println!("✓ 'reddit.com/' shows Reddit root guide");
-            }
-            _ => panic!("Expected Multiple action for 'reddit.com/'"),
-        }
-        
-        match graph.parse("r/") {
-            ParserAction::ShowMultiple { actions } => {
-                let has_scrolling_suggestions = actions.iter()
-                    .any(|a| matches!(a, ParserAction::ShowScrollingSuggestions { .. }));
-                let has_db_suggestions = actions.iter()
-                    .any(|a| matches!(a, ParserAction::SuggestSubredditsFromDb { .. }));
-                assert!(has_scrolling_suggestions && has_db_suggestions, 
-                       "Path 'r/' should show scrolling suggestions and DB suggestions");
-                println!("✓ 'r/' shows subreddit selection");
-            }
-            _ => panic!("Expected Multiple action for 'r/'"),
-        }
-    }
-    
-    #[test]
-    fn test_deep_navigation() {
-        let graph = build_reddit_graph();
-        
-        // Test navigation to subreddit - now uses ResolveAndDisplaySubreddit
-        match graph.parse("reddit.com/r/rust") {
-            ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => {
-                assert_eq!(subreddit, "rust");
-                assert_eq!(prefix, "reddit.com/r/rust");
-                println!("✓ reddit.com/r/rust recognized");
-            }
-            _ => panic!("Expected ResolveAndDisplaySubreddit for subreddit"),
-        }
-        
-        // Test with alias (r/ goes directly to subreddit, no double r/)
-        match graph.parse("r/programming") {
-            ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => {
-                assert_eq!(subreddit, "programming");
-                assert_eq!(prefix, "r/programming");
-                println!("✓ r/programming (alias) recognized");
-            }
-            _ => panic!("Expected ResolveAndDisplaySubreddit for subreddit via alias"),
-        }
+    fn rejects_garbage() {
+        assert!(parse_reddit_url("hello world").is_err());
     }
 }
diff --git a/server/src/parser_action.rs b/server/src/parser_action.rs
deleted file mode 100644
index 2b98556b562d548ce231a726f9e704f595e8f4a1..0000000000000000000000000000000000000000
--- a/server/src/parser_action.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! Parser output actions — graph handlers return these; HTML render turns them into markup.
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Suggestion {
-    pub text: String,
-    pub completion: String,
-    pub description: Option<String>,
-    pub score: f64,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ScrollingSuggestion {
-    pub completion: String,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct GuideOption {
-    pub key: String,
-    pub label: String,
-    pub description: String,
-    pub completion: String,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct SuggestionsData {
-    pub query: String,
-    pub suggestion: Option<Suggestion>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ErrorData {
-    pub error_type: String,
-    pub message: String,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum ParserAction {
-    ShowSuggestions(SuggestionsData),
-    ShowScrollingSuggestions {
-        query: String,
-        suggestions: Vec<ScrollingSuggestion>,
-        interval_ms: u64,
-        r#loop: bool,
-    },
-    ShowStaticGuide {
-        query: String,
-        title: String,
-        subtitle: String,
-        options: Vec<GuideOption>,
-    },
-    ShowMultiple {
-        actions: Vec<ParserAction>,
-    },
-    ShowError(ErrorData),
-    SuggestSubredditsFromDb {
-        partial: String,
-        prefix: String,
-    },
-    ResolveAndDisplaySubreddit {
-        subreddit: String,
-        prefix: String,
-    },
-    RenderEntityView {
-        ns: String,
-        pk: String,
-    },
-}
-
-impl ParserAction {
-    pub fn suggest(query: String, suggestion: Option<Suggestion>) -> Self {
-        Self::ShowSuggestions(SuggestionsData { query, suggestion })
-    }
-
-    pub fn error(error_type: String, message: String) -> Self {
-        Self::ShowError(ErrorData {
-            error_type,
-            message,
-        })
-    }
-
-    pub fn multiple(actions: Vec<Self>) -> Self {
-        Self::ShowMultiple { actions }
-    }
-
-    pub fn scrolling_suggestions(
-        query: String,
-        suggestions: Vec<ScrollingSuggestion>,
-        interval_ms: u64,
-        r#loop: bool,
-    ) -> Self {
-        Self::ShowScrollingSuggestions {
-            query,
-            suggestions,
-            interval_ms,
-            r#loop,
-        }
-    }
-
-    pub fn guide(
-        query: String,
-        title: String,
-        subtitle: String,
-        options: Vec<GuideOption>,
-    ) -> Self {
-        Self::ShowStaticGuide {
-            query,
-            title,
-            subtitle,
-            options,
-        }
-    }
-
-    /// Primary tab-completion string, if any.
-    pub fn primary_completion(&self) -> Option<&str> {
-        match self {
-            Self::ShowSuggestions(data) => data
-                .suggestion
-                .as_ref()
-                .map(|s| s.completion.as_str()),
-            Self::ShowMultiple { actions } => actions.iter().find_map(|a| a.primary_completion()),
-            _ => None,
-        }
-    }
-}
diff --git a/server/src/parser_render.rs b/server/src/parser_render.rs
index 05e4f519cc3832392282b319272b61c104eaabf6..f2341afe21476b689a536137798d97277211a962 100644
--- a/server/src/parser_render.rs
+++ b/server/src/parser_render.rs
@@ -2,12 +2,9 @@ use maud::{html, Markup};
 
 use crate::{
     form_template::template_json_compact,
-    parser_action::{GuideOption, ParserAction, ScrollingSuggestion, Suggestion},
     ui_action::UI_RPC_FIELD,
 };
 
-const SAMPLE_SUBREDDITS: &[&str] = &["programming", "askreddit", "rust", "webdev", "aww"];
-
 fn parse_query_rpc_template() -> String {
     template_json_compact(&serde_json::json!({
         "action": "parse_query",
@@ -16,193 +13,32 @@ fn parse_query_rpc_template() -> String {
     .expect("parse_query rpc template")
 }
 
-fn completion_button(completion: &str, label: &str, primary: bool) -> Markup {
-    let class = if primary {
-        "parser-completion parser-suggestion-primary btn-link"
-    } else {
-        "parser-completion btn-link"
-    };
-    html! {
-        button
-            type="button"
-            class=(class)
-            data-completion=(completion)
-            title="Use this path" {
-            (label)
-        }
-    }
-}
-
-fn render_suggestion(s: &Suggestion) -> Markup {
-    let desc = s
-        .description
-        .as_deref()
-        .unwrap_or("Tab to complete");
-    html! {
-        p class="parser-suggestion" {
-            (completion_button(&s.completion, &s.completion, true))
-            span class="muted small" { " — " (desc) }
-        }
-    }
-}
-
-fn render_scrolling(suggestions: &[ScrollingSuggestion]) -> Markup {
-    html! {
-        div class="parser-scrolling muted small" {
-            p { "Examples:" }
-            ul class="parser-scroll-list" {
-                @for s in suggestions {
-                    li { (completion_button(&s.completion, &s.completion, false)) }
-                }
-            }
-        }
-    }
-}
-
-fn render_guide(title: &str, subtitle: &str, options: &[GuideOption]) -> Markup {
-    html! {
-        div class="parser-guide" {
-            h3 { (title) }
-            p class="muted" { (subtitle) }
-            ul class="parser-guide-list" {
-                @for opt in options {
-                    li {
-                        strong { (opt.key) ": " }
-                        (completion_button(&opt.completion, &opt.label, false))
-                        span class="muted small" { " — " (opt.description) }
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn render_db_subs(partial: &str, prefix: &str) -> Markup {
-    let needle = partial.to_lowercase();
-    let matches: Vec<_> = SAMPLE_SUBREDDITS
-        .iter()
-        .filter(|s| s.contains(&needle) || prefix.ends_with('/') && needle.is_empty())
-        .take(6)
-        .collect();
-    html! {
-        @if !matches.is_empty() {
-            div class="parser-db-subs muted small" {
-                p { "Subreddits:" }
-                ul {
-                    @for sub in matches {
-                        @let completion = format!("{prefix}{sub}");
-                        li { (completion_button(&completion, &format!("r/{sub}"), false)) }
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn render_action(action: &ParserAction) -> Markup {
-    match action {
-        ParserAction::ShowSuggestions(data) => html! {
-            div class="parser-result parser-suggestions" {
-                @if let Some(s) = &data.suggestion {
-                    (render_suggestion(s))
-                } @else {
-                    p class="muted" { "No completion" }
-                }
-            }
-        },
-        ParserAction::ShowScrollingSuggestions { suggestions, .. } => {
-            render_scrolling(suggestions)
-        }
-        ParserAction::ShowStaticGuide {
-            title,
-            subtitle,
-            options,
-            ..
-        } => render_guide(title, subtitle, options),
-        ParserAction::ShowMultiple { actions } => html! {
-            div class="parser-multiple" {
-                @for a in actions {
-                    (render_action(a))
-                }
-            }
-        },
-        ParserAction::ShowError(data) => html! {
-            p class="parser-error muted" {
-                strong { (data.error_type) ": " }
-                (data.message)
-            }
-        },
-        ParserAction::SuggestSubredditsFromDb { partial, prefix } => {
-            render_db_subs(partial, prefix)
-        }
-        ParserAction::ResolveAndDisplaySubreddit { subreddit, prefix } => html! {
-            div class="parser-resolve" {
-                p {
-                    "Subreddit "
-                    strong { "r/" (subreddit) }
-                    @if subreddit.len() <= 3 {
-                        span class="muted small" { " (partial — tab or pick a match)" }
-                    }
-                }
-                p {
-                    a class="parser-rank-link"
-                        href=(format!("/?sub={subreddit}")) {
-                        "Rank r/" (subreddit) " →"
-                    }
-                }
-                (render_db_subs(subreddit, prefix))
-            }
-        },
-        ParserAction::RenderEntityView { ns, pk } => html! {
-            div class="parser-entity" {
-                p {
-                    "Would open "
-                    code { (ns) "/" (pk) }
-                }
-            }
-        },
-    }
-}
-
-/// Parser output panel (inner content for `#parser-panel`).
-pub fn parser_panel(query: &str, action: &ParserAction) -> Markup {
+/// Navigate panel: paste a Reddit URL and click Go.
+pub fn navigate_panel(query: &str, error: Option<&str>) -> Markup {
     html! {
         section id="parser-panel" class="demo-panel" {
             h2 { "Navigate" }
             p class="muted small" {
-                "Type a Reddit path — "
-                code { "r/rust" }
-                ", "
-                code { "reddit.com/r/programming/hot" }
-                ", etc. Tab completes; each keystroke posts "
-                code { "__rpc__" }
-                " to "
-                code { "/ui" }
-                "."
+                "Paste a Reddit URL or "
+                code { "r/subreddit" }
+                " path, then click Go to rank that subreddit."
             }
             form method="post" action="/ui" id="parser-form" {
-                input
-                    type="text"
+                textarea
                     name="query"
                     id="parser-input"
-                    value=(query)
-                    placeholder="r/ or reddit.com/…"
+                    rows="3"
+                    placeholder="https://reddit.com/r/rust or r/rust"
                     autocomplete="off"
-                    spellcheck="false";
+                    spellcheck="false" {
+                    (query)
+                }
                 input type="hidden" name=(UI_RPC_FIELD) value=(parse_query_rpc_template());
+                button type="submit" class="btn-primary" { "Go" }
             }
-            div id="parser-output" {
-                @if query.is_empty() {
-                    p class="muted" { "Start typing…" }
-                } @else {
-                    (render_action(action))
-                }
+            @if let Some(msg) = error {
+                p class="parser-error muted" { (msg) }
             }
         }
     }
 }
-
-/// Wrap panel HTML for Idiomorph (morph `#parser-panel` only).
-pub fn parser_panel_morph(query: &str, action: &ParserAction) -> Markup {
-    parser_panel(query, action)
-}
diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs
index 8c357b133599b798a9c06a77a826bcef05a3a407..0e030b3448b8e45acbe49d2de47ea26372445c54 100644
--- a/server/src/ui_action.rs
+++ b/server/src/ui_action.rs
@@ -22,7 +22,7 @@ pub enum HtmlUiAction {
         #[serde(default)]
         scope: String,
     },
-    /// Parse address-bar query via Reddit transition graph; morph `#parser-panel`.
+    /// Parse pasted Reddit URL/path; redirect to subreddit ranking on success.
     ParseQuery {
         query: String,
     },
diff --git a/server/static/sorter_ui.js b/server/static/sorter_ui.js
index 1e5c3c13d6f7d8f180a4126ba25b44e9801cdb5d..9c475d8e076ba527aaf7a25c177d0d651bd46ca9 100644
--- a/server/static/sorter_ui.js
+++ b/server/static/sorter_ui.js
@@ -19,39 +19,6 @@
     }).then(evalJs);
   }
 
-  // Parser responses race: a slow response for an earlier keystroke can arrive
-  // after a newer one and clobber the panel. Tag each request with a monotonic
-  // sequence number and only apply a response if it is newer than the last one
-  // applied, so stale (superseded) responses are discarded.
-  var parserSeq = 0;
-  var parserApplied = 0;
-
-  function postParserForm(form) {
-    var mySeq = ++parserSeq;
-    return fetch(form.action, {
-      method: 'POST',
-      body: new URLSearchParams(new FormData(form)),
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      credentials: 'same-origin',
-    }).then(function (resp) {
-      return resp.text();
-    }).then(function (js) {
-      if (mySeq <= parserApplied) return;
-      parserApplied = mySeq;
-      evalJs(js);
-    });
-  }
-
-  var parserTimer = null;
-
-  function scheduleParserInput(input) {
-    if (parserTimer) clearTimeout(parserTimer);
-    parserTimer = setTimeout(function () {
-      var form = document.getElementById('parser-form');
-      if (form) postParserForm(form);
-    }, 120);
-  }
-
   function initSorterUi() {
     document.addEventListener('submit', async function (e) {
       var f = e.target;
@@ -67,38 +34,6 @@
         if (firstField) firstField.focus();
       }
     });
-
-    document.addEventListener('input', function (e) {
-      if (e.target && e.target.id === 'parser-input') {
-        scheduleParserInput(e.target);
-      }
-    });
-
-    document.addEventListener('keydown', function (e) {
-      if (!e.target || e.target.id !== 'parser-input') return;
-      if (e.key !== 'Tab') return;
-      var completion =
-        e.target.dataset.completion ||
-        (function () {
-          var btn = document.querySelector('#parser-output .parser-suggestion-primary');
-          return btn && btn.getAttribute('data-completion');
-        })();
-      if (!completion) return;
-      e.preventDefault();
-      e.target.value = completion;
-      scheduleParserInput(e.target);
-    });
-
-    document.addEventListener('click', function (e) {
-      var btn = e.target.closest('.parser-completion');
-      if (!btn) return;
-      var input = document.getElementById('parser-input');
-      if (!input) return;
-      var completion = btn.getAttribute('data-completion');
-      if (!completion) return;
-      input.value = completion;
-      scheduleParserInput(input);
-    });
   }
 
   if (document.readyState === 'loading') {
diff --git a/server/static/theme_default.css b/server/static/theme_default.css
index c5fc9e7abf865ed689f58ff0763d3656d73e35f5..6ad0ac712bbc840bedee60f613794de9385fbbd1 100644
--- a/server/static/theme_default.css
+++ b/server/static/theme_default.css
@@ -129,34 +129,12 @@ code {
   background: var(--bg);
   color: var(--fg);
   font-size: 1rem;
+  font-family: inherit;
+  resize: vertical;
 }
 
-.btn-link {
-  background: none;
-  border: none;
-  padding: 0;
-  color: var(--accent);
-  cursor: pointer;
-  font: inherit;
-}
-
-.btn-link:hover {
-  text-decoration: underline;
-}
-
-.parser-rank-link {
-  display: inline-block;
-  margin: 0.5rem 0;
-  padding: 0.4rem 0.8rem;
-  background: var(--accent);
-  color: #0f1115;
-  border-radius: 4px;
-  font-weight: 600;
-  text-decoration: none;
-}
-
-.parser-rank-link:hover {
-  filter: brightness(1.1);
+#parser-form .btn-primary {
+  margin-top: 0.5rem;
 }
 
 .scope-name {
diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs
index 5112cb79ffe6e53df3d2432646770fc316cf4787..afeeee24e32f2d7f1d852ca96ac799fac8bce665 100644
--- a/server/tests/integration_ui.rs
+++ b/server/tests/integration_ui.rs
@@ -71,11 +71,11 @@ async fn post_ui_record_vote_morphs_ranking_and_persists() {
 }
 
 #[tokio::test]
-async fn post_ui_parse_query_morphs_parser_panel() {
+async fn post_ui_parse_query_redirects_to_subreddit() {
     let (addr, _tmp) = start_test_server().await;
     let rpc = serde_json::json!({
         "action": "parse_query",
-        "query": "r"
+        "query": "r/rust"
     })
     .to_string();
     let mut form = HashMap::new();
@@ -92,7 +92,6 @@ async fn post_ui_parse_query_morphs_parser_panel() {
         .await
         .unwrap();
 
-    assert!(body.contains("Idiomorph.morph"));
-    assert!(body.contains("parser-panel"));
-    assert!(body.contains("r/"));
+    assert!(body.contains("window.location.href"));
+    assert!(body.contains("/?sub=rust"));
 }
diff --git a/test/parser_race.clj b/test/parser_race.clj
deleted file mode 100644
index 23783837f8192ff24a556b73bdd670dc63b606cb..0000000000000000000000000000000000000000
--- a/test/parser_race.clj
+++ /dev/null
@@ -1,185 +0,0 @@
-(ns test.parser-race
-  "Browser test (spel / Playwright) for the parser search-box response race.
-
-   The search box debounces keystrokes, POSTs each to `/ui`, and eval()s the
-   returned JS, which morphs `#parser-panel` (input value + `#parser-output`).
-   If responses are applied in arrival order with no ordering guard, a slow
-   response for an *earlier* query can land after a newer one and clobber it.
-
-   To force the race deterministically without touching the Rust server, the
-   browser talks to a small in-process reverse proxy that injects an asymmetric
-   per-query delay: the earlier query (`r/rust`) is delayed far longer than the
-   later query (`r/aww`). The later query therefore renders first, then the
-   stale earlier response arrives. Correct behavior: the panel reflects the
-   *latest* query the user typed (`r/aww`)."
-  (:require [babashka.process :as process]
-            [clojure.java.io :as io]
-            [clojure.string :as str]
-            [clojure.test :refer [deftest is testing]]
-            [com.blockether.spel.assertions :as assert]
-            [com.blockether.spel.core :as core]
-            [com.blockether.spel.locator :as locator]
-            [com.blockether.spel.page :as page])
-  (:import [com.sun.net.httpserver HttpServer HttpHandler]
-           [java.io ByteArrayOutputStream]
-           [java.net InetSocketAddress URI URLDecoder]
-           [java.net.http HttpClient HttpClient$Version HttpRequest
-            HttpRequest$BodyPublishers HttpResponse$BodyHandlers]
-           [java.nio.charset StandardCharsets]
-           [java.util.concurrent Executors]))
-
-(def ^:private slow-query "r/rust")
-(def ^:private fast-query "r/aww")
-(def ^:private slow-delay-ms 800)
-
-(defn- repo-root []
-  (.getCanonicalPath (io/file (System/getProperty "user.dir"))))
-
-(defn- pick-port []
-  (with-open [s (java.net.ServerSocket. 0)]
-    (.getLocalPort s)))
-
-(defn- wait-health [base-url ms]
-  (let [deadline (+ (System/currentTimeMillis) ms)
-        url (str base-url "/healthz")]
-    (loop []
-      (let [resp (try
-                   (process/shell {:out :string :err :string} "curl" "-sf" url)
-                   (catch Exception _ nil))]
-        (if (and resp (zero? (:exit resp)) (= "ok" (str/trim (:out resp ""))))
-          true
-          (if (< (System/currentTimeMillis) deadline)
-            (do (Thread/sleep 200) (recur))
-            false))))))
-
-(defn- start-server
-  "Builds the release binary and starts it on a random port. Returns a map with
-   :proc and :base."
-  [root]
-  (is (zero? (:exit (process/shell {:dir root}
-                                   "cargo" "build" "--release" "--package" "sorter2-server")))
-      "release build succeeds")
-  (let [bin (str root "/target/release/sorter2-server")]
-    (is (.exists (io/file bin)) "binary exists")
-    (let [data-dir (.getAbsolutePath
-                    (doto (io/file (System/getProperty "java.io.tmpdir")
-                                   (str "sorter2-race-" (System/currentTimeMillis)))
-                      (.mkdirs)))
-          port (pick-port)
-          base (str "http://127.0.0.1:" port)
-          proc (process/process {:dir root
-                                 :env {"SORTER2_DATA_DIR" data-dir
-                                       "SORTER2_EVENT_LOG" (str data-dir "/events.jsonl")
-                                       "PORT" (str port)}
-                                 :out :string
-                                 :err :string}
-                                bin)]
-      {:proc proc :base base})))
-
-(defn- read-all-bytes ^bytes [in]
-  (let [bos (ByteArrayOutputStream.)]
-    (io/copy in bos)
-    (.toByteArray bos)))
-
-(defn- ui-query
-  "Extracts the decoded `query` form field from a urlencoded body, or nil."
-  [body-str]
-  (some-> (re-find #"(?:^|&)query=([^&]*)" body-str)
-          second
-          (URLDecoder/decode "UTF-8")))
-
-(defn- start-proxy
-  "Reverse proxy to `upstream` that sleeps `(delay-fn method path body-str)` ms
-   before forwarding each request. Runs handlers on a thread pool so concurrent
-   requests are delayed independently (the race needs out-of-order arrival).
-   Returns a map with :server and :base."
-  [upstream delay-fn]
-  (let [client (-> (HttpClient/newBuilder)
-                   (.version HttpClient$Version/HTTP_1_1)
-                   (.build))
-        server (HttpServer/create (InetSocketAddress. "127.0.0.1" 0) 0)
-        handler (reify HttpHandler
-                  (handle [_ ex]
-                    (try
-                      (let [method (.getRequestMethod ex)
-                            uri (.getRequestURI ex)
-                            path (.getRawPath uri)
-                            query (.getRawQuery uri)
-                            req-body (read-all-bytes (.getRequestBody ex))
-                            body-str (String. req-body StandardCharsets/UTF_8)
-                            delay-ms (delay-fn method path body-str)]
-                        (when (pos? delay-ms)
-                          (Thread/sleep (long delay-ms)))
-                        (let [target (str upstream path (when query (str "?" query)))
-                              builder (doto (HttpRequest/newBuilder)
-                                        (.uri (URI/create target)))
-                              ct (.getFirst (.getRequestHeaders ex) "Content-Type")
-                              _ (when ct (.header builder "Content-Type" ct))
-                              publisher (if (zero? (alength req-body))
-                                          (HttpRequest$BodyPublishers/noBody)
-                                          (HttpRequest$BodyPublishers/ofByteArray req-body))
-                              _ (.method builder method publisher)
-                              resp (.send client (.build builder)
-                                          (HttpResponse$BodyHandlers/ofByteArray))
-                              resp-body (.body resp)
-                              resp-ct (-> (.headers resp)
-                                          (.firstValue "content-type")
-                                          (.orElse nil))]
-                          (when resp-ct
-                            (.set (.getResponseHeaders ex) "Content-Type" resp-ct))
-                          (.sendResponseHeaders ex (.statusCode resp) (alength resp-body))
-                          (with-open [os (.getResponseBody ex)]
-                            (.write os resp-body))))
-                      (catch Throwable t
-                        (let [msg (.getBytes (str "proxy error: " (.getMessage t))
-                                             StandardCharsets/UTF_8)]
-                          (try
-                            (.sendResponseHeaders ex 500 (alength msg))
-                            (with-open [os (.getResponseBody ex)]
-                              (.write os msg))
-                            (catch Throwable _ nil))))
-                      (finally
-                        (.close ex)))))]
-    (.createContext server "/" handler)
-    (.setExecutor server (Executors/newCachedThreadPool))
-    (.start server)
-    {:server server
-     :base (str "http://127.0.0.1:" (.getPort (.getAddress server)))}))
-
-(defn- parser-delay-fn [method path body-str]
-  (if (and (= method "POST") (= path "/ui") (= (ui-query body-str) slow-query))
-    slow-delay-ms
-    0))
-
-(deftest latest-search-query-wins
-  (testing "a slow earlier parser response must not clobber a newer one"
-    (let [root (repo-root)
-          {:keys [proc base]} (start-server root)]
-      (try
-        (is (wait-health base 15000) "server responds to /healthz")
-        (let [{:keys [server] proxy-base :base} (start-proxy base parser-delay-fn)]
-          (try
-            (core/with-testing-page [pg]
-              (page/navigate pg proxy-base)
-              (let [input (page/locator pg "#parser-input")
-                    output (page/locator pg "#parser-output")]
-                ;; Type the slow query first; wait past the 120ms debounce so its
-                ;; (slow) request is in flight, then type the fast query.
-                (locator/fill input slow-query)
-                (Thread/sleep 300)
-                (locator/fill input fast-query)
-                ;; Wait until the slow response has certainly arrived and been
-                ;; (mis)applied if the race exists.
-                (Thread/sleep 2000)
-                ;; The panel must reflect the latest query, not the stale one.
-                (is (nil? (assert/contains-text (assert/assert-that output) fast-query))
-                    "output shows the latest query (r/aww)")
-                (is (nil? (assert/contains-text
-                           (assert/loc-not (assert/assert-that output)) slow-query))
-                    "output does NOT show the stale earlier query (r/rust)")
-                (is (nil? (assert/has-value (assert/assert-that input) fast-query))
-                    "input value is the latest query (r/aww)")))
-            (finally
-              (.stop server 0))))
-        (finally
-          (process/destroy proc))))))