You are a constitutional council ranking individual git commits for ownership allocation.

Compare these two commits. Decide which contributed more lasting value to the project.

Judge substance, not spectacle:
- Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise.
- Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one.
- Do not favor a side merely because its patch is longer or noisier.
- Weight what the change does for the project, not the contributor's name.

Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."}
The explanation must cite concrete differences in the patches (1-3 sentences).

Side A — contributor: tommy-mor
Side A — commit message:
[7287df45] Add browser test for pool-scoped vote sequence.

Seeds ~/pool/a-j (10 letters), enters /vote?pool=~/pool, then follows
the vote → next-pair loop up to 15 iterations. Asserts each vote lands
in edge history and each pair shown belongs to the pool.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Side A — unified diff (full patch):
diff --git a/test/browser_vote_pool.clj b/test/browser_vote_pool.clj
new file mode 100644
index 0000000000000000000000000000000000000000..d51f05db47dc3cb013e56e65f3a1edfbbcbd96ab
--- /dev/null
+++ b/test/browser_vote_pool.clj
@@ -0,0 +1,137 @@
+(ns test.browser-vote-pool
+  "Pool-scoped voting: seed ~/pool/a-j, enter via /vote?pool=~/pool, follow
+   the vote → next-pair → vote sequence until no next pair or 15 iterations."
+  (:require [babashka.fs :as fs]
+            [cheshire.core :as json]
+            [clojure.string :as str]
+            [clojure.test :refer [deftest is]]
+            [com.blockether.spel.core :as core]
+            [com.blockether.spel.locator :as locator]
+            [com.blockether.spel.page :as page]
+            [test.common :as common]
+            [test.oauth :as oauth]))
+
+(defn- wait-for-text [pg selector expected timeout-ms]
+  (let [deadline (+ (System/currentTimeMillis) timeout-ms)]
+    (loop []
+      (let [text (locator/text-content (page/locator pg selector))]
+        (if (and (string? text) (str/includes? text expected))
+          true
+          (if (< (System/currentTimeMillis) deadline)
+            (do (Thread/sleep 200) (recur))
+            false))))))
+
+(defn- element-text [pg selector]
+  (try (locator/text-content (page/locator pg selector)) (catch Exception _ nil)))
+
+(defn- enc [^String s]
+  (java.net.URLEncoder/encode s "UTF-8"))
+
+(def letters ["a" "b" "c" "d" "e" "f" "g" "h" "i" "j"])
+
+(defn vote-pool-flow! []
+  (println "\n━━━ browser vote pool (/vote?pool= seeds + follow next-pair sequence) ━━━\n")
+
+  (common/letlocals
+   (bind build (common/run-cargo-build-release! ["slugsocial-server"]))
+   (is (zero? (:exit build)) "cargo build succeeds")
+   (bind server-bin "target/release/slugsocial-server")
+
+   (bind tmp-dir (str (fs/create-temp-dir {:prefix "slug-browser-vote-pool-"})))
+   (bind slug-port (common/pick-port))
+   (bind google-port (common/pick-port))
+   (bind base-url (str "http://127.0.0.1:" slug-port))
+   (bind google-url (str "http://127.0.0.1:" google-port))
+
+   (bind !server (atom nil))
+   (bind !google (atom nil))
+   (bind server-env (common/slug-server-env tmp-dir base-url google-url slug-port))
+   (try
+     (reset! !google (oauth/start-mock-google google-port
+                                              :google-users ["google-user-alice"]))
+     (reset! !server (common/start-server server-bin server-env))
+     (is (common/wait-for-server base-url 10000) "server responds to /healthz")
+
+     (let [alice-token (oauth/fetch-bearer-token! base-url :username "alice")
+           thread-tag  "browser-vote-pool"
+           ;; seed ~/pool/a through ~/pool/j as items with bodies
+           item-lines  (str/join "\n"
+                                 (map (fn [l] (str "~/pool/" l " {" l "}")) letters))
+           raw         (str "# " thread-tag "\n\n~/pool {root}\n" item-lines "\n")
+           post-resp   (oauth/http-post-json
+                        (str base-url "/api/v0/rpc")
+                        [{"Post" {"room"             "public"
+                                  "thread_tag"       thread-tag
+                                  "text"             raw
+                                  "return_rank_diff" false}}]
+                        :headers {"Authorization" (str "Bearer " alice-token)})
+           post-json   (json/parse-string (:body post-resp) false)
+           _           (is (true? (get-in post-json ["results" 0 "ok"]))
+                           "seed ~/pool/a-j items via rpc")
+           pool-url    (str base-url "/vote?pool=" (enc "~/pool"))]
+
+       (core/with-playwright [pw]
+         (core/with-browser [browser (core/launch-chromium pw {:headless true :channel "chrome"})]
+           (core/with-context [ctx (core/new-context browser)]
+             (core/with-page [pg (core/new-page-from-context ctx)]
+               (page/navigate pg (str base-url "/login"))
+               (is (wait-for-text pg "body" "@alice" 15000) "alice session after login")
+
+               ;; Enter via pool URL — page picks first pair automatically.
+               (page/navigate pg pool-url)
+               (is (wait-for-text pg "body.view-vote-compare" "compare" 15000)
+                   "pool entry: vote compare page loads")
+
+               ;; Verify the initial pair is within the pool.
+               (let [pair-text (element-text pg ".vote-compare-pair")]
+                 (is (and (string? pair-text) (str/includes? pair-text "~/pool/"))
+                     (str "initial pair is within ~/pool: " pair-text)))
+
+               ;; Follow vote → next-pair sequence up to 15 iterations.
+               (let [votes-cast
+                     (loop [i 0]
+                       (if (>= i 15)
+                         i
+                         (let [explanation (str "pool vote " i " reason")]
+                           (locator/fill (page/locator pg "#vote-explain") explanation)
+                           (locator/click (page/locator pg "#vote-compare-form button[type=submit]"))
+                           ;; Wait for edge history morph confirming the vote landed.
+                           (if-not (wait-for-text pg "ul.vote-edge-history" explanation 20000)
+                             (do (println "  vote" i "history morph timed out — stopping")
+                                 i)
+                             (let [has-next (wait-for-text pg "[data-testid=\"vote-next-pair\"]"
+                                                           "next pair" 8000)]
+                               (if-not has-next
+                                 ;; "no next pair" — pool exhausted.
+                                 (do (println "  no next pair after vote" i " — pool exhausted")
+                                     (inc i))
+                                 (do
+                                   ;; Verify the pair on this page is within the pool before advancing.
+                                   (let [pt (element-text pg ".vote-compare-pair")]
+                                     (is (and (string? pt) (str/includes? pt "~/pool/"))
+                                         (str "pair at vote " i " is within ~/pool: " pt)))
+                                   (locator/click (page/locator pg "[data-testid=\"vote-next-pair\"]"))
+                                   ;; Wait for next pair to load.
+                                   (wait-for-text pg "body.view-vote-compare" "compare" 10000)
+                                   (recur (inc i)))))))))]
+
+                 (is (>= votes-cast 1) (str "cast at least 1 vote, got: " votes-cast))
+                 (println (str "  pool voting sequence complete: " votes-cast " vote(s) cast")))
+
+               ;; After the sequence, the current page is still a pool-scoped vote page.
+               (let [url (page/url pg)]
+                 (is (str/includes? (or url "") "/vote")
+                     (str "still on /vote after sequence: " url))))))))
+
+     (finally
+       (when-some [s @!server] (common/kill-server s))
+       (when-some [g @!google] ((:stop-fn g)))
+       (fs/delete-tree tmp-dir)))
+
+   nil))
+
+(defn vote-pool-browser-test [& _args]
+  (vote-pool-flow!))
+
+(deftest browser-vote-pool-sequence
+  (vote-pool-flow!))


Side B — contributor: tommy-mor
Side B — commit message:
[78964dd7] nice

Side B — unified diff (full patch):
diff --git a/server/src/fetch/html.rs b/server/src/fetch/html.rs
index 9b6c2d0964640a157bca2a6a64cb0820238d8e4f..3e0309ff1c2ac1b17923922d2340ba6710e0f9d1 100644
--- a/server/src/fetch/html.rs
+++ b/server/src/fetch/html.rs
@@ -11,6 +11,9 @@ use crate::{
 };
 
 fn entity_panel(node: &NodeState) -> Markup {
+    if let Some(markup) = crate::render::reddit::entity_markup(node) {
+        return markup;
+    }
     html! {
         @if let Some(data) = &node.data {
             div id="entity-panel" class="entity-card" {
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index e88cc43ddc9d8100f7994be6f5960ec4d8f22c55..3bf9fc7e92e50beed24e2c25106a77421038c90b 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -153,16 +153,21 @@ pub fn breadcrumb_path(item: &ItemId) -> Markup {
     }
 }
 
-fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup {
+fn rank_list(label: &str, items: &[RankedItem], start_rank: usize, tree: &GlobalTree) -> Markup {
     html! {
         @if !items.is_empty() {
             h3 class="rank-heading muted small" { (label) }
             ol class="rank-list" {
                 @for (i, r) in items.iter().enumerate() {
-                    li {
+                    @let href = item_href(&r.item);
+                    li class=(if crate::render::reddit::is_reddit_post(&r.item) { "reddit-post-row" } else { "" }) {
                         span class="rank-num" { (start_rank + i) ". " }
-                        a href=(item_href(&r.item)) {
-                            strong { (display_label(&r.item)) }
+                        @if let Some(row) = crate::render::reddit::child_row_markup(tree, &r.item, &href) {
+                            (row)
+                        } @else {
+                            a href=(href) {
+                                strong { (display_label(&r.item)) }
+                            }
                         }
                         span class="muted" {
                             " — "
@@ -196,9 +201,14 @@ fn unranked_list(label: &str, items: &[ItemId], tree: &GlobalTree) -> Markup {
             h3 class="rank-heading muted small" { (label) }
             ul class="rank-list unranked" {
                 @for it in items {
-                    li {
-                        a href=(item_href(it)) {
-                            strong { (child_label(tree, it)) }
+                    @let href = item_href(it);
+                    li class=(if crate::render::reddit::is_reddit_post(it) { "reddit-post-row" } else { "" }) {
+                        @if let Some(row) = crate::render::reddit::child_row_markup(tree, it, &href) {
+                            (row)
+                        } @else {
+                            a href=(href) {
+                                strong { (child_label(tree, it)) }
+                            }
                         }
                     }
                 }
@@ -253,7 +263,7 @@ pub fn ranking_panel(item: &ItemId, node: &NodeState, tree: &GlobalTree) -> Mark
             } @else {
                 @for (gi, ranked) in ranked_groups.iter().enumerate() {
                     @let label = if multi { format!("Ranking group {}", gi + 1) } else { "Ranking".to_string() };
-                    (rank_list(&label, ranked, 1))
+                    (rank_list(&label, ranked, 1, tree))
                 }
                 (unranked_list("Unranked", &unranked, tree))
             }
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 0677363e0ed21d244bfa065f7ec728549ddd9e50..da5f3ebecec1794b05a2a69cc78379551b2ad769 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -8,6 +8,7 @@ pub mod parser;
 pub mod path_types;
 pub mod ranking;
 pub mod reddit;
+pub mod render;
 pub mod reducer;
 pub mod journal;
 pub mod state;
diff --git a/server/src/reddit.rs b/server/src/reddit.rs
index 69d979bc7e4a1cb078f70114dc539bdc1986b574..1168ec2afc77c092514eec91b513bac301cbe225 100644
--- a/server/src/reddit.rs
+++ b/server/src/reddit.rs
@@ -608,6 +608,8 @@ fn parse_subreddit_about(v: &Value) -> Option<crate::reducer::EntityData> {
         author: None,
         body_html,
         thumb_url,
+        image_url: None,
+        link_url: None,
     })
 }
 
@@ -635,15 +637,64 @@ fn parse_post_listing(v: &Value) -> Option<crate::reducer::EntityData> {
         .and_then(|t| t.as_str())
         .filter(|s| s.starts_with("http"))
         .map(|s| s.to_string());
+    let image_url = reddit_post_image_url(child);
+    let link_url = reddit_post_link_url(child);
 
     Some(crate::reducer::EntityData {
         title,
         author,
         body_html,
         thumb_url,
+        image_url,
+        link_url,
     })
 }
 
+fn reddit_post_link_url(data: &Value) -> Option<String> {
+    for key in ["url_overridden_by_dest", "url"] {
+        if let Some(u) = data.get(key).and_then(|v| v.as_str()) {
+            if u.starts_with("http") {
+                return Some(u.to_string());
+            }
+        }
+    }
+    None
+}
+
+/// Full-size still for post detail: direct image `url`, else Reddit preview source.
+fn reddit_post_image_url(data: &Value) -> Option<String> {
+    for key in ["url", "url_overridden_by_dest"] {
+        if let Some(u) = data.get(key).and_then(|v| v.as_str()) {
+            if reddit_direct_image_url(u) {
+                return Some(u.to_string());
+            }
+        }
+    }
+    reddit_preview_source_url(data)
+}
+
+fn reddit_preview_source_url(data: &Value) -> Option<String> {
+    data.pointer("/preview/images/0/source/url")
+        .and_then(|v| v.as_str())
+        .filter(|s| s.starts_with("http"))
+        .map(str::to_string)
+}
+
+fn reddit_direct_image_url(url: &str) -> bool {
+    let u = url.to_ascii_lowercase();
+    if u.contains("redgifs.com") {
+        return false;
+    }
+    u.contains("i.redd.it")
+        || u.contains("preview.redd.it")
+        || u.contains("external-preview.redd.it")
+        || u.ends_with(".jpg")
+        || u.ends_with(".jpeg")
+        || u.ends_with(".png")
+        || u.ends_with(".gif")
+        || u.ends_with(".webp")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -672,4 +723,20 @@ mod tests {
         .unwrap();
         assert_eq!(entity.title, "The Rust Programming Language");
     }
+
+    #[test]
+    fn parse_post_listing_extracts_thumb_and_full_preview() {
+        let json = include_str!("../../test/fixtures/reddit/post_preview.json");
+        let v: Value = serde_json::from_str(json).unwrap();
+        let id = ItemId::parse("reddit.com/r/nsfw/comments/1tpy6a1/angel_eyes").unwrap();
+        let entity = entity_view_from_payload(&id, &v).unwrap();
+        assert_eq!(entity.title, "Angel Eyes");
+        assert!(entity.thumb_url.as_ref().unwrap().contains("width=140"));
+        assert!(entity.image_url.as_ref().unwrap().contains("auto=webp"));
+        assert!(!entity.image_url.as_ref().unwrap().contains("redgifs"));
+        assert_eq!(
+            entity.link_url.as_deref(),
+            Some("http://v3.redgifs.com/watch/impossibleprestigioushedgehog")
+        );
+    }
 }
diff --git a/server/src/reducer.rs b/server/src/reducer.rs
index 4e42d0369dab50bb2f8ca664aa69b628292f6c07..336e78b77d3ab59361b89af5c9868e13da4ac962 100644
--- a/server/src/reducer.rs
+++ b/server/src/reducer.rs
@@ -122,7 +122,12 @@ pub struct EntityData {
     pub title: String,
     pub author: Option<String>,
     pub body_html: Option<String>,
+    /// Small preview (subreddit listing / child rows).
     pub thumb_url: Option<String>,
+    /// Full-size still image for the post detail view.
+    pub image_url: Option<String>,
+    /// Outbound link for link/video posts (`url` / `url_overridden_by_dest`).
+    pub link_url: Option<String>,
 }
 
 /// One node in the fractal tree: entity + ranked children.
diff --git a/server/src/render/mod.rs b/server/src/render/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c2c41404abe01c671139658fcccdeced5be388e4
--- /dev/null
+++ b/server/src/render/mod.rs
@@ -0,0 +1,3 @@
+//! Domain-specific HTML fragments for imported entities.
+
+pub mod reddit;
diff --git a/server/src/render/reddit.rs b/server/src/render/reddit.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4a18de93cf57d8395ded3caa373a708f39b3f43f
--- /dev/null
+++ b/server/src/render/reddit.rs
@@ -0,0 +1,64 @@
+//! Reddit post cards: thumbnail in child lists, full image on the post page.
+
+use maud::{html, Markup};
+
+use crate::{
+    path_types::ItemId,
+    reducer::{EntityData, GlobalTree, NodeState},
+};
+
+pub fn is_reddit_post(id: &ItemId) -> bool {
+    id.as_str().starts_with("reddit.com/") && id.as_str().contains("/comments/")
+}
+
+/// Post detail card (`#entity-panel`).
+pub fn entity_markup(node: &NodeState) -> Option<Markup> {
+    if !is_reddit_post(&node.id) {
+        return None;
+    }
+    let data = node.data.as_ref()?;
+    Some(post_entity_card(data))
+}
+
+/// One row in a parent ranking list (thumbnail + title).
+pub fn child_row_markup(tree: &GlobalTree, id: &ItemId, href: &str) -> Option<Markup> {
+    if !is_reddit_post(id) {
+        return None;
+    }
+    let data = tree.get(id)?.data.as_ref()?;
+    Some(html! {
+        @if let Some(thumb) = &data.thumb_url {
+            a class="reddit-post-thumb-link" href=(href) {
+                img class="reddit-post-thumb" src=(thumb) alt="" loading="lazy";
+            }
+        }
+        a href=(href) {
+            strong { (data.title) }
+        }
+    })
+}
+
+fn post_entity_card(data: &EntityData) -> Markup {
+    let image = data.image_url.as_ref().or(data.thumb_url.as_ref());
+    html! {
+        div id="entity-panel" class="entity-card reddit-post" {
+            h2 { (data.title) }
+            @if let Some(author) = &data.author {
+                p class="muted small" { "by " (author) }
+            }
+            @if let Some(url) = &data.link_url {
+                p class="reddit-post-url muted small" {
+                    a href=(url) rel="noopener noreferrer" { (url) }
+                }
+            }
+            @if let Some(src) = image {
+                figure class="reddit-post-figure" {
+                    img class="reddit-post-image" src=(src) alt="" loading="lazy";
+                }
+            }
+            @if let Some(body) = &data.body_html {
+                div class="entity-body" { (maud::PreEscaped(body)) }
+            }
+        }
+    }
+}
diff --git a/server/static/sorter.css b/server/static/sorter.css
index 1f9f5158414902d43a380dd899232c70d8cf5d63..021918f8e778b84e4b3eac8559fab7d223a3d490 100644
--- a/server/static/sorter.css
+++ b/server/static/sorter.css
@@ -171,6 +171,41 @@ code {
   margin-top: 0;
 }
 
+.reddit-post-row {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+}
+
+.reddit-post-thumb-link {
+  flex-shrink: 0;
+  line-height: 0;
+}
+
+.reddit-post-thumb {
+  width: 64px;
+  height: 64px;
+  object-fit: cover;
+  border-radius: 4px;
+  border: 1px solid var(--border);
+}
+
+.reddit-post-url a {
+  word-break: break-all;
+}
+
+.reddit-post-figure {
+  margin: 0.75rem 0;
+}
+
+.reddit-post-image {
+  display: block;
+  max-width: 100%;
+  height: auto;
+  border-radius: 6px;
+  border: 1px solid var(--border);
+}
+
 .scope-name {
   color: var(--accent);
   font-weight: 600;
diff --git a/test/fixtures/reddit/post_preview.json b/test/fixtures/reddit/post_preview.json
new file mode 100644
index 0000000000000000000000000000000000000000..c6ed31ae397dc0f7b6e07e5e010e617df78d9c18
--- /dev/null
+++ b/test/fixtures/reddit/post_preview.json
@@ -0,0 +1,22 @@
+{
+  "kind": "t3",
+  "data": {
+    "title": "Angel Eyes",
+    "permalink": "/r/nsfw/comments/1tpy6a1/angel_eyes/",
+    "author": "alice",
+    "thumbnail": "https://external-preview.redd.it/Kb6Nf5Q4RAucat-2RFcYMeQb2d6vgYNo5EPlf6kGLbs.jpeg?width=140&height=140&auto=webp&s=d7238240ebf191b954ef5f42b0cf61b67aecec88",
+    "url": "http://v3.redgifs.com/watch/impossibleprestigioushedgehog",
+    "post_hint": "rich:video",
+    "preview": {
+      "images": [
+        {
+          "source": {
+            "url": "https://external-preview.redd.it/Kb6Nf5Q4RAucat-2RFcYMeQb2d6vgYNo5EPlf6kGLbs.jpeg?auto=webp&s=ccdabee3b81e46ef2d7cec072f6604a09f61dc9a",
+            "width": 480,
+            "height": 480
+          }
+        }
+      ]
+    }
+  }
+}