{"messages":[{"content":"You are a constitutional council ranking individual git commits for ownership allocation.\n\nCompare these two commits. Decide which contributed more lasting value to the project.\n\nJudge substance, not spectacle:\n- Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise.\n- Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one.\n- Do not favor a side merely because its patch is longer or noisier.\n- Weight what the change does for the project, not the contributor's name.\n\nReturn ONLY a JSON object: {\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}\nThe explanation must cite concrete differences in the patches (1-3 sentences).\n\nSide A — contributor: tommy-mor\nSide A — commit message:\n[15e1037a] url stuff\n\nSide A — unified diff (full patch):\ndiff --git a/server/src/url_rules/graph.rs b/server/src/url_rules/graph.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..f7ac0f9a551a1727cb2f9294778c283b9885b147\n--- /dev/null\n+++ b/server/src/url_rules/graph.rs\n@@ -0,0 +1,831 @@\n+//! Semantic URL graph: DFA traversal on host + path, query in context, generic fallback.\n+\n+use std::collections::HashMap;\n+use std::sync::OnceLock;\n+\n+use url::Url;\n+\n+use super::graph_builder::GraphBuilder;\n+use super::parse::{normalize_match_host, strip_tracking_query, UrlParts};\n+\n+#[derive(Debug, Clone, Default)]\n+pub struct Context {\n+    pub vars: HashMap<String, String>,\n+    pub query: HashMap<String, String>,\n+}\n+\n+pub type CanonicalFn = fn(&Context) -> Option<String>;\n+\n+#[derive(Clone, Copy)]\n+pub enum EdgePattern {\n+    Literal(&'static str),\n+    Variable(&'static str),\n+    /// Absorb any trailing segment without leaving this node (e.g. post title slug).\n+    AbsorbAny,\n+    /// Absorb segment when `cond(seg)` (e.g. subreddit listing suffix).\n+    AbsorbIf(fn(&str) -> bool),\n+}\n+\n+pub struct Edge {\n+    pub pattern: EdgePattern,\n+    pub target: &'static str,\n+}\n+\n+pub struct Node {\n+    pub edges: Vec<Edge>,\n+    pub canonical: CanonicalFn,\n+    pub parent: Option<&'static str>,\n+}\n+\n+impl Node {\n+    pub(crate) fn empty() -> Self {\n+        Self {\n+            edges: Vec::new(),\n+            canonical: |_| None,\n+            parent: None,\n+        }\n+    }\n+}\n+\n+pub struct Graph {\n+    pub nodes: HashMap<&'static str, Node>,\n+}\n+\n+static GRAPH: OnceLock<Graph> = OnceLock::new();\n+\n+pub fn graph() -> &'static Graph {\n+    GRAPH.get_or_init(build_graph)\n+}\n+\n+impl Graph {\n+    pub fn resolve_canonical(&self, parts: &UrlParts) -> Option<String> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+\n+        if let Some(node_id) = self.traverse(parts, &mut ctx) {\n+            if let Some(canon) = (self.nodes.get(node_id)?.canonical)(&ctx) {\n+                return Some(canon);\n+            }\n+        }\n+        Some(generic_canonical(parts))\n+    }\n+\n+    pub fn breadcrumbs(&self, parts: &UrlParts) -> Vec<String> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+\n+        if let Some(mut node_id) = self.traverse(parts, &mut ctx) {\n+            let mut paths = Vec::new();\n+            loop {\n+                let node = match self.nodes.get(node_id) {\n+                    Some(n) => n,\n+                    None => break,\n+                };\n+                if let Some(url) = (node.canonical)(&ctx) {\n+                    if paths.last() != Some(&url) {\n+                        paths.push(url);\n+                    }\n+                }\n+                match node.parent {\n+                    Some(p) => node_id = p,\n+                    None => break,\n+                }\n+            }\n+            paths.reverse();\n+            if !paths.is_empty() {\n+                return paths;\n+            }\n+        }\n+        generic_breadcrumbs(parts)\n+    }\n+\n+    fn traverse(&self, parts: &UrlParts, ctx: &mut Context) -> Option<&'static str> {\n+        let host = parts.match_host();\n+        let mut node_id = match host.as_str() {\n+            \"reddit.com\" => \"reddit_root\",\n+            \"youtube.com\" => \"youtube_root\",\n+            \"youtu.be\" => \"youtu_be_entry\",\n+            _ => return None,\n+        };\n+\n+        let segs: Vec<&str> = parts.path_segments.iter().map(String::as_str).collect();\n+        let mut i = 0;\n+        while i < segs.len() {\n+            let seg = segs[i];\n+            match self.follow_edge(node_id, seg, ctx) {\n+                Ok(next) => {\n+                    node_id = next;\n+                    i += 1;\n+                }\n+                Err(()) => {\n+                    if self.try_absorb(node_id, seg) {\n+                        i += 1;\n+                        continue;\n+                    }\n+                    return None;\n+                }\n+            }\n+        }\n+        Some(node_id)\n+    }\n+\n+    fn follow_edge(\n+        &self,\n+        node_id: &'static str,\n+        seg: &str,\n+        ctx: &mut Context,\n+    ) -> Result<&'static str, ()> {\n+        let node = self.nodes.get(node_id).ok_or(())?;\n+        for edge in &node.edges {\n+            match edge.pattern {\n+                EdgePattern::Literal(lit) if lit == seg => return Ok(edge.target),\n+                EdgePattern::Variable(name) => {\n+                    ctx.vars.insert(name.to_string(), seg.to_string());\n+                    return Ok(edge.target);\n+                }\n+                EdgePattern::AbsorbAny\n+                | EdgePattern::AbsorbIf(_)\n+                | EdgePattern::Literal(_)\n+                | EdgePattern::Variable(_) => {}\n+            }\n+        }\n+        Err(())\n+    }\n+\n+    fn try_absorb(&self, node_id: &'static str, seg: &str) -> bool {\n+        let node = match self.nodes.get(node_id) {\n+            Some(n) => n,\n+            None => return false,\n+        };\n+        for edge in &node.edges {\n+            match edge.pattern {\n+                EdgePattern::AbsorbAny => return true,\n+                EdgePattern::AbsorbIf(cond) if cond(seg) => return true,\n+                EdgePattern::AbsorbIf(_) | EdgePattern::Literal(_) | EdgePattern::Variable(_) => {}\n+            }\n+        }\n+        false\n+    }\n+\n+    /// Test hook: terminal graph node and captured context after traversal.\n+    #[cfg(test)]\n+    pub fn traverse_terminal(&self, parts: &UrlParts) -> Option<(&'static str, Context)> {\n+        let mut query = parts.query.clone();\n+        strip_tracking_query(&mut query);\n+        let mut ctx = Context {\n+            vars: HashMap::new(),\n+            query,\n+        };\n+        let node = self.traverse(parts, &mut ctx)?;\n+        Some((node, ctx))\n+    }\n+}\n+\n+fn is_reddit_listing_suffix(seg: &str) -> bool {\n+    matches!(seg, \"hot\" | \"top\" | \"new\" | \"rising\" | \"controversial\")\n+}\n+\n+/// Percent-encode a path or query fragment so `&`, `?`, etc. cannot break URL structure.\n+fn enc(s: &str) -> String {\n+    urlencoding::encode(s).into_owned()\n+}\n+\n+// --- Canonical formatters ---\n+\n+fn canon_reddit_root(_: &Context) -> Option<String> {\n+    Some(\"https://reddit.com\".to_string())\n+}\n+\n+fn canon_reddit_r_hub(_: &Context) -> Option<String> {\n+    Some(\"https://reddit.com/r\".to_string())\n+}\n+\n+fn canon_reddit_subreddit(ctx: &Context) -> Option<String> {\n+    let sub = ctx.vars.get(\"subreddit\")?;\n+    Some(format!(\n+        \"https://reddit.com/r/{}\",\n+        enc(&sub.to_ascii_lowercase())\n+    ))\n+}\n+\n+fn canon_reddit_post(ctx: &Context) -> Option<String> {\n+    let sub = ctx.vars.get(\"subreddit\")?.to_ascii_lowercase();\n+    let id = ctx.vars.get(\"post_id\")?;\n+    Some(format!(\n+        \"https://reddit.com/r/{}/comments/{}\",\n+        enc(&sub),\n+        enc(id)\n+    ))\n+}\n+\n+fn canon_youtube_root(_: &Context) -> Option<String> {\n+    Some(\"https://youtube.com\".to_string())\n+}\n+\n+fn canon_youtube_watch(ctx: &Context) -> Option<String> {\n+    let v = ctx\n+        .query\n+        .get(\"v\")\n+        .or_else(|| ctx.vars.get(\"video_id\"))?;\n+    Some(format!(\"https://youtube.com/watch?v={}\", enc(v)))\n+}\n+\n+fn canon_youtu_be(ctx: &Context) -> Option<String> {\n+    let v = ctx.vars.get(\"vid_id\")?;\n+    Some(format!(\"https://youtube.com/watch?v={}\", enc(v)))\n+}\n+\n+pub fn build_graph() -> Graph {\n+    GraphBuilder::new()\n+        .node(\"reddit_root\")\n+        .canonical(canon_reddit_root)\n+        .edge(EdgePattern::Literal(\"r\"), \"reddit_r_hub\")\n+        .node(\"reddit_r_hub\")\n+        .parent(\"reddit_root\")\n+        .canonical(canon_reddit_r_hub)\n+        .edge(EdgePattern::Variable(\"subreddit\"), \"reddit_subreddit\")\n+        .node(\"reddit_subreddit\")\n+        .parent(\"reddit_r_hub\")\n+        .canonical(canon_reddit_subreddit)\n+        .edge(\n+            EdgePattern::AbsorbIf(is_reddit_listing_suffix),\n+            \"reddit_subreddit\",\n+        )\n+        .edge(EdgePattern::Literal(\"comments\"), \"reddit_comments_gate\")\n+        .node(\"reddit_comments_gate\")\n+        .parent(\"reddit_subreddit\")\n+        .canonical(canon_reddit_subreddit)\n+        .edge(EdgePattern::Variable(\"post_id\"), \"reddit_post\")\n+        .node(\"reddit_post\")\n+        .parent(\"reddit_subreddit\")\n+        .canonical(canon_reddit_post)\n+        .edge(EdgePattern::AbsorbAny, \"reddit_post\")\n+        .node(\"youtube_root\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Literal(\"watch\"), \"youtube_watch\")\n+        .edge(EdgePattern::Literal(\"shorts\"), \"youtube_shorts_gate\")\n+        .node(\"youtube_watch\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtube_watch)\n+        .node(\"youtube_shorts_gate\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Variable(\"video_id\"), \"youtube_watch\")\n+        .node(\"youtu_be_entry\")\n+        .canonical(canon_youtube_root)\n+        .edge(EdgePattern::Variable(\"vid_id\"), \"youtu_be_video\")\n+        .node(\"youtu_be_video\")\n+        .parent(\"youtube_root\")\n+        .canonical(canon_youtu_be)\n+        .build()\n+}\n+\n+// --- Generic internet fallback ---\n+\n+pub fn generic_canonical(parts: &UrlParts) -> String {\n+    let host = normalize_match_host(&parts.host);\n+    let path_segments: Vec<String> = parts.path_segments.clone();\n+    let mut query = parts.query.clone();\n+    strip_tracking_query(&mut query);\n+\n+    let mut url = if path_segments.is_empty() {\n+        Url::parse(&format!(\"https://{host}\"))\n+            .unwrap_or_else(|_| Url::parse(\"https://invalid\").unwrap())\n+    } else {\n+        let path = format!(\"/{}\", path_segments.join(\"/\"));\n+        Url::parse(&format!(\"https://{host}{path}\"))\n+            .unwrap_or_else(|_| Url::parse(\"https://invalid\").unwrap())\n+    };\n+\n+    if !query.is_empty() {\n+        let mut pairs: Vec<_> = query.iter().collect();\n+        pairs.sort_by(|a, b| a.0.cmp(b.0));\n+        url.query_pairs_mut().clear();\n+        for (k, v) in pairs {\n+            url.query_pairs_mut().append_pair(k, v);\n+        }\n+    }\n+\n+    let mut s = url.to_string();\n+    if path_segments.is_empty() {\n+        s = s.trim_end_matches('/').to_string();\n+    }\n+    s\n+}\n+\n+pub fn generic_breadcrumbs(parts: &UrlParts) -> Vec<String> {\n+    let host = normalize_match_host(&parts.host);\n+    let n = parts.path_segments.len();\n+    let mut out = Vec::new();\n+\n+    let base = generic_canonical(&UrlParts {\n+        scheme: \"https\".to_string(),\n+        host: host.clone(),\n+        path_segments: vec![],\n+        query: HashMap::new(),\n+    });\n+    out.push(base);\n+\n+    for i in 0..n {\n+        let segs: Vec<String> = parts.path_segments[..=i].to_vec();\n+        let url = generic_canonical(&UrlParts {\n+            scheme: \"https\".to_string(),\n+            host: host.clone(),\n+            path_segments: segs,\n+            query: HashMap::new(),\n+        });\n+        if out.last() != Some(&url) {\n+            out.push(url);\n+        }\n+    }\n+    out\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+    use crate::url_rules::parse::test_parts;\n+\n+    fn g() -> &'static Graph {\n+        graph()\n+    }\n+\n+    fn canon(parts: &UrlParts) -> String {\n+        g().resolve_canonical(parts).unwrap()\n+    }\n+\n+    fn crumbs(parts: &UrlParts) -> Vec<String> {\n+        g().breadcrumbs(parts)\n+    }\n+\n+    fn terminal(parts: &UrlParts) -> Option<&'static str> {\n+        g().traverse_terminal(parts).map(|(n, _)| n)\n+    }\n+\n+    fn vars(parts: &UrlParts) -> HashMap<String, String> {\n+        g().traverse_terminal(parts)\n+            .map(|(_, c)| c.vars)\n+            .unwrap_or_default()\n+    }\n+\n+    #[test]\n+    fn youtu_be_malicious_segment_encoded_not_injected() {\n+        let p = test_parts(\"youtu.be\", &[\"abc&t=1\"], &[]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=abc%26t%3D1\");\n+        assert!(!canon(&p).contains(\"abc&t=1\"));\n+    }\n+\n+    #[test]\n+    fn youtube_query_v_encoded() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"a&b=c\")]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=a%26b%3Dc\");\n+    }\n+\n+    #[test]\n+    fn absorb_patterns_live_on_edges_not_in_engine() {\n+        let g = build_graph();\n+        let sub = g.nodes.get(\"reddit_subreddit\").unwrap();\n+        assert!(sub\n+            .edges\n+            .iter()\n+            .any(|e| matches!(e.pattern, EdgePattern::AbsorbIf(_))));\n+        let post = g.nodes.get(\"reddit_post\").unwrap();\n+        assert!(post\n+            .edges\n+            .iter()\n+            .any(|e| matches!(e.pattern, EdgePattern::AbsorbAny)));\n+    }\n+\n+    #[test]\n+    fn builder_rejects_missing_parent() {\n+        let result = std::panic::catch_unwind(|| {\n+            GraphBuilder::new()\n+                .node(\"orphan\")\n+                .parent(\"nonexistent_parent\")\n+                .build();\n+        });\n+        assert!(result.is_err());\n+    }\n+\n+    #[test]\n+    fn generic_canonical_forces_https_and_strips_www() {\n+        let p = test_parts(\"www.example.com\", &[\"blog\", \"post\"], &[]);\n+        assert_eq!(canon(&p), \"https://example.com/blog/post\");\n+    }\n+\n+    #[test]\n+    fn generic_canonical_sorts_query_keys() {\n+        let p = test_parts(\"example.com\", &[\"search\"], &[(\"q\", \"rust\"), (\"page\", \"2\")]);\n+        assert_eq!(canon(&p), \"https://example.com/search?page=2&q=rust\");\n+    }\n+\n+    #[test]\n+    fn generic_canonical_strips_tracking_from_query() {\n+        let p = test_parts(\n+            \"news.ycombinator.com\",\n+            &[\"item\"],\n+            &[(\"id\", \"1\"), (\"utm_medium\", \"social\")],\n+        );\n+        assert_eq!(canon(&p), \"https://news.ycombinator.com/item?id=1\");\n+    }\n+\n+    #[test]\n+    fn generic_breadcrumbs_cumulative_path() {\n+        let p = test_parts(\"paulgraham.com\", &[\"articles\", \"lisp.html\"], &[]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\n+                \"https://paulgraham.com\",\n+                \"https://paulgraham.com/articles\",\n+                \"https://paulgraham.com/articles/lisp.html\"\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn generic_breadcrumbs_domain_only() {\n+        let p = test_parts(\"example.com\", &[], &[]);\n+        assert_eq!(crumbs(&p), vec![\"https://example.com\"]);\n+    }\n+\n+    #[test]\n+    fn unknown_host_uses_generic_not_graph() {\n+        let p = test_parts(\"hackernews.com\", &[\"item\", \"123\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+        assert_eq!(canon(&p), \"https://hackernews.com/item/123\");\n+    }\n+\n+    #[test]\n+    fn traverse_captures_subreddit_variable() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"Rust\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(vars(&p).get(\"subreddit\").map(String::as_str), Some(\"Rust\"));\n+    }\n+\n+    #[test]\n+    fn traverse_captures_post_id() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"abc123\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_post\"));\n+        assert_eq!(vars(&p).get(\"post_id\").map(String::as_str), Some(\"abc123\"));\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_listing_suffix_stays_on_subreddit() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"hot\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_all_listing_suffixes() {\n+        for suffix in [\"hot\", \"top\", \"new\", \"rising\", \"controversial\"] {\n+            let p = test_parts(\"reddit.com\", &[\"r\", \"test\", suffix], &[]);\n+            assert_eq!(terminal(&p), Some(\"reddit_subreddit\"), \"suffix {suffix}\");\n+            assert_eq!(canon(&p), \"https://reddit.com/r/test\", \"suffix {suffix}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn traverse_absorbs_post_title_slug() {\n+        let p = test_parts(\n+            \"reddit.com\",\n+            &[\"r\", \"rust\", \"comments\", \"aaa\", \"my_great_post_title\"],\n+            &[],\n+        );\n+        assert_eq!(terminal(&p), Some(\"reddit_post\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/comments/aaa\");\n+    }\n+\n+    #[test]\n+    fn traverse_unknown_segment_falls_back_to_generic() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"wiki\", \"faq\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/wiki/faq\");\n+    }\n+\n+    #[test]\n+    fn traverse_youtube_watch_requires_v_in_query() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"xyz\")]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+    }\n+\n+    #[test]\n+    fn traverse_youtu_be_captures_vid_id() {\n+        let p = test_parts(\"youtu.be\", &[\"dQw4w9WgXcQ\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtu_be_video\"));\n+        assert_eq!(vars(&p).get(\"vid_id\").map(String::as_str), Some(\"dQw4w9WgXcQ\"));\n+    }\n+\n+    #[test]\n+    fn traverse_shorts_sets_video_id_var() {\n+        let p = test_parts(\"youtube.com\", &[\"shorts\", \"abc99\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+        assert_eq!(vars(&p).get(\"video_id\").map(String::as_str), Some(\"abc99\"));\n+    }\n+\n+    #[test]\n+    fn reddit_domain_canonical() {\n+        let p = test_parts(\"reddit.com\", &[], &[]);\n+        assert_eq!(canon(&p), \"https://reddit.com\");\n+    }\n+\n+    #[test]\n+    fn reddit_r_hub_canonical() {\n+        let p = test_parts(\"reddit.com\", &[\"r\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_r_hub\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r\");\n+    }\n+\n+    #[test]\n+    fn reddit_subreddit_lowercases_name() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"AmITheAsshole\"], &[]);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/amitheasshole\");\n+    }\n+\n+    #[test]\n+    fn reddit_host_aliases_old_new_www() {\n+        for host in [\"old.reddit.com\", \"new.reddit.com\", \"www.reddit.com\"] {\n+            let p = test_parts(host, &[\"r\", \"rust\"], &[]);\n+            assert_eq!(canon(&p), \"https://reddit.com/r/rust\", \"host {host}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn reddit_post_strips_slug_and_query() {\n+        let p = test_parts(\n+            \"old.reddit.com\",\n+            &[\"r\", \"Rust\", \"comments\", \"1abc\", \"title_slug_here\"],\n+            &[(\"sort\", \"new\")],\n+        );\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust/comments/1abc\");\n+    }\n+\n+    #[test]\n+    fn reddit_post_multiple_slugs_absorbed() {\n+        let p = test_parts(\n+            \"reddit.com\",\n+            &[\"r\", \"x\", \"comments\", \"id1\", \"slug1\", \"extra\"],\n+            &[],\n+        );\n+        assert_eq!(canon(&p), \"https://reddit.com/r/x/comments/id1\");\n+    }\n+\n+    #[test]\n+    fn reddit_listing_with_query_only() {\n+        let p = test_parts(\"www.reddit.com\", &[\"r\", \"programming\"], &[(\"sort\", \"top\")]);\n+        assert_eq!(canon(&p), \"https://reddit.com/r/programming\");\n+    }\n+\n+    #[test]\n+    fn reddit_subreddit_breadcrumbs_include_r_hub() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"movies\"], &[]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\n+                \"https://reddit.com\",\n+                \"https://reddit.com/r\",\n+                \"https://reddit.com/r/movies\"\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn reddit_post_breadcrumbs_skip_comments_node() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"1trnvdl\"], &[]);\n+        let c = crumbs(&p);\n+        assert!(!c.iter().any(|u| u.ends_with(\"/comments\")));\n+        assert_eq!(\n+            c.last().map(String::as_str),\n+            Some(\"https://reddit.com/r/aww/comments/1trnvdl\")\n+        );\n+        assert!(c.contains(&\"https://reddit.com/r/aww\".to_string()));\n+    }\n+\n+    #[test]\n+    fn reddit_post_parent_is_subreddit_not_comments() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"1trnvdl\"], &[]);\n+        let c = crumbs(&p);\n+        let parent = c.get(c.len() - 2).unwrap();\n+        assert_eq!(parent, \"https://reddit.com/r/aww\");\n+    }\n+\n+    #[test]\n+    fn reddit_domain_parent_is_none_in_breadcrumb_chain() {\n+        let p = test_parts(\"reddit.com\", &[], &[]);\n+        assert_eq!(crumbs(&p), vec![\"https://reddit.com\"]);\n+    }\n+\n+    #[test]\n+    fn youtube_watch_canonical_uses_v_only() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\"), (\"t\", \"99\")]);\n+        assert_eq!(canon(&p), \"https://youtube.com/watch?v=abc\");\n+    }\n+\n+    #[test]\n+    fn youtube_query_order_independent() {\n+        let a = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\"), (\"t\", \"4\")]);\n+        let b = test_parts(\"youtube.com\", &[\"watch\"], &[(\"t\", \"4\"), (\"v\", \"abc\")]);\n+        assert_eq!(canon(&a), canon(&b));\n+    }\n+\n+    #[test]\n+    fn youtube_host_aliases() {\n+        for host in [\"www.youtube.com\", \"m.youtube.com\"] {\n+            let p = test_parts(host, &[\"watch\"], &[(\"v\", \"x\")]);\n+            assert_eq!(canon(&p), \"https://youtube.com/watch?v=x\", \"host {host}\");\n+        }\n+    }\n+\n+    #[test]\n+    fn youtube_shorts_canonical_matches_watch() {\n+        let shorts = test_parts(\"youtube.com\", &[\"shorts\", \"vid123\"], &[]);\n+        let watch = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"vid123\")]);\n+        assert_eq!(canon(&shorts), canon(&watch));\n+        assert_eq!(canon(&shorts), \"https://youtube.com/watch?v=vid123\");\n+    }\n+\n+    #[test]\n+    fn youtu_be_matches_youtube_watch() {\n+        let be = test_parts(\"youtu.be\", &[\"dQw4w9WgXcQ\"], &[]);\n+        let watch = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"dQw4w9WgXcQ\")]);\n+        assert_eq!(canon(&be), canon(&watch));\n+    }\n+\n+    #[test]\n+    fn youtube_breadcrumbs_domain_then_watch() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[(\"v\", \"abc\")]);\n+        assert_eq!(\n+            crumbs(&p),\n+            vec![\"https://youtube.com\", \"https://youtube.com/watch?v=abc\"]\n+        );\n+    }\n+\n+    #[test]\n+    fn youtu_be_breadcrumbs_include_youtube_domain() {\n+        let p = test_parts(\"youtu.be\", &[\"abc\"], &[]);\n+        let c = crumbs(&p);\n+        assert_eq!(c.first().map(String::as_str), Some(\"https://youtube.com\"));\n+        assert_eq!(\n+            c.last().map(String::as_str),\n+            Some(\"https://youtube.com/watch?v=abc\")\n+        );\n+    }\n+\n+    #[test]\n+    fn parsed_urls_match_hand_built_parts() {\n+        let raw = \"https://www.reddit.com/r/rust/comments/aaa/title/?utm=x\";\n+        let parsed = UrlParts::parse(raw).unwrap();\n+        let hand = test_parts(\n+            \"www.reddit.com\",\n+            &[\"r\", \"rust\", \"comments\", \"aaa\", \"title\"],\n+            &[(\"utm\", \"x\")],\n+        );\n+        assert_eq!(canon(&parsed), canon(&hand));\n+    }\n+\n+    #[test]\n+    fn equivalence_cluster_youtube_formats() {\n+        let urls = [\n+            \"https://youtu.be/abc123\",\n+            \"https://www.youtube.com/watch?v=abc123\",\n+            \"https://youtube.com/watch?v=abc123&t=1\",\n+            \"https://m.youtube.com/watch?t=1&v=abc123\",\n+        ];\n+        let canonical: Vec<_> = urls\n+            .iter()\n+            .map(|u| canon(&UrlParts::parse(u).unwrap()))\n+            .collect();\n+        assert!(canonical.iter().all(|c| *c == \"https://youtube.com/watch?v=abc123\"));\n+    }\n+\n+    #[test]\n+    fn equivalence_cluster_reddit_post_formats() {\n+        let urls = [\n+            \"https://old.reddit.com/r/Rust/comments/aaa/slug/\",\n+            \"reddit.com/r/rust/comments/aaa/other_slug\",\n+            \"https://reddit.com/r/RUST/comments/aaa\",\n+        ];\n+        let canonical: Vec<_> = urls\n+            .iter()\n+            .map(|u| canon(&UrlParts::parse(u).unwrap()))\n+            .collect();\n+        assert!(\n+            canonical\n+                .iter()\n+                .all(|c| *c == \"https://reddit.com/r/rust/comments/aaa\")\n+        );\n+    }\n+\n+    #[test]\n+    fn graph_nodes_all_have_valid_parent_links() {\n+        let g = build_graph();\n+        for (id, node) in &g.nodes {\n+            if let Some(parent) = node.parent {\n+                assert!(g.nodes.contains_key(parent), \"node {id} parent {parent}\");\n+            }\n+        }\n+    }\n+\n+    #[test]\n+    fn graph_terminal_canonical_always_succeeds_for_reddit_paths() {\n+        let cases: &[(&[&str], &str)] = &[\n+            (&[\"r\", \"rust\"], \"https://reddit.com/r/rust\"),\n+            (\n+                &[\"r\", \"rust\", \"comments\", \"x\"],\n+                \"https://reddit.com/r/rust/comments/x\",\n+            ),\n+        ];\n+        for (segs, want) in cases {\n+            let p = test_parts(\"reddit.com\", segs, &[]);\n+            assert_eq!(canon(&p), *want);\n+        }\n+    }\n+\n+    #[test]\n+    fn breadcrumb_parent_walk_matches_parent_url_semantics() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"aww\", \"comments\", \"id1\"], &[]);\n+        let c = crumbs(&p);\n+        assert_eq!(c.len(), 4);\n+        assert_eq!(\n+            c.get(c.len() - 2).map(String::as_str),\n+            Some(\"https://reddit.com/r/aww\")\n+        );\n+    }\n+\n+    #[test]\n+    fn youtube_watch_without_v_falls_back_to_generic() {\n+        let p = test_parts(\"youtube.com\", &[\"watch\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtube_watch\"));\n+        assert_eq!(canon(&p), \"https://youtube.com/watch\");\n+    }\n+\n+    #[test]\n+    fn reddit_only_comments_path_stops_at_gate() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"comments\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_comments_gate\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn generic_deep_path_many_segments() {\n+        let segs: Vec<&str> = (0..10)\n+            .map(|i| match i {\n+                0 => \"a\",\n+                1 => \"b\",\n+                2 => \"c\",\n+                3 => \"d\",\n+                4 => \"e\",\n+                5 => \"f\",\n+                6 => \"g\",\n+                7 => \"h\",\n+                8 => \"i\",\n+                _ => \"j\",\n+            })\n+            .collect();\n+        let p = test_parts(\"site.com\", &segs, &[]);\n+        assert_eq!(crumbs(&p).len(), 11);\n+    }\n+\n+    #[test]\n+    fn traverse_literal_r_required_for_subreddit() {\n+        let p = test_parts(\"reddit.com\", &[\"rust\"], &[]);\n+        assert_eq!(terminal(&p), None);\n+    }\n+\n+    #[test]\n+    fn http_scheme_upgraded_via_generic_fallback_host() {\n+        let parsed = UrlParts::parse(\"http://example.com/page\").unwrap();\n+        assert_eq!(canon(&parsed), \"https://example.com/page\");\n+    }\n+\n+    #[test]\n+    fn each_graph_node_canonical_is_invokable() {\n+        let g = build_graph();\n+        let empty = Context::default();\n+        for (id, node) in &g.nodes {\n+            let _ = (node.canonical)(&empty);\n+            let _ = id;\n+        }\n+    }\n+\n+    #[test]\n+    fn reddit_double_listing_suffix_both_absorbed() {\n+        let p = test_parts(\"reddit.com\", &[\"r\", \"rust\", \"hot\", \"new\"], &[]);\n+        assert_eq!(terminal(&p), Some(\"reddit_subreddit\"));\n+        assert_eq!(canon(&p), \"https://reddit.com/r/rust\");\n+    }\n+\n+    #[test]\n+    fn youtu_be_empty_path_stays_at_entry() {\n+        let p = test_parts(\"youtu.be\", &[], &[]);\n+        assert_eq!(terminal(&p), Some(\"youtu_be_entry\"));\n+    }\n+}\ndiff --git a/server/src/url_rules/graph_builder.rs b/server/src/url_rules/graph_builder.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..243204ad5ca514fff459057956080cacb5bf38e2\n--- /dev/null\n+++ b/server/src/url_rules/graph_builder.rs\n@@ -0,0 +1,73 @@\n+//! Declarative construction of the URL graph with build-time link validation.\n+\n+use std::collections::HashMap;\n+\n+use super::graph::{CanonicalFn, Edge, EdgePattern, Graph, Node};\n+\n+pub struct GraphBuilder {\n+    nodes: HashMap<&'static str, Node>,\n+    current: Option<&'static str>,\n+}\n+\n+impl GraphBuilder {\n+    pub fn new() -> Self {\n+        Self {\n+            nodes: HashMap::new(),\n+            current: None,\n+        }\n+    }\n+\n+    pub fn node(mut self, id: &'static str) -> Self {\n+        self.nodes.entry(id).or_insert_with(Node::empty);\n+        self.current = Some(id);\n+        self\n+    }\n+\n+    pub fn canonical(mut self, f: CanonicalFn) -> Self {\n+        let id = self.current.expect(\"canonical() without node()\");\n+        self.nodes.get_mut(id).expect(\"node missing\").canonical = f;\n+        self\n+    }\n+\n+    pub fn parent(mut self, parent_id: &'static str) -> Self {\n+        let id = self.current.expect(\"parent() without node()\");\n+        self.nodes.get_mut(id).expect(\"node missing\").parent = Some(parent_id);\n+        self\n+    }\n+\n+    pub fn edge(mut self, pattern: EdgePattern, target: &'static str) -> Self {\n+        let id = self.current.expect(\"edge() without node()\");\n+        self.nodes\n+            .get_mut(id)\n+            .expect(\"node missing\")\n+            .edges\n+            .push(Edge { pattern, target });\n+        self\n+    }\n+\n+    pub fn build(self) -> Graph {\n+        for (id, node) in &self.nodes {\n+            if let Some(parent) = node.parent {\n+                assert!(\n+                    self.nodes.contains_key(parent),\n+                    \"node {id}: parent {parent} does not exist\"\n+                );\n+            }\n+            for edge in &node.edges {\n+                if !matches!(\n+                    edge.pattern,\n+                    EdgePattern::AbsorbAny | EdgePattern::AbsorbIf(_)\n+                ) {\n+                    assert!(\n+                        self.nodes.contains_key(edge.target),\n+                        \"node {id}: edge target {} does not exist\",\n+                        edge.target\n+                    );\n+                }\n+            }\n+        }\n+        Graph {\n+            nodes: self.nodes,\n+        }\n+    }\n+}\ndiff --git a/server/src/url_rules/mod.rs b/server/src/url_rules/mod.rs\nindex 9e1445346ce77a49dd6a7e7713bf9c57aef353cc..ba4ac662acc7bd4d50ee34613eb7eb6fccbfb17b 100644\n--- a/server/src/url_rules/mod.rs\n+++ b/server/src/url_rules/mod.rs\n@@ -1,6 +1,7 @@\n //! URL canonicalization and hierarchy via a semantic graph (DFA + generic fallback).\n \n mod graph;\n+mod graph_builder;\n mod parse;\n mod registry;\n \ndiff --git a/server/src/url_rules/parse.rs b/server/src/url_rules/parse.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..19d0c82feb718817168b8b445fcbfa39cf6aa6ba\n--- /dev/null\n+++ b/server/src/url_rules/parse.rs\n@@ -0,0 +1,169 @@\n+//! Parse raw strings into host, path segments, and query (order-independent).\n+\n+use std::collections::HashMap;\n+\n+use url::Url;\n+\n+#[derive(Debug, Clone)]\n+pub struct UrlParts {\n+    pub scheme: String,\n+    pub host: String,\n+    pub path_segments: Vec<String>,\n+    pub query: HashMap<String, String>,\n+}\n+\n+impl UrlParts {\n+    pub fn parse(raw: &str) -> Option<Self> {\n+        let trimmed = raw.trim();\n+        if trimmed.is_empty() {\n+            return None;\n+        }\n+\n+        let with_scheme = if trimmed.contains(\"://\") {\n+            trimmed.to_string()\n+        } else if trimmed.starts_with(\"r/\") || trimmed.starts_with(\"/r/\") {\n+            let rest = trimmed.trim_start_matches('/').trim_start_matches(\"r/\");\n+            format!(\"https://reddit.com/r/{rest}\")\n+        } else if trimmed.contains('.') && !trimmed.starts_with('/') {\n+            format!(\"https://{trimmed}\")\n+        } else {\n+            trimmed.to_string()\n+        };\n+\n+        let url = Url::parse(&with_scheme).ok()?;\n+        let host = url.host_str()?.to_string();\n+        let path_segments: Vec<String> = url\n+            .path_segments()\n+            .map(|segs| segs.filter(|s| !s.is_empty()).map(str::to_string).collect())\n+            .unwrap_or_default();\n+\n+        let mut query = HashMap::new();\n+        for (k, v) in url.query_pairs() {\n+            query.insert(k.into_owned(), v.into_owned());\n+        }\n+\n+        Some(Self {\n+            scheme: url.scheme().to_string(),\n+            path_segments,\n+            query,\n+            host,\n+        })\n+    }\n+\n+    /// Host normalized for graph entry matching (lowercase, aliases).\n+    pub fn match_host(&self) -> String {\n+        normalize_match_host(&self.host)\n+    }\n+}\n+\n+pub fn normalize_match_host(host: &str) -> String {\n+    let h = host\n+        .strip_prefix(\"www.\")\n+        .unwrap_or(host)\n+        .to_ascii_lowercase();\n+    match h.as_str() {\n+        \"old.reddit.com\" | \"new.reddit.com\" => \"reddit.com\".to_string(),\n+        \"m.youtube.com\" => \"youtube.com\".to_string(),\n+        _ => h,\n+    }\n+}\n+\n+pub fn strip_tracking_query(query: &mut HashMap<String, String>) {\n+    query.retain(|k, _| {\n+        let lower = k.to_ascii_lowercase();\n+        !(lower.starts_with(\"utm_\")\n+            || matches!(\n+                lower.as_str(),\n+                \"fbclid\" | \"gclid\" | \"ref\" | \"ref_src\" | \"ref_source\" | \"mc_cid\" | \"mc_eid\"\n+            ))\n+    });\n+}\n+\n+#[cfg(test)]\n+pub(crate) fn test_parts(host: &str, segs: &[&str], query: &[(&str, &str)]) -> UrlParts {\n+    UrlParts {\n+        scheme: \"https\".to_string(),\n+        host: host.to_string(),\n+        path_segments: segs.iter().map(|s| (*s).to_string()).collect(),\n+        query: query\n+            .iter()\n+            .map(|(k, v)| (k.to_string(), v.to_string()))\n+            .collect(),\n+    }\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn parse_full_url_splits_host_path_query() {\n+        let p = UrlParts::parse(\"https://www.youtube.com/watch?v=abc&t=4\").unwrap();\n+        assert_eq!(p.host, \"www.youtube.com\");\n+        assert_eq!(p.path_segments, vec![\"watch\"]);\n+        assert_eq!(p.query.get(\"v\").map(String::as_str), Some(\"abc\"));\n+        assert_eq!(p.query.get(\"t\").map(String::as_str), Some(\"4\"));\n+    }\n+\n+    #[test]\n+    fn parse_r_shortcut_expands_to_reddit() {\n+        let p = UrlParts::parse(\"r/rust\").unwrap();\n+        assert_eq!(p.match_host(), \"reddit.com\");\n+        assert_eq!(p.path_segments, vec![\"r\", \"rust\"]);\n+    }\n+\n+    #[test]\n+    fn parse_slash_r_shortcut() {\n+        let p = UrlParts::parse(\"/r/aww\").unwrap();\n+        assert_eq!(p.path_segments, vec![\"r\", \"aww\"]);\n+    }\n+\n+    #[test]\n+    fn parse_schemeless_host_path() {\n+        let p = UrlParts::parse(\"reddit.com/r/rust/comments/aaa/slug\").unwrap();\n+        assert_eq!(p.match_host(), \"reddit.com\");\n+        assert_eq!(\n+            p.path_segments,\n+            vec![\"r\", \"rust\", \"comments\", \"aaa\", \"slug\"]\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_empty_returns_none() {\n+        assert!(UrlParts::parse(\"\").is_none());\n+        assert!(UrlParts::parse(\"   \").is_none());\n+    }\n+\n+    #[test]\n+    fn normalize_match_host_reddit_aliases() {\n+        assert_eq!(normalize_match_host(\"old.reddit.com\"), \"reddit.com\");\n+        assert_eq!(normalize_match_host(\"NEW.reddit.com\"), \"reddit.com\");\n+        assert_eq!(normalize_match_host(\"www.reddit.com\"), \"reddit.com\");\n+    }\n+\n+    #[test]\n+    fn normalize_match_host_youtube_aliases() {\n+        assert_eq!(normalize_match_host(\"m.youtube.com\"), \"youtube.com\");\n+        assert_eq!(normalize_match_host(\"www.youtube.com\"), \"youtube.com\");\n+    }\n+\n+    #[test]\n+    fn strip_tracking_query_removes_known_params() {\n+        let mut q = HashMap::from([\n+            (\"v\".into(), \"1\".into()),\n+            (\"utm_source\".into(), \"x\".into()),\n+            (\"fbclid\".into(), \"y\".into()),\n+            (\"ref\".into(), \"z\".into()),\n+        ]);\n+        strip_tracking_query(&mut q);\n+        assert_eq!(q.len(), 1);\n+        assert_eq!(q.get(\"v\").map(String::as_str), Some(\"1\"));\n+    }\n+\n+    #[test]\n+    fn strip_tracking_query_utm_prefix() {\n+        let mut q = HashMap::from([(\"utm_campaign\".into(), \"email\".into())]);\n+        strip_tracking_query(&mut q);\n+        assert!(q.is_empty());\n+    }\n+}\ndiff --git a/server/src/url_rules/registry_tests.rs b/server/src/url_rules/registry_tests.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..7b76b550f808f590e011469fdae02adf603b43d2\n--- /dev/null\n+++ b/server/src/url_rules/registry_tests.rs\n@@ -0,0 +1,195 @@\n+//! End-to-end tests for the public registry API (`canonicalize_raw`, breadcrumbs, parent).\n+\n+use super::registry::{\n+    canonicalize_raw, looks_like_url, navigable_breadcrumbs, parent_url, resolve_id,\n+};\n+\n+fn canon(raw: &str) -> String {\n+    canonicalize_raw(raw).unwrap().canonical\n+}\n+\n+#[test]\n+fn looks_like_url_positive_cases() {\n+    for raw in [\n+        \"https://reddit.com/r/rust\",\n+        \"r/rust\",\n+        \"/r/aww\",\n+        \"reddit.com/r/x\",\n+        \"www.example.com/path\",\n+        \"youtu.be/abc\",\n+    ] {\n+        assert!(looks_like_url(raw), \"{raw}\");\n+    }\n+}\n+\n+#[test]\n+fn looks_like_url_negative_cases() {\n+    for raw in [\"alpha\", \"beta\", \"\", \"hello world\", \"no-dots\"] {\n+        assert!(!looks_like_url(raw), \"{raw}\");\n+    }\n+}\n+\n+#[test]\n+fn resolve_id_matches_canonicalize_raw() {\n+    let raw = \"https://youtu.be/xyz\";\n+    assert_eq!(\n+        resolve_id(raw).as_deref(),\n+        Some(canon(raw).as_str())\n+    );\n+}\n+\n+#[test]\n+fn canonicalize_empty_returns_none() {\n+    assert!(canonicalize_raw(\"\").is_none());\n+}\n+\n+#[test]\n+fn alias_when_slug_stripped() {\n+    let r = canonicalize_raw(\n+        \"https://reddit.com/r/rust/comments/aaa/very_long_title_slug\",\n+    )\n+    .unwrap();\n+    assert_eq!(r.canonical, \"https://reddit.com/r/rust/comments/aaa\");\n+    assert!(r.alias_of.is_some());\n+}\n+\n+#[test]\n+fn alias_none_when_already_canonical() {\n+    let raw = \"https://reddit.com/r/rust\";\n+    let r = canonicalize_raw(raw).unwrap();\n+    assert_eq!(r.canonical, raw);\n+    assert!(r.alias_of.is_none());\n+}\n+\n+#[test]\n+fn parent_url_subreddit_under_r_hub() {\n+    assert_eq!(\n+        parent_url(\"https://reddit.com/r/movies\").as_deref(),\n+        Some(\"https://reddit.com/r\")\n+    );\n+}\n+\n+#[test]\n+fn parent_url_domain_has_none() {\n+    assert_eq!(parent_url(\"https://reddit.com\").as_deref(), None);\n+}\n+\n+#[test]\n+fn parent_url_generic_site() {\n+    assert_eq!(\n+        parent_url(\"https://example.com/a/b\").as_deref(),\n+        Some(\"https://example.com/a\")\n+    );\n+}\n+\n+#[test]\n+fn breadcrumbs_from_canonical_string_roundtrip() {\n+    let id = \"https://reddit.com/r/golang/comments/abc123\";\n+    let crumbs = navigable_breadcrumbs(id);\n+    assert_eq!(crumbs.last().map(String::as_str), Some(id));\n+}\n+\n+// --- Table: Reddit raw URLs → canonical ---\n+\n+#[test]\n+fn reddit_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\"r/rust\", \"https://reddit.com/r/rust\"),\n+        (\"/r/aww\", \"https://reddit.com/r/aww\"),\n+        (\"https://reddit.com/r/rust\", \"https://reddit.com/r/rust\"),\n+        (\n+            \"https://www.reddit.com/r/programming/new\",\n+            \"https://reddit.com/r/programming\",\n+        ),\n+        (\n+            \"https://old.reddit.com/r/test/comments/xyz/slug/\",\n+            \"https://reddit.com/r/test/comments/xyz\",\n+        ),\n+        (\n+            \"reddit.com/r/Movies/comments/abc/Title_Case_Slug\",\n+            \"https://reddit.com/r/movies/comments/abc\",\n+        ),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Table: YouTube raw URLs → canonical ---\n+\n+#[test]\n+fn youtube_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\n+            \"https://youtube.com/watch?v=abc\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+        (\n+            \"https://www.youtube.com/watch?v=abc&t=1&feature=share\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+        (\"https://youtu.be/abc\", \"https://youtube.com/watch?v=abc\"),\n+        (\n+            \"https://youtube.com/shorts/abc\",\n+            \"https://youtube.com/watch?v=abc\",\n+        ),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Table: generic sites ---\n+\n+#[test]\n+fn generic_canonical_matrix() {\n+    let cases: &[(&str, &str)] = &[\n+        (\n+            \"https://news.ycombinator.com/item?id=38472\",\n+            \"https://news.ycombinator.com/item?id=38472\",\n+        ),\n+        (\n+            \"https://www.github.com/rust-lang/rust/issues/1?utm_source=x\",\n+            \"https://github.com/rust-lang/rust/issues/1\",\n+        ),\n+        (\"https://example.com\", \"https://example.com\"),\n+    ];\n+    for (raw, want) in cases {\n+        assert_eq!(canon(raw), *want, \"raw={raw}\");\n+    }\n+}\n+\n+// --- Phantom /comments/ regression (sorter2-specific) ---\n+\n+#[test]\n+fn phantom_comments_not_in_breadcrumbs_for_post() {\n+    let crumbs = navigable_breadcrumbs(\"https://reddit.com/r/rust/comments/aaa\");\n+    assert!(!crumbs.iter().any(|c| c.ends_with(\"/comments\")));\n+}\n+\n+#[test]\n+fn phantom_comments_not_sibling_of_subreddit_in_breadcrumb_chain() {\n+    let crumbs = navigable_breadcrumbs(\"https://reddit.com/r/rust/comments/aaa\");\n+    let subs: Vec<_> = crumbs\n+        .iter()\n+        .filter(|c| c.contains(\"/r/rust\") && !c.contains(\"/comments/\"))\n+        .collect();\n+    assert_eq!(subs, vec![\"https://reddit.com/r/rust\"]);\n+}\n+\n+// --- Distinct items must stay distinct ---\n+\n+#[test]\n+fn different_posts_different_canonical() {\n+    let a = canon(\"https://reddit.com/r/rust/comments/aaa\");\n+    let b = canon(\"https://reddit.com/r/rust/comments/bbb\");\n+    assert_ne!(a, b);\n+}\n+\n+#[test]\n+fn different_subreddits_different_canonical() {\n+    assert_ne!(\n+        canon(\"https://reddit.com/r/rust\"),\n+        canon(\"https://reddit.com/r/golang\")\n+    );\n+}\n\n\nSide B — contributor: tommy-mor\nSide B — commit message:\n[23c8134e] Fix /-/ external garden index; resolvers/ + GitHub import cards (#150)\n\n* Fix external garden root listing; add resolvers/ with GitHub cards\n\nThe public and room external index pages queried children of a bogus\nhttps://./ parent, so /-/ always looked empty. Collect host-only https\nroots from all Web items and item_children edges so ghost parents from\nadd_child_edge appear.\n\nMove GitHub resolver into server/src/resolvers/ with default_external.rs\nand a try_render_resolver_item_body hook. Resolver ingests now store\nslug-github-card fenced JSON; render_item_body_in_scope shows a small\nGitHub article card (with legacy support for schema-less json fences on\ngithub.com URLs). Styling in theme_default.css; agents.md updated.\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n* Vote compare: GitHub cards in columns, layout CSS, tests\n\nPass item_bodies into vote_compare_item_card for linkified tooltips on\nnon-card bodies; clone item_bodies before dropping reducer read guard.\n\nAdd layout rules so rich cards sit in the grid corners (default + retro).\n\nUnit test on vote_compare_item_card; integration GET /vote/compare with\ningested slug-github-card bodies. agents.md clarifies compare columns.\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n---------\n\nCo-authored-by: Cursor Agent <cursoragent@cursor.com>\n\nSide B — unified diff (full patch):\ndiff --git a/agents.md b/agents.md\nindex 7508234d9b04223d0e64cfe69fedbebd06a256b5..d8b801e454fdf37e7ac6038b91a69f83b0746d59 100644\n--- a/agents.md\n+++ b/agents.md\n@@ -42,7 +42,7 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma\n \n - **`VoteComparePost`:** On success returns **`text/javascript`** that **morphs** **`#vote-edge-history-region`** (recomputed **`<ul>`** — ratios match **`left`/`right`** query order, bullets, sorted by strength toward **`left`** then newer) and **`.vote-compare-nav`** (fresh next-pair link). The compare **`GET`** page uses **`layout_full_bleed_chromeless`** (no breadcrumbs, no **`#controls`**, no **`slug-pin-hud`**; **`view-vote-compare-fullscreen`** full-width **`body`**). **`__rpc__`** carries **`form_action: \"/ui\"`**; **`thread_tag`** and ratio fields come from the same form as **`$form`** holes.\n \n-- **`ResolveExternal`:** GitHub resolver buttons are browser actions through **`POST /ui`**. Success responses morph **`#external-resolver-status`** then redirect to the sanitized shareable **`GET`** page so imported children render through the normal page path; errors morph the same status region. Resolver results are durable system ingests, while cooldown state is RAM-only.\n+- **`ResolveExternal`:** GitHub resolver buttons are browser actions through **`POST /ui`**. Success responses morph **`#external-resolver-status`** then redirect to the sanitized shareable **`GET`** page so imported children render through the normal page path; errors morph the same status region. Resolver results are durable system ingests, while cooldown state is RAM-only. Implementation lives under **`server/src/resolvers/`** (GitHub resolver + import card JSON); ontology item pages and the **`GET /vote/compare`** left/right columns use **`render_item_body_in_scope`** in **`server/src/html/mod.rs`**, which calls **`server/src/resolvers/mod.rs::try_render_resolver_item_body`** before falling back to the usual **`<pre>`** linkified view.\n \n - **Garden pin / compare voting:** Cookie **`slug_garden_pin`** via **`set_garden_pin`**. Pairwise UI: **`GET /vote/compare?…`** / **`GET /r/:room_key/vote/compare?…`** (fullscreen **`GET`** page: no HUD; other garden pages). HUD (**`#slug-pin-hud`**): only when **`layout`** passes garden metadata on **`body`**; the label is **`POST /ui`** **`set_garden_pin`** **`clear:true`** (**`slug_ui.js`**), not a permalink to the item.\n \ndiff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs\nindex 4b0214d18b173cd506d09176104f461dc4c4f208..c9eb8e242072e41fcf70da838bdf02dd4c838db8 100644\n--- a/server/src/api/ui_html.rs\n+++ b/server/src/api/ui_html.rs\n@@ -18,7 +18,7 @@ use crate::{\n         rpc::{rpc_post_redact, rpc_post_with_bearer, rpc_room_delete},\n     },\n     canonical_path::canonicalize_tag,\n-    external_resolver::resolve_github_children,\n+    resolvers::resolve_github_children,\n     html::vote_compare_post_success_js,\n     html::{\n         external_resolver_status_markup, fragment_new_thread_slot, login_to_post_hint_markup,\ndiff --git a/server/src/external_resolver.rs b/server/src/external_resolver.rs\ndeleted file mode 100644\nindex a5812250fed7613950b5417f396f886a55fafccf..0000000000000000000000000000000000000000\n--- a/server/src/external_resolver.rs\n+++ /dev/null\n@@ -1,630 +0,0 @@\n-use async_trait::async_trait;\n-use serde_json::Value;\n-use tokio::sync::oneshot;\n-\n-use crate::{path_types::ItemId, state::AppState, write_cmd::WriteCmd};\n-\n-const GITHUB_SYSTEM_PRINCIPAL: &str = \"system:github-resolver\";\n-const GITHUB_RESOLVER_COOLDOWN_MS: i64 = 15_000;\n-const GITHUB_MAX_PAGES: usize = 3;\n-\n-fn now_ms() -> i64 {\n-    use std::time::{SystemTime, UNIX_EPOCH};\n-    SystemTime::now()\n-        .duration_since(UNIX_EPOCH)\n-        .unwrap_or_default()\n-        .as_millis() as i64\n-}\n-\n-#[derive(Debug, Clone, PartialEq, Eq)]\n-pub struct ResolvedChild {\n-    pub url: String,\n-    pub title: String,\n-    pub body: Option<String>,\n-}\n-\n-#[async_trait]\n-pub trait ExternalResolver: Send + Sync {\n-    /// e.g. `\"github.com\"`\n-    fn domain_match(&self) -> &'static str;\n-\n-    /// Normalizes URLs (e.g. stripping fragments); extend per-domain later.\n-    fn normalize(&self, path: &str) -> String;\n-\n-    /// Fetches body when missing; GitHub hook lands here in a follow-up.\n-    async fn fetch_body(&self, item: &ItemId) -> Result<String, String>;\n-}\n-\n-#[derive(Clone)]\n-pub struct GitHubResolver {\n-    client: reqwest::Client,\n-    api_base_url: String,\n-    token: Option<String>,\n-}\n-\n-impl GitHubResolver {\n-    pub fn from_env() -> Self {\n-        let api_base_url = std::env::var(\"SLUG_GITHUB_API_BASE_URL\")\n-            .ok()\n-            .filter(|s| !s.trim().is_empty())\n-            .unwrap_or_else(|| \"https://api.github.com\".to_string());\n-        let token = std::env::var(\"SLUG_GITHUB_TOKEN\")\n-            .ok()\n-            .filter(|s| !s.trim().is_empty());\n-        Self {\n-            client: reqwest::Client::new(),\n-            api_base_url: api_base_url.trim_end_matches('/').to_string(),\n-            token,\n-        }\n-    }\n-\n-    pub fn can_resolve_children(&self, item: &ItemId) -> bool {\n-        github_segments(item).is_some()\n-    }\n-\n-    pub async fn list_children(&self, item: &ItemId) -> Result<Vec<ResolvedChild>, String> {\n-        let segments = github_segments(item).ok_or_else(|| \"not a GitHub URL\".to_string())?;\n-        match segments.as_slice() {\n-            [] => Ok(vec![]),\n-            [owner] => self.list_repos(owner).await,\n-            [owner, repo] => Ok(github_repo_sections(owner, repo)),\n-            [owner, repo, section] if section == \"issues\" => self.list_issues(owner, repo).await,\n-            [owner, repo, section] if section == \"pulls\" => self.list_pulls(owner, repo).await,\n-            [owner, repo, section] if section == \"commits\" => self.list_commits(owner, repo).await,\n-            [owner, repo, section] if section == \"releases\" => {\n-                self.list_releases(owner, repo).await\n-            }\n-            _ => Ok(vec![]),\n-        }\n-    }\n-\n-    async fn get_json(&self, path: &str) -> Result<Value, String> {\n-        let url = format!(\"{}/{}\", self.api_base_url, path.trim_start_matches('/'));\n-        let mut req = self\n-            .client\n-            .get(url)\n-            .header(reqwest::header::USER_AGENT, \"slugsocial-github-resolver\");\n-        if let Some(token) = &self.token {\n-            req = req.bearer_auth(token);\n-        }\n-        let resp = req\n-            .send()\n-            .await\n-            .map_err(|e| format!(\"GitHub request failed: {e}\"))?;\n-        let status = resp.status();\n-        if !status.is_success() {\n-            return Err(format!(\"GitHub request returned {status}\"));\n-        }\n-        resp.json::<Value>()\n-            .await\n-            .map_err(|e| format!(\"GitHub response JSON failed: {e}\"))\n-    }\n-\n-    async fn get_json_array_pages(&self, path: &str) -> Result<Vec<Value>, String> {\n-        let sep = if path.contains('?') { '&' } else { '?' };\n-        let mut out = Vec::new();\n-        for page in 1..=GITHUB_MAX_PAGES {\n-            let value = self.get_json(&format!(\"{path}{sep}page={page}\")).await?;\n-            let arr = value\n-                .as_array()\n-                .ok_or_else(|| \"GitHub paged response was not an array\".to_string())?;\n-            let n = arr.len();\n-            out.extend(arr.iter().cloned());\n-            if n < 100 {\n-                break;\n-            }\n-        }\n-        Ok(out)\n-    }\n-\n-    async fn list_repos(&self, owner: &str) -> Result<Vec<ResolvedChild>, String> {\n-        let arr = self\n-            .get_json_array_pages(&format!(\n-                \"/users/{owner}/repos?per_page=100&sort=updated&type=owner\"\n-            ))\n-            .await?;\n-        let mut out = Vec::new();\n-        for repo in &arr {\n-            let name = repo\n-                .get(\"name\")\n-                .and_then(|v| v.as_str())\n-                .unwrap_or_default();\n-            if name.is_empty() {\n-                continue;\n-            }\n-            let full_name = repo\n-                .get(\"full_name\")\n-                .and_then(|v| v.as_str())\n-                .map(|s| s.to_ascii_lowercase())\n-                .unwrap_or_else(|| format!(\"{owner}/{name}\").to_ascii_lowercase());\n-            out.push(ResolvedChild {\n-                url: format!(\"https://github.com/{full_name}\"),\n-                title: full_name.clone(),\n-                body: Some(github_repo_body(repo)),\n-            });\n-        }\n-        out.sort_by(|a, b| a.url.cmp(&b.url));\n-        Ok(out)\n-    }\n-\n-    async fn list_issues(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n-        let arr = self\n-            .get_json_array_pages(&format!(\n-                \"/repos/{owner}/{repo}/issues?state=open&per_page=100\"\n-            ))\n-            .await?;\n-        let mut out = Vec::new();\n-        for issue in &arr {\n-            if issue.get(\"pull_request\").is_some() {\n-                continue;\n-            }\n-            let Some(number) = issue.get(\"number\").and_then(|v| v.as_i64()) else {\n-                continue;\n-            };\n-            let title = issue\n-                .get(\"title\")\n-                .and_then(|v| v.as_str())\n-                .unwrap_or(\"Untitled issue\");\n-            out.push(ResolvedChild {\n-                url: format!(\"https://github.com/{owner}/{repo}/issues/{number}\"),\n-                title: format!(\"#{number} {title}\"),\n-                body: Some(github_issue_body(issue, \"issue\")),\n-            });\n-        }\n-        out.sort_by(|a, b| a.url.cmp(&b.url));\n-        Ok(out)\n-    }\n-\n-    async fn list_pulls(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n-        let arr = self\n-            .get_json_array_pages(&format!(\n-                \"/repos/{owner}/{repo}/pulls?state=open&per_page=100\"\n-            ))\n-            .await?;\n-        let mut out = Vec::new();\n-        for pull in &arr {\n-            let Some(number) = pull.get(\"number\").and_then(|v| v.as_i64()) else {\n-                continue;\n-            };\n-            let title = pull\n-                .get(\"title\")\n-                .and_then(|v| v.as_str())\n-                .unwrap_or(\"Untitled pull request\");\n-            out.push(ResolvedChild {\n-                url: format!(\"https://github.com/{owner}/{repo}/pulls/{number}\"),\n-                title: format!(\"#{number} {title}\"),\n-                body: Some(github_issue_body(pull, \"pull request\")),\n-            });\n-        }\n-        out.sort_by(|a, b| a.url.cmp(&b.url));\n-        Ok(out)\n-    }\n-\n-    async fn list_commits(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n-        let arr = self\n-            .get_json_array_pages(&format!(\"/repos/{owner}/{repo}/commits?per_page=100\"))\n-            .await?;\n-        let mut out = Vec::new();\n-        for commit in &arr {\n-            let Some(sha) = github_string(commit, \"sha\") else {\n-                continue;\n-            };\n-            let short = sha.chars().take(7).collect::<String>();\n-            let title = commit\n-                .get(\"commit\")\n-                .and_then(|c| c.get(\"message\"))\n-                .and_then(|v| v.as_str())\n-                .and_then(|m| m.lines().next())\n-                .filter(|s| !s.trim().is_empty())\n-                .unwrap_or(\"commit\");\n-            let url = github_string(commit, \"html_url\")\n-                .map(|s| s.to_string())\n-                .unwrap_or_else(|| format!(\"https://github.com/{owner}/{repo}/commit/{sha}\"));\n-            out.push(ResolvedChild {\n-                url,\n-                title: format!(\"{short} {title}\"),\n-                body: Some(github_commit_body(commit)),\n-            });\n-        }\n-        out.sort_by(|a, b| a.url.cmp(&b.url));\n-        Ok(out)\n-    }\n-\n-    async fn list_releases(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n-        let arr = self\n-            .get_json_array_pages(&format!(\"/repos/{owner}/{repo}/releases?per_page=100\"))\n-            .await?;\n-        let mut out = Vec::new();\n-        for release in &arr {\n-            let Some(tag) = github_string(release, \"tag_name\") else {\n-                continue;\n-            };\n-            let title = github_string(release, \"name\").unwrap_or(tag);\n-            let url = github_string(release, \"html_url\")\n-                .map(|s| s.to_string())\n-                .unwrap_or_else(|| format!(\"https://github.com/{owner}/{repo}/releases/tag/{tag}\"));\n-            out.push(ResolvedChild {\n-                url,\n-                title: title.to_string(),\n-                body: Some(github_release_body(release)),\n-            });\n-        }\n-        out.sort_by(|a, b| a.url.cmp(&b.url));\n-        Ok(out)\n-    }\n-}\n-\n-fn github_segments(item: &ItemId) -> Option<Vec<String>> {\n-    let url = url::Url::parse(item.as_str()).ok()?;\n-    if url.host_str()?.eq_ignore_ascii_case(\"github.com\") {\n-        Some(\n-            url.path_segments()\n-                .map(|segments| {\n-                    segments\n-                        .filter(|s| !s.is_empty())\n-                        .map(|s| s.to_ascii_lowercase())\n-                        .collect::<Vec<_>>()\n-                })\n-                .unwrap_or_default(),\n-        )\n-    } else {\n-        None\n-    }\n-}\n-\n-fn github_repo_sections(owner: &str, repo: &str) -> Vec<ResolvedChild> {\n-    [\n-        (\"issues\", \"GitHub issues for this repository.\"),\n-        (\"pulls\", \"GitHub pull requests for this repository.\"),\n-        (\"commits\", \"GitHub commits for this repository.\"),\n-        (\"releases\", \"GitHub releases for this repository.\"),\n-    ]\n-    .into_iter()\n-    .map(|(section, body)| ResolvedChild {\n-        url: format!(\"https://github.com/{owner}/{repo}/{section}\"),\n-        title: section.to_string(),\n-        body: Some(body.to_string()),\n-    })\n-    .collect()\n-}\n-\n-fn resolver_thread_tag(item: &ItemId) -> String {\n-    let tail = item\n-        .display_path()\n-        .trim_start_matches(\"-/\")\n-        .replace('/', \":\")\n-        .replace('?', \":\");\n-    format!(\"import:{tail}\")\n-}\n-\n-fn sanitize_body(s: &str) -> String {\n-    s.replace('{', \"(\")\n-        .replace('}', \")\")\n-        .replace(\"```\", \"` ` `\")\n-        .chars()\n-        .take(4_000)\n-        .collect()\n-}\n-\n-fn github_string<'a>(value: &'a Value, key: &str) -> Option<&'a str> {\n-    value\n-        .get(key)\n-        .and_then(|v| v.as_str())\n-        .filter(|s| !s.trim().is_empty())\n-}\n-\n-fn github_user_login(value: &Value) -> Option<&str> {\n-    value\n-        .get(\"user\")\n-        .and_then(|u| u.get(\"login\"))\n-        .and_then(|v| v.as_str())\n-        .filter(|s| !s.trim().is_empty())\n-}\n-\n-fn github_labels(value: &Value) -> Vec<String> {\n-    value\n-        .get(\"labels\")\n-        .and_then(|v| v.as_array())\n-        .into_iter()\n-        .flat_map(|labels| labels.iter())\n-        .filter_map(|label| label.get(\"name\").and_then(|v| v.as_str()))\n-        .filter(|name| !name.trim().is_empty())\n-        .map(|name| name.to_string())\n-        .collect()\n-}\n-\n-fn github_repo_body(repo: &Value) -> String {\n-    let full_name = github_string(repo, \"full_name\")\n-        .or_else(|| github_string(repo, \"name\"))\n-        .unwrap_or(\"GitHub repository\");\n-    let mut lines = vec![full_name.to_string()];\n-    if let Some(desc) = github_string(repo, \"description\") {\n-        lines.push(String::new());\n-        lines.push(desc.to_string());\n-    }\n-    if let Some(url) = github_string(repo, \"html_url\") {\n-        lines.push(String::new());\n-        lines.push(format!(\"Source: {url}\"));\n-    }\n-    if let Some(lang) = github_string(repo, \"language\") {\n-        lines.push(format!(\"Language: {lang}\"));\n-    }\n-    lines.join(\"\\n\")\n-}\n-\n-fn github_issue_body(issue: &Value, kind: &str) -> String {\n-    let number = issue\n-        .get(\"number\")\n-        .and_then(|v| v.as_i64())\n-        .map(|n| format!(\"#{n} \"))\n-        .unwrap_or_default();\n-    let title = github_string(issue, \"title\").unwrap_or(\"Untitled\");\n-    let state = github_string(issue, \"state\").unwrap_or(\"unknown\");\n-    let mut lines = vec![format!(\"{kind} {number}{title}\")];\n-    lines.push(format!(\"State: {state}\"));\n-    if let Some(author) = github_user_login(issue) {\n-        lines.push(format!(\"Author: @{author}\"));\n-    }\n-    let labels = github_labels(issue);\n-    if !labels.is_empty() {\n-        lines.push(format!(\"Labels: {}\", labels.join(\", \")));\n-    }\n-    if let Some(url) = github_string(issue, \"html_url\") {\n-        lines.push(format!(\"Source: {url}\"));\n-    }\n-    if let Some(body) = github_string(issue, \"body\") {\n-        lines.push(String::new());\n-        lines.push(body.to_string());\n-    }\n-    lines.join(\"\\n\")\n-}\n-\n-fn github_commit_body(commit: &Value) -> String {\n-    let sha = github_string(commit, \"sha\").unwrap_or(\"unknown\");\n-    let short = sha.chars().take(7).collect::<String>();\n-    let commit_obj = commit.get(\"commit\");\n-    let message = commit_obj\n-        .and_then(|c| c.get(\"message\"))\n-        .and_then(|v| v.as_str())\n-        .unwrap_or(\"commit\");\n-    let mut lines = vec![format!(\"commit {short}\")];\n-    if let Some(author) = commit_obj\n-        .and_then(|c| c.get(\"author\"))\n-        .and_then(|a| a.get(\"name\"))\n-        .and_then(|v| v.as_str())\n-        .filter(|s| !s.trim().is_empty())\n-    {\n-        lines.push(format!(\"Author: {author}\"));\n-    }\n-    if let Some(login) = github_user_login(commit) {\n-        lines.push(format!(\"GitHub user: @{login}\"));\n-    }\n-    if let Some(date) = commit_obj\n-        .and_then(|c| c.get(\"author\"))\n-        .and_then(|a| a.get(\"date\"))\n-        .and_then(|v| v.as_str())\n-    {\n-        lines.push(format!(\"Date: {date}\"));\n-    }\n-    if let Some(url) = github_string(commit, \"html_url\") {\n-        lines.push(format!(\"Source: {url}\"));\n-    }\n-    lines.push(String::new());\n-    lines.push(message.to_string());\n-    lines.join(\"\\n\")\n-}\n-\n-fn github_release_body(release: &Value) -> String {\n-    let tag = github_string(release, \"tag_name\").unwrap_or(\"untagged\");\n-    let title = github_string(release, \"name\").unwrap_or(tag);\n-    let mut lines = vec![format!(\"release {title}\")];\n-    lines.push(format!(\"Tag: {tag}\"));\n-    if release\n-        .get(\"draft\")\n-        .and_then(|v| v.as_bool())\n-        .unwrap_or(false)\n-    {\n-        lines.push(\"Draft: yes\".to_string());\n-    }\n-    if release\n-        .get(\"prerelease\")\n-        .and_then(|v| v.as_bool())\n-        .unwrap_or(false)\n-    {\n-        lines.push(\"Prerelease: yes\".to_string());\n-    }\n-    if let Some(author) = github_user_login(release) {\n-        lines.push(format!(\"Author: @{author}\"));\n-    }\n-    if let Some(published) = github_string(release, \"published_at\") {\n-        lines.push(format!(\"Published: {published}\"));\n-    }\n-    if let Some(url) = github_string(release, \"html_url\") {\n-        lines.push(format!(\"Source: {url}\"));\n-    }\n-    if let Some(body) = github_string(release, \"body\") {\n-        lines.push(String::new());\n-        lines.push(body.to_string());\n-    }\n-    lines.join(\"\\n\")\n-}\n-\n-fn children_to_dsl(children: &[ResolvedChild]) -> String {\n-    let mut out = String::new();\n-    for child in children {\n-        let body = child\n-            .body\n-            .as_deref()\n-            .filter(|s| !s.trim().is_empty())\n-            .unwrap_or(child.title.as_str());\n-        if body.trim_start().starts_with(\"```\") {\n-            out.push_str(&format!(\"{} {{\\n{}\\n}}\\n\\n\", child.url, body.trim()));\n-        } else {\n-            out.push_str(&format!(\n-                \"{} {{\\n{}\\n}}\\n\\n\",\n-                child.url,\n-                sanitize_body(body)\n-            ));\n-        }\n-    }\n-    out\n-}\n-\n-pub async fn resolve_github_children(\n-    state: &AppState,\n-    room: &str,\n-    item: &ItemId,\n-) -> Result<usize, String> {\n-    if !state.github_resolver.can_resolve_children(item) {\n-        return Err(\"no GitHub resolver for this item\".to_string());\n-    }\n-\n-    let key = format!(\"github:{}:{}\", room.trim(), item.as_str());\n-    let now = now_ms();\n-    {\n-        let mut runs = state.resolver_runs.write().await;\n-        if let Some(last) = runs.get(&key) {\n-            let remaining = GITHUB_RESOLVER_COOLDOWN_MS - (now - *last);\n-            if remaining > 0 {\n-                return Err(format!(\n-                    \"GitHub resolver cooldown: try again in {}s\",\n-                    (remaining + 999) / 1000\n-                ));\n-            }\n-        }\n-        runs.insert(key, now);\n-    }\n-\n-    let children = state.github_resolver.list_children(item).await?;\n-    if children.is_empty() {\n-        return Ok(0);\n-    }\n-    let text = children_to_dsl(&children);\n-    let thread_tag = resolver_thread_tag(item);\n-    let (tx, rx) = oneshot::channel();\n-    state\n-        .write_tx\n-        .send(WriteCmd::SystemIngest {\n-            room: room.to_string(),\n-            thread_tag,\n-            text,\n-            principal: GITHUB_SYSTEM_PRINCIPAL.to_string(),\n-            reply: tx,\n-        })\n-        .await\n-        .map_err(|_| \"writer unavailable\".to_string())?;\n-    rx.await\n-        .map_err(|_| \"writer dropped\".to_string())?\n-        .map_err(|(msg, hint)| hint.map_or(msg.clone(), |h| format!(\"{msg}: {h}\")))?;\n-    Ok(children.len())\n-}\n-\n-/// Placeholder until other domain-specific resolvers exist.\n-pub struct DefaultExternalResolver;\n-\n-#[async_trait]\n-impl ExternalResolver for DefaultExternalResolver {\n-    fn domain_match(&self) -> &'static str {\n-        \"\"\n-    }\n-\n-    fn normalize(&self, path: &str) -> String {\n-        path.to_string()\n-    }\n-\n-    async fn fetch_body(&self, _item: &ItemId) -> Result<String, String> {\n-        Err(\"external fetch not implemented\".to_string())\n-    }\n-}\n-\n-#[cfg(test)]\n-mod tests {\n-    use super::*;\n-\n-    #[test]\n-    fn github_segments_parse_normalized_url() {\n-        let item = ItemId::parse(\"https://github.com/Sortersocial/Slug/issues\").unwrap();\n-        assert_eq!(\n-            github_segments(&item),\n-            Some(vec![\n-                \"sortersocial\".to_string(),\n-                \"slug\".to_string(),\n-                \"issues\".to_string()\n-            ])\n-        );\n-    }\n-\n-    #[test]\n-    fn repo_sections_are_direct_children() {\n-        let sections = github_repo_sections(\"sortersocial\", \"slug\");\n-        let urls: Vec<String> = sections.into_iter().map(|c| c.url).collect();\n-        assert!(urls.contains(&\"https://github.com/sortersocial/slug/issues\".to_string()));\n-        assert!(urls.contains(&\"https://github.com/sortersocial/slug/pulls\".to_string()));\n-    }\n-\n-    #[test]\n-    fn children_to_dsl_contains_item_bodies() {\n-        let dsl = children_to_dsl(&[ResolvedChild {\n-            url: \"https://github.com/o/r/issues/1\".into(),\n-            title: \"#1 title\".into(),\n-            body: Some(\"body with {braces}\".into()),\n-        }]);\n-        assert!(dsl.contains(\"https://github.com/o/r/issues/1\"));\n-        assert!(dsl.contains(\"body with (braces)\"));\n-    }\n-\n-    #[test]\n-    fn children_to_dsl_preserves_fenced_json_bodies() {\n-        let dsl = children_to_dsl(&[ResolvedChild {\n-            url: \"https://github.com/o/r/issues/1\".into(),\n-            title: \"#1 title\".into(),\n-            body: Some(\"```json\\n{\\\"test\\\": true}\\n```\".into()),\n-        }]);\n-        assert!(dsl.contains(\"https://github.com/o/r/issues/1 {\\n```json\"));\n-        assert!(dsl.contains(\"{\\\"test\\\": true}\"));\n-        assert!(dsl.contains(\"```\\n}\\n\"));\n-    }\n-\n-    #[test]\n-    fn github_issue_body_is_readable_text_not_json_dump() {\n-        let issue = serde_json::json!({\n-            \"number\": 12,\n-            \"title\": \"Render children\",\n-            \"state\": \"open\",\n-            \"html_url\": \"https://github.com/o/r/issues/12\",\n-            \"user\": {\"login\": \"octo\"},\n-            \"labels\": [{\"name\": \"bug\"}],\n-            \"body\": \"The issue body.\"\n-        });\n-        let body = github_issue_body(&issue, \"issue\");\n-        assert!(body.contains(\"issue #12 Render children\"));\n-        assert!(body.contains(\"Author: @octo\"));\n-        assert!(body.contains(\"The issue body.\"));\n-        assert!(!body.trim_start().starts_with(\"```json\"));\n-    }\n-\n-    #[test]\n-    fn github_commit_and_release_bodies_are_readable() {\n-        let commit = serde_json::json!({\n-            \"sha\": \"abcdef123456\",\n-            \"html_url\": \"https://github.com/o/r/commit/abcdef123456\",\n-            \"author\": {\"login\": \"octo\"},\n-            \"commit\": {\n-                \"message\": \"Fix vote page\\n\\nDetails here.\",\n-                \"author\": {\"name\": \"Octo Dev\", \"date\": \"2026-05-17T00:00:00Z\"}\n-            }\n-        });\n-        let release = serde_json::json!({\n-            \"tag_name\": \"v1.2.3\",\n-            \"name\": \"Release 1.2.3\",\n-            \"html_url\": \"https://github.com/o/r/releases/tag/v1.2.3\",\n-            \"author\": {\"login\": \"octo\"},\n-            \"prerelease\": true,\n-            \"body\": \"Release notes.\"\n-        });\n-        assert!(github_commit_body(&commit).contains(\"commit abcdef1\"));\n-        assert!(github_commit_body(&commit).contains(\"Fix vote page\"));\n-        assert!(github_release_body(&release).contains(\"release Release 1.2.3\"));\n-        assert!(github_release_body(&release).contains(\"Prerelease: yes\"));\n-    }\n-}\ndiff --git a/server/src/html/garden.rs b/server/src/html/garden.rs\nindex 9ca66e7c5860d428e95abf5df518fc1e7b4f6332..e2dc6e5529d4a3126723d0dea75931d0738b6c83 100644\n--- a/server/src/html/garden.rs\n+++ b/server/src/html/garden.rs\n@@ -7,7 +7,7 @@ use axum_extra::extract::cookie::CookieJar;\n use maud::html;\n use serde::Deserialize;\n use serde_json::json;\n-use std::collections::HashSet;\n+use std::collections::{HashMap, HashSet};\n \n use base64::{engine::general_purpose::URL_SAFE_NO_PAD as B64_ENGINE, Engine as _};\n \n@@ -21,8 +21,8 @@ use crate::{\n     path_types::ItemId,\n     reducer::{ContentState, ReducerState, ScopeId},\n     scope_rank::{\n-        build_children_rankings, build_rankings_for_item_set, resolve_scope_recursive,\n-        suggest_next_pair_in_pool, ChildrenRankings,\n+        build_children_rankings, build_rankings_for_item_set, external_root_host_items,\n+        resolve_scope_recursive, suggest_next_pair_in_pool, ChildrenRankings,\n     },\n     state::AppState,\n     timeago,\n@@ -33,7 +33,7 @@ use super::{\n     breadcrumb_path::{ExternalOntologyPath, OntologyPath},\n     cli_panel,\n     forum::ThreadNav,\n-    layout, layout_full_bleed_chromeless, now_ms, ratio_pct, render_linkified_with_embeds_in_scope,\n+    layout, layout_full_bleed_chromeless, now_ms, ratio_pct, render_item_body_in_scope,\n     theme_from_jar, theme_next_from_uri,\n };\n \n@@ -358,6 +358,7 @@ fn vote_compare_item_card(\n     item: &ItemId,\n     body: Option<&String>,\n     side_class: &str,\n+    item_bodies: Option<&HashMap<ItemId, String>>,\n ) -> maud::Markup {\n     html! {\n         div class=(format!(\"vote-compare-side {side_class}\")) {\n@@ -366,10 +367,10 @@ fn vote_compare_item_card(\n             }\n             @if let Some(body) = body.filter(|b| !b.trim().is_empty()) {\n                 div class=\"vote-compare-item-body\" {\n-                    (render_linkified_with_embeds_in_scope(\n+                    (render_item_body_in_scope(\n                         body,\n                         nav.garden_root_url(),\n-                        None,\n+                        item_bodies,\n                     ))\n                 }\n             } @else {\n@@ -678,10 +679,11 @@ pub async fn external_garden_index(\n ) -> impl IntoResponse {\n     let nav = ThreadNav::public();\n     let ext_path = ExternalOntologyPath::from_input(\"\");\n-    let parent = ItemId::parse(\"https://.\").unwrap();\n     let child_rankings = {\n         let reduced = state.reduced.read().await;\n-        build_children_rankings(reduced.public(), &parent)\n+        let content = reduced.public();\n+        let hosts = external_root_host_items(content);\n+        build_rankings_for_item_set(content, &hosts)\n     };\n \n     let url_key = canonical_view_url(&uri);\n@@ -812,9 +814,11 @@ pub async fn room_external_garden_index(\n         return room_not_found_page(&jar, &uri).into_response();\n     }\n     let ext_path = ExternalOntologyPath::from_input(\"\");\n-    let parent = ItemId::parse(\"https://.\").unwrap();\n-    let child_rankings =\n-        build_children_rankings(content_for_garden_view(&reduced, &nav.scope()), &parent);\n+    let child_rankings = {\n+        let content = content_for_garden_view(&reduced, &nav.scope());\n+        let hosts = external_root_host_items(content);\n+        build_rankings_for_item_set(content, &hosts)\n+    };\n     drop(reduced);\n \n     let url_key = canonical_view_url(&uri);\n@@ -1334,7 +1338,7 @@ async fn render_scope_view(\n                 }\n                 @if let Some(body) = &model.body {\n                     div class=\"ont-item-content\" {\n-                        (render_linkified_with_embeds_in_scope(\n+                        (render_item_body_in_scope(\n                             body,\n                             nav.garden_root_url(),\n                             Some(&scope_content.item_bodies),\n@@ -1592,6 +1596,7 @@ async fn vote_compare_inner(\n     let edge_history = vote_edge_history_markup(content, &left, &right);\n     let left_body = content.item_bodies.get(&left).cloned();\n     let right_body = content.item_bodies.get(&right).cloned();\n+    let item_bodies_for_cards = content.item_bodies.clone();\n     let next_pair = suggest_next_vote_pair(content, &left, &right);\n     drop(reduced);\n \n@@ -1623,9 +1628,21 @@ async fn vote_compare_inner(\n     section class=\"vote-compare-shell\" {\n         h2 { \"compare\" }\n         div class=\"vote-compare-pair\" {\n-            (vote_compare_item_card(&nav, &left, left_body.as_ref(), \"vote-compare-left\"))\n+            (vote_compare_item_card(\n+                &nav,\n+                &left,\n+                left_body.as_ref(),\n+                \"vote-compare-left\",\n+                Some(&item_bodies_for_cards),\n+            ))\n             span class=\"vote-compare-vs\" { \"vs\" }\n-            (vote_compare_item_card(&nav, &right, right_body.as_ref(), \"vote-compare-right\"))\n+            (vote_compare_item_card(\n+                &nav,\n+                &right,\n+                right_body.as_ref(),\n+                \"vote-compare-right\",\n+                Some(&item_bodies_for_cards),\n+            ))\n         }\n         (vote_compare_nav_markup(&nav, next_pair.as_ref(), &left, &right, q.thread.as_deref()))\n         div id=\"vote-edge-history-region\" {\n@@ -2020,6 +2037,40 @@ mod tests {\n         assert!(items.contains(\"https://slug.social/~/topic/b\"));\n     }\n \n+    #[test]\n+    fn vote_compare_item_card_renders_github_import_markup() {\n+        use crate::html::forum::ThreadNav;\n+        use super::vote_compare_item_card;\n+        use crate::path_types::ItemId;\n+\n+        let nav = ThreadNav::public();\n+        let item = ItemId::parse(\"https://github.com/o/r/issues/1\").unwrap();\n+        let json = serde_json::json!({\n+            \"v\": 1,\n+            \"schema\": \"slug_github_import\",\n+            \"kind\": \"issue\",\n+            \"url\": \"https://github.com/o/r/issues/1\",\n+            \"headline\": \"#1 Compare card\",\n+            \"sublines\": [\"State: open\"],\n+        });\n+        let body = format!(\"```slug-github-card\\n{}\\n```\", json.to_string());\n+        let html = vote_compare_item_card(\n+            &nav,\n+            &item,\n+            Some(&body),\n+            \"vote-compare-left\",\n+            None,\n+        )\n+        .into_string();\n+        assert!(\n+            html.contains(\"github-import-card\"),\n+            \"expected rich GitHub card markup, got: {html}\"\n+        );\n+        assert!(html.contains(\"item-body-rich\"));\n+        assert!(html.contains(\"vote-compare-left\"));\n+        assert!(html.contains(\"#1 Compare card\"));\n+    }\n+\n     #[test]\n     fn external_source_href_maps_youtube_path_identity_back_to_watch_url() {\n         assert_eq!(\ndiff --git a/server/src/html/mod.rs b/server/src/html/mod.rs\nindex a1b929625acbd5298c0cf62f3ca0892079edcb2a..3b23e19a8b35aa4c0b0480e29de7d46ad57ab276 100644\n--- a/server/src/html/mod.rs\n+++ b/server/src/html/mod.rs\n@@ -793,6 +793,20 @@ pub(super) fn render_linkified_with_embeds_in_scope(\n     }\n }\n \n+/// Item page / thread body: resolver-specific rich HTML, else linkified `<pre>` + media embeds.\n+pub(super) fn render_item_body_in_scope(\n+    raw: &str,\n+    garden_prefix: &str,\n+    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n+) -> Markup {\n+    if let Some(m) = crate::resolvers::try_render_resolver_item_body(raw) {\n+        return html! {\n+            div class=\"item-body-rich\" { (m) }\n+        };\n+    }\n+    render_linkified_with_embeds_in_scope(raw, garden_prefix, item_bodies)\n+}\n+\n /// CLI strings are embedded in a single-quoted JS literal; they must never need escaping.\n fn assert_cli_panel_cmd_js_single_quote_safe(s: &str) {\n     assert!(\ndiff --git a/server/src/lib.rs b/server/src/lib.rs\nindex 84e94bbec144eae77de68482385941cd2c5845eb..c1d477d21aea03aff00e6f0689b0b4379d0d68d2 100644\n--- a/server/src/lib.rs\n+++ b/server/src/lib.rs\n@@ -5,7 +5,7 @@ pub mod canonical_path;\n pub mod dsl;\n pub mod event_log;\n pub mod events;\n-pub mod external_resolver;\n+pub mod resolvers;\n pub mod form_template;\n pub mod html;\n pub mod identity;\n@@ -51,7 +51,7 @@ pub fn create_app_state(cfg: AppConfig) -> AppState {\n         write_tx,\n         views,\n         resolver_runs: Arc::new(RwLock::new(HashMap::new())),\n-        github_resolver: Arc::new(crate::external_resolver::GitHubResolver::from_env()),\n+        github_resolver: Arc::new(crate::resolvers::GitHubResolver::from_env()),\n     };\n     tokio::spawn(crate::api::write_actor::writer_actor(\n         write_rx,\ndiff --git a/server/src/resolvers/default_external.rs b/server/src/resolvers/default_external.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..d37c222abcee3c20b22189b2822da9e9a6ff0515\n--- /dev/null\n+++ b/server/src/resolvers/default_external.rs\n@@ -0,0 +1,22 @@\n+use async_trait::async_trait;\n+\n+use crate::path_types::ItemId;\n+use super::github::ExternalResolver;\n+\n+/// Placeholder until other domain-specific resolvers exist.\n+pub struct DefaultExternalResolver;\n+\n+#[async_trait]\n+impl ExternalResolver for DefaultExternalResolver {\n+    fn domain_match(&self) -> &'static str {\n+        \"\"\n+    }\n+\n+    fn normalize(&self, path: &str) -> String {\n+        path.to_string()\n+    }\n+\n+    async fn fetch_body(&self, _item: &ItemId) -> Result<String, String> {\n+        Err(\"external fetch not implemented\".to_string())\n+    }\n+}\ndiff --git a/server/src/resolvers/github.rs b/server/src/resolvers/github.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..5a9c0c38ff01ca5894f7dc62c1008371dacb0cf1\n--- /dev/null\n+++ b/server/src/resolvers/github.rs\n@@ -0,0 +1,755 @@\n+use async_trait::async_trait;\n+use maud::html;\n+use serde::{Deserialize, Serialize};\n+use serde_json::Value;\n+use tokio::sync::oneshot;\n+\n+use crate::{path_types::ItemId, state::AppState, write_cmd::WriteCmd};\n+\n+pub const SLUG_GITHUB_SCHEMA: &str = \"slug_github_import\";\n+\n+const GITHUB_SYSTEM_PRINCIPAL: &str = \"system:github-resolver\";\n+const GITHUB_RESOLVER_COOLDOWN_MS: i64 = 15_000;\n+const GITHUB_MAX_PAGES: usize = 3;\n+\n+fn now_ms() -> i64 {\n+    use std::time::{SystemTime, UNIX_EPOCH};\n+    SystemTime::now()\n+        .duration_since(UNIX_EPOCH)\n+        .unwrap_or_default()\n+        .as_millis() as i64\n+}\n+\n+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\n+#[serde(rename_all = \"snake_case\")]\n+pub enum GithubImportKind {\n+    Repo,\n+    RepoSection,\n+    Issue,\n+    Pull,\n+    Commit,\n+    Release,\n+}\n+\n+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\n+pub struct GithubImportCard {\n+    pub v: u32,\n+    #[serde(default)]\n+    pub schema: String,\n+    pub kind: GithubImportKind,\n+    pub url: String,\n+    pub headline: String,\n+    #[serde(default)]\n+    pub sublines: Vec<String>,\n+    #[serde(default)]\n+    pub excerpt: Option<String>,\n+}\n+\n+impl GithubImportCard {\n+    fn new(kind: GithubImportKind, url: String, headline: String) -> Self {\n+        Self {\n+            v: 1,\n+            schema: SLUG_GITHUB_SCHEMA.to_string(),\n+            kind,\n+            url,\n+            headline,\n+            sublines: Vec::new(),\n+            excerpt: None,\n+        }\n+    }\n+}\n+\n+#[derive(Debug, Clone, PartialEq, Eq)]\n+pub struct ResolvedChild {\n+    pub url: String,\n+    pub title: String,\n+    pub card: GithubImportCard,\n+}\n+\n+#[async_trait]\n+pub trait ExternalResolver: Send + Sync {\n+    /// e.g. `\"github.com\"`\n+    fn domain_match(&self) -> &'static str;\n+\n+    /// Normalizes URLs (e.g. stripping fragments); extend per-domain later.\n+    fn normalize(&self, path: &str) -> String;\n+\n+    /// Fetches body when missing; GitHub hook lands here in a follow-up.\n+    async fn fetch_body(&self, item: &ItemId) -> Result<String, String>;\n+}\n+\n+#[derive(Clone)]\n+pub struct GitHubResolver {\n+    client: reqwest::Client,\n+    api_base_url: String,\n+    token: Option<String>,\n+}\n+\n+impl GitHubResolver {\n+    pub fn from_env() -> Self {\n+        let api_base_url = std::env::var(\"SLUG_GITHUB_API_BASE_URL\")\n+            .ok()\n+            .filter(|s| !s.trim().is_empty())\n+            .unwrap_or_else(|| \"https://api.github.com\".to_string());\n+        let token = std::env::var(\"SLUG_GITHUB_TOKEN\")\n+            .ok()\n+            .filter(|s| !s.trim().is_empty());\n+        Self {\n+            client: reqwest::Client::new(),\n+            api_base_url: api_base_url.trim_end_matches('/').to_string(),\n+            token,\n+        }\n+    }\n+\n+    pub fn can_resolve_children(&self, item: &ItemId) -> bool {\n+        github_segments(item).is_some()\n+    }\n+\n+    pub async fn list_children(&self, item: &ItemId) -> Result<Vec<ResolvedChild>, String> {\n+        let segments = github_segments(item).ok_or_else(|| \"not a GitHub URL\".to_string())?;\n+        match segments.as_slice() {\n+            [] => Ok(vec![]),\n+            [owner] => self.list_repos(owner).await,\n+            [owner, repo] => Ok(github_repo_sections(owner, repo)),\n+            [owner, repo, section] if section == \"issues\" => self.list_issues(owner, repo).await,\n+            [owner, repo, section] if section == \"pulls\" => self.list_pulls(owner, repo).await,\n+            [owner, repo, section] if section == \"commits\" => self.list_commits(owner, repo).await,\n+            [owner, repo, section] if section == \"releases\" => {\n+                self.list_releases(owner, repo).await\n+            }\n+            _ => Ok(vec![]),\n+        }\n+    }\n+\n+    async fn get_json(&self, path: &str) -> Result<Value, String> {\n+        let url = format!(\"{}/{}\", self.api_base_url, path.trim_start_matches('/'));\n+        let mut req = self\n+            .client\n+            .get(url)\n+            .header(reqwest::header::USER_AGENT, \"slugsocial-github-resolver\");\n+        if let Some(token) = &self.token {\n+            req = req.bearer_auth(token);\n+        }\n+        let resp = req\n+            .send()\n+            .await\n+            .map_err(|e| format!(\"GitHub request failed: {e}\"))?;\n+        let status = resp.status();\n+        if !status.is_success() {\n+            return Err(format!(\"GitHub request returned {status}\"));\n+        }\n+        resp.json::<Value>()\n+            .await\n+            .map_err(|e| format!(\"GitHub response JSON failed: {e}\"))\n+    }\n+\n+    async fn get_json_array_pages(&self, path: &str) -> Result<Vec<Value>, String> {\n+        let sep = if path.contains('?') { '&' } else { '?' };\n+        let mut out = Vec::new();\n+        for page in 1..=GITHUB_MAX_PAGES {\n+            let value = self.get_json(&format!(\"{path}{sep}page={page}\")).await?;\n+            let arr = value\n+                .as_array()\n+                .ok_or_else(|| \"GitHub paged response was not an array\".to_string())?;\n+            let n = arr.len();\n+            out.extend(arr.iter().cloned());\n+            if n < 100 {\n+                break;\n+            }\n+        }\n+        Ok(out)\n+    }\n+\n+    async fn list_repos(&self, owner: &str) -> Result<Vec<ResolvedChild>, String> {\n+        let arr = self\n+            .get_json_array_pages(&format!(\n+                \"/users/{owner}/repos?per_page=100&sort=updated&type=owner\"\n+            ))\n+            .await?;\n+        let mut out = Vec::new();\n+        for repo in &arr {\n+            let name = repo\n+                .get(\"name\")\n+                .and_then(|v| v.as_str())\n+                .unwrap_or_default();\n+            if name.is_empty() {\n+                continue;\n+            }\n+            let full_name = repo\n+                .get(\"full_name\")\n+                .and_then(|v| v.as_str())\n+                .map(|s| s.to_ascii_lowercase())\n+                .unwrap_or_else(|| format!(\"{owner}/{name}\").to_ascii_lowercase());\n+            let url = format!(\"https://github.com/{full_name}\");\n+            let mut card = card_for_repo(repo, &url);\n+            card.headline = full_name.clone();\n+            out.push(ResolvedChild {\n+                url,\n+                title: full_name,\n+                card,\n+            });\n+        }\n+        out.sort_by(|a, b| a.url.cmp(&b.url));\n+        Ok(out)\n+    }\n+\n+    async fn list_issues(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n+        let arr = self\n+            .get_json_array_pages(&format!(\n+                \"/repos/{owner}/{repo}/issues?state=open&per_page=100\"\n+            ))\n+            .await?;\n+        let mut out = Vec::new();\n+        for issue in &arr {\n+            if issue.get(\"pull_request\").is_some() {\n+                continue;\n+            }\n+            let Some(number) = issue.get(\"number\").and_then(|v| v.as_i64()) else {\n+                continue;\n+            };\n+            let title = issue\n+                .get(\"title\")\n+                .and_then(|v| v.as_str())\n+                .unwrap_or(\"Untitled issue\");\n+            let url = format!(\"https://github.com/{owner}/{repo}/issues/{number}\");\n+            let card = card_for_issue(issue, &url, GithubImportKind::Issue);\n+            out.push(ResolvedChild {\n+                url: url.clone(),\n+                title: format!(\"#{number} {title}\"),\n+                card,\n+            });\n+        }\n+        out.sort_by(|a, b| a.url.cmp(&b.url));\n+        Ok(out)\n+    }\n+\n+    async fn list_pulls(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n+        let arr = self\n+            .get_json_array_pages(&format!(\n+                \"/repos/{owner}/{repo}/pulls?state=open&per_page=100\"\n+            ))\n+            .await?;\n+        let mut out = Vec::new();\n+        for pull in &arr {\n+            let Some(number) = pull.get(\"number\").and_then(|v| v.as_i64()) else {\n+                continue;\n+            };\n+            let title = pull\n+                .get(\"title\")\n+                .and_then(|v| v.as_str())\n+                .unwrap_or(\"Untitled pull request\");\n+            let url = format!(\"https://github.com/{owner}/{repo}/pulls/{number}\");\n+            let card = card_for_issue(pull, &url, GithubImportKind::Pull);\n+            out.push(ResolvedChild {\n+                url: url.clone(),\n+                title: format!(\"#{number} {title}\"),\n+                card,\n+            });\n+        }\n+        out.sort_by(|a, b| a.url.cmp(&b.url));\n+        Ok(out)\n+    }\n+\n+    async fn list_commits(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n+        let arr = self\n+            .get_json_array_pages(&format!(\"/repos/{owner}/{repo}/commits?per_page=100\"))\n+            .await?;\n+        let mut out = Vec::new();\n+        for commit in &arr {\n+            let Some(sha) = github_string(commit, \"sha\") else {\n+                continue;\n+            };\n+            let short = sha.chars().take(7).collect::<String>();\n+            let title = commit\n+                .get(\"commit\")\n+                .and_then(|c| c.get(\"message\"))\n+                .and_then(|v| v.as_str())\n+                .and_then(|m| m.lines().next())\n+                .filter(|s| !s.trim().is_empty())\n+                .unwrap_or(\"commit\");\n+            let url = github_string(commit, \"html_url\")\n+                .map(|s| s.to_string())\n+                .unwrap_or_else(|| format!(\"https://github.com/{owner}/{repo}/commit/{sha}\"));\n+            let card = card_for_commit(commit, &url, &short, title);\n+            out.push(ResolvedChild {\n+                url: url.clone(),\n+                title: format!(\"{short} {title}\"),\n+                card,\n+            });\n+        }\n+        out.sort_by(|a, b| a.url.cmp(&b.url));\n+        Ok(out)\n+    }\n+\n+    async fn list_releases(&self, owner: &str, repo: &str) -> Result<Vec<ResolvedChild>, String> {\n+        let arr = self\n+            .get_json_array_pages(&format!(\"/repos/{owner}/{repo}/releases?per_page=100\"))\n+            .await?;\n+        let mut out = Vec::new();\n+        for release in &arr {\n+            let Some(tag) = github_string(release, \"tag_name\") else {\n+                continue;\n+            };\n+            let title = github_string(release, \"name\").unwrap_or(tag);\n+            let url = github_string(release, \"html_url\")\n+                .map(|s| s.to_string())\n+                .unwrap_or_else(|| format!(\"https://github.com/{owner}/{repo}/releases/tag/{tag}\"));\n+            let card = card_for_release(release, &url, title);\n+            out.push(ResolvedChild {\n+                url: url.clone(),\n+                title: title.to_string(),\n+                card,\n+            });\n+        }\n+        out.sort_by(|a, b| a.url.cmp(&b.url));\n+        Ok(out)\n+    }\n+}\n+\n+fn github_segments(item: &ItemId) -> Option<Vec<String>> {\n+    let url = url::Url::parse(item.as_str()).ok()?;\n+    if url.host_str()?.eq_ignore_ascii_case(\"github.com\") {\n+        Some(\n+            url.path_segments()\n+                .map(|segments| {\n+                    segments\n+                        .filter(|s| !s.is_empty())\n+                        .map(|s| s.to_ascii_lowercase())\n+                        .collect::<Vec<_>>()\n+                })\n+                .unwrap_or_default(),\n+        )\n+    } else {\n+        None\n+    }\n+}\n+\n+fn title_case_segment(seg: &str) -> String {\n+    let mut c = seg.chars();\n+    match c.next() {\n+        None => String::new(),\n+        Some(f) => f.to_uppercase().chain(c).collect(),\n+    }\n+}\n+\n+fn github_repo_sections(owner: &str, repo: &str) -> Vec<ResolvedChild> {\n+    [\n+        (\"issues\", \"GitHub issues for this repository.\"),\n+        (\"pulls\", \"GitHub pull requests for this repository.\"),\n+        (\"commits\", \"GitHub commits for this repository.\"),\n+        (\"releases\", \"GitHub releases for this repository.\"),\n+    ]\n+    .into_iter()\n+    .map(|(section, blurb)| {\n+        let url = format!(\"https://github.com/{owner}/{repo}/{section}\");\n+        let mut card = GithubImportCard::new(\n+            GithubImportKind::RepoSection,\n+            url.clone(),\n+            format!(\"{owner}/{repo} — {}\", title_case_segment(section)),\n+        );\n+        card.excerpt = Some(blurb.to_string());\n+        ResolvedChild {\n+            url,\n+            title: section.to_string(),\n+            card,\n+        }\n+    })\n+    .collect()\n+}\n+\n+fn resolver_thread_tag(item: &ItemId) -> String {\n+    let tail = item\n+        .display_path()\n+        .trim_start_matches(\"-/\")\n+        .replace('/', \":\")\n+        .replace('?', \":\");\n+    format!(\"import:{tail}\")\n+}\n+\n+fn children_to_dsl(children: &[ResolvedChild]) -> String {\n+    let mut out = String::new();\n+    for child in children {\n+        let json = serde_json::to_string(&child.card).unwrap_or_else(|_| \"{}\".to_string());\n+        let inner = format!(\"```slug-github-card\\n{json}\\n```\");\n+        out.push_str(&format!(\"{} {{\\n{}\\n}}\\n\\n\", child.url, inner));\n+    }\n+    out\n+}\n+\n+fn card_for_repo(repo: &Value, fallback_url: &str) -> GithubImportCard {\n+    let url = github_string(repo, \"html_url\")\n+        .map(|s| s.to_string())\n+        .filter(|s| !s.is_empty())\n+        .unwrap_or_else(|| fallback_url.to_string());\n+    let full_name = github_string(repo, \"full_name\")\n+        .or_else(|| github_string(repo, \"name\"))\n+        .unwrap_or(\"repository\");\n+    let mut card = GithubImportCard::new(GithubImportKind::Repo, url, full_name.to_string());\n+    if let Some(lang) = github_string(repo, \"language\") {\n+        card.sublines.push(format!(\"Language: {lang}\"));\n+    }\n+    if let Some(desc) = github_string(repo, \"description\") {\n+        card.excerpt = Some(desc.to_string());\n+    }\n+    card\n+}\n+\n+fn excerpt_from_github_body(body: Option<&str>) -> Option<String> {\n+    let b = body?.trim();\n+    if b.is_empty() {\n+        return None;\n+    }\n+    let max = 1200usize;\n+    if b.len() <= max {\n+        Some(b.to_string())\n+    } else {\n+        Some(format!(\"{}…\", b.chars().take(max).collect::<String>()))\n+    }\n+}\n+\n+fn card_for_issue(v: &Value, url: &str, kind: GithubImportKind) -> GithubImportCard {\n+    let number = v.get(\"number\").and_then(|n| n.as_i64());\n+    let title = github_string(v, \"title\").unwrap_or(\"Untitled\");\n+    let state = github_string(v, \"state\").unwrap_or(\"unknown\");\n+    let headline = match number {\n+        Some(n) => format!(\"#{n} {title}\"),\n+        None => title.to_string(),\n+    };\n+    let mut card = GithubImportCard::new(kind, url.to_string(), headline);\n+    card.sublines.push(format!(\"State: {state}\"));\n+    if let Some(a) = github_user_login(v) {\n+        card.sublines.push(format!(\"Author: @{a}\"));\n+    }\n+    let labels = github_labels(v);\n+    if !labels.is_empty() {\n+        card.sublines\n+            .push(format!(\"Labels: {}\", labels.join(\", \")));\n+    }\n+    card.excerpt = excerpt_from_github_body(github_string(v, \"body\"));\n+    card\n+}\n+\n+fn card_for_commit(v: &Value, url: &str, short_sha: &str, subject: &str) -> GithubImportCard {\n+    let headline = format!(\"{short_sha} {subject}\");\n+    let mut card = GithubImportCard::new(GithubImportKind::Commit, url.to_string(), headline);\n+    if let Some(name) = v\n+        .get(\"commit\")\n+        .and_then(|c| c.get(\"author\"))\n+        .and_then(|a| a.get(\"name\"))\n+        .and_then(|n| n.as_str())\n+        .filter(|s| !s.trim().is_empty())\n+    {\n+        card.sublines.push(format!(\"Author: {name}\"));\n+    }\n+    if let Some(login) = github_user_login(v) {\n+        card.sublines.push(format!(\"GitHub: @{login}\"));\n+    }\n+    if let Some(date) = v\n+        .get(\"commit\")\n+        .and_then(|c| c.get(\"author\"))\n+        .and_then(|a| a.get(\"date\"))\n+        .and_then(|d| d.as_str())\n+    {\n+        card.sublines.push(format!(\"Date: {date}\"));\n+    }\n+    if let Some(msg) = v\n+        .get(\"commit\")\n+        .and_then(|c| c.get(\"message\"))\n+        .and_then(|m| m.as_str())\n+    {\n+        card.excerpt = excerpt_from_github_body(Some(msg));\n+    }\n+    card\n+}\n+\n+fn card_for_release(v: &Value, url: &str, title: &str) -> GithubImportCard {\n+    let tag = github_string(v, \"tag_name\").unwrap_or(\"untagged\");\n+    let mut card = GithubImportCard::new(\n+        GithubImportKind::Release,\n+        url.to_string(),\n+        format!(\"Release — {title}\"),\n+    );\n+    card.sublines.push(format!(\"Tag: {tag}\"));\n+    if v.get(\"draft\").and_then(|b| b.as_bool()).unwrap_or(false) {\n+        card.sublines.push(\"Draft: yes\".to_string());\n+    }\n+    if v.get(\"prerelease\")\n+        .and_then(|b| b.as_bool())\n+        .unwrap_or(false)\n+    {\n+        card.sublines.push(\"Prerelease: yes\".to_string());\n+    }\n+    if let Some(a) = github_user_login(v) {\n+        card.sublines.push(format!(\"Author: @{a}\"));\n+    }\n+    if let Some(pub_at) = github_string(v, \"published_at\") {\n+        card.sublines.push(format!(\"Published: {pub_at}\"));\n+    }\n+    card.excerpt = excerpt_from_github_body(github_string(v, \"body\"));\n+    card\n+}\n+\n+fn github_string<'a>(value: &'a Value, key: &str) -> Option<&'a str> {\n+    value\n+        .get(key)\n+        .and_then(|v| v.as_str())\n+        .filter(|s| !s.trim().is_empty())\n+}\n+\n+fn github_user_login(value: &Value) -> Option<&str> {\n+    value\n+        .get(\"user\")\n+        .and_then(|u| u.get(\"login\"))\n+        .and_then(|v| v.as_str())\n+        .filter(|s| !s.trim().is_empty())\n+}\n+\n+fn github_labels(value: &Value) -> Vec<String> {\n+    value\n+        .get(\"labels\")\n+        .and_then(|v| v.as_array())\n+        .into_iter()\n+        .flat_map(|labels| labels.iter())\n+        .filter_map(|label| label.get(\"name\").and_then(|v| v.as_str()))\n+        .filter(|name| !name.trim().is_empty())\n+        .map(|name| name.to_string())\n+        .collect()\n+}\n+\n+pub async fn resolve_github_children(\n+    state: &AppState,\n+    room: &str,\n+    item: &ItemId,\n+) -> Result<usize, String> {\n+    if !state.github_resolver.can_resolve_children(item) {\n+        return Err(\"no GitHub resolver for this item\".to_string());\n+    }\n+\n+    let key = format!(\"github:{}:{}\", room.trim(), item.as_str());\n+    let now = now_ms();\n+    {\n+        let mut runs = state.resolver_runs.write().await;\n+        if let Some(last) = runs.get(&key) {\n+            let remaining = GITHUB_RESOLVER_COOLDOWN_MS - (now - *last);\n+            if remaining > 0 {\n+                return Err(format!(\n+                    \"GitHub resolver cooldown: try again in {}s\",\n+                    (remaining + 999) / 1000\n+                ));\n+            }\n+        }\n+        runs.insert(key, now);\n+    }\n+\n+    let children = state.github_resolver.list_children(item).await?;\n+    if children.is_empty() {\n+        return Ok(0);\n+    }\n+    let text = children_to_dsl(&children);\n+    let thread_tag = resolver_thread_tag(item);\n+    let (tx, rx) = oneshot::channel();\n+    state\n+        .write_tx\n+        .send(WriteCmd::SystemIngest {\n+            room: room.to_string(),\n+            thread_tag,\n+            text,\n+            principal: GITHUB_SYSTEM_PRINCIPAL.to_string(),\n+            reply: tx,\n+        })\n+        .await\n+        .map_err(|_| \"writer unavailable\".to_string())?;\n+    rx.await\n+        .map_err(|_| \"writer dropped\".to_string())?\n+        .map_err(|(msg, hint)| hint.map_or(msg.clone(), |h| format!(\"{msg}: {h}\")))?;\n+    Ok(children.len())\n+}\n+\n+fn extract_fence<'a>(body: &'a str, lang: &str) -> Option<&'a str> {\n+    let b = body.trim();\n+    let prefix = format!(\"```{lang}\");\n+    let rest = b.strip_prefix(prefix.as_str())?;\n+    let rest = rest\n+        .strip_prefix('\\n')\n+        .or_else(|| rest.strip_prefix('\\r'))\n+        .unwrap_or(rest);\n+    let end = rest.find(\"\\n```\")?;\n+    Some(rest[..end].trim())\n+}\n+\n+fn parse_github_import_from_body(body: &str) -> Option<GithubImportCard> {\n+    let trimmed = body.trim();\n+    if let Some(json) = extract_fence(trimmed, \"slug-github-card\") {\n+        let c: GithubImportCard = serde_json::from_str(json).ok()?;\n+        return (c.v == 1 && (c.schema.is_empty() || c.schema == SLUG_GITHUB_SCHEMA)).then_some(c);\n+    }\n+    if let Some(json) = extract_fence(trimmed, \"json\") {\n+        if let Ok(c) = serde_json::from_str::<GithubImportCard>(json) {\n+            if c.v == 1\n+                && (c.schema == SLUG_GITHUB_SCHEMA\n+                    || (c.schema.is_empty() && c.url.contains(\"github.com\")))\n+            {\n+                return Some(c);\n+            }\n+        }\n+    }\n+    if trimmed.starts_with('{') {\n+        let c: GithubImportCard = serde_json::from_str(trimmed).ok()?;\n+        return (c.v == 1\n+            && (c.schema == SLUG_GITHUB_SCHEMA\n+                || (c.schema.is_empty() && c.url.contains(\"github.com\"))))\n+        .then_some(c);\n+    }\n+    None\n+}\n+\n+fn kind_badge(kind: &GithubImportKind) -> &'static str {\n+    match kind {\n+        GithubImportKind::Repo => \"GitHub · repository\",\n+        GithubImportKind::RepoSection => \"GitHub · tree\",\n+        GithubImportKind::Issue => \"GitHub · issue\",\n+        GithubImportKind::Pull => \"GitHub · pull request\",\n+        GithubImportKind::Commit => \"GitHub · commit\",\n+        GithubImportKind::Release => \"GitHub · release\",\n+    }\n+}\n+\n+fn render_github_card(card: &GithubImportCard) -> maud::Markup {\n+    html! {\n+        article.github-import-card {\n+            header.github-import-card__hdr {\n+                span class=\"github-import-card__badge\" { (kind_badge(&card.kind)) }\n+                h3.github-import-card__title { (card.headline.as_str()) }\n+            }\n+            @if !card.sublines.is_empty() {\n+                ul.github-import-card__meta {\n+                    @for line in &card.sublines {\n+                        li { (line.as_str()) }\n+                    }\n+                }\n+            }\n+            @if let Some(ex) = &card.excerpt {\n+                div.github-import-card__excerpt {\n+                    @for block in ex.split(\"\\n\\n\") {\n+                        @if !block.trim().is_empty() {\n+                            p { (block) }\n+                        }\n+                    }\n+                }\n+            }\n+            p.github-import-card__link {\n+                a href=(card.url.as_str()) rel=\"noopener noreferrer\" target=\"_blank\" {\n+                    \"Open on GitHub\"\n+                }\n+            }\n+        }\n+    }\n+}\n+\n+/// Rich HTML for bodies that contain a [`GithubImportCard`] fence (or equivalent JSON).\n+pub fn try_render_github_import_markup(raw: &str) -> Option<maud::Markup> {\n+    let card = parse_github_import_from_body(raw)?;\n+    Some(render_github_card(&card))\n+}\n+\n+#[async_trait]\n+impl ExternalResolver for GitHubResolver {\n+    fn domain_match(&self) -> &'static str {\n+        \"github.com\"\n+    }\n+\n+    fn normalize(&self, path: &str) -> String {\n+        path.to_string()\n+    }\n+\n+    async fn fetch_body(&self, _item: &ItemId) -> Result<String, String> {\n+        Err(\"GitHub fetch_body not implemented\".to_string())\n+    }\n+}\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn github_segments_parse_normalized_url() {\n+        let item = ItemId::parse(\"https://github.com/Sortersocial/Slug/issues\").unwrap();\n+        assert_eq!(\n+            github_segments(&item),\n+            Some(vec![\n+                \"sortersocial\".to_string(),\n+                \"slug\".to_string(),\n+                \"issues\".to_string()\n+            ])\n+        );\n+    }\n+\n+    #[test]\n+    fn repo_sections_are_direct_children() {\n+        let sections = github_repo_sections(\"sortersocial\", \"slug\");\n+        let urls: Vec<String> = sections.into_iter().map(|c| c.url).collect();\n+        assert!(urls.contains(&\"https://github.com/sortersocial/slug/issues\".to_string()));\n+        assert!(urls.contains(&\"https://github.com/sortersocial/slug/pulls\".to_string()));\n+    }\n+\n+    #[test]\n+    fn children_to_dsl_wraps_slug_github_card() {\n+        let dsl = children_to_dsl(&[ResolvedChild {\n+            url: \"https://github.com/o/r/issues/1\".into(),\n+            title: \"#1 title\".into(),\n+            card: GithubImportCard::new(\n+                GithubImportKind::Issue,\n+                \"https://github.com/o/r/issues/1\".into(),\n+                \"#1 title\".into(),\n+            ),\n+        }]);\n+        assert!(dsl.contains(\"https://github.com/o/r/issues/1\"));\n+        assert!(dsl.contains(\"```slug-github-card\"));\n+        assert!(dsl.contains(\"\\\"schema\\\":\\\"slug_github_import\\\"\"));\n+    }\n+\n+    #[test]\n+    fn parse_accepts_slug_github_fence() {\n+        let card = GithubImportCard::new(\n+            GithubImportKind::Repo,\n+            \"https://github.com/o/r\".into(),\n+            \"o/r\".into(),\n+        );\n+        let body = format!(\"```slug-github-card\\n{}\\n```\\n\", serde_json::to_string(&card).unwrap());\n+        let parsed = parse_github_import_from_body(&body).expect(\"parses\");\n+        assert_eq!(parsed, card);\n+    }\n+\n+    #[test]\n+    fn parse_accepts_schema_json_fence() {\n+        let card = GithubImportCard::new(\n+            GithubImportKind::Issue,\n+            \"https://github.com/o/r/issues/2\".into(),\n+            \"#2 hi\".into(),\n+        );\n+        let json = serde_json::to_string(&card).unwrap();\n+        let body = format!(\"```json\\n{json}\\n```\");\n+        let parsed = parse_github_import_from_body(&body).expect(\"parses json fence\");\n+        assert_eq!(parsed.headline, \"#2 hi\");\n+    }\n+\n+    #[test]\n+    fn issue_card_includes_author_and_excerpt() {\n+        let issue = serde_json::json!({\n+            \"number\": 12,\n+            \"title\": \"Render children\",\n+            \"state\": \"open\",\n+            \"html_url\": \"https://github.com/o/r/issues/12\",\n+            \"user\": {\"login\": \"octo\"},\n+            \"labels\": [{\"name\": \"bug\"}],\n+            \"body\": \"The issue body.\"\n+        });\n+        let card = card_for_issue(\n+            &issue,\n+            \"https://github.com/o/r/issues/12\",\n+            GithubImportKind::Issue,\n+        );\n+        assert!(card.sublines.iter().any(|l| l.contains(\"@octo\")));\n+        assert_eq!(card.excerpt.as_deref(), Some(\"The issue body.\").as_deref());\n+    }\n+}\ndiff --git a/server/src/resolvers/mod.rs b/server/src/resolvers/mod.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..3e4caad081acdd2f89cba9f661de43996d6470f3\n--- /dev/null\n+++ b/server/src/resolvers/mod.rs\n@@ -0,0 +1,18 @@\n+//! Domain resolvers (GitHub, …) and matching HTML renderers for imported item bodies.\n+//!\n+//! Resolver output is ingested as DSL; bodies may embed a `slug-github-card` fenced JSON\n+//! envelope that [`crate::html::render_item_body_in_scope`] renders instead of a raw `<pre>`.\n+\n+pub mod github;\n+pub mod default_external;\n+\n+pub use default_external::DefaultExternalResolver;\n+pub use github::{\n+    resolve_github_children, try_render_github_import_markup, ExternalResolver, GitHubResolver,\n+    GithubImportCard, GithubImportKind, ResolvedChild,\n+};\n+\n+/// Extension point: add more `try_render_*` calls here as new resolvers ship.\n+pub fn try_render_resolver_item_body(raw: &str) -> Option<maud::Markup> {\n+    github::try_render_github_import_markup(raw)\n+}\ndiff --git a/server/src/scope_rank.rs b/server/src/scope_rank.rs\nindex 06c560b8eff09b34896d3935d3917fb28f602bc6..2361b2be5ae6b8e1813b6b7ebd5bbf317429b6ad 100644\n--- a/server/src/scope_rank.rs\n+++ b/server/src/scope_rank.rs\n@@ -162,6 +162,45 @@ pub fn build_children_rankings(content: &ContentState, parent: &ItemId) -> Child\n     build_rankings_for_item_set(content, &items)\n }\n \n+/// Host-only `https://…` roots for the external garden index (`/-/`).\n+///\n+/// Includes every `https://host` ancestor of any [`ItemId::Web`] item that appears in\n+/// `content.items`, as a parent key in `item_children`, or as a child in `item_children`\n+/// (so implied “ghost” parents created only via [`ReducerState::add_child_edge`] still show up).\n+pub fn external_root_host_items(content: &ContentState) -> Vec<ItemId> {\n+    let mut hosts: HashSet<ItemId> = HashSet::new();\n+\n+    let mut consider = |id: ItemId| {\n+        let id = id.normalized_storage();\n+        if !matches!(&id, ItemId::Web(_)) {\n+            return;\n+        }\n+        let mut cur = id;\n+        while let Some(p) = cur.parent() {\n+            cur = p.normalized_storage();\n+        }\n+        if matches!(cur, ItemId::Web(_)) {\n+            hosts.insert(cur);\n+        }\n+    };\n+\n+    for it in &content.items {\n+        consider(it.clone());\n+    }\n+    for parent in content.item_children.keys() {\n+        consider(parent.clone());\n+    }\n+    for set in content.item_children.values() {\n+        for ch in set {\n+            consider(ch.clone());\n+        }\n+    }\n+\n+    let mut out: Vec<ItemId> = hosts.into_iter().collect();\n+    out.sort();\n+    out\n+}\n+\n pub fn is_pair_voted_in_group(group: &GroupState, a: &ItemId, b: &ItemId) -> bool {\n     let Some(&a_idx) = group.item_to_idx.get(a) else {\n         return false;\n@@ -305,4 +344,29 @@ mod tests {\n         assert!(next.0 == c || next.1 == c);\n         assert_ne!(canonical_pair(&next.0, &next.1), canonical_pair(&a, &b));\n     }\n+\n+    #[test]\n+    fn external_root_hosts_include_ghost_chain_hosts() {\n+        use crate::reducer::ContentState;\n+        let gh = ItemId::parse(\"https://github.com\").unwrap();\n+        let org = ItemId::parse(\"https://github.com/org\").unwrap();\n+        let repo = ItemId::parse(\"https://github.com/org/rep\").unwrap();\n+        let mut item_children: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();\n+        item_children.entry(gh.clone()).or_default().insert(org.clone());\n+        item_children.entry(org.clone()).or_default().insert(repo.clone());\n+        let mut items = HashSet::new();\n+        items.insert(repo.clone());\n+        let content = ContentState {\n+            ranking_group: crate::reducer::GroupState::new(),\n+            items,\n+            item_bodies: HashMap::new(),\n+            item_children,\n+            item_votes: HashMap::new(),\n+            item_snippets: HashMap::new(),\n+            item_threads: HashMap::new(),\n+            rank_history: HashMap::new(),\n+        };\n+        let roots = external_root_host_items(&content);\n+        assert_eq!(roots, vec![gh]);\n+    }\n }\ndiff --git a/server/src/state.rs b/server/src/state.rs\nindex 48298e2e66456268d23a6462536eb32bfeb5f29b..648ab5304764a329fcabbbbcd3782b94e3e005a8 100644\n--- a/server/src/state.rs\n+++ b/server/src/state.rs\n@@ -4,7 +4,7 @@ use std::sync::Arc;\n use tokio::sync::{broadcast, mpsc, RwLock};\n \n use crate::{\n-    event_log::EventLog, events::ThreadCapability, external_resolver::GitHubResolver,\n+    event_log::EventLog, events::ThreadCapability, resolvers::GitHubResolver,\n     reducer::ReducerState, write_cmd::WriteCmd,\n };\n \ndiff --git a/server/static/theme_default.css b/server/static/theme_default.css\nindex 184e11a590e7019773f7f0abfa41e79161556c71..7ea5f502f9b0b6341ce56d60ae883479070760d6 100644\n--- a/server/static/theme_default.css\n+++ b/server/static/theme_default.css\n@@ -1023,6 +1023,23 @@ body.view-vote-compare .vote-compare-shell > h2 {\n   line-height: 1.35;\n   padding: 8px 10px;\n }\n+.vote-compare-item-body .item-body-rich {\n+  min-width: 0;\n+  text-align: start;\n+}\n+.vote-compare-right .vote-compare-item-body .item-body-rich {\n+  display: flex;\n+  flex-direction: column;\n+  align-items: flex-end;\n+}\n+.vote-compare-item-body .item-body-rich article.github-import-card {\n+  box-sizing: border-box;\n+  width: 100%;\n+  max-width: min(100%, 420px);\n+}\n+.vote-compare-right .vote-compare-item-body .item-body-rich article.github-import-card {\n+  margin-left: auto;\n+}\n .vote-compare-item-body-empty {\n   font-size: 12px;\n   margin: 8px 0 0;\n@@ -1675,3 +1692,47 @@ body.view-ontology-light .rank-history-cause {\n body.view-ontology-light .rank-history-vote {\n   margin-top: 6px;\n }\n+\n+/* GitHub resolver import cards (rich bodies on -/ garden + vote compare) */\n+article.github-import-card {\n+  border: 1px solid var(--lo);\n+  background: var(--g2);\n+  border-radius: 6px;\n+  padding: 12px 14px;\n+  margin: 8px 0;\n+  max-width: 100%;\n+}\n+.github-import-card__hdr {\n+  margin-bottom: 6px;\n+}\n+.github-import-card__badge {\n+  display: block;\n+  font-size: 0.78em;\n+  color: var(--muted);\n+  margin-bottom: 4px;\n+}\n+.github-import-card__title {\n+  margin: 0;\n+  font-size: 1.05em;\n+  font-weight: 600;\n+}\n+ul.github-import-card__meta {\n+  margin: 8px 0 0 1.1em;\n+  padding: 0;\n+  font-size: 0.9em;\n+}\n+.github-import-card__meta li {\n+  margin: 2px 0;\n+}\n+.github-import-card__excerpt {\n+  margin-top: 10px;\n+  font-size: 0.92em;\n+  white-space: pre-wrap;\n+}\n+.github-import-card__excerpt p {\n+  margin: 6px 0;\n+}\n+.github-import-card__link {\n+  margin-top: 12px;\n+  font-size: 0.95em;\n+}\ndiff --git a/server/static/theme_retro.css b/server/static/theme_retro.css\nindex 6747f59eb1ec5c335029fe92d4e5c55b3125a210..d366be6fc8e8fcbc8122b8954b1e356ee36e6bc9 100644\n--- a/server/static/theme_retro.css\n+++ b/server/static/theme_retro.css\n@@ -278,3 +278,20 @@ body.view-ontology .vote-compare-item-body pre {\n   border: 1px solid #ccc;\n   padding: 0.5rem 0.65rem;\n }\n+body.view-ontology .vote-compare-item-body .item-body-rich {\n+  min-width: 0;\n+  text-align: start;\n+}\n+body.view-ontology .vote-compare-right .vote-compare-item-body .item-body-rich {\n+  display: flex;\n+  flex-direction: column;\n+  align-items: flex-end;\n+}\n+body.view-ontology .vote-compare-item-body .item-body-rich article.github-import-card {\n+  box-sizing: border-box;\n+  width: 100%;\n+  max-width: min(100%, 420px);\n+}\n+body.view-ontology .vote-compare-right .vote-compare-item-body .item-body-rich article.github-import-card {\n+  margin-left: auto;\n+}\ndiff --git a/server/static/theme_retro_craft.css b/server/static/theme_retro_craft.css\nindex 55d984a6dd70ebeadeca7baef86b844955f1d78c..d5bc384437f05f001924630947457d416772e950 100644\n--- a/server/static/theme_retro_craft.css\n+++ b/server/static/theme_retro_craft.css\n@@ -907,6 +907,23 @@ body.view-ontology .vote-compare-item-body pre {\n   line-height: 1.35;\n   padding: 0.55rem 0.65rem;\n }\n+body.view-ontology .vote-compare-item-body .item-body-rich {\n+  min-width: 0;\n+  text-align: start;\n+}\n+body.view-ontology .vote-compare-right .vote-compare-item-body .item-body-rich {\n+  display: flex;\n+  flex-direction: column;\n+  align-items: flex-end;\n+}\n+body.view-ontology .vote-compare-item-body .item-body-rich article.github-import-card {\n+  box-sizing: border-box;\n+  width: 100%;\n+  max-width: min(100%, 420px);\n+}\n+body.view-ontology .vote-compare-right .vote-compare-item-body .item-body-rich article.github-import-card {\n+  margin-left: auto;\n+}\n body.view-ontology .vote-compare-item-body-empty {\n   font-size: 0.78rem;\n   margin: 0.45rem 0 0;\ndiff --git a/server/tests/integration.rs b/server/tests/integration.rs\nindex fb0b9335440181d4d50104d37926b0b2eeeb602a..d979000292b6a39db7c7b54f2b804adb9cd39369 100644\n--- a/server/tests/integration.rs\n+++ b/server/tests/integration.rs\n@@ -3,7 +3,7 @@ use sha2::{Digest, Sha256};\n use slug_types::{room_route_segment, ItemId};\n use slugsocial_server::{\n     event_log::EventLog,\n-    events::{Event, TokenIssued, UserRegistered},\n+    events::{Event, Ingest, TokenIssued, UserRegistered},\n     middleware::canonical_view_url,\n     spawn_writer_actor_for_test,\n     state::{AppConfig, AppState},\n@@ -1614,6 +1614,71 @@ async fn test_view_counts_increment_and_display() {\n     );\n }\n \n+#[tokio::test]\n+async fn test_vote_compare_renders_github_import_cards() {\n+    let (addr, _tmp, _log, state, _handle) = create_test_server_with_state().await;\n+    let client = reqwest::Client::new();\n+\n+    let raw = \"@00000000-0000-0000-0000-000000000000:test:local/test\\n\\\n+https://github.com/ghvotehi/a/issues/9 {\\n\\\n+```slug-github-card\\n\\\n+{\\\"v\\\":1,\\\"schema\\\":\\\"slug_github_import\\\",\\\"kind\\\":\\\"issue\\\",\\\"url\\\":\\\"https://github.com/ghvotehi/a/issues/9\\\",\\\"headline\\\":\\\"#9 Left corner\\\",\\\"sublines\\\":[\\\"State: open\\\"]}\\n\\\n+```\\n\\\n+}\\n\\\n+\\n\\\n+https://github.com/ghvotehi/a/issues/10 {\\n\\\n+```slug-github-card\\n\\\n+{\\\"v\\\":1,\\\"schema\\\":\\\"slug_github_import\\\",\\\"kind\\\":\\\"issue\\\",\\\"url\\\":\\\"https://github.com/ghvotehi/a/issues/10\\\",\\\"headline\\\":\\\"#10 Right corner\\\",\\\"sublines\\\":[\\\"State: open\\\"]}\\n\\\n+```\\n\\\n+}\\n\";\n+\n+    {\n+        let mut w = state.reduced.write().await;\n+        w.apply_event(Event::Ingest(Ingest {\n+            ts: 10,\n+            id: \"ing-vote-github-cards\".to_string(),\n+            raw: raw.to_string(),\n+            principal: \"testuser\".to_string(),\n+            delegate: Some(\n+                \"00000000-0000-0000-0000-000000000000:test:local/test\".to_string(),\n+            ),\n+            room_id: \"public\".to_string(),\n+            thread_tag: \"gh-vote-cards\".to_string(),\n+        }));\n+    }\n+\n+    let left = ItemId::parse(\"https://github.com/ghvotehi/a/issues/9\")\n+        .unwrap()\n+        .normalized_storage()\n+        .to_storage_string();\n+    let right = ItemId::parse(\"https://github.com/ghvotehi/a/issues/10\")\n+        .unwrap()\n+        .normalized_storage()\n+        .to_storage_string();\n+    let q = format!(\n+        \"/vote/compare?left={}&right={}\",\n+        urlencoding::encode(&left),\n+        urlencoding::encode(&right)\n+    );\n+    let resp = client\n+        .get(format!(\"http://{addr}{q}\"))\n+        .send()\n+        .await\n+        .unwrap();\n+    assert!(resp.status().is_success(), \"{}\", resp.status());\n+    let body = resp.text().await.unwrap();\n+    let n_cards = body.matches(\"github-import-card\").count();\n+    assert!(\n+        n_cards >= 2,\n+        \"expected two GitHub import cards on vote compare, count={n_cards}, snippet={}\",\n+        body.chars().take(1500).collect::<String>()\n+    );\n+    assert!(body.contains(\"vote-compare-left\"));\n+    assert!(body.contains(\"vote-compare-right\"));\n+    assert!(body.contains(\"#9 Left corner\"));\n+    assert!(body.contains(\"#10 Right corner\"));\n+}\n+\n #[tokio::test]\n async fn test_search_handles_multibyte_unicode() {\n     // HTML search pages are offline during the auth-v3 refactor.\n","role":"user"}],"model":"openai/gpt-chat-latest"}