c_c124c217f89c94a637

Side B implements a substantial, well-tested feature: an async Reddit fetch worker with OAuth token management, rate-limit/backoff handling, JSON parsing for subreddits/posts, and integration into AppState/routes, including unit tests for URL mapping and JSON parsing. Side A mostly removes an existing theme feature and refactors URL routing (/?item= to /~/...), which is a reasonable but comparatively minor and partly destructive change (deleting theme CSS/cookie logic) with less enduring functional value.

B replaces the Reddit fetch stub with a full background broker (OAuth, rate-limit/backoff, dedup/TTL, JSON parsing for subreddits/posts) wired into browse and ensure_node—core lasting product capability. A mainly deletes the theme/cookie stack and consolidates CSS while adding cleaner `/~/` browse URLs on ItemId; useful routing design, but mostly simplification versus B’s new domain functionality.

Side B adds a substantive new capability: a background Reddit fetch pipeline with request deduplication, rate-limit handling, optional OAuth, JSON parsing into entity data, and integration into application state so browsing or ensuring a node can populate metadata asynchronously. Side A mainly refactors navigation to canonical `/~/` browse URLs and removes the theme system while simplifying static asset handling; although useful and supported by tests, much of the patch is restructuring and feature removal rather than adding enduring functionality.

Side A implements a complete, testable Reddit fetch worker (OAuth token handling, rate-limit/backoff logic, URL mapping, JSON parsing for posts/subreddits, and unit tests) that is real, functioning capability wired into AppState and routes. Side B is a smaller, valuable refactor—fixing duplicate `#entity-section` ids via a per-item selector and deduplicating vote-compare card rendering—but it's a cleanup/bugfix on top of existing UI rather than new lasting functionality.

A implements a full Reddit fetch pipeline (broker worker, OAuth, rate-limit/backoff, URL mapping, JSON parsers, tree updates, and browse/ensure wiring)—core lasting product capability. B mainly refactors UI targeting (id→data-entity-section) and reuses entity_section on the vote page with CSS cleanup; useful DRY/SSE polish but much smaller lasting design impact.

Side A replaces a Reddit import placeholder with a working background fetch system, including request queuing, OAuth support, rate-limit handling, caching/deduplication, JSON parsing, integration into application state, and automatic fetch triggering when Reddit items are viewed or added. Side B is primarily a UI refactor that introduces per-item entity-section selectors for DOM morphing and reuses the existing entity component in the vote page, improving maintainability but adding far less core functionality.

Side B implements a substantial, functional feature (a real Reddit fetch worker with OAuth, rate-limit backoff, dedup, JSON parsing, and unit tests) that provides real lasting functionality wired into the app state and HTML handler. Side A is a useful but small config simplification (collapsing two kaocha suites into one glob pattern), which is a low-risk convenience change with much less substance and no new tested behavior.

B implements a full Reddit fetch pipeline (broker, OAuth, rate-limit/backoff, JSON parsing, tree integration, and tests), turning a stub into working product behavior. A only rewrites tests.edn to a single auto-discovery suite—useful hygiene, but a small config change with far less lasting system impact.

Side B implements substantial new functionality: a background Reddit import system with request queuing, OAuth support, rate-limit handling, JSON parsing, integration into application state and request flow, plus unit tests for URL mapping and parsing. Side A only changes Kaocha configuration from manually enumerated test namespaces to a single auto-discovered suite, which improves maintainability but does not add comparable runtime capability.

Side A adds a real, working feature: a background Reddit-fetch worker with OAuth, rate-limit/backoff handling, JSON parsing, and unit tests, properly wired into state.rs and html/mod.rs. Side B is a disorganized dump of loose top-level files (ranking.rs, reducer.rs, vote.rs, forms.rs, etc.) placed outside server/src, some containing raw shell-prompt artifacts from a `cat` command, indicating it's an unintegrated snapshot rather than a coherent commit.

Commit A delivers a complete, integrated Reddit fetch broker (OAuth, rate-limit backoff, dedup worker, JSON parsers, browse/state hooks, tests) that replaces a stub with production-ready code. Commit B is mostly unintegrated scrapes/notes (tdsl ideas, shell-prompt-contaminated dumps of parser/ranking/reducer/vote) plus minor scripts, adding far less durable project value despite higher line count.

Side A replaces a Reddit import placeholder with a complete background fetch system: queued async worker, OAuth support, rate-limit handling, JSON parsing into entity data, request deduplication/caching, integration into application state, and tests, plus triggering fetches from browse/create paths. Side B adds many planning documents and large code drops, but several files contain accidental terminal transcripts rather than clean source, and much of the content is speculative or scaffolding rather than a clearly integrated, production-ready feature.

Side B implements a real, functional feature (a background Reddit fetch worker with OAuth, rate-limit handling, backoff, JSON parsing, and integration into the tree/state, backed by tests), delivering concrete user-facing value. Side A adds a useful but narrower dev-only CLI tool (compile/scan) that mainly wraps existing server logic for offline linting, which is helpful tooling but less impactful than shipping working product functionality.

B replaces a stub with a real Reddit fetch path (background broker, OAuth, rate-limit/backoff, URL mapping, JSON parsing, and wiring into browse/ensure_path), which is lasting product capability. A is solid, tested offline DSL/JSONL tooling, but it is workspace/dev-only support rather than core runtime behavior; B’s impact outweighs A’s polish despite A’s cleaner docs.

Side A adds a substantial, reusable offline tooling capability by introducing a new `sorterc` workspace binary plus shared `server::offline` APIs for compiling `.sorter` files, replaying JSONL event logs, diagnostics, and tests. Side B adds Reddit background fetching and request integration, but it is more specialized, includes a placeholder-style `todo` file, and introduces significant networking complexity without the same broadly reusable development and validation infrastructure.

Side B replaces a no-op stub with a real, tested Reddit fetch worker including OAuth token handling, rate-limit/backoff logic, JSON parsing for subreddits and posts, and wiring into the item-fetch path plus unit tests for URL mapping and parsing. Side A mainly wires a new CLI room-create subcommand end-to-end and removes an unused room 'visibility' concept, which is useful cleanup and plumbing but smaller in scope and impact than the working external-integration feature added in B.

Commit A lands the end-to-end private room create path (CLI RoomCmd + RPC usage) and a lasting domain cleanup (drop ThreadVisibility, rooms as HashSet) with docs and tests aligned. Commit B is a large, well-structured Reddit fetch worker, but it is a peripheral import path still marked incomplete (rendering etc. in todo), so it adds less durable product core than A.

Side A delivers a complete user-facing capability by adding a `room create` CLI command wired through the existing RPC, improving documentation, and simplifying the room model by removing the unused visibility field and replacing the room registry with a `HashSet` of room IDs. Side B introduces substantial Reddit import infrastructure (background worker, OAuth, rate limiting, parsing, and fetch triggers), but it is a larger, partially integrated feature with placeholder/TODO elements and more implementation complexity, whereas Side A provides a cohesive, immediately usable feature and durable model cleanup.

Side A implements a substantial new feature: a background Reddit worker with OAuth token handling, rate-limit/backoff logic, JSON parsing for subreddits/posts, and integration into the browse route and AppState, complete with unit tests. Side B is a real but narrower type-safety refactor (String -> CanonicalItemUrl, adding Deref impls) that reduces stringly-typed code and removes redundant parsing, which is valuable but lower-impact than shipping a working external-data integration.

A delivers a complete, production-shaped Reddit import path (background broker, OAuth, rate-limit/backoff/dedup, JSON parsers, UI trigger, and wiring into AppState) that adds real external capability. B is a worthwhile type-hygiene refactor (Deref on URL newtypes and threading CanonicalItemUrl through resolve_item/pair/rank helpers) but only removes string churn with no new behavior.

Side A adds substantial new functionality: an asynchronous Reddit import pipeline with a background worker, OAuth support, rate-limit handling, JSON parsing into project entities, and integration that triggers fetches when Reddit items are added or browsed. Side B is a useful type-safety refactor that replaces many String usages with CanonicalItemUrl and adds Deref implementations, but it largely restructures existing code rather than introducing new project capabilities or fixing a significant behavioral issue.

B delivers a complete, testable feature (Reddit import) with real production concerns handled—OAuth token refresh, rate-limit/backoff, dedup/caching, and comprehensive unit tests for URL mapping and JSON parsing—replacing a previous stub. A is a solid refactor (unified /ui endpoint with $form-hole JSON templating) that reduces duplication and adds tests, but it's mostly indirection/plumbing rather than new capability, and its generic templating mechanism adds complexity whose long-term payoff is less certain than B's concrete, working integration.

A adds a lasting UI protocol: form_template hole-filling, HtmlUiAction, and a unified POST /ui handler that reuses extracted web_post runners and lazy-expands new-thread forms—core product architecture with tests. B implements a solid Reddit broker (OAuth, rate limits, parse/map, background worker) replacing stubs, but it is an external integration plus minor noise (.env gitignore, todo), so it trails A’s foundational design impact.

Side A introduces a new generalized HTML UI action system with a single `/ui` endpoint, reusable `run_*` handlers extracted from existing web post logic, and a JSON form-template mechanism (`$form` substitution) backed by tests. Side B adds a substantial Reddit background fetcher with OAuth, rate limiting, and parsing, but much of it is infrastructure tied to an external integration, whereas Side A delivers a reusable architectural improvement that consolidates browser UI handling and reduces duplication across the project.

Side B implements substantial new functionality: a real Reddit OAuth-enabled fetch worker with rate-limiting, backoff, caching, URL mapping, JSON parsing for subreddits/posts, and unit tests, replacing a placeholder stub—this is a foundational feature. Side A is a smaller, focused bugfix (correct child attachment under parent without ensure_path pollution, unranked label fix) plus test updates, which is valuable but narrower in scope and impact than the feature Side B introduces.

B introduces the durable Reddit subsystem (broker/worker, OAuth, rate-limit/backoff, URL mapping, JSON parsers, AppState wiring), whereas A is a follow-on fix: children attach via apply_entity_under_parent instead of link_child+ensure_path, ranking_panel/child_label title lookup, and tighter SSE/integration tests. That foundational import path outweighs A's correct but narrower wiring and UI label repairs.

Side A fixes concrete Reddit import behavior by introducing `apply_entity_under_parent` to attach imported children without `ensure_path` creating unwanted `/comments` hierarchy, and updates the ranking panel to display imported child titles from the tree instead of fallback IDs. It also updates all call sites and adds integration tests covering SSE updates, child fetching, and the corrected UI, whereas Side B is a large initial Reddit-fetch implementation with infrastructure but less directly tied to a verified user-facing correctness fix.

Side B implements a substantial, self-contained new feature: an async Reddit fetch broker with OAuth handling, rate-limit backoff, caching, JSON parsing for subreddits/posts, and tests, wired cleanly into AppState and the browse handler. Side A is a large, mostly mechanical DSL syntax reshuffle (trailing to leading explanation blocks) touching many tests/fixtures/docs, which is a real but narrower, more churn-heavy change with less net new capability despite its size.

A redesigns the core sorter DSL (block/explanation-first votes, clearer item bodies) with real parser changes in dsl.rs plus coordinated docs/UI/fixture updates, which shapes how every ingest works. B adds a solid Reddit fetch worker (OAuth, rate limits, URL mapping) but it is a peripheral, still-incomplete integration on a placeholder path rather than a lasting core-language change.

Side A implements a substantive DSL redesign by changing vote syntax to use leading explanation blocks, refactoring the parser to support pending block parsing, adding validation and error cases, updating UI generation, and comprehensively updating tests and documentation to match the new grammar. Side B adds a useful but incomplete Reddit background fetch pipeline and request hooks, but much of it is new integration code without equivalent end-to-end validation and includes placeholder planning, making its lasting project impact smaller than the coordinated language and parser change in Side A.

Side B implements substantial, working end-to-end functionality: cookie-based web sessions, room-scoped thread navigation, a unified web posting form wired to the existing RPC layer, and access-control checks for private rooms, all integrated into the router. Side A adds a genuinely useful background Reddit-fetch worker with rate-limiting and OAuth plus tests, but it includes unrelated scratch content (a speculative 'plan2.md' chat transcript in B is noise, but A's diff is cleaner overall); still, B's changes wire up more real, load-bearing UI/auth functionality that the app will depend on going forward, despite the plan2.md clutter.

B delivers lasting core product value by wiring browser sessions (HttpOnly slug_session cookies, /login|/logout, optional_principal), a real /post web ingest path reuse of RPC, and full private-room UI (ThreadNav scoping, /r/... room/thread/post/expand routes, grant checks, compose forms, home room list). A is a solid specialized feature (RedditBroker worker, OAuth, rate-limit/backoff, JSON parsers + tests replacing a stub) but narrower and less foundational than making multi-room forum usable in the browser; B’s plan2.md is pure noise and does not change the ranking.

Side A replaces a Reddit import placeholder with a working background fetch system: it adds a broker/worker, OAuth support, rate-limit handling, URL mapping, JSON parsing into EntityData, and integrates lazy fetching into state and page browsing. Side B delivers substantial UI wiring for browser sessions, room pages, posting, and routing, but it is primarily application interface expansion, while Side A establishes a reusable backend integration with deduplication, caching, and tests that adds enduring infrastructure.

Commit A adds substantial new functionality: a real background Reddit fetch worker with OAuth, rate-limit handling, backoff, JSON parsing for subreddits/posts, and integration into the tree/state, plus tests for URL mapping and parsing. Commit B simplifies the UI by ripping out a large complex (but working, tested) autocomplete graph and replacing it with a simpler paste-and-go parser, which is reasonable cleanup but net removes more functionality/tests than it adds, and its 'value' is largely subtractive/simplifying rather than building new capability.

Commit A replaces a no-op Reddit placeholder with a complete background broker (OAuth, rate-limit/backoff, dedup, JSON parsers for subreddits/posts, tree integration and fetch-on-browse), delivering durable core import capability. Commit B mainly deletes an over-engineered ~1800-line keystroke graph plus race-prone JS/Playwright harness in favor of a short paste-and-go URL parser; that cleanup is valuable but less foundational than A’s working data-import path.

Side A implements substantial new functionality: a background Reddit fetch broker with request deduplication, rate-limit/backoff handling, optional OAuth, JSON parsing into project entities, integration into application state, and automatic fetch triggering when Reddit items are browsed or created. Side B mainly removes a large autocomplete/transition-graph system in favor of a much simpler paste-and-go URL parser and redirect UI, reducing complexity but largely replacing existing behavior rather than adding enduring infrastructure.

Side A implements a real, working feature: a background Reddit fetch worker with OAuth, rate-limit handling, backoff, JSON parsing into EntityData, and unit tests, wired into the UI to actually populate node data. Side B is largely a structural refactor (settlement->journal rename, scope->ItemId tree plumbing, path canonicalization) that is valuable groundwork but leaves reddit.rs as an unchanged placeholder (fetch_reddit_entity still returns None), so it delivers less concrete end-user functionality than A's completed fetch pipeline.

B replaces flat string scopes/GroupMap/settlement with the hierarchical GlobalTree, rich ItemId canonicalization/parents/breadcrumbs, NodeEnsured events, journal worker, and UI wired to tree nodes—core lasting design. A adds a solid RedditBroker (OAuth, rate limits, JSON parse, tests) on that stub, but it is feature work that depends on B’s model rather than reshaping the project.

Side A turns the Reddit integration from a placeholder into a working subsystem: it adds a background fetch broker, OAuth support, rate-limit handling, request deduplication/caching, JSON parsing into EntityData, automatic fetch triggering from navigation and node creation, and tests. Side B mainly restructures the application around hierarchical ItemId/GlobalTree concepts, updates the UI to use breadcrumbs and node-based rankings, and renames the settlement worker to a journal, but much of it is architectural refactoring and scaffolding, whereas Side A delivers substantial new functionality that persists in the project.

B implements a real, self-contained feature: a background Reddit fetch worker with OAuth token handling, rate-limit/backoff logic, JSON parsing, and unit tests, wired cleanly into AppState—genuine new capability with lasting value. A is a URL-refactor that centralizes room-route encoding (good) but changes the public room URL format from '/r/{short}/{slug}' to '/r/{short}{slug}' (ambiguous, harder to read) and bundles in a large, seemingly unrelated speculative youtube-normalization/url-identity-test module that adds significant surface area without clear necessity for the stated 'url refactor' goal.

A lands durable core design: centralized room path encoding (`room_route_segment` / fixed-width short id), route and link call sites rewritten to one segment, plus real external URL identity normalization (YouTube rewrites, sorted query pairs) with tests—replacing scattered `split_once('/')` URL building. B is a solid vertical feature (Reddit broker, OAuth, rate-limit/dedup worker, parsers) that replaces a stub, but it is product-specific integration plus a scratch `todo` file, so it adds less lasting cross-cutting value than A’s URL/types foundation.

Side A performs a broad but coherent refactor that centralizes room URL encoding/decoding into shared helpers (`room_route_segment`, `room_id_from_route_segment`, `ROOM_SHORT_ID_LEN`), updates routing and link generation consistently across the server, and adds URL normalization logic with tests, reducing duplicated parsing and making URL handling more maintainable. Side B adds a substantial Reddit background fetch pipeline with OAuth, rate limiting, and parsing, but it is a new feature with placeholders still remaining (for example the TODO file and no rendering changes), making its long-term project impact less certain than A's foundational cleanup and normalization.

Side A implements a genuinely new subsystem (a dedicated Reddit fetch worker with dedup, backoff, rate-limit handling, OAuth token refresh, and JSON parsing for both subreddits and posts) backed by unit tests, integrating cleanly into AppState and the browse handler. Side B adds a useful but smaller UX feature (pool-scoped vote pairing) that mostly threads an optional parameter through several existing functions and adds a UI link, which is real but far less substantial in scope and risk than A's networking/backoff/OAuth logic.

A replaces a stub Reddit fetch with a full background broker (OAuth, rate-limit/backoff, dedup, JSON→EntityData mapping, browse/ensure_path hooks, and unit tests), adding a lasting data-import subsystem. B is a useful but smaller product polish: threading an optional pool through /vote, pair suggestion, and post-success nav plus a “vote on children” link—clear UX value without new infrastructure.

Side A implements a complete Reddit integration pipeline: a background fetch broker, OAuth token handling, rate-limit/backoff logic, JSON parsing into project entities, request deduplication/caching, and wiring it into application state and page loading so Reddit items are populated on demand. Side B is a useful feature that scopes pairwise voting to a parent item's children and threads the new pool parameter through the UI and navigation, but it is a localized workflow enhancement compared with the new external data ingestion subsystem introduced in Side A.

Side B implements a substantial, real feature: a background Reddit fetch worker with OAuth, rate-limit/backoff handling, JSON parsing for posts/subreddits, URL mapping, and wiring into AppState/HTML routes, backed by several unit tests—this is genuine, functional lasting capability. Side A is a well-tested refinement to an already-existing pair-selection heuristic, which is useful but more incremental/tuning-focused than a new capability.

B replaces a Reddit fetch stub with a lasting broker/worker (OAuth, rate-limit backoff, dedup/TTL, JSON mapping/parsing, browse/ensure_path hooks), which is foundational product capability. A meaningfully improves core pair selection (attach-isolate before isolate-isolate, then rank-adjacent zip) with solid tests, but it refines an existing path rather than delivering a new end-to-end subsystem.

Side B implements a substantial new capability: an asynchronous Reddit import pipeline with a background worker, request deduplication, OAuth support, rate-limit handling, JSON parsing into entity data, integration into application state and page loading, plus tests for URL mapping and parsing. Side A improves pair-selection heuristics with better bridge prioritization and rank-based refinement ordering backed by tests, but it is a targeted algorithm refinement rather than a broad new feature.

Side A delivers a coherent, tested feature (server-rendered theme cookie handling plus room-scoped canonical URL helpers) with unit tests and a genuine bugfix (theme cookie dropped on login). Side B's Reddit importer, while more elaborate, ships with rough edges—a leftover 'sorter2' user-agent string, a stray 'todo' file admitting the feature is unfinished, a duplicated reqwest dependency, and an auto-fetch-on-view behavior that contradicts its own todo note about fetching only on explicit request—making it less polished and less clearly finished than Side A's focused, tested changes.

A lands durable product correctness: cookie/SSR theme switching with auth cookie re-issue, plus room-aware wire URLs (`item_path_for_api_in_room`, `forum_thread_web_url`) wired through RPC with tests—fixing private-room API links and CLI hints. B adds a solid Reddit fetch worker (OAuth, rate limits, parse/map tests), but it is a narrower external-import foundation still marked incomplete versus A’s core API/UX paths.

Side A delivers two lasting functional improvements across the codebase: a complete server-backed theme system (cookie persistence, theme selection, propagation through layouts, preserving the theme across authentication redirects) and correct room-aware URL generation for RPC/web responses via new helper functions with accompanying tests. Side B adds substantial Reddit background-fetch infrastructure with OAuth, rate limiting, and parsing, but it is only partially integrated (triggering fetches while rendering/importing) and leaves rendering and broader functionality unfinished, reducing its immediate long-term project value.

Side A fixes a real design flaw in B's auto-fetch-on-browse behavior by making imports explicit user actions, persists the full API payload through the event log for correct replay/audit (via a new EntityImported event and apply_entity_raw), and adds solid regression tests (replay test, fixture-based Reddit test, and an end-to-end mock-API integration test). Side B is the initial (and reasonable) implementation of the Reddit worker/broker, but it auto-fetches on every browse without persisting raw payloads, which A explicitly corrects and extends with more durable, testable design.

A turns B’s in-memory-only auto-fetch into a durable design: EntityImported events store full API payloads, replay restores entity_raw + derived views, and fetch is an explicit UI action with configurable API bases. B still matters as the first real RedditBroker (OAuth, rate limits, URL mapping, parsers), but much of that surface is reshaped by A, and A adds the fixture plus end-to-end mock import test that locks the behavior in.

Side A substantially evolves the Reddit import design by replacing automatic fetch-on-browse with an explicit user-triggered fetch UI, persisting full API payloads as `EntityImported` events, replaying them into state, adding configurable API endpoints, dotenv support, and tests for replay and end-to-end import. Side B mainly introduces the initial background Reddit fetch worker and automatic fetching on browse, but lacks the event-sourced persistence, explicit fetch workflow, configurability, and broader architectural improvements that make Side A's changes more durable.

Side A implements a real, working feature (a background Reddit fetch worker with OAuth, rate-limit handling, caching, and JSON parsing, wired into the tree/state) with its own tests, delivering concrete new functionality. Side B is a substantial but purely mechanical refactor moving path/URL types from server into a shared types crate, preserving identical behavior without adding new capability, so its value is organizational rather than functional, and it duplicates rather than improves logic (mostly copy-paste plus type wrapping).

A replaces a stub with a full Reddit import path: background broker/worker, OAuth, rate-limit/backoff/dedup, JSON parsing into EntityData, browse/ensure_path hooks, and focused tests—real lasting product capability. B centralizes existing path canonicalization and wire URL helpers into slug-types (GardenItemUrl/ForumThreadUrl) for clearer typed APIs, but is mostly relocate/wrap refactor without new behavior.

Side A adds substantial new functionality: a background Reddit import system with OAuth support, rate-limit/backoff handling, request deduplication, JSON parsing into project entities, integration into application state, and automatic fetch triggering when Reddit items are browsed or added. Side B is a useful architectural refactor that centralizes path and URL types into `slug-types` and updates API consumers to use those newtypes, but it largely preserves existing behavior rather than adding new capabilities.

Side A implements a substantial, working feature: a rate-limited, deduplicated background Reddit-fetch worker with OAuth handling, JSON parsing, URL mapping, tests, and wiring into AppState/routes—real lasting functionality. Side B is a small, correct bugfix that moves a zero-ratio guard earlier to avoid ghost items, valuable but minor in scope compared to A's feature work.

A ships a full Reddit import path (broker/worker, OAuth, rate-limit/backoff, URL mapping, JSON parsers, AppState wiring, and unit tests) that turns a placeholder into lasting product capability. B is a real, precise reducer correctness fix (zero-ratio guard moved before ensure_item/voted_pairs) but is narrow in scope versus the feature subsystem in A.

Side A replaces a Reddit import placeholder with a complete background-fetch subsystem: it adds an async broker/worker, OAuth support, rate-limit handling, JSON parsing into EntityData, request deduplication/caching, integrates fetch triggering into application state and browse flow, and includes tests. Side B is a good correctness fix that moves the zero-ratio early return before ensure_item and voted_pairs insertion to prevent ghost items and stale voted pairs, but its scope and lasting impact are much smaller than the new functionality and infrastructure added in Side A.

Side A turns the previously stubbed-out Reddit import into a real, working feature: a background worker with OAuth token management, rate-limit handling/backoff, dedup, JSON parsing for both subreddits and post listings, wired into the UI, plus solid unit tests for URL mapping and parsing. Side B is a valuable refactor (bridge-based pair suggestion algorithm, ID-normalization fix, morph-based vote UI, test infra cleanup), but it builds on and refines functionality that side A actually introduced, making A's contribution more foundational and self-contained.

B delivers the core pairwise-vote product surface (vote.rs UI, in-place morph after record instead of navigation churn) plus lasting algorithmic design in pair.rs (bridge-first unvoted pair selection with tests) and real ID correctness via ItemId::from_storage. A is substantial Reddit ingestion plumbing (worker, OAuth, rate limits, parsers) that replaces a stub, but it is more peripheral integration than B’s ranking-loop and path-normalization work.

Side A implements a substantial new Reddit integration: it adds an asynchronous background fetch broker with request deduplication, OAuth support, rate-limit/backoff handling, JSON parsing into project entities, automatic fetch triggering from browsing and item creation, and supporting tests. Side B contains useful refactoring and new pairwise voting UI logic (including pair selection, morph updates, and item ID normalization), but much of it reorganizes or extends existing UI behavior, whereas Side A introduces a major new subsystem with lasting functionality.

Side A is a disciplined, well-motivated refactor that fixes real correctness issues (strict wire-identity validation, optional delegate, removing ad-hoc reducer-side identity rewriting) and updates the entire call graph and test suite consistently across CLI, server, and types crates. Side B adds a genuinely useful Reddit-fetch feature with reasonable async/rate-limit design and tests, but the commit is poorly scoped/labeled ('reddit'), bundles unrelated changes (.gitignore, duplicate reqwest dependency, a stray 'todo' file), and is less clearly integrated with lasting architectural clarity.

A permanently hardens core identity/API design: splits path vs identity modules, makes wire form naked (no @), optional delegate, and stops the reducer from rewriting principals/agents—contract and correctness across auth, ingest, feed, and types. B replaces a reddit stub with a real broker/OAuth/rate-limit fetch path, but that is an additive integration on browse/tree rather than a foundational domain fix.

Side A introduces a substantial architectural refactor by separating path normalization into `canonical_path.rs` and identity parsing into `identity.rs`, removing identity rewriting from the reducer, making delegate identities optional, and consistently enforcing stored-form usernames/agent IDs across APIs with validation. Side B adds a useful Reddit background fetch worker with OAuth, rate limiting, and lazy fetch triggering, but it is a narrower feature addition compared with A's broad cleanup of identity semantics and API/storage invariants that affects core project design.

Side A introduces the entire Reddit fetching subsystem from scratch (background worker, rate-limit/backoff, OAuth token handling, JSON parsing for posts/subreddits, wiring into AppState/UI, plus tests), representing substantial new lasting functionality. Side B is a smaller, valuable but incremental fix on top of that existing system (forcing OAuth, retry-on-401/403, error message cleanup), which is real but narrower in scope compared to the foundational architecture A establishes.

A replaces the Reddit placeholder with the full broker/worker design (OAuth, rate-limit/backoff, URL mapping, JSON parsers, AppState/browse integration, and tests), which is the lasting feature foundation. B is a focused production fix (force OAuth when creds exist, 401/403 refresh, error truncation, fly env pin) that hardens that path but adds comparatively little new architecture.

Side A adds the core Reddit integration: a background fetch broker, OAuth support, request deduplication and rate limiting, JSON parsing into project entities, wiring into application state, and triggering fetches from browsing and path creation. Side B is a targeted refinement that improves the existing integration by requiring OAuth when configured, refreshing tokens after 401/403 responses, and producing clearer error messages for Reddit's block pages, but it builds on the infrastructure introduced in Side A.

A fixes a real security bug (votes silently falling back to anonymous instead of failing closed), adds tests for the sanitize/redirect logic, pins the durable dependency to an immutable rev instead of a mutable branch, and adds Secure-cookie support plus nav UX—concrete, verifiable hardening. B adds a substantial Reddit fetch worker with real logic (rate-limiting, OAuth, caching) which is useful, but is less critical to correctness/security and includes a stray 'todo' file and unrelated .gitignore tweak, making it slightly less polished/cohesive than A's tightly scoped security fix.

A delivers lasting security/correctness: fail-closed vote actors (no anon fallback), mock-OAuth gating, Secure cookies, tighter return-to sanitization with tests, plus dependency pinning—directly protecting vote integrity. B’s Reddit broker is a real feature with worker/rate-limit/OAuth design and tests, but it is product surface on top of stubs rather than core integrity fixes, and it also carries minor noise (.env gitignore, todo file).

Side A delivers durable security and correctness improvements: voting now fails closed instead of silently falling back to an anonymous actor, auth cookies gain conditional Secure handling, open-redirect sanitization is tightened and tested, mock OAuth is gated behind an explicit environment flag, and the durable dependency is pinned by immutable revision. Side B adds substantial Reddit import infrastructure with background fetching, OAuth support, and parsing, but it is largely new feature code with a TODO trail, whereas Side A fixes authentication and reproducibility issues that have broader long-term impact on project integrity.

Commit B implements a substantial, working feature: a background Reddit fetch worker with OAuth token handling, rate-limit/backoff logic, URL mapping, JSON parsing, and integration into app state/routing, backed by unit tests. Commit A is a small, valuable but narrow security fix (HTML sanitization via ammonia) plus a large generated Cargo.lock diff, which is useful but much smaller in scope and lasting design impact than B's core feature implementation.

B replaces a stub Reddit fetch with a full broker/worker (OAuth, rate limits, URL mapping, JSON parsing, tree updates, and tests), which is core product capability. A is a necessary XSS harden (ammonia + render call sites) but is a small follow-on safety layer on body_html, not comparable in lasting scope to the integration itself.

Side B implements a substantial Reddit integration: it adds a background fetch broker with deduplication, rate limiting, OAuth support, JSON parsing into EntityData, automatic fetch triggering from application state and browse requests, and accompanying tests. Side A fixes an important XSS risk by introducing Ammonia-based sanitization before rendering Reddit HTML with tests, but it is a focused security hardening change affecting only rendering, whereas Side B establishes a major lasting subsystem for Reddit data ingestion.

Side A delivers a complete, testable feature (Reddit fetch worker with OAuth, rate-limiting, backoff, JSON parsing, and unit tests) that adds real product capability, whereas Side B is mainly an internal refactor (removing demo-counter cruft, adding a settlement worker for batched vote persistence and cached ranking). B's correctness fix (persist event before mutating state) and caching are valuable, but A's scope and lasting functional value to the project's core purpose (importing Reddit items) is larger and more concrete.

Commit A replaces a stub with a complete RedditBroker background worker (OAuth, rate-limit backoff, dedup/TTL, URL mapping, JSON parsers for subreddits/posts, and request-path integration), delivering a real lasting feature. Commit B mainly deletes the demo-counter scaffold and adds a settlement worker plus score cache for votes—valuable concurrency hygiene, but smaller in scope and largely refining existing ranking paths rather than adding new capability.

Side A replaces a Reddit placeholder with a functional background import system: it adds a broker/worker, OAuth support, rate-limit handling, request deduplication, JSON parsing into EntityData, automatic fetch triggering from page views and item creation, plus tests for URL mapping and parsing. Side B contains worthwhile architectural cleanup by removing demo code and introducing a settlement worker with cached ranking computation, but much of the patch is refactoring and performance-oriented, whereas Side A delivers a substantial new capability that is likely to provide more lasting project value.

Side A fixes a genuine multi-user bug (shared sentinel delegate blocking all-but-first browser voter) with a minimal, well-tested schema/type change (Option<String> agent) plus a substantial new integration test proving the fix; Side B adds a large speculative Reddit-fetch worker feature with no tests exercised against real behavior beyond unit URL-mapping tests, and includes a stray 'todo' file and unrelated .env ignore, making it more exploratory/incomplete than a solid bugfix. Side A's change is smaller, precise, and directly resolves a concrete correctness issue affecting real usage, giving it more lasting value despite Side B's larger code volume.

A fixes a real multi-user correctness bug by removing shared browser sentinel delegates (WEB_BROWSER_AGENT/INVITE_BROWSER_AGENT), making PendingSession.agent optional end-to-end, and proving two humans can vote without AgentBound collisions via solid integration tests. B adds substantial Reddit fetch infrastructure (broker, OAuth, rate-limit backoff, JSON mapping), but it is still an incomplete integration surface (plus todo/.gitignore noise) rather than a core multi-user correctness repair.

Side A fixes a concrete correctness bug by removing shared browser sentinel delegates, changing pending sessions to carry an optional delegate only for CLI flows, updating UI posts to use no delegate, and adding integration tests proving two browser users can vote independently without creating erroneous AgentBound entries. Side B adds a large Reddit import framework with background fetching, OAuth, and parsing, but it is a new feature with substantial unproven complexity and no evidence of fixing an existing project-wide correctness issue comparable to A's tested bugfix.

Side B fixes a real correctness bug (feed cutoffs using non-monotonic timestamps and leaking/hiding private-room content across concurrent users), refactors duplicated feed logic into a shared function, and backs it with substantial targeted integration tests. Side A adds a genuinely useful Reddit-fetch worker with good design (rate limiting, OAuth, backoff) but is a new feature buildout without the bug-fix urgency, and includes a stray 'todo' file that adds no lasting value.

B hardens core feed catch-up by anchoring on durable ingest index (not wall-clock ms), scanning the ordered ledger for explicit since, and enforcing per-viewer scope checks so concurrent same-ms posts and private-room grants/revokes neither drop updates nor leak; it ships FeedPost.room plus multi-user integration tests for those cases. A replaces a Reddit stub with a real broker/OAuth/rate-limit/parser path and browse hooks—valuable feature work—but B’s correctness and permission fixes are more foundational lasting product value.

Side B fixes a subtle correctness issue in feed catch-up by anchoring implicit feeds to durable ingest order instead of timestamps, preserving behavior under same-millisecond posts and clock rollback while enforcing permission-aware visibility. It also refactors duplicated feed-building logic into a shared function, adds room metadata to feed responses, and includes comprehensive integration tests for multi-user and private-room edge cases, whereas Side A adds substantial Reddit import functionality but is primarily a new feature rather than a core correctness improvement.

Side A fixes a real correctness bug (tilde ontology root canonicalization mismatch between HTML router, storage keys, and children lookups) and backs it with substantial new unit, integration, and browser tests validating the fix end-to-end. Side B adds a sizeable but clearly unfinished Reddit-fetch feature (background worker, OAuth, rate-limiting) accompanied by a stray 'todo' file listing many missing pieces (rendering, voting, nsfw gating), indicating scaffolding rather than a finished, load-bearing capability.

A fixes core path-identity bugs by unifying tilde ontology root storage (`SLUG_TILDE_ONTOLOGY_ROOT`, `normalized_storage`, `tilde_http_path_to_canonical`), so garden child rankings and sibling rank look up the same HashMap keys, with unit, integration, and browser regressions. B adds a real Reddit fetch worker (OAuth, rate limits, JSON parse) and wires `request_fetch` into browse, but that is an optional external integration plus a loose todo dump, not a lasting design fix to the product’s central graph/routing model.

Side A fixes canonical ontology path handling by introducing a shared `tilde_http_path_to_canonical` conversion, normalizing storage keys for the `~/` root, updating ranking lookups to use normalized keys, and correcting root-page behavior, backed by extensive unit, integration, and browser regression tests. Side B adds a substantial Reddit background fetch worker with OAuth and rate limiting, but it is largely new feature infrastructure without end-to-end validation and includes a placeholder TODO, whereas Side A directly resolves correctness bugs in core routing and ranking behavior with durable normalization logic.

Side B implements a real, previously-stubbed feature (Reddit fetching with OAuth token management, rate-limit/backoff handling, JSON parsing, and tests) that delivers working functionality end-to-end. Side A is a substantial refactor of the ranking system (commit-level vs contributor-level pairwise ranking) which is valuable but is an internal restructuring of existing logic rather than new capability, and its large diff carries more churn relative to net new behavior.

A redesigns the core ownership-ranking path from author-bundled short-circuiting to true per-commit pairwise comparison with contributor rollup, evidence/UI surfaces, and targeted tests (same-author multi-commit, single-commit skip). B is a solid Reddit fetch worker (OAuth, rate limits, parsing) replacing a stub, but it is peripheral feature work plus .gitignore/todo noise, not a lasting change to the project's constitutive allocation logic.

Side A changes the core ranking algorithm from contributor-level to commit-level, removes the incorrect single-contributor short-circuit, rolls commit scores back up to contributors for payouts, updates evidence/UI to expose per-commit rankings, and adds tests covering the new behavior. Side B adds a substantial Reddit background fetch pipeline with OAuth, rate limiting, and parsing, but it is a new feature with a TODO and less central impact than the fundamental correctness fix to ownership allocation.