{"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[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[595b3850] Fix star-topology ranking by using degree-based d_max (#146).\n\nA pure forward star at the default `>` ratio (2:1) produced uniform 1/3\nscores, and the alphabetical-fallback sort placed the unambiguous winner\nlast. Root cause: `compute_scores_from_edges` divided by the max sum of\npairwise-normalized weights, so every node ended up with P_ii = 0 — a\nbipartite Markov chain whose power iteration oscillated and, after the\nconfigured even iteration count, returned to the uniform initial state.\n\nSwitch the divisor to the unweighted max neighbor degree, matching the\ncanonical Rank Centrality definition in Negahban–Oh–Shah 2012 §3.1\n(arXiv:1209.1688, eq. defP and the d_max definition in §6). This gives\nevery non-saturated node a positive self-loop, makes the chain aperiodic,\nand converges the star to π_zebra = 1/2, π_alpha = π_beta = 1/4.\n\nAdd Rust regression test and a Clojure test that drives the sorterc\nbinary against four .sorter fixtures (star, inverse star, chain, cycle).\n\nCo-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>\n\nSide B — unified diff (full patch):\ndiff --git a/server/src/ranking.rs b/server/src/ranking.rs\nindex 3710c9f64437f5bef3b2121905b6f3bcb7611047..38e6d09b4370e5f8cbae09c0e5760b4e7f1ef7db 100644\n--- a/server/src/ranking.rs\n+++ b/server/src/ranking.rs\n@@ -1,4 +1,4 @@\n-use std::collections::HashMap;\n+use std::collections::{HashMap, HashSet};\n \n use crate::path_types::ItemId;\n use crate::reducer::GroupState;\n@@ -143,23 +143,35 @@ fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usiz\n         }\n     }\n \n+    // Rank Centrality (Negahban, Oh, Shah 2012, §3.1):\n+    //   P_ij = (1/d_max) * A_ij           for i ≠ j compared\n+    //   P_ii = 1 - (1/d_max) * Σ_k A_ik\n+    // where d_i is the *degree* (number of distinct neighbors compared) and\n+    // d_max = max_i d_i. Using the unweighted degree — not the sum of\n+    // pairwise-normalized weights — is what guarantees aperiodicity: it\n+    // forces P_ii > 0 for every non-maximum-degree node, and for max-degree\n+    // nodes whenever any neighbor weight is below 1 (i.e. not a unanimous\n+    // loss). Without this, regular comparison graphs (e.g. a pure star at\n+    // ratio 2:1) produce a bipartite chain that oscillates instead of\n+    // converging — see issue #146.\n     let mut out_edges: Vec<Vec<(usize, f64)>> = vec![Vec::new(); n];\n-    let mut out_deg: Vec<f64> = vec![0.0; n];\n+    let mut neighbors: Vec<HashSet<usize>> = vec![HashSet::new(); n];\n \n     for ((src, dst), w) in &normalized {\n         out_edges[*src].push((*dst, *w));\n-        out_deg[*src] += w;\n+        neighbors[*src].insert(*dst);\n+        neighbors[*dst].insert(*src);\n     }\n \n-    let mut max_out = 0.0f64;\n-    for &d in &out_deg {\n-        if d > max_out {\n-            max_out = d;\n-        }\n-    }\n-    if max_out <= 1e-12 {\n+    let weight_sum: Vec<f64> = out_edges\n+        .iter()\n+        .map(|es| es.iter().map(|(_, w)| *w).sum())\n+        .collect();\n+    let d_max = neighbors.iter().map(|s| s.len()).max().unwrap_or(0);\n+    if d_max == 0 {\n         return vec![1.0 / n as f64; n];\n     }\n+    let d_max_f = d_max as f64;\n \n     let mut scores = vec![1.0 / n as f64; n];\n     let mut next = vec![0.0f64; n];\n@@ -167,14 +179,14 @@ fn compute_scores_from_edges(n: usize, edges: impl Iterator<Item = ((usize, usiz\n     for _ in 0..max_iters {\n         next.fill(0.0);\n         for i in 0..n {\n-            let stay_prob = (max_out - out_deg[i]) / max_out;\n+            let stay_prob = (d_max_f - weight_sum[i]) / d_max_f;\n             next[i] += scores[i] * stay_prob;\n \n             if out_edges[i].is_empty() {\n                 continue;\n             }\n             for &(dst, w) in &out_edges[i] {\n-                next[dst] += scores[i] * (w / max_out);\n+                next[dst] += scores[i] * (w / d_max_f);\n             }\n         }\n \n@@ -270,6 +282,38 @@ mod tests {\n         }\n     }\n \n+    /// Regression for issue #146: pure forward star at default `>` ratio (2:1).\n+    /// Under the old (sum-of-weights) divisor every node had P_ii = 0 and the\n+    /// chain was bipartite; power iteration oscillated and returned the\n+    /// uniform initial distribution after an even number of steps. Using the\n+    /// paper's degree-based d_max gives every node a positive self-loop and\n+    /// the chain converges to the correct stationary distribution.\n+    #[test]\n+    fn star_topology_winner_at_top_via_subset() {\n+        let mut g = mk_group();\n+        g.apply_vote(vote(1, \"zebra\", \"alpha\", 2, 1));\n+        g.apply_vote(vote(2, \"zebra\", \"beta\", 2, 1));\n+\n+        let mut items: Vec<(usize, String)> = g\n+            .idx_to_item\n+            .iter()\n+            .enumerate()\n+            .map(|(i, it)| (i, it.as_str().to_string()))\n+            .collect();\n+        items.sort_by(|a, b| a.1.cmp(&b.1));\n+        let idxs: Vec<usize> = items.iter().map(|(i, _)| *i).collect();\n+\n+        let ranked = ranked_items_subset(&g, &idxs, 10000, 1e-8);\n+        for r in &ranked {\n+            eprintln!(\"{}: {}\", r.item.as_str(), r.score);\n+        }\n+        assert_eq!(\n+            ranked[0].item.as_str(),\n+            \"https://slug.social/zebra\",\n+            \"zebra won both votes and should rank #1\"\n+        );\n+    }\n+\n     #[test]\n     fn group_ranking_cache_dirty_flow() {\n         let mut g = mk_group();\ndiff --git a/test/fixtures/ranking/chain.sorter b/test/fixtures/ranking/chain.sorter\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..912a96bdc08f631be27f3c9afc7e05004a2457c0\n--- /dev/null\n+++ b/test/fixtures/ranking/chain.sorter\n@@ -0,0 +1,10 @@\n+#t3\n+\n+~/t3/a { head of chain }\n+~/t3/b { middle }\n+~/t3/c { tail }\n+\n+{ a > b }\n+~/t3/a > ~/t3/b\n+{ b > c }\n+~/t3/b > ~/t3/c\ndiff --git a/test/fixtures/ranking/cycle.sorter b/test/fixtures/ranking/cycle.sorter\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..771731ae176e5d77e00ab89767ff2d7465bb7c6b\n--- /dev/null\n+++ b/test/fixtures/ranking/cycle.sorter\n@@ -0,0 +1,12 @@\n+#t4\n+\n+~/t4/a { node a }\n+~/t4/b { node b }\n+~/t4/c { node c }\n+\n+{ a > b }\n+~/t4/a > ~/t4/b\n+{ b > c }\n+~/t4/b > ~/t4/c\n+{ c > a }\n+~/t4/c > ~/t4/a\ndiff --git a/test/fixtures/ranking/star.sorter b/test/fixtures/ranking/star.sorter\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..135c9f9097d57b73c7ab18fac737ed3598d76fbe\n--- /dev/null\n+++ b/test/fixtures/ranking/star.sorter\n@@ -0,0 +1,11 @@\n+#repro\n+\n+~/repro/zebra { winner — beats both others }\n+~/repro/alpha { loser — alphabetically first }\n+~/repro/beta { loser — alphabetically middle }\n+\n+{ zebra beats alpha }\n+~/repro/zebra > ~/repro/alpha\n+\n+{ zebra beats beta }\n+~/repro/zebra > ~/repro/beta\ndiff --git a/test/fixtures/ranking/star_inverse.sorter b/test/fixtures/ranking/star_inverse.sorter\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..dab842fa924e5124865ee216b9565f6c7471c812\n--- /dev/null\n+++ b/test/fixtures/ranking/star_inverse.sorter\n@@ -0,0 +1,11 @@\n+#t2\n+\n+~/t2/win { source of incoming edges (loses both) }\n+~/t2/loss-a { winner }\n+~/t2/loss-b { winner }\n+\n+{ loss-a beats win }\n+~/t2/loss-a > ~/t2/win\n+\n+{ loss-b beats win }\n+~/t2/loss-b > ~/t2/win\ndiff --git a/test/ranking.clj b/test/ranking.clj\nnew file mode 100644\nindex 0000000000000000000000000000000000000000..e1358783a84a264ee633bd79151ba29750b717cf\n--- /dev/null\n+++ b/test/ranking.clj\n@@ -0,0 +1,74 @@\n+(ns test.ranking\n+  \"Drives sorterc on .sorter fixtures and asserts ranking properties.\n+\n+   Regression coverage for issue #146 — pure forward star at default ratio\n+   (2:1 for `>`) used to produce tied uniform scores because the random walk\n+   on the normalized edge weights was bipartite. Fixed by switching to the\n+   degree-based d_max from Negahban–Oh–Shah rank centrality (§3.1).\"\n+  (:require [clojure.test :refer [deftest is testing]]\n+            [babashka.process :as p]\n+            [cheshire.core :as json]\n+            [clojure.java.io :as io]))\n+\n+(def sorterc-bin\n+  \"Path to the locally-built sorterc binary. Builds on demand if missing.\"\n+  (let [dbg     \"target/debug/sorterc\"\n+        release \"target/release/sorterc\"]\n+    (cond\n+      (.exists (io/file release)) release\n+      (.exists (io/file dbg))     dbg\n+      :else\n+      (do (println \"building sorterc…\")\n+          (let [r (p/shell {:out :string :err :string :continue true}\n+                           \"cargo build -p sorterc\")]\n+            (when-not (zero? (:exit r))\n+              (throw (ex-info \"cargo build -p sorterc failed\"\n+                              {:stderr (:err r)}))))\n+          dbg))))\n+\n+(defn compile-sorter [fixture-path]\n+  (let [{:keys [out exit]} (p/shell {:out :string :err :string :continue true}\n+                                    sorterc-bin \"compile\" fixture-path)]\n+    (when-not (zero? exit)\n+      (throw (ex-info \"sorterc exit nonzero\" {:fixture fixture-path :out out})))\n+    (json/parse-string out true)))\n+\n+(defn first-component-ranking [result]\n+  (-> result :rankings first :components first :ranking))\n+\n+(defn item-leaf [item]\n+  (last (clojure.string/split item #\"/\")))\n+\n+(deftest chain-ranks-head-first\n+  (let [ranking (first-component-ranking (compile-sorter \"test/fixtures/ranking/chain.sorter\"))\n+        names   (mapv (comp item-leaf :item) ranking)]\n+    (is (= [\"a\" \"b\" \"c\"] names)\n+        \"chain a>b>c should rank a, b, c in order\")\n+    (is (apply > (map :score ranking))\n+        \"scores should attenuate strictly down the chain\")))\n+\n+(deftest inverse-star-puts-winners-on-top\n+  (let [ranking (first-component-ranking (compile-sorter \"test/fixtures/ranking/star_inverse.sorter\"))\n+        names   (mapv (comp item-leaf :item) ranking)]\n+    (is (= \"win\" (last names))\n+        \"the item that lost to both others should be ranked last\")))\n+\n+(deftest cycle-produces-uniform-scores\n+  (let [ranking (first-component-ranking (compile-sorter \"test/fixtures/ranking/cycle.sorter\"))\n+        scores  (map :score ranking)]\n+    (is (every? #(< (Math/abs (- % 1/3)) 1e-3) scores)\n+        \"a perfectly symmetric 3-cycle should give every node ~1/3\")))\n+\n+(deftest star-topology-winner-at-top\n+  ;; Issue #146 regression: source-only star at default `>` ratio (2:1).\n+  ;; Pre-fix produced uniform 1/3 scores; alphabetical fallback put the\n+  ;; unambiguous winner at the bottom. Post-fix the chain is aperiodic and\n+  ;; converges to π_zebra = 1/2, π_alpha = π_beta = 1/4.\n+  (let [ranking (first-component-ranking (compile-sorter \"test/fixtures/ranking/star.sorter\"))\n+        names   (mapv (comp item-leaf :item) ranking)\n+        by-name (into {} (map (juxt (comp item-leaf :item) :score) ranking))]\n+    (is (= \"zebra\" (first names))\n+        \"zebra won both votes and should rank #1\")\n+    (is (< (Math/abs (- (by-name \"zebra\") 0.5)) 1e-3))\n+    (is (< (Math/abs (- (by-name \"alpha\") 0.25)) 1e-3))\n+    (is (< (Math/abs (- (by-name \"beta\") 0.25)) 1e-3))))\n","role":"user"}],"model":"openai/gpt-chat-latest"}