c_bc8c17a00ed71092d2

Commit A makes a broader functional improvement to the UI by changing the color-mapping algorithm from list-position-based to score-range-based normalization. It introduces a reusable helper, updates the rendering logic to compute group score bounds, changes the styling behavior, documents the rationale, and adds multiple targeted tests covering edge cases and correctness. Commit B is a useful but narrower data-ingestion fix that skips pinned Reddit posts during import by checking stickied/pinned flags and adds a focused regression test. Both improve correctness, but A affects a more central presentation algorithm and involves a more substantial implementation.

Commit A makes a deeper, cross-cutting change to how ranking visuals are computed, replacing position-based coloring with score-based normalization, updating function signatures, call sites, and adding several targeted tests. It alters core UI behavior and improves consistency as data scales. Commit B is a focused data-cleanup improvement (skipping pinned posts) with a small helper and a single test, valuable but much narrower in scope and impact.

Side A introduces a more substantial behavioral change by redesigning the rank row coloring logic from ordinal-based to score-based min–max normalization, modifying function signatures, updating call sites, and adding multiple focused tests to validate edge cases and invariants. This improves visual semantics and scalability of the UI. Side B adds a useful but relatively small filtering enhancement (skipping pinned posts) with a helper and a single test. Overall, Side A represents a broader and more impactful contribution.

Commit A introduces a functional behavior change by excluding pinned/stickied Reddit posts during subreddit import, adds a dedicated helper, updates documentation, and includes a regression test covering both relevant Reddit fields (`stickied` and `pinned`). This is a meaningful correctness improvement that affects imported data. Commit B is primarily a cleanup/refactoring change that removes dead code made redundant by earlier validation, updates expectations in a test, and preserves existing behavior through lower-level edge handling. While valuable for code simplicity, its impact is smaller than the new functionality and regression protection added in A.

Commit A introduces a meaningful behavior change to the Reddit ingestion pipeline by filtering out pinned/stickied posts, adds a helper function, updates documentation, and includes a targeted test. This improves data quality and affects downstream processing. Commit B mainly removes a redundant guard and adjusts tests to reflect existing behavior, a smaller refactor with minor behavioral implications. Overall, A has broader functional impact.

Side A introduces new functional behavior (skipping pinned/stickied Reddit posts), adds a dedicated helper function, updates documentation, and includes a comprehensive unit test. This meaningfully changes import semantics and improves correctness. Side B removes a redundant guard and adjusts tests to reflect existing behavior, which is a smaller refactor/cleanup. Overall, Side A delivers a more substantial contribution.

Side A changes the ranking color logic from list-position-based to score-based min–max normalization within each group, introducing a dedicated `score_gradient_t` helper, updating rendering to use score ranges, and adding focused tests for normalization behavior and edge cases like tied scores. Side B fixes a practical import issue by skipping stickied/pinned Reddit posts with a helper and regression test, but its impact is narrower than A's broader improvement to core ranking visualization behavior.

A replaces a position-based coloring scheme with score-based min–max normalization, altering function signatures, computing per-group ranges, and adding targeted tests—an enduring improvement to how data is represented. B is a straightforward filter that skips pinned posts via a simple helper and test, useful but narrower in scope.

Side B prevents pinned/stickied Reddit posts from being imported by adding `child_is_pinned` and filtering in `parse_children`, plus a focused test—improving data correctness and avoiding persistent noise in stored listings. Side A refactors row coloring to use min–max score normalization and adds solid tests, but it primarily affects UI presentation rather than core data integrity or behavior.

B fixes a real data-quality bug (pinned/stickied posts polluting subreddit imports) with a clear, testable behavior change that affects actual content correctness. A is a UI-only cosmetic tweak to color gradient math for rank rows, which is a minor visual refinement with no functional or data-correctness impact.

B fixes import data quality by excluding stickied/pinned Reddit posts (with a clear helper and regression test), which permanently keeps non-content noise out of the ranking pipeline. A only refinines rank-row coloring from list ordinal to min–max score within a group—a solid, tested UX tweak, but presentation polish rather than correctness of ingested data.

Side A fixes importer behavior by explicitly skipping stickied/pinned Reddit posts in `parse_children`, adds a dedicated `child_is_pinned` helper checking both `stickied` and `pinned` flags, and includes a regression test covering both cases. Side B mainly removes a guard that is asserted to be unreachable because earlier validation already rejects zero ratios, updating tests to reflect existing behavior rather than adding new functionality or fixing a user-visible issue.

A adds a concrete behavioral improvement by filtering out stickied/pinned Reddit posts in `parse_children`, with a dedicated helper and test ensuring only real posts are imported. B mainly removes a supposedly dead zero-ratio guard in `apply_vote` and adjusts tests, which is a cleanup with minor semantic change but less clear user-facing impact.

Side A adds a concrete behavioral improvement by skipping stickied/pinned Reddit posts during import via a new `child_is_pinned` check in `parse_children`, along with a focused test verifying only non-pinned posts are returned. Side B merely removes a zero-ratio early return in `apply_vote` and adjusts a test, changing when items are registered but not adding new functionality; it’s largely cleanup of redundant logic.

Side A fixes a real behavioral bug (pinned posts polluting subreddit imports) with a working implementation and a dedicated regression test, directly improving data correctness. Side B is a minor cleanup removing dead code and relies on assuming add_edge_weight's zero-skip behavior is correct elsewhere, which is lower-risk but also lower-impact than A's functional fix.

A adds lasting import behavior by filtering stickied/pinned Reddit posts in parse_children, with a dedicated helper and a focused unit test covering both sticky fields and a normal post. B only deletes a defensive zero-ratio early-return already enforced upstream and adjusts a test to match; useful hygiene, but no new capability or user-facing fix.

Side B is a focused, well-tested bugfix (skip pinned/stickied Reddit posts) with a clean helper function and a clear regression test, with no side effects outside its scope. Side A fixes a real UI bug but sprawls into unrelated CSS/JS changes (widening columns, complex gradient logic) and silently removes the `vote_back_nav` call without explanation, risking an unintended regression.

A fixes core vote-compare UX/correctness (per-group rank gradients, center-anchored winner fill, history sliders aligned with HUD polarity) with multi-layer changes and strong invariant tests. B is a clean, valuable import filter for stickied/pinned Reddit posts with a focused test, but narrower in product impact.

Side B makes a focused behavioral fix to the Reddit importer by skipping stickied/pinned posts during subreddit parsing, preventing unwanted permanent entries from being imported, and adds a regression test covering both the `stickied` and `pinned` fields. Side A fixes UI highlighting/orientation issues and adds several tests, but much of the patch is presentation and styling changes, making its lasting impact somewhat narrower than the importer correctness fix.

Side B adds a real, self-contained product feature (filtering pinned/stickied Reddit posts) with a clear unit test verifying the behavior, directly improving import correctness. Side A is test-infrastructure churn fixing bugs introduced by prior test-only code (regex vs string split, wrong request-body method, negative content-length), valuable for CI health but not for the shipped product.

A restores broken E2E auth by fixing real mock-server bugs (query split on #"=", getRequestBody vs getInputStream, 302 content-length, null-safe token/state, handler error handling) plus selector-based login assertions. B is a clean, tested product tweak (skip stickied/pinned listing children) but narrower in scope than unblocking auth flows and correcting the shared OAuth/Reddit test doubles.

Side A repairs multiple concrete failures in the OAuth test infrastructure: it fixes query parsing (`str/split` regex), reads POST bodies correctly (`getRequestBody`), avoids null token/state crashes, adjusts redirect handling, wraps handlers to prevent server crashes, and improves Playwright test synchronization and selectors. Side B is a focused behavioral improvement that skips pinned Reddit posts during import with a helper and regression test, but its scope and impact are narrower than restoring and hardening the end-to-end authentication test framework.

Side B fixes a real user-facing bug (hrefs leaking full storage URLs instead of display paths) and substantially strengthens test coverage to actually validate ranking correctness across all pairs, which is meaningful lasting value. Side A adds a small, correct feature (skipping pinned posts) with a focused unit test, which is solid but narrower in scope than B's combined bugfix + test rigor improvement.

B fixes production vote hrefs to encode short display_path forms (matching UI/DSL) and upgrades the pool browser test from a shallow ≤15-iteration smoke check into a full C(10,2)=45-pair run with GetGardenRank assertions (one component, a→j). A is a correct, well-tested Reddit import filter for stickied/pinned posts, but it is a narrower edge-case skip versus B’s core voting UX fix plus substantial ranking coverage.

Side B fixes link generation to use `display_path()` instead of stored full URLs for `left`, `right`, and `pool` parameters, aligning vote URLs with the user-facing path format, and adds an end-to-end test that exercises all 45 pairwise votes and verifies the resulting ranking. Side A is a targeted correctness fix that skips `stickied`/`pinned` Reddit posts during import with a focused unit test, but its impact is narrower than the combination of user-visible URL correctness and substantially stronger integration coverage in Side B.

Side A introduces a real architectural improvement (a settlement worker that batches vote writes, caches scores, and avoids recomputing ranking on every read) alongside removal of dead demo-counter code, which is a meaningful lasting design change despite some churn. Side B is a small, well-tested but narrow bugfix (skip pinned Reddit posts) that is useful but far more limited in scope and impact.

A adds a real settlement worker with batched vote apply/persist, ranking score caching, and read-only HTTP ranking paths, plus removes demo-counter scaffolding—lasting architecture for the core product. B is a correct, tested one-line filter to skip stickied/pinned Reddit children, valuable but narrow next to A’s design change.

Side A replaces synchronous vote handling with a dedicated settlement worker that batches event logging and ranking recomputation, introduces cached ranking reads (`ranked_items_cached`), warms the cache at startup, and switches UI rendering from write locks to read locks, while also removing the temporary demo-counter feature. Side B is a correct, targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds a regression test, but its scope and architectural impact are much smaller.

Side B implements a real, non-trivial UI/UX feature (clickable unpin from ranked child groups) with coordinated changes across markup, CSS themes, and an updated browser test covering the new flow, delivering tangible user-facing value. Side A is a small, well-tested bugfix (skipping pinned Reddit posts) which is useful but narrower in scope and impact than B's cross-cutting feature work.

A is a precise ingest correctness fix: it filters stickied/pinned Reddit listing children via a small helper and locks the behavior with a unit test, so meta posts never enter stored data. B improves UX by wiring an existing set_garden_pin clear path into ranked-child pin glyphs (plus CSS and browser coverage), but that is incremental UI consistency on an already-supported flow rather than a foundational data-quality change.

Side B adds a meaningful user-facing capability by turning the ranked child-group pin indicator into a working unpin control that reuses the existing POST /ui set_garden_pin flow, updates rendering to preserve navigation, adjusts styling, and extends browser integration tests to verify the full interaction. Side A is a solid import bugfix that filters stickied/pinned Reddit posts during subreddit listing import and adds unit tests, but its scope is narrower than the end-to-end UI functionality and coverage added in Side B.

Side A fixes a real data-correctness bug (pinned Reddit posts polluting imports) with a clear implementation and an accompanying regression test verifying both 'stickied' and 'pinned' fields are handled. Side B's fix is plausible (defining a missing GITHUB_API_BASE_URL constant to avoid a NameError) but the diff shows no test and no context of where/how the variable is actually used, making its correctness harder to verify.

B fixes a real NameError by defining the missing GITHUB_API_BASE_URL used in the OAuth callback, restoring broken auth. A only filters stickied/pinned Reddit listing children (with a small helper and unit test), which is a useful import refinement but not a correctness fix on a critical path.

Side A changes subreddit import behavior to intentionally exclude stickied/pinned posts by adding a dedicated check in `parse_children`, documents the behavior, and adds a regression test covering both `stickied` and `pinned` flags. Side B fixes a real runtime issue by defining `GITHUB_API_BASE_URL` with a default, preventing a NameError in the OAuth callback, but it is a smaller configuration fix without accompanying tests or broader behavioral improvements.

Side B is a substantive CLI restructuring (splitting ingest into forum list/show/post, updating docs, RPC hints, and integration tests) that improves usability and consistency across the whole tool, whereas Side A is a small, self-contained bugfix (skip pinned Reddit posts) with a good test but narrower scope. Both are real, non-noise changes, but B touches and improves more of the system's actual interface and documentation, giving it broader lasting value despite being a larger diff.

A is a tight, correct Reddit import fix (skip stickied/pinned children plus a focused unit test) but narrow in blast radius. B reshapes the lasting CLI contract—forum becomes list/show/post, ingest becomes tagged forum post with required --delegate, room scoping is documented end-to-end, and RPC next-move strings plus integration tests follow—so the product’s primary agent/human interface is clearer and stickier than A’s single parser filter.

Side A implements a functional behavior change by skipping stickied/pinned Reddit posts during subreddit import, adds a dedicated helper checking both `stickied` and `pinned` flags, and includes a regression test verifying only normal posts are imported. Side B is largely a CLI/documentation reshaping and command reorganization with corresponding test updates, which improves interface consistency but contributes less core project behavior or correctness.

Side A fixes a real functional bug (pinned posts polluting imports) with a targeted code change plus a test verifying both stickied and pinned fields are handled. Side B is a config simplification for test discovery that reduces maintenance friction but carries risk (auto-discovery could unintentionally pick up unwanted namespaces) and has no functional/test-of-behavior impact on the product itself.

A adds lasting product behavior: skip stickied/pinned Reddit listing children via a small helper, with a unit test covering both flag shapes. B only collapses hand-enumerated kaocha suites into one ns-pattern in tests.edn—useful DX, but config hygiene rather than app correctness.

Side A changes runtime behavior by filtering stickied/pinned Reddit posts during subreddit import, adds a dedicated helper, and includes a regression test verifying only normal posts are imported. Side B improves test configuration by replacing manually enumerated Kaocha suites with automatic namespace discovery, reducing maintenance, but it does not change application behavior.

Side A is a small, well-tested bugfix that prevents pinned Reddit posts from polluting imported listings, with clear rationale and a dedicated test. Side B is a terse, under-documented refactor that removes the eager on-write trimming of recent_votes (now unbounded storage growth, capped only at read time) and bumps the schema version, which is a riskier architectural change without clear justification in the commit message.

B is a substantive storage/apply redesign: recent_votes moves from capped Deque/VecDeque with write-time trim to append-only List/Vec with query-time capping, drops projection_apply’s BTreeSet + trim_recent_votes path, and bumps schema with a focused load test. A is a correct, well-tested filter for stickied/pinned Reddit children, but it is a narrow import-side tweak versus B’s lasting core-model simplification.

Side B changes the persistence model for recent votes from a write-trimmed deque to an append-only list with query-time capping, updates the schema version, removes trimming logic, adjusts the in-memory representation, and adds a test verifying only the newest capped window is loaded. Side A is a focused bug fix that skips stickied/pinned Reddit posts during import with a helper and regression test, but its impact is narrower than the storage design change in Side B.

Side A is a small, correct, well-tested bugfix that prevents pinned Reddit posts from polluting listings, with a focused unit test. Side B vendors an entire speculative 'durable' crate (with generated Cargo.lock noise, READMEs, RFCs, example programs) and reworks storage/replay in a way that is far more invasive and mostly unproven infrastructure rather than a lasting, necessary fix; most of its diff is boilerplate/dependency churn rather than reviewed, load-bearing logic.

B delivers lasting architectural value by offloading entity JSON from in-memory GlobalTree to a RocksDB-backed EntityStore, streaming event-log replay to cut startup RAM, and wiring those paths through reducer/state/reddit. A is a correct but narrow filter (skip stickied/pinned children) plus one unit test, and does not change core scalability or persistence design.

Side B introduces substantial lasting infrastructure: it adds a new RocksDB-backed `durable` workspace crate, moves raw Reddit entity payloads out of in-memory state into a persistent `EntityStore`, and changes event-log replay to stream entries one at a time, reducing startup memory while preserving replay semantics with new tests. Side A is a correct, targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds a regression test, but its scope and long-term impact are much smaller than the storage and replay architecture changes in Side B.

Side B is a substantial, well-tested architectural rework: it introduces a composable url_rules engine/registry, migrates ItemId to canonical full URLs, fixes breadcrumb/parent logic for structural path segments, and updates all call sites and tests consistently, providing lasting infrastructure value. Side A is a small, useful bugfix (skip pinned Reddit posts) with a good test, but it is narrow in scope compared to B's broad canonicalization redesign.

B replaces ad-hoc schemeless path IDs with a real full-URL ItemId model and a composable url_rules engine (Reddit/YouTube canonicalization, breadcrumbs, parent hierarchy), which is core lasting design wired through the stack. A is a correct, tested import filter for stickied/pinned posts, but it is a narrow local improvement versus B’s foundational identity/schema work.

Side B introduces a substantial URL canonicalization architecture by extracting normalization into a new `url_rules` module, converting `ItemId` to canonical HTTPS URLs, updating parsing, parent/breadcrumb logic, projection application, and Reddit mapping, with broad test coverage. Side A is a useful targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds a regression test, but its impact is much narrower than the lasting infrastructure and consistency improvements in Side B.

Side A fixes a real bug (external garden index always empty due to a bogus parent), introduces a substantive resolvers/ module with structured GitHub import cards, rich rendering hooks, layout CSS, and both unit and integration test coverage across multiple files. Side B is a small, focused but narrow fix (skip pinned Reddit posts) with a single test, which is useful but far more limited in scope and lasting impact.

A fixes a real empty-index bug on `/-/` via `external_root_host_items`, modularizes resolvers, and adds structured GitHub import cards with render hooks, CSS, and compare/integration tests—durable product surface. B only skips stickied/pinned Reddit children in `parse_children` plus a unit test: a correct but narrow filter with far less lasting design impact.

Side A fixes a real functional bug where the external garden index incorrectly queried a bogus `https://.` parent by introducing `external_root_host_items`, ensuring host roots are discovered even from implicit child edges, and it adds a lasting resolver architecture (`server/src/resolvers/`) with rich GitHub import-card rendering integrated into item pages and vote comparison, backed by unit and integration tests. Side B is a useful but narrow correctness improvement that skips stickied/pinned Reddit posts during subreddit import by filtering `stickied`/`pinned` entries, with a corresponding test.

Side B fixes multiple real bugs (misattributed vote posts, silent fallback to unrelated items masking a data issue, dead UI element) and cleans up route naming across the codebase with corresponding test updates, representing broader functional correctness improvements. Side A is a smaller, well-tested but narrower fix that only addresses one specific import edge case (pinned Reddit posts).

B fixes real product behavior on a core path: delegate attribution is passed out-of-band via `delegate_opt` instead of embedded in body text, and `suggest_next_vote_pair` no longer silently falls back to the full item set when the sibling pool is too small. A is a clean, tested Reddit filter for stickied/pinned posts, but it is narrower import hygiene; much of B’s remaining diff is route rename/UI cleanup, so A still carries solid secondary value.

Side A fixes a concrete data-import issue by filtering Reddit stickied/pinned posts during subreddit listing parsing, adds a dedicated helper that checks both `stickied` and `pinned` flags, and includes a regression test verifying only normal posts are imported. Side B bundles several UI and routing tweaks plus a small behavioral fix (returning no next pair instead of falling back to all items), but much of the patch is route renaming, link updates, and interface cleanup rather than durable core functionality.

Commit B is a substantial, coherent feature/refactor: it introduces explicit user-triggered entity fetching, persists full raw API payloads via a new EntityImported event for proper replay, decouples Reddit API base URLs for testability, adds dotenv support, and includes a real integration test with a mock Reddit server plus fixture data. Commit A is a small, well-tested but narrow bugfix (skipping pinned posts) that adds real value but is far more limited in scope and lasting architectural impact compared to B's persistence/import redesign.

B redesigns Reddit import around event-sourced EntityImported payloads, explicit user fetch (no auto-fetch on browse), configurable API bases, raw+view storage, and end-to-end tests—foundational lasting architecture. A only adds a small stickied/pinned skip in parse_children plus one unit test, a correct but narrow data-quality tweak.

Side B introduces substantial new architecture: it replaces ephemeral Reddit entity updates with persisted `EntityImported` events, stores raw API payloads plus derived views, adds replay support, configurable API/OAuth endpoints, and an explicit user-triggered fetch flow with tests. Side A is a focused correctness fix that skips stickied/pinned subreddit posts during import and adds a targeted regression test, but its scope and long-term impact are much smaller than the persistence and fetch redesign in Side B.

Side B implements a real UI/UX fix (HUD unpin now POSTs a clear action instead of merely navigating), adds vote-count display on the garden vote icon with a helper function and a matching unit test, and updates CSS/browser tests accordingly, touching multiple layers coherently. Side A is a small, focused bugfix (skip pinned Reddit posts) with a good targeted test, which is solid but narrower in scope and impact than B's multi-file behavioral correction.

B delivers lasting product fixes: pairwise vote counts on garden rows (with a focused helper + unit test), HUD pin control changed from a misleading item link to a real unpin POST, matching browser coverage, and supporting CSS/docs. A is a clean, tested Reddit import filter for stickied/pinned posts, but it is a narrower data-hygiene tweak with less ongoing impact on the app.

Side B adds meaningful user-facing functionality and supporting infrastructure: it introduces pairwise vote counts in the garden UI via a new `edge_vote_count_for_pair` helper, changes the pin HUD into an in-place unpin action using `POST /ui`, updates styling, and adds both unit and browser tests to verify the behavior. Side A is a solid, targeted bug fix that skips stickied/pinned Reddit posts during import with a helper and regression test, but its scope and long-term impact are narrower.

Side A fixes a real functional bug (pinned/stickied posts polluting import results) with a targeted implementation plus a dedicated regression test. Side B is a reasonable cleanup/simplification (removing a redundant toolbar action and always-SSR-ing the compose slot) but is more of a refactor/dead-code removal without a new capability or bugfix, and adds no new tests.

B removes a redundant ExpandNewThreadForm action, handler, toolbar POST, and tests, SSR-ing #new-thread-ui-slot on home like room pages so compose is one consistent path instead of collapsed-then-morph. A is a correct, tested filter for stickied/pinned Reddit children, but it is a narrow import tweak versus B’s lasting UI simplification and deleted surface area.

Side A fixes a concrete data-import issue by filtering stickied/pinned Reddit posts during subreddit listing parsing, adds a dedicated helper, and includes a regression test covering both `stickied` and `pinned` flags. Side B simplifies the HTML/UI flow by removing the `ExpandNewThreadForm` action and server-rendering the compose slot on the home page, but it is primarily a refactor and UX consolidation rather than a functional correctness improvement.

Side B fixes a real cross-cutting bug (hardcoded staging hostname breaking custom-domain OAuth/redirects) by consolidating logic into a shared util fn and using dynamic HOSTNAME/window.location, touching multiple backend integrations and deploy config consistently. Side A is a small, well-tested but narrow fix skipping pinned Reddit posts, valuable but of much smaller scope and impact than B's multi-file correctness fix.

B replaces scattered hardcoded host/case logic with a shared HOSTNAME-driven get-base-url (plus window.location.origin on the client), fixing OAuth/redirect correctness across login, Linear, Spotify, Twitter, and YouTube and enabling real staging deploys—broader lasting design impact than A’s narrow Reddit filter. A is a clean, tested skip of stickied/pinned children, but it only trims one import path and does less for cross-environment correctness.

Side B centralizes base URL generation into a shared utility, replaces multiple hardcoded environment/hostname checks across OAuth, login, and callback code with that utility, uses the browser origin when available, and updates deployment to staging, improving configurability for custom hosts. Side A is a focused correctness fix that skips stickied/pinned Reddit posts during import and adds a targeted regression test, but it affects a narrower part of the system.

Side B implements a full, working feature end-to-end (CLI `room create` command, RPC handler simplification, event/type cleanup removing unused ThreadVisibility, updated docs and integration/bb tests), representing broader lasting functional and architectural value. Side A is a small, well-tested but narrow bugfix (skip pinned Reddit posts) that is correct and useful but much more limited in scope compared to B's feature-plus-cleanup work.

B adds the end-to-end `room create` CLI/RPC path and simplifies the domain (drops `ThreadVisibility`/`RoomState`, rooms become a `HashSet` of private ids) with matching tests and docs—core product surface. A only skips stickied/pinned Reddit children in `parse_children` plus one unit test, a correct but narrow import filter.

Side B adds a complete user-facing room creation path to the CLI, wires it through the RPC layer, updates the protocol by removing the unused visibility parameter, simplifies room storage from a HashMap to a HashSet where only existence is needed, and updates tests and documentation accordingly. Side A is a solid targeted bug fix that skips stickied/pinned Reddit posts during import and adds a regression test, but its impact is narrower than the end-to-end feature and API simplification in Side B.

Side B is a substantive type-safety refactor that threads CanonicalItemUrl through resolve_item, validation, scope-rank computation, and pair selection, eliminating repeated string-to-newtype conversions and reducing risk of key-mismatch bugs, backed by real call-site updates across multiple files. Side A is a small, focused bugfix (skip pinned Reddit posts) with a test, which is valuable but narrower in scope and impact than B's broader structural improvement.

B threads CanonicalItemUrl through resolve_item, validation, pair/rank RPCs, and connectivity helpers and adds Deref on href newtypes, cutting repeated String↔canonical wrapping across the API core—a lasting type-design improvement. A is a correct, tested Reddit importer tweak (skip stickied/pinned children) but is a narrow edge-case filter with local scope only.

Side B makes a broad, lasting type-safety refactor by changing `resolve_item` to return `CanonicalItemUrl` instead of `String`, propagating canonical URL types through validation, ranking, RPC logic, connectivity calculations, and pair selection, while also adding `Deref<str>` implementations to reduce string conversions. Side A fixes a specific importer behavior by skipping stickied/pinned Reddit posts and adds a focused regression test, but its impact is limited to one import path compared with B's architectural improvement across many APIs.

Side B implements a real DSL redesign (explanation-first vote syntax, block-prefix parsing logic) with corresponding parser changes, error handling, and updates across many test fixtures, docs, and browser tests, representing substantial lasting design work. Side A is a small, focused bugfix (skip pinned Reddit posts) with a test, which is valuable but far narrower in scope and impact than B's language-level change.

B redesigns the core sorter DSL so vote explanations lead and items stay title-then-body, with real parser/API/UI changes plus fixture updates—lasting product/language design. A is a correct, tested Reddit import filter for stickied/pinned posts, but it is a narrow integration tweak versus B’s central syntax and ingest model.

Side B implements a substantive DSL redesign by changing vote syntax to use leading explanation blocks, refactoring the parser (`parse_block_prefixed_statement` vs. item parsing), updating UI generation, documentation, fixtures, and adding parser tests for the new semantics and error cases. Side A is a valuable targeted bug fix that skips stickied/pinned Reddit posts during import with a helper and regression test, but its impact is much narrower than the cross-cutting language and parser change in Side B.

B implements a coherent, tested-in-context UX flow change (fragment-based auth response, JS morph handling, layout unification, CSS across both themes) touching multiple coordinated files, representing meaningful feature work. A is a small, well-scoped bugfix with a unit test for skipping pinned Reddit posts, which is solid but narrower in scope and impact than B's cross-cutting improvement to the auth flow architecture.

B delivers a lasting auth UX redesign: POST responses become HTML fragments with poem-JS innerHTML morphing, unified layout usage, and inline success/error handling—structural product improvement across auth.rs, html, and themes. A is a correct, well-tested filter for pinned Reddit posts, but it is a narrow import tweak with far less systemic impact.

Side B redesigns the auth form flow to return HTML fragments instead of redirects, updates the shared Poem JavaScript to morph form contents from non-empty responses, refactors the auth templates for reuse, and adds supporting styling, enabling inline validation and success handling without page reloads. Side A is a solid targeted bug fix that filters stickied/pinned Reddit posts during import and includes a regression test, but its impact is narrower than the broader, reusable interaction infrastructure added in Side B.

Side A fixes a real, self-contained bug (pinned posts polluting ranked imports) with a clear implementation and a targeted regression test. Side B is a fragile fix-up that switches a fallback default to a panic (`.expect(...)`) on missing data, which risks introducing crashes on malformed/edge-case input rather than clearly improving correctness, and mostly consists of doc-comment tweaks and index-off-by-one churn.

A adds lasting import logic: skip stickied/pinned Reddit children with a small helper and a focused unit test, improving data quality at the source. B mainly tightens indexing (drop unwrap_or(0)/1-based optionality for expect + 0-based paths, always render the link, doc/test tweaks)—valuable consistency, but more corrective of local model/UI wiring than a new durable behavior.

Side A fixes a concrete import behavior by skipping Reddit stickied/pinned posts during subreddit listing parsing, adds a dedicated helper checking both `stickied` and `pinned` flags, and includes a focused regression test verifying only normal posts are imported. Side B mainly changes an optional lookup into an asserted invariant, updates indexing semantics/documentation, and adjusts tests and UI links, which is valuable for consistency but is a narrower refactor rather than a user-facing correctness fix.

Side A adds a precise, tested behavioral fix (skipping stickied/pinned Reddit posts) with clear correctness value and regression coverage. Side B is essentially a mechanical cleanup—deleting a stale duplicate forum.rs and re-exporting already-split modules—valuable for resolving a module ambiguity but mostly code relocation without new functional value or tests.

A adds a precise behavioral filter (child_is_pinned on stickied/pinned) inside parse_children plus a focused unit test, improving import quality. B only deletes the leftover monolithic forum.rs and re-exports already-split forum/* modules to resolve Rust module ambiguity—necessary hygiene but no new logic or design beyond the prior split.

Side A makes a functional behavior change by filtering Reddit listing entries with `stickied` or `pinned` flags in `parse_children`, preventing pinned posts from being imported, and adds a targeted regression test covering both flags. Side B is primarily a structural refactor that deletes the old `forum.rs` and reorganizes the same code into `forum/mod.rs` and submodules to resolve module layout, which improves maintainability but adds little new runtime behavior.

B adds substantial new functionality (image/link extraction, dedicated render module, thumbnail rendering in lists, and full-size images in post detail) with a new module, CSS, and fixture-backed tests, providing broader lasting value despite the terse commit message. A is a small, focused, well-tested bugfix (skipping pinned posts) that is correct and clean but narrower in scope and impact than B's feature work.

B adds lasting product surface: EntityData image/link fields, Reddit image/URL parsing, a new render module with post cards/thumb rows, and HTML/CSS integration plus a fixture test. A is a correct, tested filter to skip stickied/pinned listing children, but it is a narrow import tweak versus B’s end-to-end Reddit presentation path.

Side B adds substantial new functionality across the data model and UI: it extends `EntityData` with `image_url` and `link_url`, extracts those fields from Reddit payloads, introduces reusable Reddit-specific rendering for post cards and thumbnail rows, wires it into existing HTML, and includes fixture-backed tests. Side A is a targeted correctness fix that skips stickied/pinned subreddit posts during import with a focused helper and regression test, but its scope and impact are much narrower than the end-to-end feature added in Side B.

Side A is a small, focused, correct bugfix (skip pinned/stickied Reddit posts) with a clear test verifying the exact behavior, adding real lasting value with minimal risk. Side B is a sprawling, vague 'reconfigure' commit that reworks the entire ID/scope/state model (renaming settlement->journal, scope->ItemId tree, new files) with much higher risk of regressions and no clear single purpose, making it harder to attribute clean ownership value despite its size.

B is a foundational redesign: ItemId path model, GlobalTree/NodeState, journal worker replacing settlement scopes, breadcrumbs/entity UI, and parser/state migration—core lasting architecture. A is a small, correct filter (skip stickied/pinned children) plus one test, valuable but narrow against B’s structural contribution.

Side B introduces a substantial architectural shift from flat subreddit scopes to a hierarchical `ItemId`/`GlobalTree` model, updating parsing, state management, UI navigation (breadcrumbs and item links), vote recording, event handling, and tests to support canonical item identities and per-node rankings. Side A is a correct, targeted bug fix that skips `stickied`/`pinned` Reddit posts during import and adds a regression test, but its impact is much narrower than the persistent data model and UI capabilities added in Side B.

Side B implements a complete, self-contained user-facing feature (garden ranking markdown copy) spanning a new module, RPC action, route wiring, unit tests, integration test, and a browser test, showing lasting design value. Side A is a small, focused bugfix (skip pinned posts) with a good targeted test, valuable but much narrower in scope and impact than B's feature addition.

B ships a full product path (new HtmlUiAction, garden copy module, ranking→markdown, UI affordances, integration + browser coverage) that users keep relying on, whereas A is a tight but narrow import filter plus one unit test. A’s stickied/pinned skip is correct and durable data hygiene, but its blast radius and ongoing utility are far smaller than B’s copy-rank feature.

Side B adds a complete end-user capability: a new `CopyGardenRank` UI action, server handler, markdown formatting logic, copy button integration across garden views, and accompanying unit, integration, and browser tests. Side A is a worthwhile, targeted bug fix that skips stickied/pinned Reddit posts during import with a helper function and regression test, but its scope and long-term impact are narrower than the new reusable clipboard feature implemented in Side B.

Side B implements a substantive feature (morphing the new vote card into the compare preview, sorting edge-history rows meaningfully, a fullscreen chromeless layout) with actual bugfix content (the preview region previously wasn't populated) plus test/CSS updates across themes. Side A is a small, correct, well-tested bugfix (skip pinned posts) that's clean but narrower in scope and impact than B's multi-file feature completion.

B delivers lasting product value: correct edge-history ratios aligned to page left/right, strength-based sort, post-success morph of the ingest preview, a reusable chromeless layout, CSS, and tests. A is a clean, tested Reddit pinned-post skip, but it is a narrow import filter versus B’s broader compare-flow design and bugfix.

Side B introduces several lasting functional improvements to the vote comparison flow: it adds a reusable chromeless fullscreen layout, updates the post-success path to morph in the newly created vote preview, normalizes vote ratios to the page's left/right orientation, sorts edge history by preference strength, and adds corresponding unit/browser test updates. Side A is a solid, targeted import bugfix that skips stickied/pinned Reddit posts and includes a regression test, but its scope and long-term impact are narrower than the multiple user-facing behavior and architectural improvements in Side B.

Side A is a focused, well-documented bugfix (skip pinned Reddit posts) with a clear commit message and a dedicated unit test proving correctness. Side B, despite its size, is a sprawling, undocumented ('fix') mix of unrelated changes (Cargo.lock/dep additions, form_template typed holes, ui_action changes) that references a new `html::vote` module without including its source file, suggesting an incomplete or non-compiling commit.

B ships core voting product work: typed `$form:i32` template holes with tests, a `/vote` flow wired through actions/UI (including post-vote `next` navigation), item-page vote CTA, and supporting slider JS/CSS. A is a correct, tested filter to skip stickied/pinned Reddit children, but it is a narrow import tweak versus B’s broader lasting feature surface.

Side A implements a focused behavioral bug fix by skipping stickied/pinned Reddit posts during subreddit import, adds a dedicated helper checking both `stickied` and `pinned` flags, updates documentation, and includes a regression test verifying only normal posts are imported. Side B is a large feature/dependency change (new routing, UI behavior, form typing, CSS, JS, and lockfile updates), but much of the patch is infrastructure and generated dependency churn rather than a clearly demonstrated correctness improvement.

Side B removes a substantial amount of legacy dual-path projection code (GitDiscovery-based fallback rendering) across constitution.py, simplifying the evidence page logic to a single source of truth and updating tests/schema accordingly, which is a meaningful architectural cleanup with lasting maintainability benefit. Side A is a small, well-tested but narrow bugfix (skip pinned Reddit posts) that is useful but far more limited in scope and impact.

B removes the dual legacy/Evidence code paths (_legacy_commit_row, projected GitDiscovery UI, optional Emission fields) so epoch/commit pages and the schema only trust Evidence envelopes— lasting architectural simplification with matching test updates. A is a correct, well-tested filter for stickied/pinned Reddit children, but it is a narrow import tweak with far less project-wide impact.

Side B removes the legacy GitDiscovery projection path across epoch, commit, and patch views, making the application rely solely on Evidence envelopes, tightening required Emission metadata, and updating integration/tests to match the current schema. Side A is a solid targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds regression tests, but its impact is narrower than the project-wide simplification and consistency introduced by Side B.

Commit B fixes a real deadlock bug (holding a RwLock guard across nested read/write calls in RPC handlers) plus adds timeouts to prevent test hangs and corrects test assertions to match actual stored username format, all substantive correctness fixes with a new integration test. Commit A is a small, clean, well-tested feature addition (skip pinned posts), but is narrower in scope and impact compared to B's deadlock fix which addresses a potentially serious production issue.

B fixes a real tokio RwLock deadlock by scoping read guards so they drop before nested read/write awaits in RoomCreate/RoomGrant, plus lasting test harness fixes (log-file piping to avoid pipe-buffer deadlock, HTTP timeouts) and an integration test. A is a correct, tested product tweak (skip stickied/pinned Reddit children) but is narrower and lower-impact than the concurrency and reliability work.

Side B fixes a concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls, preventing self-deadlocks in RPC handlers for room creation and grants. It also adds an integration test for private room creation and related test infrastructure improvements, whereas Side A is a narrower import behavior change that skips stickied/pinned Reddit posts with a focused unit test.