c_a896b2dc05d5ee3d6b

Commit B makes a broader architectural change by replacing the persistent recent-vote deque with an append-only list, removing post-apply trimming, updating the in-memory representation, adjusting storage schema/versioning, changing read/write behavior to cap results at query time, and adding a regression test. This affects persistence, projection, reducer logic, and storage semantics. Commit A is a useful user-facing improvement that exposes existing connectivity statistics in the CLI with formatting and tests, but it primarily adds presentation of already-available data rather than changing core system behavior.

Side B makes substantial architectural changes across the server: it replaces the deque-based recent vote storage with an append-only list, shifts capping from write-time to read-time, updates the storage schema and version, removes trimming logic, and adjusts reducer behavior. This affects persistence, memory handling, and data loading semantics, with accompanying tests to validate the new model. In contrast, Side A is a localized CLI enhancement that formats and displays existing connectivity stats with some tests—useful, but much narrower in scope and impact.

Side B makes a deeper architectural change to the server’s persistence and reducer model: replacing a Deque with an append-only List, shifting the vote cap from write-time to query-time, removing trimming logic, bumping the schema version, updating projection application, and adding a non-trivial test to validate the new behavior. This affects storage schema, reducer logic, projection flow, and durability semantics. Side A adds a useful CLI formatting helper and tests, but it is a localized, presentation-layer enhancement. Overall, Side B has significantly broader and more structural impact.

Commit A makes a substantial behavioral and storage-layer change. It replaces the recent-votes deque with an append-only list, updates the storage schema version, removes write-time trimming in favor of query-time capping, adjusts the in-memory representation, updates persistence logic and comments, removes obsolete code, and adds a regression test covering the new behavior. This affects data structures, persistence semantics, migration/versioning, and tests. Commit B is a small cleanup that simplifies an HTML form by removing client-side check attributes, with a minimal code change and much narrower impact.

Side A introduces a substantial change to how recent votes are stored and managed, replacing a deque with an append-only list, shifting from write-time trimming to read-time capping, updating schema versioning, and adding tests to validate the new behavior. This affects storage, in-memory structures, and data loading logic. Side B is a minor UI tweak removing form attributes, with negligible impact by comparison.

Side A introduces substantial architectural changes: migrating from Deque to List in storage, altering recent vote capping semantics (write-time to read-time), updating schema version, modifying reducer logic, removing trimming logic, and adding a new test. This impacts persistence, in-memory state, and query behavior. Side B is a minor HTML form attribute cleanup with negligible functional impact.

Side B makes a durable design change by replacing the persisted recent-vote deque with an append-only list, removing post-apply trimming, updating loading logic to enforce the cap at query time, and adding a test verifying only the newest 200 votes are exposed. Side A is a useful CLI enhancement that formats and displays existing connectivity statistics with tests, but it primarily improves presentation rather than changing core project behavior or storage semantics.

Side A adds a small, tested, low-risk CLI feature that surfaces existing connectivity data, improving usability without touching persistence layout. Side B refactors the recent-votes storage from a capped Deque to an unbounded List, removing the write-time trim entirely and only capping at read time—this risks unbounded on-disk growth of recent_votes and bumps the schema version, a riskier tradeoff than the modest but safe UI addition in A.

B is a lasting core-design change: recent_votes moves from capped Deque/VecDeque with write-time trim (and post-apply trim_recent_votes over vote_parents) to append-only List/Vec with query-time cap, schema bump, and a real load-cap test. A only formats already-available ConnectivityStats in the CLI plus two string-format unit tests—useful UX, but not structural.

B makes a fundamental storage-model change from a capped deque to an append-only list with query-time capping, removes write-time trimming, updates schema version, and adjusts reconstruction logic—affecting persistence semantics and correctness. A only adds CLI formatting and tests to display existing connectivity stats without changing core behavior.

Side B makes a substantive architectural change from a capped `Deque` to an append-only `List` with query-time capping, updating reducer logic, storage schema (schema version bump 3→4), write path (`push_front`→`push`), read path slicing, and adding a test to enforce the new cap semantics. Side A only adds CLI formatting and tests to display existing `ConnectivityStats`, which is useful but purely presentational and does not alter core behavior.

Side A performs a substantive schema/data-structure change (Deque -> List, moving vote capping from write-time to read-time), updates all call sites, bumps the schema version, and adds a test verifying the new cap behavior. Side B is a trivial one-line removal of unused form attributes with no functional impact or test coverage.

A replaces durable Deque with append-only List, moves the recent-votes cap to query time, drops write-path trim/batch bookkeeping, and adds a regression test—real storage/reducer design. B only strips check-action attrs from one HTML form (a tiny UI nit) with no lasting subsystem impact.

Side A makes a substantive storage design change by replacing the durable recent-votes deque with an append-only list, removing post-commit trimming, updating schema versioning, adapting in-memory state, and adding a regression test that verifies query-time capping. Side B only removes client-side validation attributes from a single HTML form, a small UI simplification with far less lasting architectural impact.

A fundamentally changes how recent votes are stored and read: it replaces a Deque with an append-only List, removes write-time trimming, introduces query-time capping, updates the schema version, and adds tests to verify behavior. B only removes a data-check attribute block from a form, which is a minor UI tweak with limited lasting impact.

Side A makes a substantive storage design change: replacing a write-time-capped `Deque` with an append-only `List`, removing `trim_recent_votes`, bumping the schema version, shifting the cap to query-time in `build_group_state`, and adding a test to verify the new behavior. Side B merely removes `data-check-*` attributes from a form tag, a minor HTML simplification with limited architectural impact.

Side B is a real, tested code change: it replaces a Deque-based recent-votes storage with an append-only List, removes now-dead trim logic, bumps the schema version, and adds a passing test verifying cap behavior on read—concrete lasting value to the storage layer. Side A is purely a planning document (plan.md) plus a thin, largely unused RouteContext wrapper that doesn't migrate any real call sites, offering speculative direction rather than delivered functionality.

B makes a lasting design change: recent votes become append-only Vec/List with query-time capping, drops write-path trim and BTreeSet bookkeeping, bumps the projection schema, and adds a regression test. A mostly adds a temporary plan.md plus a thin RouteContext newtype over ThreadNav with no call-site migration, so it is scaffolding rather than shipped substance.

Side B makes a functional architectural change by replacing the durable recent-vote deque with an append-only list, removing post-write trimming, updating the in-memory representation to `Vec`, bumping the storage schema version, and adding a test that verifies query-time capping of recent votes. Side A mostly adds a detailed planning document plus a thin `RouteContext` wrapper re-export around `ThreadNav`, which introduces little immediate behavior beyond an API convenience layer.

B fixes a real design/performance issue: it replaces the Deque-based recent_votes storage (which required an expensive truncate_back on every vote) with an append-only List capped at read time, bumps the schema version, and adds a test verifying the capping behavior. A is a large CLI/docs restructuring (renaming ingest to forum post, adding subcommands, updating DSL.txt/GUIDE.sorter/tests) that is mostly naming/UX churn, and it even drops XML escaping of post bodies (a minor regression) without replacing it with anything equivalent. B's change is smaller but more clearly a lasting correctness/performance improvement backed by a test.

A redesigns the CLI’s real command surface (forum list/show/post, ingest→scoped forum post with required tag/delegate, simplified check) and lands matching docs, RPC next-move strings, and integration tests—lasting product/API structure. B is a tighter internal win (Deque/VecDeque→List/Vec, drop write-time trim_recent_votes, read-time cap + schema 4) but narrower scope and leaves storage uncapped on write.

Side B makes a substantive storage and data-flow redesign by replacing the durable recent-vote deque with an append-only list, removing post-apply trimming, moving the cap to query time, updating the schema version, and adding a regression test verifying the new behavior. Side A is a broad CLI/interface reshape (`ingest` to `forum post`, `forum` split into `list/show/post`, extensive documentation and command updates) that improves usability but is primarily an API reorganization rather than a core behavioral improvement.

B fixes a real design/perf issue: replacing an unbounded Deque with append-only List and moving capping to read-time avoids per-vote trim writes (deleting the trim_recent_votes call in the hot apply path) while adding a schema version bump and a targeted regression test proving correctness. A is a useful UX fix (display_path in hrefs) plus a much stronger e2e test, but it's a smaller, more localized improvement compared to B's storage-layer correctness/performance change with test coverage.

A fixes real vote URL correctness (encoding display_path short forms in hrefs instead of storage URLs) and turns a loose ≤15-iteration smoke test into a full C(10,2)=45-pair flow that asserts GetGardenRank yields one component ordered a→j. B’s Deque→List/Vec change is a coherent storage simplification (write-trim removed, read-time cap, schema v4 + unit test) but is more internal plumbing with weaker product-level impact than A’s bugfix plus end-to-end ranking guarantee.

Side A makes a user-facing correctness fix by generating vote URLs from `display_path()` instead of stored URLs, keeping links consistent with the displayed DSL, and substantially strengthens coverage by exercising all 45 pairwise votes and asserting the final ranking through `GetGardenRank`. Side B mainly refactors recent-vote storage from a deque to an append-only list with query-time capping, removes trimming logic, and updates tests for that behavior, but the patch is largely an internal representation change without an equally clear project-wide functional improvement.

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 delivers a self-contained, well-tested UI feature (clickable unpin from ranked child list) with corresponding CSS and updated browser test coverage exercising the new flow end-to-end. Side B refactors the recent-votes storage from a capped Deque to an append-only List but removes the write-time trim entirely, meaning storage now grows unbounded per node while only capping at query time—a real scalability regression traded for simplicity, despite the added unit test.

B redesigns the core recent-votes path (Deque/VecDeque → append-only List/Vec, schema v3→v4, drop write-time trim in projection_apply, cap only on load) with a dedicated unit test—lasting storage/reducer simplification. A is a solid but narrower UX win: wiring the existing set_garden_pin clear POST into ranked child pin icons plus CSS and browser coverage.

Side B makes a deeper architectural change by replacing the durable recent-vote deque with an append-only list, removing write-time trimming logic, updating the in-memory representation, bumping the storage schema version, and adding a test that verifies query-time capping. Side A improves usability by making pinned child-group icons submit the existing unpin flow and adds browser coverage, but it is a localized UI enhancement rather than a broader storage/design improvement.

Side B fixes a real user-facing bug (vote polarity/highlighting) with targeted logic changes, new regression tests proving correctness (ratios_for_page orientation, winner_side, slider mapping, ranking invariant), plus supporting CSS/JS fixes—delivering concrete lasting value. Side A is a reasonable internal refactor (Deque->List) with a schema version bump and a test, but it's more of a data-structure churn/cleanup than a bugfix, and removing capacity enforcement on write shifts an invariant to read-time without clear necessity.

A redesigns recent-vote persistence (Deque/VecDeque → List/Vec, schema 3→4), dropping write-time trim and parent tracking in projection_apply in favor of append-only writes with a query-time cap plus a test—lasting data-model simplification. B is a solid UI bugfix (per-group rank gradients, center-anchored slider polarity, history HUD parity) with good tests, but it is presentation-layer polish rather than durable core design.

Side A makes a substantive persistence-model change by replacing the durable recent-vote deque with an append-only list, removing post-commit trimming, updating schema versioning, reconstructing only the newest capped window on read, and adding a regression test for the new query-time cap. Side B primarily fixes UI vote highlighting and gradient behavior with supporting tests; while useful, it is largely presentation logic and does not alter the project's core storage or data-handling design.

Side A fixes a real UI correctness bug (color mapped by score via min-max normalization instead of arbitrary list position) with clear rationale and thorough new unit tests validating the fix. Side B refactors a Deque to a Vec and removes the on-write trim/eviction logic in favor of a cap applied only at query time, which risks unbounded on-disk growth of vote history and is explained by only a terse, unclear commit message ('dequeue -> vec') despite touching more files.

B redesigns the recent-votes path end-to-end (Deque→List/Vec, write-time trim removed, read-time cap, schema v4, simpler apply_records) with a focused regression test, which is lasting storage/reducer design. A only retunes rank-row gradient mapping from list ordinal to in-group min–max score—a correct UI polish with tests, but shallow and presentation-only next to B’s core data-model change.

Side A changes the UI logic to color rank rows based on each group's actual score range instead of ordinal position, introducing a dedicated `score_gradient_t` function, updating callers, and adding focused tests for normalization, tied scores, and stability. Side B is largely a storage refactor from deque to list with query-time capping and schema updates; while it changes persistence behavior, it mainly reorganizes data handling and removes write-time trimming rather than delivering a comparably clear user-facing improvement or bug fix.

Side A performs a real storage-design fix: replaces a capped Deque with an append-only List plus query-time capping, removes the now-unnecessary trim_recent_votes machinery, bumps the schema version, and adds a regression test verifying correct capping behavior. Side B merely deletes a stale duplicate forum.rs that had already been superseded by the forum/ submodule split, resolving a module ambiguity but contributing no new design or behavior beyond cleanup already implied by prior refactors.

Commit A redesigns recent-votes storage (Deque→List/Vec, write-time trim removed in favor of read-time cap, schema bump + regression test), a lasting core-data-model improvement; B only deletes a leftover monolithic forum.rs so the already-split forum/ modules become unambiguous, which is necessary cleanup but mostly mechanical deduplication.

Side A makes a substantive storage design change: it replaces the durable `Deque` with an append-only `List`, removes post-commit trimming, applies the recent-vote cap at query time, bumps the schema version, and adds a test verifying the new loading behavior. Side B is primarily a codebase reorganization that deletes the duplicate `forum.rs` and splits functionality into `forum/` modules, improving maintainability but largely preserving existing behavior.

Side A fixes several concrete correctness issues (out-of-band delegate attribution instead of embedding it in post text, erroring rather than silently falling back to an incorrect large pool when siblings <2, removing a dead swap button) and updates route naming with matching test coverage across Rust and Clojure tests. Side B's Deque→Vec refactor removes the write-time trim (trim_recent_votes) in favor of an append-only list capped only at read time, which risks unbounded on-disk growth for hot nodes—a plausible regression—despite adding a decent capping test for in-memory behavior.

B redesigns core vote projection storage (Deque→List/Vec, write-time trim removed, query-time cap, schema v4) with a focused unit test, which is a lasting data-model change in the hot path. A’s valuable fixes (out-of-band WEB_BROWSER_AGENT delegation, no all-items fallback when sibling pool < 2) are real, but much of the diff is route rename (/vote/compare→/vote), nav cleanup, and test URL churn.

Side B makes a substantive architectural change by replacing the persistent recent-vote deque with an append-only list, removing post-apply trimming, capping results at read time, updating the schema version, and adding a regression test that verifies query-time limiting. Side A bundles several useful UI and routing fixes (passing delegate attribution out-of-band, preventing an incorrect fallback when sibling pools are too small, simplifying navigation, and renaming `/vote/compare` to `/vote`), but much of the patch is route and UI churn rather than a deeper storage design improvement.

Side A replaces an O(n log n) per-batch deque-truncation trim with a simpler append-only List + query-time cap, bumps the schema version for correct migration, and adds a dedicated test verifying the new capping behavior — a real correctness/performance fix to the storage layer. Side B adds a sizable new feature (pool-scoped voting) with broad signature changes across many functions, but includes no new tests for the added pool logic, leaving its edge cases (empty pools, duplicate items, next-pair selection) unverified despite the larger diff.

B adds end-to-end pool-scoped voting (query param, pair selection, next-pair navigation, success JS, and UI entry points), a durable product capability. A is a real storage/reducer redesign (Deque→List/Vec, write-time trim→read-time cap) but mainly internal simplification with unbounded list growth and no new behavior for users.

Side B adds a substantial new user-facing capability: pool-scoped voting, extending the `/vote` flow with a `pool` parameter, automatic pair selection from a parent's children, preserved navigation context after voting, new UI links, request validation, and wiring through handlers and rendering. Side A mainly refactors recent-vote storage from a deque to an append-only list with query-time capping, removing write-time trimming and adding a regression test; while useful as a storage design simplification, it is narrower in project impact than the end-to-end feature introduced in Side B.

Side B removes a ~1800-line brittle keystroke-transition parser/autocomplete graph (with its race-condition test harness, client-side debounce logic, and CSS) and replaces it with a small, correct, well-tested URL-parsing function plus a simple paste-and-go form, meaningfully simplifying the codebase while fixing real reliability issues. Side A is a reasonable internal storage refactor (deque->append-only list with query-time capping) but is a much smaller, more localized change with lower overall impact.

B replaces an unreliable ~1800-line keystroke graph parser (plus parser_action, race-handling JS, and Playwright test) with a small paste-and-go URL extractor and redirect, permanently removing a complex failure-prone subsystem. A is a sound but narrower design change (Deque→List, write-time trim→read-time cap) in the projection path; valuable, yet secondary to B’s net simplicity and correctness gain on a core user flow.

Side A makes a substantive storage-model redesign by replacing the durable recent-vote deque with an append-only list, removing post-commit trimming, updating the schema version, and enforcing the cap at read time with a regression test. Side B largely simplifies the UI by deleting the complex autocomplete/parser graph in favor of a paste-and-go textarea and redirect flow, which is a product simplification but removes substantial functionality rather than adding durable infrastructure.

Side A is a coherent, well-reasoned refactor (deque→vec, moving the recent-votes cap to query time) with clear rationale in comments and a new test verifying correctness, directly improving code clarity and correctness. Side B is a disorganized 'seed' commit dumping unrelated deployment configs (Dockerfile, fly.toml, deps.edn for Clojure) and duplicate/misplaced source files (event_log.rs, views.rs at repo root) with no tests or integration, offering little lasting architectural value.

A is a deliberate storage/reducer redesign: Deque→List/Vec, write-time trim removed for append-only votes with a query-time cap, schema bump, call-site cleanup, and a new cap test—lasting correctness and simpler projection apply. B mostly dumps seed scaffolding (root event_log/views, deps.edn, Dockerfile/fly.toml) that is foundational but rough/noisy versus A’s integrated design change.

Side A introduces a lasting redesign of recent-vote storage by replacing the durable deque with an append-only list, removing post-commit trimming, updating the reducer and loading logic to cap results at query time, bumping the storage schema version, and adding a regression test for the new behavior. Side B adds useful infrastructure (Dockerfile, Fly configuration, and new `EventLog`/`ViewStore` modules), but those additions are more ancillary than the core persistence and data-model changes in Side A.

B fixes a concrete UX bug (the HUD 'pin' link actually just navigated instead of unpinning, now properly issues a set_garden_pin clear POST) and adds a genuinely useful feature (per-edge vote counts on the compare icon), backed by both a Rust unit test and an updated browser test. A's refactor swaps a write-time-capped VecDeque for an uncapped append-only List with cap-on-read slicing, which removes bounded-growth guarantees on disk (recent_votes can now grow unboundedly, requiring a full scan/slice at read time) — a debatable tradeoff whose benefit isn't clearly established beyond the rename, despite adding a decent test for the new cap-on-read behavior.

A redesigns durable recent-votes from Deque to append-only List/Vec, drops write-path trim_recent_votes and projection batch bookkeeping, bumps schema, and caps only on read with a solid regression test—core lasting storage simplification. B is real product polish (HUD unpin fix, edge vote counts, CSS/tests) but stays UI-layer and does not change foundational durability semantics.

Side A makes a substantive persistence-model redesign by replacing the durable recent-vote deque with an append-only list, removing post-commit trimming, updating schema versioning, changing in-memory storage, and adding a test that verifies query-time capping of recent votes. Side B mainly improves UI behavior (HUD unpin action and displaying pairwise vote counts) with associated styling and browser/tests, which is useful but has less architectural impact than the storage and data-flow simplification in Side A.

Side B delivers a substantial, coherent feature: it converts entity fetch from an implicit auto-fetch to an explicit user-initiated, event-sourced import (EntityImported event, replay support, configurable API base for testing, dotenv support), plus real tests and an integration test harness with fixtures. Side A is a smaller refactor (Deque->Vec/List) that removes an eager trim optimization in favor of a query-time cap, which is reasonable but much lower impact and scope than B's architectural and testability improvements.

B adds durable EntityImported events, stores full API payloads for replay, switches Reddit loading to explicit user fetch with real integration coverage, and rewires the broker/UI around that model—lasting product and architecture value. A is a sound but narrower storage simplification (Deque→List/Vec, trim-on-write → cap-on-read) without comparable feature or durability impact.

Side B introduces a substantive new architecture for importing and persisting external entity data: it adds an `EntityImported` event, stores full API payloads for replay, refactors Reddit fetching to append events instead of mutating state directly, adds explicit user-triggered fetch UI, and includes replay and integration tests. Side A mainly replaces a durable deque with an append-only list, removes write-time trimming in favor of query-time capping, updates the reducer to use `Vec`, and adds a focused test; while useful, it is a narrower storage optimization compared with B's end-to-end feature and persistence design.

Side B introduces a substantial, reusable architecture (a generic form-template/hole-filling system plus a unified `/ui` HTML action endpoint) that refactors duplicated POST handlers into shared functions and adds meaningful new tests, delivering lasting design value. Side A is a smaller, focused refactor (Deque→List/Vec with query-time capping) that fixes a real inefficiency but has much narrower scope and impact than B's endpoint/template infrastructure.

B adds lasting UI architecture: a tested form_template hole-fill layer, HtmlUiAction + parse path, POST /ui dispatch, and shared web_post runners, enabling progressive form expansion rather than only refactoring existing endpoints. A is a sound but narrower storage cleanup (Deque→List/Vec, drop write-time trim_recent_votes, cap on read + one test) that simplifies projections without introducing comparable new capability.

Side B adds a substantial new UI command infrastructure: a unified `POST /ui` endpoint, typed `HtmlUiAction` parsing from JSON form templates with `$form` substitution, reusable web-post handlers, new routing, and tests, enabling broader browser interactions with shared server logic. Side A refactors recent-vote storage from a deque to an append-only list with query-time capping and removes write-time trimming, which is a meaningful storage design change, but its scope is narrower than the new reusable UI architecture introduced in Side B.

Side B fixes a real correctness bug in the rank-centrality algorithm (wrong divisor causing bipartite oscillation on star topologies), grounds the fix in the cited paper's definition, and adds substantial regression coverage (Rust unit test plus Clojure end-to-end fixtures). Side A is a data-structure swap (Deque->List/VecDeque->Vec) that changes cap semantics from write-time truncation to read-time slicing, which is reasonable cleanup but lower-impact than a genuine algorithmic bugfix with broad topology test coverage.

B fixes a real correctness bug in Rank Centrality (wrong d_max made star topologies bipartite and return uniform scores), aligning the divisor with the paper and adding Rust plus end-to-end Clojure regression coverage. A only swaps Deque/VecDeque for List/Vec and moves the recent-votes cap from write-time trim to read-time slicing—a storage simplification without comparable functional impact.

Side B fixes a substantive correctness bug in the ranking algorithm by changing Rank Centrality to use degree-based d_max instead of summed edge weights, preventing oscillation on star graphs and restoring correct stationary rankings. It also adds focused regression tests in Rust and end-to-end fixture tests covering star, inverse star, chain, and cycle cases, whereas Side A is primarily a storage representation change from deque to append-only list with query-time capping and corresponding cleanup/tests.

Side B fixes a real, user-facing bug (hardcoded staging hostnames breaking OAuth redirects on custom hosts) by consolidating URL logic into a shared util and using env/window.location, plus fixes CI deploy targeting—concrete, deployable value across multiple files. Side A is a refactor (Deque->Vec) that changes storage semantics and adds a test, which is reasonable cleanup but lower-impact than fixing broken redirect/deploy behavior in production.

A redesigns recent-vote storage (Deque→List, write-time trim→read-time cap, schema v4) and simplifies the apply path with a real test; that is lasting core data-model work. B usefully centralizes OAuth/base URLs and moves deploy to staging, but is mostly config/ops plumbing with narrower long-term design impact.

Side A makes a substantive storage-model redesign: it replaces the durable deque with an append-only list, removes post-commit trimming, updates the in-memory representation to `Vec`, bumps the schema version, and adds a test verifying query-time capping of recent votes. Side B mainly centralizes base-URL generation around a `HOSTNAME` helper, fixes redirect/callback URL construction, and adjusts the deployment workflow to staging, which is useful but narrower in long-term architectural impact.

Side A fixes concrete, crash-causing bugs (string split needing a regex arg, wrong HttpExchange method for reading POST bodies, missing null guards, unhandled exceptions crashing the mock server) that were breaking the OAuth e2e test suite, directly restoring test reliability. Side B is a legitimate but debatable refactor (Deque->Vec/List, deferred capping) that trades write-time bounded storage for unbounded growth capped only at read time, which is a real design tradeoff rather than a clear correctness win, despite including a new test.

B redesigns core projection storage (Deque→List, write-time trim→read-time cap, schema v4, simpler vote application) with a focused regression test, lasting in the production server path. A only repairs test OAuth mocks (query split, request body, null/state guards) and E2E selectors—real but confined to test infra.

Side A fixes multiple concrete failures in the OAuth test infrastructure: it corrects query parsing (`str/split` with regex), reads POST bodies from `getRequestBody`, guards against null tokens/state, adjusts redirect handling, wraps handlers to avoid crashes, and improves Playwright test synchronization and selector lookup. Side B is largely a storage refactor from deque to list with schema changes and query-time capping, but it mostly changes implementation strategy rather than addressing a demonstrated correctness issue, making its lasting impact less certain than A's direct restoration of broken end-to-end authentication tests.

Side A performs a real data-model migration (Deque→List) with a schema version bump, correctly moves the cap logic to query time, and adds a dedicated test verifying capping/ordering behavior—demonstrating careful reasoning about durable storage semantics. Side B is a reasonable UX improvement (form morphing instead of redirects) but is smaller in scope, purely additive UI plumbing without tests, and lower architectural stakes than a storage schema change.

A redesigns core projection storage (Deque→append-only List, write-time trim→read-time cap, schema v4) and deletes projection_apply trim bookkeeping, with a concrete load-cap test—lasting data-path simplification. B improves auth UX via fragment morphs and shared layout, but is surface UI/JS plumbing without comparable structural impact.

Side A makes a substantive storage-model redesign by replacing the durable recent-votes deque with an append-only list, removing post-commit trimming, updating the reducer and load path to apply the cap at query time, bumping the schema version, and adding a regression test for the new behavior. Side B mainly improves authentication UX by returning HTML fragments for inline form updates and extending the generic form JavaScript, which is useful but more localized and less foundational than the persistence-layer change.

Side A adds a genuine, well-tested feature (pretty `/~/` browse URLs backed by a canonical ItemId encoding) while cleanly removing an unused theme system, keeping the codebase coherent and reducing surface area. Side B's refactor swaps a bounded Deque for an unbounded List and defers capping to read time, which removes the write-time trim guarantee and risks unbounded storage growth for recent_votes, a more questionable trade-off despite its own test coverage.

A introduces a durable browse URL scheme (`/~/*` routes, `ItemId::browse_href`/`from_browse_uri` with normalization and tests) and deletes the entire theme subsystem (cookies, `/theme` handler, dual CSS, controls UI), replacing brittle `/?item=` redirects. B only swaps `Deque`/`VecDeque` recent-votes for append-only `List`/`Vec` with read-time capping and drops write-time trim—useful internal simplification, but narrower and leaves on-disk growth unbounded.

Side A introduces a lasting routing and URL design change by adding canonical browse paths (`/~/...`), centralizing link generation with `ItemId::browse_href()`, parsing browse URLs, updating redirects, and adding integration/tests for the new navigation behavior. Although it also removes the theme feature and simplifies static asset handling, the new browse URL infrastructure affects routing and link consistency across the project, whereas Side B is primarily an internal storage refactor from deque to append-only list with query-time capping and corresponding cleanup/tests.

Side B implements a real feature (fullscreen vote-compare page with morph-on-post preview card, correct ratio/sort semantics, new layout variant, CSS across three themes, updated browser test), providing tangible user-facing value. Side A is a reasonable internal refactor (Deque->List, moving vote-cap trimming to read-time) but is a smaller, more mechanical change with less lasting functional impact, and both are equally well-tested.

A replaces Deque/write-time trim with an append-only List and query-time cap (schema 3→4), deletes post-apply trim/BTreeSet bookkeeping, and adds a focused cap test—lasting storage design. B is valuable UI work (fullscreen shell, edge-history sort/display, success morph/CSS) but remains presentation-layer polish over a narrower surface.

Side A makes a durable storage design change by replacing the persisted recent-votes deque with an append-only list, removing post-commit trimming, updating schema versioning, and enforcing the cap at load time with a regression test. Side B improves the vote-compare UI with a fullscreen layout, preview updates, and better edge-history presentation and sorting, but those are primarily user-interface enhancements rather than foundational persistence behavior.

Side B is a substantial feature commit introducing a hierarchical ItemId/fractal-tree model (parent/child, breadcrumbs, URL canonicalization), rewiring state/journal/reducer/UI to use it, replacing the flat scope-based GroupMap, with new tests and CSS support—clearly lasting architectural work. Side A is a small, focused refactor (Deque -> List with query-time capping) that removes a write-amplifying trim step, which is a solid but narrow correctness/perf improvement compared to B's broad structural redesign.

B reshapes the product around a hierarchical ItemId/GlobalTree model (path canonicalization, parent/child wiring, NodeEnsured, journal-backed votes, breadcrumbs/UI), a lasting architectural shift; A only swaps recent_votes Deque/VecDeque for append-only List/Vec with read-time capping and drops write-time trim—a correct but narrow storage simplification.

Side B introduces a substantial architectural evolution from flat string-scoped rankings to a hierarchical ItemId/GlobalTree model, adds canonical URL parsing, breadcrumb navigation, node registration events, and a journal worker while updating state, UI, and tests to support the new design. Side A mainly replaces a deque with an append-only list, removes write-time trimming in favor of query-time capping, bumps the schema version, and adds a targeted test; useful, but much narrower in long-term impact.

B adds genuinely new, tested functionality (typed `$form:i32` template holes with round-trip tests, a post-vote redirect via `next`, and wiring for a new `/vote` route with supporting CSS/JS), which extends the project's real capability. A is a more narrow internal refactor (Deque→Vec for recent_votes) that removes write-time capping (`trim_recent_votes`) in favor of read-time capping, a plausible simplification but one that trades bounded storage growth for simplicity, with less clear net benefit despite the added test.

A is a focused core design change: recent_votes moves from capped Deque/VecDeque with write-time trim to append-only List/Vec with query-time cap, drops apply-path parent tracking, bumps schema, and adds a concrete load-cap test. B adds useful vote UX wiring (form :i32 holes, next redirect, slider/CSS, route hooks) but is diluted by Cargo.lock noise and leaves the declared vote/pair modules out of the patch, so less durable substance per line.

Side A makes a substantive storage-model redesign by replacing the durable recent-vote deque with an append-only list, removing post-commit trimming, updating schema versioning, capping history at query time, and adding a focused regression test to verify only the newest 200 votes are loaded. Side B mostly adds UI features (vote page plumbing, typed form holes, navigation, CSS/JS, and dependencies), but despite its size it contains comparatively less core architectural value than A's persistence and data-loading changes.

Commit A fixes a real correctness/performance issue (unbounded Deque growth, extra write-amplifying trim step) by switching to an append-only List with query-time capping, and adds a test verifying the cap behavior. Commit B is a large architectural rewrite (deleting engine.rs, introducing graph/parse modules) but the diff shown deletes the old implementation and tests without showing the new graph/parse modules' content, making it impossible to verify the new design's correctness or completeness from this patch alone.

B replaces the ad-hoc composable normalizer pipeline (engine.rs + host switch) with a graph/DFA-based URL identity and hierarchy model, which is core lasting design for ItemId canonicalization across the project. A is a real but narrower storage/reducer change (Deque→List, trim-on-write→cap-on-read, schema 4 + test) on recent_votes only, so less project-wide leverage than B’s identity-layer rewrite.

Side A makes a substantive storage-model change by replacing the durable deque with an append-only list, removing post-commit trimming, updating schema versioning, and capping recent votes at load time with a regression test verifying only the newest 200 entries are returned. Side B is largely a refactor of the URL canonicalization module structure (moving from an engine to graph/parse modules and updating registry calls) plus documentation changes; while it may improve organization, the shown patch primarily rewires interfaces rather than demonstrating a clear new behavioral improvement.

B is a substantial, well-tested refactor that moves path/URL logic into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing string-formatting duplication and improving type safety across server and DTOs, while preserving existing test coverage. A is a smaller, focused change (Deque->Vec plus dropping an eager trim in favor of a query-time cap) that is reasonable and adds a targeted test, but is narrower in scope and impact compared to B's broader architectural improvement.

A changes core projection storage from a write-capped Deque to an append-only List/Vec with query-time capping, drops the separate post-batch trim_recent_votes path, and bumps schema with a focused regression test—this is a lasting durability/design fix. B mainly relocates existing canonicalization helpers into slug-types and wraps API strings in GardenItemUrl/ForumThreadUrl newtypes, which improves consistency but is largely organizational move/rename churn rather than new behavior.

Side B centralizes path normalization, canonicalization, and room-aware URL generation into a shared `slug_types::paths` module, replacing duplicated string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and related types across server and API code. This is a broad architectural improvement that reduces duplication and makes path handling consistent across serialization and validation, whereas Side A is a more localized storage refactor from `Deque` to append-only `List` with read-time capping and accompanying tests.

Side B removes a substantial amount of legacy dual-path code (GitDiscovery projection fallbacks) across the evidence rendering system, simplifying epoch/commit views to a single canonical Evidence-envelope source and updating tests accordingly, which is a meaningful architectural cleanup with real behavioral impact. Side A is a smaller, self-contained refactor (deque to vec) that fixes a subtle correctness improvement (query-time capping vs write-time truncation) but touches less surface area and lower-stakes code.

B removes an entire dual-path legacy projection (GitDiscovery/Emission inventing epoch/commit pages) and forces Evidence-envelope-only reads, tightening Emission required fields and tests—lasting correctness for the ledger model. A is a sound but narrower storage refactor (Deque→List/Vec, trim-on-write→cap-on-read) that simplifies recent_votes without the same system-level invariant payoff.

Side B removes the application's legacy GitDiscovery projection path and makes evidence envelopes the only supported source across epoch, commit, and patch views, simplifying the data model and eliminating fallback code. It also tightens the Emission schema by requiring evidence-related fields and updates tests accordingly, whereas Side A mainly changes recent-vote storage from a deque to an append-only list with query-time capping and removes trimming logic, a more localized internal refactor despite adding a useful regression test.

Side A changes the durable storage schema (Deque -> List) with a real design rationale (avoiding a costly truncate-on-write, moving the cap to read-time), removes now-dead code paths, bumps schema version, and adds a targeted test validating the new capping behavior—this is substantive production logic. Side B is a pure test-suite refactor (deduplicating HTTP/OAuth helpers across bb test scripts) which improves maintainability but has no runtime/product impact.

Commit A redesigns core projection storage (Deque→List, trim-on-write→cap-on-read, schema bump, reducer/apply path cleanup) and adds a regression test, which is lasting production behavior. Commit B only consolidates duplicated Babashka test helpers/OAuth fixtures without changing product semantics, so it is useful hygiene but lower lasting value.

Side A changes the project's storage design by replacing the durable recent-vote deque with an append-only list, removing per-apply trimming, moving the cap to query time, bumping the schema version, and adding a regression test that verifies only the newest 200 votes are loaded. Side B is a useful refactoring of the integration test infrastructure (shared HTTP/OAuth helpers, common build/env functions, and reduced duplication), but it primarily improves test maintainability rather than changing core project behavior.