{"messages":[{"content":"You are ranking individual git commits to an open source project.\nCompare these two commits. Decide which commit contributed more.\nReturn ONLY a JSON object: {\"winner\": \"A\" or \"B\", \"ratio\": \"N:M\", \"explanation\": \"...\"}\n\nSide A — contributor: tommy-mor\nSide A — commit message:\n[07715165] nice\n\nSide A — unified diff (full patch):\ndiff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs\nindex c3c62a76f424010d77a6090c84dd0b82098f573e..da2536112faea313352624cf2ce0ddd0ab3377c1 100644\n--- a/server/src/api/ui_html.rs\n+++ b/server/src/api/ui_html.rs\n@@ -6,7 +6,7 @@ use axum::{\n use std::collections::HashMap;\n \n use crate::{\n-    html::{demo_counter_panel, js_string_literal, ranking_panel, JsBuilder},\n+    html::{js_string_literal, ranking_panel, JsBuilder},\n     parser::parse_reddit_url,\n     parser_render::parser_panel_morph,\n     state::AppState,\n@@ -35,13 +35,6 @@ pub async fn post_ui_html(\n     };\n \n     match action {\n-        HtmlUiAction::BumpDemoCounter => {\n-            let count = state.bump_demo_counter().await;\n-            let panel = demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref());\n-            JsBuilder::new()\n-                .morph_selector(\"#demo-counter-panel\", panel)\n-                .into_response()\n-        }\n         HtmlUiAction::RecordVote {\n             a,\n             b,\n@@ -54,8 +47,8 @@ pub async fn post_ui_html(\n             {\n                 return ui_js_warn(&e).into_response();\n             }\n-            let mut group = state.group.write().await;\n-            let panel = ranking_panel(&mut group);\n+            let group = state.group.read().await;\n+            let panel = ranking_panel(&group);\n             JsBuilder::new()\n                 .morph_selector(\"#ranking-panel\", panel)\n                 .into_response()\n@@ -87,20 +80,6 @@ mod tests {\n         assert!(matches!(err, HtmlUiParseError::MissingRpc));\n     }\n \n-    #[test]\n-    fn bump_action_deserializes() {\n-        let template = serde_json::json!({ \"action\": \"bump_demo_counter\" });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        assert_eq!(\n-            parse_html_ui_from_form(&form).unwrap(),\n-            HtmlUiAction::BumpDemoCounter\n-        );\n-    }\n-\n     #[test]\n     fn record_vote_action_deserializes() {\n         let template = serde_json::json!({\ndiff --git a/server/src/events.rs b/server/src/events.rs\nindex b969242534e184d4f0a689543a479670b08a18df..eff80aef0257f706d2341f666e63d6a3d921bf6e 100644\n--- a/server/src/events.rs\n+++ b/server/src/events.rs\n@@ -5,8 +5,6 @@ use serde::{Deserialize, Serialize};\n pub enum Event {\n     /// Page view recorded (path → counter in views.json).\n     ViewRecorded { path: String, ts: i64 },\n-    /// Demo counter bump from `POST /ui` (persisted in the single JSONL log).\n-    DemoCounterBumped { ts: i64, value: u64 },\n     /// Pairwise comparison vote (replayed into [`crate::reducer::GroupState`] on boot).\n     VoteRecorded {\n         ts: i64,\ndiff --git a/server/src/html/mod.rs b/server/src/html/mod.rs\nindex 5b1d0b5a887d89e7e80796aa7a6c8ed5baaf2782..d69ed962b5c8625bc83c933b1825f2cc1d0868e2 100644\n--- a/server/src/html/mod.rs\n+++ b/server/src/html/mod.rs\n@@ -13,7 +13,7 @@ use crate::{\n     form_template::template_json_compact,\n     parser_action::ParserAction,\n     parser_render::parser_panel,\n-    ranking::ranked_items,\n+    ranking::ranked_items_cached,\n     reducer::GroupState,\n     state::AppState,\n     ui_action::UI_RPC_FIELD,\n@@ -199,10 +199,8 @@ fn layout(title: &str, body: Markup, views: u64, theme: &str, theme_next: &str)\n     }\n }\n \n-pub fn ranking_panel(group: &mut GroupState) -> Markup {\n-    const MAX_ITERS: usize = 10_000;\n-    const TOL: f64 = 1e-8;\n-    let items = ranked_items(group, MAX_ITERS, TOL);\n+pub fn ranking_panel(group: &GroupState) -> Markup {\n+    let items = ranked_items_cached(group);\n     html! {\n         section id=\"ranking-panel\" class=\"demo-panel\" {\n             h2 { \"Ranking\" }\n@@ -260,35 +258,6 @@ pub fn vote_panel() -> Markup {\n }\n \n \n-pub fn demo_counter_panel(count: u64, event_log_path: &str) -> Markup {\n-    let rpc = template_json_compact(&serde_json::json!({ \"action\": \"bump_demo_counter\" }))\n-        .expect(\"rpc json\");\n-    html! {\n-        section id=\"demo-counter-panel\" class=\"demo-panel\" {\n-            h1 { \"sorter2\" }\n-            p class=\"muted\" {\n-                \"Pairwise ranking scaffold — votes persist to JSONL and replay on boot.\"\n-            }\n-            p class=\"demo-count\" {\n-                strong { \"Counter: \" }\n-                span id=\"demo-count-value\" { (count) }\n-            }\n-            p class=\"muted small\" {\n-                \"Event log: \" code { (event_log_path) }\n-            }\n-            form method=\"post\" action=\"/ui\" id=\"demo-bump-form\" {\n-                input type=\"hidden\" name=(UI_RPC_FIELD) value=(rpc);\n-                button type=\"submit\" class=\"btn-primary\" { \"Bump (POST /ui → eval JS)\" }\n-            }\n-            p class=\"muted small\" {\n-                \"Uses hidden \"\n-                code { \"__rpc__\" }\n-                \" JSON + Idiomorph morph — no full page reload.\"\n-            }\n-        }\n-    }\n-}\n-\n pub async fn home(\n     State(state): State<AppState>,\n     jar: CookieJar,\n@@ -297,16 +266,15 @@ pub async fn home(\n     let path = uri.path().to_string();\n     state.views.increment(path.clone());\n     let views = state.views.get_views(&path);\n-    let count = *state.demo_counter.read().await;\n     let theme = theme_from_jar(&jar);\n     let theme_next = theme_next_from_uri(&uri);\n-    let mut group = state.group.write().await;\n+    let group = state.group.read().await;\n     let empty_action = ParserAction::suggest(String::new(), None);\n     let body = html! {\n+        h1 { \"sorter2\" }\n         (parser_panel(\"\", &empty_action))\n         (vote_panel())\n-        (ranking_panel(&mut group))\n-        (demo_counter_panel(count, state.event_log.path().to_string_lossy().as_ref()))\n+        (ranking_panel(&group))\n     };\n     layout(\"sorter2\", body, views, theme, &theme_next)\n }\ndiff --git a/server/src/lib.rs b/server/src/lib.rs\nindex 6716c5b282e7980a7a0f03d63ad8b25eda61cc55..fa423640d598f4ba97a5885d228e78d7b97f7a22 100644\n--- a/server/src/lib.rs\n+++ b/server/src/lib.rs\n@@ -9,6 +9,7 @@ pub mod parser_render;\n pub mod path_types;\n pub mod ranking;\n pub mod reducer;\n+pub mod settlement;\n pub mod state;\n pub mod ui_action;\n pub mod views;\ndiff --git a/server/src/ranking.rs b/server/src/ranking.rs\nindex 89d3280126a8d8f841721ce8cb63ff735d68752a..2d706762792ba9239bb3f1c2e4974a2fde908013 100644\n--- a/server/src/ranking.rs\n+++ b/server/src/ranking.rs\n@@ -91,6 +91,11 @@ pub fn compute_group_ranking(group: &mut GroupState, max_iters: usize, tol: f64)\n \n pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<RankedItem> {\n     compute_group_ranking(group, max_iters, tol);\n+    ranked_items_cached(group)\n+}\n+\n+/// Read cached scores without recomputing (HTTP fast path).\n+pub fn ranked_items_cached(group: &GroupState) -> Vec<RankedItem> {\n     let mut items: Vec<RankedItem> = group\n         .idx_to_item\n         .iter()\n@@ -105,7 +110,12 @@ pub fn ranked_items(group: &mut GroupState, max_iters: usize, tol: f64) -> Vec<R\n     items\n }\n \n-fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usize), f64)>, max_iters: usize, tol: f64) -> Vec<f64> {\n+pub fn compute_scores_from_edges(\n+    n: usize,\n+    edges: impl Iterator<Item = ((usize, usize), f64)>,\n+    max_iters: usize,\n+    tol: f64,\n+) -> Vec<f64> {\n     if n == 0 {\n         return vec![];\n     }\ndiff --git a/server/src/settlement.rs b/server/src/settlement.rs\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..1f722ceaea62cda22c28ab71551f259fbf049b81\n--- /dev/null\n+++ b/server/src/settlement.rs\n@@ -0,0 +1,114 @@\n+use std::sync::Arc;\n+\n+use tokio::sync::{mpsc, oneshot, RwLock};\n+\n+use crate::{\n+    event_log::EventLog,\n+    events::Event,\n+    ranking::compute_scores_from_edges,\n+    reducer::{GroupState, VoteData},\n+};\n+\n+const MAX_ITERS: usize = 10_000;\n+const TOL: f64 = 1e-8;\n+\n+pub struct SettlementCommand {\n+    pub vote: VoteData,\n+    pub event: Event,\n+    pub reply: oneshot::Sender<Result<(), String>>,\n+}\n+\n+#[derive(Clone)]\n+pub struct SettlementClient {\n+    tx: mpsc::Sender<SettlementCommand>,\n+}\n+\n+impl SettlementClient {\n+    pub fn spawn(group: Arc<RwLock<GroupState>>, event_log: Arc<EventLog>) -> Self {\n+        let (tx, rx) = mpsc::channel(64);\n+        tokio::spawn(settlement_worker(rx, group, event_log));\n+        Self { tx }\n+    }\n+\n+    pub async fn record_vote(&self, vote: VoteData, event: Event) -> Result<(), String> {\n+        let (reply, rx) = oneshot::channel();\n+        self.tx\n+            .send(SettlementCommand {\n+                vote,\n+                event,\n+                reply,\n+            })\n+            .await\n+            .map_err(|_| \"settlement worker stopped\".to_string())?;\n+        rx.await\n+            .map_err(|_| \"settlement worker stopped\".to_string())?\n+    }\n+}\n+\n+async fn settlement_worker(\n+    mut rx: mpsc::Receiver<SettlementCommand>,\n+    group: Arc<RwLock<GroupState>>,\n+    event_log: Arc<EventLog>,\n+) {\n+    while let Some(first) = rx.recv().await {\n+        let mut batch = vec![first];\n+        while let Ok(more) = rx.try_recv() {\n+            batch.push(more);\n+        }\n+\n+        let mut disk_err: Option<String> = None;\n+        for cmd in &batch {\n+            if let Err(e) = event_log.append(&cmd.event).await {\n+                disk_err = Some(e.to_string());\n+                break;\n+            }\n+        }\n+\n+        if let Some(err) = disk_err {\n+            for cmd in batch {\n+                let _ = cmd.reply.send(Err(err.clone()));\n+            }\n+            continue;\n+        }\n+\n+        let (edges, n) = {\n+            let mut w = group.write().await;\n+            for cmd in &batch {\n+                w.apply_vote(cmd.vote.clone());\n+            }\n+            (w.edges.clone(), w.idx_to_item.len())\n+        };\n+\n+        let new_scores = compute_scores_from_edges(\n+            n,\n+            edges.iter().map(|(&k, &v)| (k, v)),\n+            MAX_ITERS,\n+            TOL,\n+        );\n+\n+        {\n+            let mut w = group.write().await;\n+            w.cached_scores = new_scores;\n+            w.dirty = false;\n+        }\n+\n+        for cmd in batch {\n+            let _ = cmd.reply.send(Ok(()));\n+        }\n+    }\n+}\n+\n+/// Compute ranking cache from current in-memory edges (startup replay only).\n+pub fn warm_ranking_cache(group: &mut GroupState) {\n+    if !group.dirty {\n+        return;\n+    }\n+    let n = group.idx_to_item.len();\n+    group.cached_scores = compute_scores_from_edges(\n+        n,\n+        group.edges.iter().map(|(&k, &v)| (k, v)),\n+        MAX_ITERS,\n+        TOL,\n+    );\n+    group.dirty = false;\n+}\ndiff --git a/server/src/state.rs b/server/src/state.rs\nindex 8ec9902e2ecc31cf8208f7ad6365891dc5537eed..1922541a4064c2de1df2d993a461cae783320e05 100644\n--- a/server/src/state.rs\n+++ b/server/src/state.rs\n@@ -6,6 +6,7 @@ use crate::{\n     event_log::EventLog,\n     events::Event,\n     reducer::{GroupState, VoteData},\n+    settlement::{warm_ranking_cache, SettlementClient},\n     views::ViewStore,\n };\n \n@@ -38,8 +39,8 @@ pub struct AppState {\n     pub cfg: Arc<AppConfig>,\n     pub event_log: Arc<EventLog>,\n     pub views: ViewStore,\n-    pub demo_counter: Arc<RwLock<u64>>,\n     pub group: Arc<RwLock<GroupState>>,\n+    settlement: SettlementClient,\n }\n \n impl AppState {\n@@ -48,14 +49,10 @@ impl AppState {\n         let views_path = format!(\"{}/views.json\", cfg.data_dir);\n         let views = ViewStore::new(&views_path);\n \n-        let mut demo_counter: u64 = 0;\n         let mut group = GroupState::new();\n         if let Ok((events, _)) = event_log.load_all().await {\n             for ev in events {\n                 match ev {\n-                    Event::DemoCounterBumped { value, .. } => {\n-                        demo_counter = demo_counter.max(value);\n-                    }\n                     Event::VoteRecorded {\n                         ts,\n                         a,\n@@ -74,30 +71,20 @@ impl AppState {\n             }\n         }\n \n+        warm_ranking_cache(&mut group);\n+\n+        let group = Arc::new(RwLock::new(group));\n+        let settlement = SettlementClient::spawn(group.clone(), event_log.clone());\n+\n         Self {\n             cfg: Arc::new(cfg),\n             event_log,\n             views,\n-            demo_counter: Arc::new(RwLock::new(demo_counter)),\n-            group: Arc::new(RwLock::new(group)),\n+            group,\n+            settlement,\n         }\n     }\n \n-    pub async fn bump_demo_counter(&self) -> u64 {\n-        let mut guard = self.demo_counter.write().await;\n-        *guard += 1;\n-        let value = *guard;\n-        drop(guard);\n-\n-        let ts = crate::html::now_ms();\n-        let _ = self\n-            .event_log\n-            .append(&Event::DemoCounterBumped { ts, value })\n-            .await;\n-\n-        value\n-    }\n-\n     pub async fn record_vote(\n         &self,\n         a: &str,\n@@ -109,23 +96,14 @@ impl AppState {\n         let vote = VoteData::from_recorded(ts, a, b, ratio_left, ratio_right)\n             .ok_or_else(|| \"invalid vote: need two distinct non-empty items\".to_string())?;\n \n-        {\n-            let mut group = self.group.write().await;\n-            group.apply_vote(vote.clone());\n-        }\n-\n-        let _ = self\n-            .event_log\n-            .append(&Event::VoteRecorded {\n-                ts,\n-                a: vote.a.as_str().to_string(),\n-                b: vote.b.as_str().to_string(),\n-                ratio_left: vote.ratio_left,\n-                ratio_right: vote.ratio_right,\n-            })\n-            .await\n-            .map_err(|e| e.to_string())?;\n+        let event = Event::VoteRecorded {\n+            ts,\n+            a: vote.a.as_str().to_string(),\n+            b: vote.b.as_str().to_string(),\n+            ratio_left: vote.ratio_left,\n+            ratio_right: vote.ratio_right,\n+        };\n \n-        Ok(())\n+        self.settlement.record_vote(vote, event).await\n     }\n }\ndiff --git a/server/src/ui_action.rs b/server/src/ui_action.rs\nindex 1d488e1ad1d8fd81bd9d016d69255adfe9b22fc8..5d94c84113607b3bcd8d31d03ef5b8e1b87b67a7 100644\n--- a/server/src/ui_action.rs\n+++ b/server/src/ui_action.rs\n@@ -12,8 +12,6 @@ pub const UI_RPC_FIELD: &str = \"__rpc__\";\n #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]\n #[serde(tag = \"action\", rename_all = \"snake_case\")]\n pub enum HtmlUiAction {\n-    /// Demo: morph `#demo-counter-panel` after bumping the persisted counter.\n-    BumpDemoCounter,\n     /// Record a pairwise vote and morph `#ranking-panel`.\n     RecordVote {\n         a: String,\n@@ -52,18 +50,6 @@ pub fn parse_html_ui_from_form(\n mod tests {\n     use super::*;\n \n-    #[test]\n-    fn bump_demo_counter_round_trip() {\n-        let template = serde_json::json!({ \"action\": \"bump_demo_counter\" });\n-        let mut form = HashMap::new();\n-        form.insert(\n-            UI_RPC_FIELD.to_string(),\n-            serde_json::to_string(&template).unwrap(),\n-        );\n-        let a = parse_html_ui_from_form(&form).unwrap();\n-        assert_eq!(a, HtmlUiAction::BumpDemoCounter);\n-    }\n-\n     #[test]\n     fn record_vote_round_trip_with_form_holes() {\n         let template = serde_json::json!({\ndiff --git a/server/tests/integration_health.rs b/server/tests/integration_health.rs\nindex 8a58bc14aac68c779e7ce4ffa57d27b3220e9953..1d816e008b9bf629967e3b3c786c41afefc284e3 100644\n--- a/server/tests/integration_health.rs\n+++ b/server/tests/integration_health.rs\n@@ -38,7 +38,7 @@ async fn healthz_ok() {\n }\n \n #[tokio::test]\n-async fn home_has_demo_panel() {\n+async fn home_has_main_panels() {\n     let (addr, _tmp) = start_test_server().await;\n     let client = reqwest::Client::new();\n     let html = client\ndiff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs\nindex bee79407dec120699a083f1a75adf9291e207fc7..7ede46d681fefbe25b1d98fc33520a185515eb1c 100644\n--- a/server/tests/integration_ui.rs\n+++ b/server/tests/integration_ui.rs\n@@ -25,33 +25,6 @@ async fn start_test_server() -> (SocketAddr, TempDir) {\n     (addr, tmp)\n }\n \n-#[tokio::test]\n-async fn post_ui_bump_returns_javascript_morph() {\n-    let (addr, tmp) = start_test_server().await;\n-    let rpc = serde_json::json!({ \"action\": \"bump_demo_counter\" }).to_string();\n-    let mut form = HashMap::new();\n-    form.insert(UI_RPC_FIELD.to_string(), rpc);\n-\n-    let client = reqwest::Client::new();\n-    let body = client\n-        .post(format!(\"http://{addr}/ui\"))\n-        .form(&form)\n-        .send()\n-        .await\n-        .unwrap()\n-        .text()\n-        .await\n-        .unwrap();\n-\n-    assert!(body.contains(\"Idiomorph.morph\"));\n-    assert!(body.contains(\"demo-counter-panel\"));\n-    assert!(body.contains(\"Counter:\"));\n-\n-    let log_path = tmp.path().join(\"events.jsonl\");\n-    let log = std::fs::read_to_string(log_path).unwrap();\n-    assert!(log.contains(\"demo_counter_bumped\"));\n-}\n-\n #[tokio::test]\n async fn post_ui_record_vote_morphs_ranking_and_persists() {\n     let (addr, tmp) = start_test_server().await;\n@@ -90,8 +63,8 @@ async fn post_ui_record_vote_morphs_ranking_and_persists() {\n         port: 0,\n     };\n     let state = create_app_state(cfg).await;\n-    let mut group = state.group.write().await;\n-    let ranked = sorter2_server::ranking::ranked_items(&mut group, 10_000, 1e-8);\n+    let group = state.group.read().await;\n+    let ranked = sorter2_server::ranking::ranked_items_cached(&group);\n     assert_eq!(ranked.len(), 2);\n     assert_eq!(ranked[0].item.as_str(), \"alpha\");\n }\ndiff --git a/test/smoke.clj b/test/smoke.clj\nindex b332324743b58baf3fe96d7477353749f137feae..11887c48282088e140d823a88ba616f6325835b3 100644\n--- a/test/smoke.clj\n+++ b/test/smoke.clj\n@@ -26,7 +26,7 @@\n             false))))))\n \n (deftest http-smoke-against-running-server\n-  (testing \"build, start, healthz, home contains RPC demo\"\n+  (testing \"build, start, healthz, home contains main panels\"\n     (let [root (repo-root)\n           data-dir (.getAbsolutePath (doto (io/file (System/getProperty \"java.io.tmpdir\")\n                                                    (str \"sorter2-smoke-\" (System/currentTimeMillis)))\n\n\nSide B — contributor: tommy-mor\nSide B — commit message:\n[08565bea] Tokenize prose refs for garden URL links (#147)\n\n* Tokenize prose refs for garden URL links\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n* Stop prose URLs at line boundaries\n\nCo-authored-by: tommy <thmorriss@gmail.com>\n\n* Require braced DSL item bodies\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/server/src/dsl.rs b/server/src/dsl.rs\nindex 4203c2f59dd8825d7a91513c4023f3ccd37f1efc..b3c785674560a0b42a7f4c3aa13d80cd350f485b 100644\n--- a/server/src/dsl.rs\n+++ b/server/src/dsl.rs\n@@ -1,7 +1,5 @@\n use std::collections::HashMap;\n \n-use rand::Rng;\n-\n /// Parsed DSL document.\n #[derive(Debug, Clone, PartialEq, Eq)]\n pub struct Document {\n@@ -39,31 +37,57 @@ pub enum DslError {\n /// Matches the legacy Python parser behavior:\n /// - Supports toggle markers (open == close), e.g. ```...```\n /// - Supports nested markers (open != close), e.g. { ... { ... } ... }\n+#[derive(Debug, Clone, Copy, PartialEq, Eq)]\n+pub enum BlockKind {\n+    CodeFence,\n+    DoubleBrace,\n+    Brace,\n+}\n+\n+#[derive(Debug, Clone, PartialEq, Eq)]\n+struct MaskedBlock {\n+    kind: BlockKind,\n+}\n+\n #[derive(Debug, Default, Clone)]\n pub struct BlockMasker {\n     pub replacements: HashMap<String, String>,\n+    blocks: HashMap<String, MaskedBlock>,\n+    next_id: u32,\n }\n \n impl BlockMasker {\n     pub fn new() -> Self {\n         Self {\n             replacements: HashMap::new(),\n+            blocks: HashMap::new(),\n+            next_id: 0,\n         }\n     }\n \n-    fn new_token(&mut self) -> String {\n-        let mut rng = rand::thread_rng();\n-        let n: u32 = rng.gen();\n-        let token = format!(\"__BLOCK_{:08x}__\", n);\n-        // Extremely unlikely collision; if it happens, regenerate.\n-        if self.replacements.contains_key(&token) {\n-            return self.new_token();\n+    fn new_token(&mut self, haystack: &str) -> String {\n+        loop {\n+            let token = format!(\"__BLOCK_{:08x}__\", self.next_id);\n+            self.next_id = self.next_id.wrapping_add(1);\n+            if !self.replacements.contains_key(&token) && !haystack.contains(&token) {\n+                return token;\n+            }\n         }\n-        token\n     }\n \n     /// Replace outermost balanced blocks with tokens.\n     pub fn mask(&mut self, text: &str, open_marker: &str, close_marker: &str) -> String {\n+        self.mask_kind(text, open_marker, close_marker, BlockKind::Brace)\n+    }\n+\n+    /// Replace outermost balanced blocks with typed deterministic tokens.\n+    pub fn mask_kind(\n+        &mut self,\n+        text: &str,\n+        open_marker: &str,\n+        close_marker: &str,\n+        kind: BlockKind,\n+    ) -> String {\n         if text.is_empty() {\n             return text.to_string();\n         }\n@@ -97,9 +121,10 @@ impl BlockMasker {\n                     // Found end of outermost block\n                     let s = start_idx.max(0) as usize;\n                     let original_block = &text[s..i];\n-                    let token = self.new_token();\n+                    let token = self.new_token(text);\n                     self.replacements\n                         .insert(token.clone(), original_block.to_string());\n+                    self.blocks.insert(token.clone(), MaskedBlock { kind });\n                     result_parts.push(token);\n                     current_idx = i;\n                 }\n@@ -176,13 +201,22 @@ impl BlockMasker {\n         }\n         token.to_string()\n     }\n+\n+    pub fn block_kind(&self, token: &str) -> Option<BlockKind> {\n+        self.blocks.get(token).map(|b| b.kind)\n+    }\n }\n \n fn mask_all(mut masker: BlockMasker, text: &str) -> (BlockMasker, String) {\n     // Mask hierarchy: Code -> Double Brace -> Single Brace.\n-    let t = masker.mask(text, \"```\", \"```\");\n-    let t = masker.mask(&t, \"{{\", \"}}\");\n-    let t = masker.mask(&t, \"{\", \"}\");\n+    let t = masker.mask_kind(text, \"```\", \"```\", BlockKind::CodeFence);\n+    let t = masker.mask_kind(&t, \"{{\", \"}}\", BlockKind::DoubleBrace);\n+    let t = masker.mask_kind(&t, \"{\", \"}\", BlockKind::Brace);\n+    (masker, t)\n+}\n+\n+fn mask_code_fences(mut masker: BlockMasker, text: &str) -> (BlockMasker, String) {\n+    let t = masker.mask_kind(text, \"```\", \"```\", BlockKind::CodeFence);\n     (masker, t)\n }\n \n@@ -253,7 +287,34 @@ fn skip_ws(s: &str, mut i: usize) -> usize {\n     i\n }\n \n-fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n+#[derive(Debug, Clone, PartialEq, Eq)]\n+pub enum ProseToken {\n+    Text(String),\n+    ItemRef(String),\n+}\n+\n+fn trim_prose_item_ref_end(s: &str, mut end: usize) -> usize {\n+    while end > 0 {\n+        let Some((idx, c)) = s[..end].char_indices().next_back() else {\n+            break;\n+        };\n+        if matches!(\n+            c,\n+            '.' | ',' | ';' | ':' | '!' | '?' | ')' | ']' | '}' | '\"' | '\\''\n+        ) {\n+            end = idx;\n+        } else {\n+            break;\n+        }\n+    }\n+    end\n+}\n+\n+fn parse_item_name_at_with_mode(\n+    s: &str,\n+    i: usize,\n+    trim_trailing_punctuation: bool,\n+) -> Option<(String, usize)> {\n     let bytes = s.as_bytes();\n     if i >= bytes.len() {\n         return None;\n@@ -263,6 +324,9 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n     if s[i..].starts_with(\"https://\") || s[i..].starts_with(\"http://\") {\n         let mut j = i;\n         while j < bytes.len() {\n+            if trim_trailing_punctuation && bytes[j] == b'\\n' {\n+                break;\n+            }\n             if bytes[j..].starts_with(b\"__BLOCK_\") || is_ws_byte(bytes[j]) {\n                 break;\n             }\n@@ -271,6 +335,12 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n         if j <= i {\n             return None;\n         }\n+        if trim_trailing_punctuation {\n+            j = trim_prose_item_ref_end(s, j);\n+            if j <= i {\n+                return None;\n+            }\n+        }\n         return Some((s[i..j].to_string(), j));\n     }\n \n@@ -296,6 +366,12 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n         if j <= i + 2 {\n             return None;\n         }\n+        if trim_trailing_punctuation {\n+            j = trim_prose_item_ref_end(s, j);\n+            if j <= i + 2 {\n+                return None;\n+            }\n+        }\n         let raw = &s[i..j];\n         if !is_item_name(raw) {\n             return None;\n@@ -336,6 +412,46 @@ fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n     Some((format!(\"~/{}\", name), j))\n }\n \n+fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {\n+    parse_item_name_at_with_mode(s, i, false)\n+}\n+\n+pub fn parse_prose_item_ref_at(s: &str, i: usize) -> Option<(String, usize)> {\n+    parse_item_name_at_with_mode(s, i, true)\n+}\n+\n+pub fn tokenize_prose_item_refs(text: &str) -> Vec<ProseToken> {\n+    if text.is_empty() {\n+        return Vec::new();\n+    }\n+    let (masker, masked) = mask_code_fences(BlockMasker::new(), text);\n+    let mut tokens = Vec::new();\n+    let mut text_start = 0usize;\n+    let mut i = 0usize;\n+\n+    while i < masked.len() {\n+        if let Some((raw, end)) = parse_prose_item_ref_at(&masked, i) {\n+            if text_start < i {\n+                tokens.push(ProseToken::Text(masker.unmask(&masked[text_start..i])));\n+            }\n+            tokens.push(ProseToken::ItemRef(masker.unmask(&raw)));\n+            i = end;\n+            text_start = i;\n+            continue;\n+        }\n+\n+        let Some((_, c)) = masked[i..].char_indices().next() else {\n+            break;\n+        };\n+        i += c.len_utf8();\n+    }\n+\n+    if text_start < masked.len() {\n+        tokens.push(ProseToken::Text(masker.unmask(&masked[text_start..])));\n+    }\n+    tokens\n+}\n+\n fn parse_block_token_at(s: &str, i: usize) -> Option<(String, usize)> {\n     let bytes = s.as_bytes();\n     if i >= bytes.len() {\n@@ -401,6 +517,12 @@ fn parse_block_prefixed_statement(\n     tail: &str,\n     masker: &BlockMasker,\n ) -> Result<Stmt, DslError> {\n+    if masker.block_kind(block_token) == Some(BlockKind::CodeFence) {\n+        return Err(DslError::Parse(\n+            \"vote explanations must use `{ ... }`; code fences belong inside body blocks\"\n+                .to_string(),\n+        ));\n+    }\n     // vote: block item_ref comparison item_ref\n     let s = tail.trim_start();\n     if s.is_empty() {\n@@ -462,6 +584,11 @@ fn parse_item_definition_statement(stripped: &str, masker: &BlockMasker) -> Resu\n     }\n \n     if let Some((tok, end)) = parse_block_token_at(stripped, i) {\n+        if masker.block_kind(&tok) == Some(BlockKind::CodeFence) {\n+            return Err(DslError::Parse(\n+                \"item bodies must use `{ ... }`; code fences belong inside body blocks\".to_string(),\n+            ));\n+        }\n         let body = masker.extract_body(&tok);\n         let tail = stripped[end..].trim();\n         if !tail.is_empty() {\n@@ -572,6 +699,10 @@ pub fn parse_full(text: &str) -> Result<Document, DslError> {\n \n             if let Some((tok, end)) = parse_block_token_at(stripped, 0) {\n                 if stripped[end..].trim().is_empty() {\n+                    if masker.block_kind(&tok) == Some(BlockKind::CodeFence) {\n+                        prose_buffer.push(line);\n+                        continue;\n+                    }\n                     pending_block = Some(tok);\n                     continue;\n                 }\n@@ -619,6 +750,70 @@ mod tests {\n         assert_eq!(roundtrip, input);\n     }\n \n+    #[test]\n+    fn blockmasker_tokens_are_deterministic_and_typed() {\n+        let input = \"x ```code``` y {body}\";\n+        let (masker, masked) = mask_all(BlockMasker::new(), input);\n+        assert!(masked.contains(\"__BLOCK_00000000__\"));\n+        assert!(masked.contains(\"__BLOCK_00000001__\"));\n+        assert_eq!(\n+            masker.block_kind(\"__BLOCK_00000000__\"),\n+            Some(BlockKind::CodeFence)\n+        );\n+        assert_eq!(\n+            masker.block_kind(\"__BLOCK_00000001__\"),\n+            Some(BlockKind::Brace)\n+        );\n+        assert_eq!(masker.unmask(&masked), input);\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_finds_tilde_dash_and_raw_url_refs() {\n+        let tokens =\n+            tokenize_prose_item_refs(\"see ~/a/b then -/example.com/x and https://Example.com/A/B.\");\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::Text(\"see \".to_string()),\n+                ProseToken::ItemRef(\"~/a/b\".to_string()),\n+                ProseToken::Text(\" then \".to_string()),\n+                ProseToken::ItemRef(\"-/example.com/x\".to_string()),\n+                ProseToken::Text(\" and \".to_string()),\n+                ProseToken::ItemRef(\"https://Example.com/A/B\".to_string()),\n+                ProseToken::Text(\".\".to_string()),\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_stops_raw_urls_at_newlines() {\n+        let tokens = tokenize_prose_item_refs(\"https://example.com/a/b.\\n-/example.com/a/b\");\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::ItemRef(\"https://example.com/a/b\".to_string()),\n+                ProseToken::Text(\".\\n\".to_string()),\n+                ProseToken::ItemRef(\"-/example.com/a/b\".to_string()),\n+            ]\n+        );\n+    }\n+\n+    #[test]\n+    fn prose_tokenizer_does_not_linkify_inside_code_fences() {\n+        let tokens = tokenize_prose_item_refs(\n+            \"before ```json\\n{\\\"url\\\":\\\"https://example.com\\\"}\\n``` after ~/x\",\n+        );\n+        assert_eq!(\n+            tokens,\n+            vec![\n+                ProseToken::Text(\n+                    \"before ```json\\n{\\\"url\\\":\\\"https://example.com\\\"}\\n``` after \".to_string()\n+                ),\n+                ProseToken::ItemRef(\"~/x\".to_string()),\n+            ]\n+        );\n+    }\n+\n     #[test]\n     fn parse_item_with_body_strips_outer_braces() {\n         let input = \"~/rust { Systems language }\";\n@@ -633,8 +828,8 @@ mod tests {\n     }\n \n     #[test]\n-    fn parse_item_with_fenced_json_body_preserves_braces() {\n-        let input = \"~/item/in/url ```json\\n{\\\"test\\\": true}\\n```\";\n+    fn parse_item_with_braced_fenced_json_body_preserves_braces() {\n+        let input = \"~/item/in/url {\\n```json\\n{\\\"test\\\": true}\\n```\\n}\";\n         let doc = parse_full(input).unwrap();\n         assert_eq!(\n             doc.statements,\n@@ -645,6 +840,51 @@ mod tests {\n         );\n     }\n \n+    #[test]\n+    fn parse_rejects_singleton_fenced_json_item_body() {\n+        let input = \"~/item/in/url ```json\\n{\\\"test\\\": true}\\n```\";\n+        let err = parse_full(input).unwrap_err().to_string();\n+        assert!(\n+            err.contains(\"item bodies must use\"),\n+            \"unexpected error: {err}\"\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_keeps_standalone_code_fence_as_prose() {\n+        let input = \"```json\\n{\\\"test\\\": true}\\n```\";\n+        let doc = parse_full(input).unwrap();\n+        assert_eq!(\n+            doc.statements,\n+            vec![Stmt::Prose {\n+                text: input.to_string(),\n+            }]\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_rejects_code_fence_vote_explanation() {\n+        let input = \"```json\\n{\\\"why\\\": true}\\n```\\n~/a 2:1 ~/b\";\n+        let err = parse_full(input).unwrap_err().to_string();\n+        assert!(\n+            err.contains(\"vote explanations must start\"),\n+            \"unexpected error: {err}\"\n+        );\n+    }\n+\n+    #[test]\n+    fn parse_raw_url_item_with_braced_fenced_json_body() {\n+        let input = \"https://example.com/itembody/slug {\\n```json\\n{\\\"test\\\": true}\\n```\\n}\";\n+        let doc = parse_full(input).unwrap();\n+        assert_eq!(\n+            doc.statements,\n+            vec![Stmt::Item {\n+                title: \"https://example.com/itembody/slug\".to_string(),\n+                body: Some(\"```json\\n{\\\"test\\\": true}\\n```\".to_string()),\n+            }]\n+        );\n+    }\n+\n     #[test]\n     fn parse_vote_ratio_and_symbols() {\n         let d1 = parse_full(\"{because}\\n~/a 3:1 ~/b\").unwrap();\ndiff --git a/server/src/external_resolver.rs b/server/src/external_resolver.rs\nindex 8481f1fbff1c4265da182a225f539f97d6829002..04bc3de32b6df1aefe197d942db67de2cbdbde4f 100644\n--- a/server/src/external_resolver.rs\n+++ b/server/src/external_resolver.rs\n@@ -256,7 +256,7 @@ fn children_to_dsl(children: &[ResolvedChild]) -> String {\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\", child.url, body.trim()));\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@@ -378,7 +378,8 @@ mod tests {\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 ```json\"));\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 }\ndiff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs\nindex 3e949ce2cb70de3f024f46af773a93f3f8852260..e48612d7d3c4df52c161499a11865d4caca607aa 100644\n--- a/server/src/html/breadcrumb_path.rs\n+++ b/server/src/html/breadcrumb_path.rs\n@@ -88,16 +88,12 @@ impl ExternalOntologyPath {\n             .filter(|x| !x.is_empty())\n             .map(|x| x.to_string())\n             .collect();\n-        let segments = if segments == [\".\"] {\n-            vec![]\n-        } else {\n-            segments\n-        };\n+        let segments = if segments == [\".\"] { vec![] } else { segments };\n         Self { item, segments }\n     }\n \n     pub(super) fn is_root(&self) -> bool {\n-        self.segments.len() <= 1\n+        self.segments.is_empty()\n     }\n \n     pub(super) fn segments(&self) -> &[String] {\n@@ -108,3 +104,28 @@ impl ExternalOntologyPath {\n         self.item.as_str()\n     }\n }\n+\n+#[cfg(test)]\n+mod tests {\n+    use super::*;\n+\n+    #[test]\n+    fn external_root_and_host_paths_are_distinct() {\n+        let root = ExternalOntologyPath::from_input(\"\");\n+        assert!(root.is_root());\n+        assert!(root.segments().is_empty());\n+\n+        let host = ExternalOntologyPath::from_input(\"example.com\");\n+        assert!(!host.is_root());\n+        assert_eq!(host.segments(), &[\"example.com\".to_string()]);\n+    }\n+\n+    #[test]\n+    fn external_path_keeps_each_url_segment_for_breadcrumbs() {\n+        let path = ExternalOntologyPath::from_input(\"https://example.com/a/b\");\n+        assert_eq!(\n+            path.segments(),\n+            &[\"example.com\".to_string(), \"a\".to_string(), \"b\".to_string()]\n+        );\n+    }\n+}\ndiff --git a/server/src/html/mod.rs b/server/src/html/mod.rs\nindex 8876a1a00a16ee3bf7a371f7a5ca27b5862b62cc..d5877eeb3632ed5d770f23a04cb4d1881209bc74 100644\n--- a/server/src/html/mod.rs\n+++ b/server/src/html/mod.rs\n@@ -20,27 +20,30 @@ mod search;\n pub mod ui_action;\n use breadcrumb_path::{ExternalOntologyPath, OntologyPath};\n \n-pub use auth::{auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment, choose_username_page};\n+pub use auth::{\n+    auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment,\n+    choose_username_page,\n+};\n pub use editor::{editor_check, editor_page};\n pub use forum::{\n     home, room_page, room_thread_post_view, room_thread_view, thread_feed_html,\n     thread_feed_html_for_room, thread_feed_region_markup, thread_post_view, thread_view, ThreadNav,\n };\n \n+pub use forum::user_profile_page;\n pub(crate) use forum::{\n     fragment_new_thread_slot, login_to_post_hint_markup, room_members_section_markup,\n     thread_ui_collapse_redacted_post, thread_ui_expand_post_full, thread_ui_expand_redacted_post,\n     user_can_post_room, user_can_view_room,\n };\n+pub(crate) use garden::{encode_pin_cookie_value, vote_compare_post_success_js, GARDEN_PIN_COOKIE};\n pub use garden::{\n     external_garden_index, external_ontology_path, garden_index, ontology_path,\n-    room_external_garden_index, room_external_ontology_path, room_garden_index,\n-    room_ontology_path, room_vote_compare_page, vote_compare_page,\n+    room_external_garden_index, room_external_ontology_path, room_garden_index, room_ontology_path,\n+    room_vote_compare_page, vote_compare_page,\n };\n-pub(crate) use garden::{encode_pin_cookie_value, vote_compare_post_success_js, GARDEN_PIN_COOKIE};\n pub use routing::RouteContext;\n pub use search::{search_page, search_results_fragment};\n-pub use forum::user_profile_page;\n pub use ui_action::{parse_html_ui_from_form, HtmlUiAction, HtmlUiParseError, UI_RPC_FIELD};\n \n /// Public profile URL path for a stored username (no `@`).\n@@ -107,8 +110,8 @@ pub struct ThemeForm {\n pub async fn post_theme(Form(form): Form<ThemeForm>) -> impl IntoResponse {\n     let theme = normalize_theme(&form.theme);\n     let next = sanitize_theme_next(form.next.as_deref());\n-    let loc = HeaderValue::try_from(next.as_str())\n-        .unwrap_or_else(|_| HeaderValue::from_static(\"/\"));\n+    let loc =\n+        HeaderValue::try_from(next.as_str()).unwrap_or_else(|_| HeaderValue::from_static(\"/\"));\n     Response::builder()\n         .status(StatusCode::SEE_OTHER)\n         .header(header::LOCATION, loc)\n@@ -179,7 +182,9 @@ pub(crate) struct JsQueryBuilder {\n \n impl JsBuilder {\n     pub(crate) fn new() -> Self {\n-        Self { snippets: Vec::new() }\n+        Self {\n+            snippets: Vec::new(),\n+        }\n     }\n \n     pub(crate) fn morph_selector(self, selector: &str, markup: Markup) -> Self {\n@@ -195,7 +200,12 @@ impl JsBuilder {\n         self.qs(selector).morph_inner(markup)\n     }\n \n-    pub(crate) fn morph_expr(mut self, expr: &str, markup: Markup, morph_style: Option<&str>) -> Self {\n+    pub(crate) fn morph_expr(\n+        mut self,\n+        expr: &str,\n+        markup: Markup,\n+        morph_style: Option<&str>,\n+    ) -> Self {\n         let html = js_string_literal(&markup.into_string());\n         let opts = morph_style\n             .map(|style| format!(\", {{morphStyle: {}}}\", js_string_literal(style)))\n@@ -217,7 +227,11 @@ impl JsBuilder {\n         self.qs(&format!(\"#{id}\"))\n     }\n \n-    pub(crate) fn if_current_path_matches(mut self, path: &str, f: impl FnOnce(JsBuilder) -> JsBuilder) -> Self {\n+    pub(crate) fn if_current_path_matches(\n+        mut self,\n+        path: &str,\n+        f: impl FnOnce(JsBuilder) -> JsBuilder,\n+    ) -> Self {\n         let inner = f(JsBuilder::new()).build();\n         self.snippets.push(format!(\n             \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0) {{ {inner} }}\",\n@@ -226,7 +240,11 @@ impl JsBuilder {\n         self\n     }\n \n-    pub(crate) fn if_current_path_not_matches(mut self, path: &str, f: impl FnOnce(JsBuilder) -> JsBuilder) -> Self {\n+    pub(crate) fn if_current_path_not_matches(\n+        mut self,\n+        path: &str,\n+        f: impl FnOnce(JsBuilder) -> JsBuilder,\n+    ) -> Self {\n         let inner = f(JsBuilder::new()).build();\n         self.snippets.push(format!(\n             \"var __slugHere = window.location.pathname + window.location.search; var __slugPath = {path}; if (!(__slugHere === __slugPath || __slugHere.indexOf(__slugPath + '?') === 0)) {{ {inner} }}\",\n@@ -301,7 +319,17 @@ pub(super) fn layout(\n     garden_room_wire: Option<&str>,\n     garden_path_prefix: Option<&str>,\n ) -> Markup {\n-    layout_embed_controls(title, view, body, views, theme, theme_next, garden_room_wire, garden_path_prefix, true)\n+    layout_embed_controls(\n+        title,\n+        view,\n+        body,\n+        views,\n+        theme,\n+        theme_next,\n+        garden_room_wire,\n+        garden_path_prefix,\n+        true,\n+    )\n }\n \n /// Minimal document shell: no bottom controls, no garden HUD data attributes (`data-garden-room` /\n@@ -315,15 +343,7 @@ pub(super) fn layout_full_bleed_chromeless(\n     theme_next: &str,\n ) -> Markup {\n     layout_embed_controls(\n-        title,\n-        view,\n-        body,\n-        views,\n-        theme,\n-        theme_next,\n-        None,\n-        None,\n-        false,\n+        title, view, body, views, theme, theme_next, None, None, false,\n     )\n }\n \n@@ -545,7 +565,58 @@ fn item_body_title_snippet(body: &str) -> Option<String> {\n     Some(format!(\"{truncated}{ellipsis}\"))\n }\n \n-/// Replace ~/path slugs in raw text with clickable links.\n+fn garden_href_for_item_ref(\n+    raw_ref: &str,\n+    garden_prefix: &str,\n+) -> Option<(crate::path_types::ItemId, String)> {\n+    let key = slug_types::canonicalize_item(raw_ref);\n+    let id = crate::path_types::ItemId::parse(&key)?;\n+    let href = if let Some(tail) = id.tilde_tail() {\n+        if tail.is_empty() {\n+            garden_prefix.trim_end_matches('/').to_string()\n+        } else {\n+            format!(\"{}/{}\", garden_prefix.trim_end_matches('/'), tail)\n+        }\n+    } else if id.as_str().starts_with(\"https://\") || id.as_str().starts_with(\"http://\") {\n+        let display = id.display_path();\n+        let rest = display.strip_prefix(\"-/\").unwrap_or(display.as_str());\n+        let ext_prefix = format!(\"{}-\", garden_prefix.trim_end_matches('~'));\n+        format!(\"{}/{}\", ext_prefix, rest)\n+    } else {\n+        return None;\n+    };\n+    Some((id, href))\n+}\n+\n+fn push_item_ref_anchor(\n+    out: &mut String,\n+    raw_ref: &str,\n+    garden_prefix: &str,\n+    item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n+) -> bool {\n+    let Some((id, href)) = garden_href_for_item_ref(raw_ref, garden_prefix) else {\n+        return false;\n+    };\n+    out.push_str(r#\"<a href=\"\"#);\n+    out.push_str(&escape_html(&href));\n+    out.push('\"');\n+    out.push_str(r#\" class=\"pre-link\"\"#);\n+    if let Some(bodies) = item_bodies {\n+        if let Some(body) = bodies.get(&id) {\n+            if let Some(snippet) = item_body_title_snippet(body) {\n+                out.push_str(r#\" title=\"\"#);\n+                out.push_str(&escape_html(&snippet));\n+                out.push('\"');\n+            }\n+        }\n+    }\n+    out.push('>');\n+    out.push_str(&escape_html(raw_ref));\n+    out.push_str(\"</a>\");\n+    true\n+}\n+\n+/// Replace item refs in raw prose with clickable garden links.\n ///\n /// When `item_bodies` is set, matching ontology items get a `title` attribute with a truncated\n /// body preview for native browser tooltips (forum posts, item pages).\n@@ -554,53 +625,16 @@ pub(super) fn linkify_slugs_with_prefix(\n     garden_prefix: &str,\n     item_bodies: Option<&HashMap<crate::path_types::ItemId, String>>,\n ) -> String {\n-    let escaped = escape_html(raw);\n-    let mut out = String::with_capacity(escaped.len() + 64);\n-    let mut i = 0;\n-    let s = escaped.as_str();\n-    while i < s.len() {\n-        let rest = &s[i..];\n-        if let Some(after_tilde) = rest.strip_prefix(\"~/\") {\n-            let path_len = after_tilde\n-                .chars()\n-                .take_while(|c| c.is_ascii_alphanumeric() || *c == '_' || *c == '-' || *c == '/')\n-                .map(|c| c.len_utf8())\n-                .sum::<usize>();\n-            if path_len > 0 {\n-                let path = &after_tilde[..path_len];\n-                out.push_str(r#\"<a href=\"\"#);\n-                out.push_str(&escape_html(garden_prefix.trim_end_matches('/')));\n-                out.push('/');\n-                out.push_str(path);\n-                out.push('\"');\n-                out.push_str(r#\" class=\"pre-link\"\"#);\n-                if let Some(bodies) = item_bodies {\n-                    let tilde_ref = format!(\"~/{}\", path);\n-                    let key = slug_types::canonicalize_item(&tilde_ref);\n-                    if let Some(id) = crate::path_types::ItemId::parse(&key) {\n-                        if let Some(body) = bodies.get(&id) {\n-                            if let Some(snippet) = item_body_title_snippet(body) {\n-                                out.push_str(r#\" title=\"\"#);\n-                                out.push_str(&escape_html(&snippet));\n-                                out.push('\"');\n-                            }\n-                        }\n-                    }\n+    let mut out = String::with_capacity(raw.len() + 64);\n+    for token in crate::dsl::tokenize_prose_item_refs(raw) {\n+        match token {\n+            crate::dsl::ProseToken::Text(text) => out.push_str(&escape_html(&text)),\n+            crate::dsl::ProseToken::ItemRef(raw_ref) => {\n+                if !push_item_ref_anchor(&mut out, &raw_ref, garden_prefix, item_bodies) {\n+                    out.push_str(&escape_html(&raw_ref));\n                 }\n-                out.push('>');\n-                out.push_str(\"~/\");\n-                out.push_str(path);\n-                out.push_str(\"</a>\");\n-                i += 2 + path_len;\n-                continue;\n             }\n         }\n-        if let Some((j, c)) = rest.char_indices().next() {\n-            out.push(c);\n-            i += j + c.len_utf8();\n-        } else {\n-            break;\n-        }\n     }\n     out\n }\n@@ -638,7 +672,13 @@ fn spotify_embed_src(url: &str) -> Option<EmbedFrame> {\n     if !(host == \"open.spotify.com\" || host == \"www.open.spotify.com\") {\n         return None;\n     }\n-    let path = tail.split('#').next().unwrap_or(tail).split('?').next().unwrap_or(tail);\n+    let path = tail\n+        .split('#')\n+        .next()\n+        .unwrap_or(tail)\n+        .split('?')\n+        .next()\n+        .unwrap_or(tail);\n     let mut segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();\n     if segs.first().is_some_and(|s| s.starts_with(\"intl-\")) {\n         segs.remove(0);\n@@ -670,8 +710,16 @@ fn youtube_embed_src(url: &str) -> Option<EmbedFrame> {\n     let host = host.to_lowercase();\n \n     let video_id = if host == \"youtu.be\" || host == \"www.youtu.be\" {\n-        clean_media_id(tail.split(['?', '#']).next().unwrap_or(tail).trim_matches('/'))\n-    } else if matches!(host.as_str(), \"youtube.com\" | \"www.youtube.com\" | \"m.youtube.com\" | \"music.youtube.com\") {\n+        clean_media_id(\n+            tail.split(['?', '#'])\n+                .next()\n+                .unwrap_or(tail)\n+                .trim_matches('/'),\n+        )\n+    } else if matches!(\n+        host.as_str(),\n+        \"youtube.com\" | \"www.youtube.com\" | \"m.youtube.com\" | \"music.youtube.com\"\n+    ) {\n         let path = format!(\"/{}\", tail.split('#').next().unwrap_or(tail));\n         if path.starts_with(\"/watch\") {\n             clean_media_id(&query_param(url, \"v\")?)\n@@ -745,10 +793,7 @@ pub(super) fn render_linkified_with_embeds_in_scope(\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!(\n-        !s.contains('\\\\')\n-            && !s.contains('\\'')\n-            && !s.contains('\\n')\n-            && !s.contains('\\r'),\n+        !s.contains('\\\\') && !s.contains('\\'') && !s.contains('\\n') && !s.contains('\\r'),\n         \"cli_panel cmd must not contain `\\\\`, `'`, or newlines (got {s:?})\"\n     );\n }\n@@ -805,15 +850,40 @@ mod linkify_title_tests {\n         let mut bodies = HashMap::new();\n         let key = ItemId::parse(&slug_types::canonicalize_item(\"~/foo/bar\")).unwrap();\n         bodies.insert(key, \"Hello  world\\nline\".to_string());\n-        let html = linkify_slugs_with_prefix(\n-            \"see ~/foo/bar ok\",\n-            \"/r/x/~\",\n-            Some(&bodies),\n-        );\n+        let html = linkify_slugs_with_prefix(\"see ~/foo/bar ok\", \"/r/x/~\", Some(&bodies));\n         assert!(html.contains(\"title=\\\"Hello world line\\\"\"));\n         assert!(html.contains(\"href=\\\"/r/x/~/foo/bar\\\"\"));\n     }\n \n+    #[test]\n+    fn raw_url_links_to_public_external_garden_page() {\n+        let html = linkify_slugs_with_prefix(\"see https://example.com/z.\", \"/~\", None);\n+        assert!(html\n+            .contains(r#\"<a href=\"/-/example.com/z\" class=\"pre-link\">https://example.com/z</a>.\"#));\n+    }\n+\n+    #[test]\n+    fn dash_ref_links_to_room_external_garden_page_with_title() {\n+        let mut bodies = HashMap::new();\n+        let key = ItemId::parse(&slug_types::canonicalize_item(\"-/example.com/z\")).unwrap();\n+        bodies.insert(key, \"External body\\npreview\".to_string());\n+        let html =\n+            linkify_slugs_with_prefix(\"see -/example.com/z\", \"/r/9ab12cdroom/~\", Some(&bodies));\n+        assert!(html.contains(r#\"href=\"/r/9ab12cdroom/-/example.com/z\"\"#));\n+        assert!(html.contains(r#\"title=\"External body preview\"\"#));\n+    }\n+\n+    #[test]\n+    fn code_fence_urls_are_not_linkified() {\n+        let html = linkify_slugs_with_prefix(\n+            \"```json\\n{\\\"url\\\":\\\"https://example.com/z\\\"}\\n```\\nthen https://example.com/a\",\n+            \"/~\",\n+            None,\n+        );\n+        assert!(!html.contains(r#\"href=\"/-/example.com/z\"\"#));\n+        assert!(html.contains(r#\"href=\"/-/example.com/a\"\"#));\n+    }\n+\n     #[test]\n     fn no_title_when_body_missing_or_empty() {\n         let html = linkify_slugs_with_prefix(\"x ~/a/b y\", \"/~\", Some(&HashMap::new()));\n","role":"user"}],"model":"openai/gpt-chat-latest"}