c_cd965c070df3841d1b

Side A is a substantial architectural overhaul—introducing a unified RPC batch protocol, room/scope model, and refactoring CLI, server routes, reducer state, and tests across dozens of files—representing significant lasting design work. Side B is a small, targeted bugfix (fixing Reddit child import wiring and unranked labels) with minor test updates, useful but narrow in scope and impact compared to A's systemic changes.

A introduces a lasting architectural pivot: batched `/api/v0/rpc`, room-scoped content (rooms vs forum threads in events/reducer), and CLI Public/Private scoping that replaces many REST handlers. B is a valuable but narrow fix—correct Reddit children attach via `apply_entity_under_parent` and title labels in the ranking panel—without core model impact comparable to A.

Side A introduces a substantial architectural change: it consolidates many REST endpoints into a batch RPC interface, adds room-scoped commands and data models (room/thread separation), updates the CLI to use the new RPC layer, and refactors validation and reducer/event handling to support room-aware behavior. Side B fixes a real Reddit import bug by attaching imported children directly under the subreddit and improving unranked labels with tree metadata, but its impact is localized compared with A's lasting API and data-model redesign.

Side B adds a complete, self-contained feature (RoomList RPC + CLI subcommand + types) with a thorough new integration test proving per-user isolation, providing clear lasting value and coverage. Side A fixes a real bug in Reddit child import wiring and adjusts a signature threaded through several call sites, which is valuable but narrower in scope and partly consists of test-shuffling rather than new capability.

A fixes core data-model wiring (replacing link_child + ensure_path with apply_entity_under_parent so listing imports do not pull Reddit comment-path segments) and makes unranked children show real titles via the tree—lasting correctness in import and UI. B adds a useful RoomList RPC/CLI with solid isolation tests, but the server logic is a straightforward grants filter, so the higher-impact design fix is A.

Side A fixes a core correctness issue in Reddit imports by introducing `apply_entity_under_parent` so imported listing children are attached directly without `ensure_path` creating incorrect `/comments/...` hierarchy, and it also improves the ranking UI by showing imported child titles instead of raw IDs. It updates the rendering pipeline and adds integration tests covering SSE morphs and children fetch behavior, whereas Side B primarily adds a useful but incremental `RoomList` RPC/CLI feature with access-control tests.

Side B fixes a real functional bug (Reddit children imports bypassing ensure_path and unranked labels showing raw IDs instead of titles) with corresponding source changes across multiple modules plus updated integration tests, delivering concrete lasting behavior fixes. Side A is a small config-only simplification of test discovery (tests.edn) that improves maintainability but has no functional or bug-fixing impact.

B fixes real product behavior: Reddit children import now attaches entities under the parent without ensure_path side effects, and unranked labels resolve titles from the tree instead of bare ids, with matching API/HTML call-site and integration-test updates. A only rewrites tests.edn to a single auto ns-pattern—useful DX hygiene, but no runtime or correctness impact comparable to B’s wiring and UI fixes.

Side B fixes functional behavior in multiple places: it corrects Reddit child imports by attaching imported entities under the intended parent without path expansion, updates the ranking panel to display imported child titles using tree data, and adds integration test coverage for both self and children fetch flows. Side A improves test configuration by replacing manually enumerated Kaocha suites with automatic discovery, reducing maintenance, but it is primarily a tooling/configuration improvement rather than a runtime correctness fix.

Side B fixes a real bug (imported Reddit children were mis-wired via ensure_path, and unranked child labels showed raw slugs instead of titles), with a targeted reducer API change and updated integration tests covering the fix. Side A is a reasonable feature addition (room create CLI + simplifying visibility away) but is more speculative scaffolding/simplification with less evidence of fixing a concrete defect, and removes visibility handling that may reduce flexibility without clear justification.

A lands an end-to-end room-create path (CLI + RPC) and a lasting domain cleanup: drops ThreadVisibility/RoomState, makes rooms a HashSet of private ids, and tightens create/audit call sites across server, types, and tests. B is a real but narrower fix—Reddit children attach via apply_entity_under_parent without ensure_path side effects, and unranked rows use stored titles—plus test wiring, so less structural impact than A’s model and feature surface.

Side A adds an end-to-end `room create` CLI command that authenticates, invokes the `RoomCreate` RPC, prints the new room ID, updates documentation, and simplifies the underlying data model by removing the unused room visibility field and replacing the room registry with a `HashSet` of room IDs. Side B fixes Reddit child import behavior by attaching imported posts directly under the fetched parent and displaying imported titles in the unranked list, with improved integration tests, but its scope is a targeted correctness fix rather than a broader capability addition.

Side A fixes an actual data-correctness bug (Reddit children imported as duplicate deep paths instead of direct children, and unranked titles falling back to raw ids) and backs it with integration test coverage. Side B is a smaller cleanup that removes redundant client-triggered toolbar/action in favor of SSR, which is nice but lower-impact and removes rather than adds test coverage.

A fixes real import semantics: children attach via apply_entity_under_parent (entity data + direct parent link without ensure_path pulling /comments/ segments) and ranking_panel/child_label show imported titles, with expanded SSE/integration coverage. B is useful UX/consistency cleanup (SSR home compose slot, delete ExpandNewThreadForm + toolbar) but mainly removes a redundant morph path rather than correcting core data wiring.

Side A fixes a functional Reddit import bug 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 global tree instead of fallback labels. It also propagates the required tree context through the UI and adds integration tests covering SSE updates, child fetching, and rendering, whereas Side B is primarily a UI simplification that removes a redundant expand action and server-renders the collapsed compose state on the home page.

Side B fixes a real bug (Reddit children imports bypassing ensure_path causing wrong path nesting) and a UI defect (unranked children showing raw ids instead of titles), backed by updated integration tests exercising the actual bug. Side A is a legitimate visual improvement (min-max gradient normalization) with good unit tests, but it's a cosmetic refinement rather than a correctness fix affecting data integrity.

B fixes real import/display bugs: Reddit children attach via apply_entity_under_parent (no ensure_path nesting) and unranked rows use stored titles through GlobalTree, with wired call sites and integration coverage. A only switches rank-row coloring from list ordinal to min–max score gradient—a correct UI polish, but narrower and non-functional versus B’s lasting data-path and labeling fixes.

Side B fixes a functional data-model and UI integration issue: Reddit child imports now attach entities directly under the intended parent via `apply_entity_under_parent`, preserves imported entity metadata, updates ranking panel rendering to use the tree for child titles, and wires the new API through callers. It also adds integration tests covering SSE updates and children fetch behavior, whereas Side A is a UI refinement that changes row color gradients from list position to score-based normalization with focused unit tests but does not address core functionality.

Side B fixes a real functional bug (Reddit children being imported without proper path wiring, causing incorrect tree structure) and also fixes unranked child labels to show titles instead of raw paths, with corresponding test updates verifying the fix. Side A is a solid but narrower UX fix (display_path in hrefs) plus a test rewrite, which is useful but less impactful than a genuine data-model correctness fix affecting import behavior.

B fixes lasting import/tree behavior: Reddit children attach via apply_entity_under_parent (no ensure_path intermediate segments) and ranking_panel shows real titles through child_label, with call sites and import tests updated. A’s production change is a narrower href encoding fix (display_path in vote links) plus a stronger 45-pair ranking browser test—valuable verification, but less core product impact than B’s data/UI wiring fix.

Side B fixes a functional import bug by introducing `apply_entity_under_parent` so Reddit child imports attach directly under the fetched parent instead of creating unintended `/comments/...` path structure, and updates the ranking panel to display imported titles for unranked children by passing the global tree into `ranking_panel`. Its integration tests also verify both self and children fetch flows with SSE morphs and rendered output, whereas Side A mainly changes vote URLs to use display paths and strengthens end-to-end testing of pool ranking behavior.

Side B fixes an actual data-modeling bug (Reddit children incorrectly running ensure_path and losing entity_view wiring), threads the tree context through ranking_panel so unranked child labels display correctly, and updates/extends integration tests to verify the fix. Side A is mostly config/env plumbing (extracting a get-base-url helper and changing deploy branch), which is useful but lower-impact and more mechanical than B's genuine bugfix with test coverage.

B fixes core import/tree semantics (apply_entity_under_parent so listing children attach without ensure_path pulling /comments/ segments) and real UI labeling via child titles, with expanded integration coverage. A is valuable centralization of OAuth/base URLs plus a deploy-branch tweak, but is more configuration consolidation than domain correctness.

Side B fixes a functional data-model bug by importing Reddit listing children directly under the parent without path expansion (`apply_entity_under_parent` replacing `link_child` behavior), updates the ranking panel to display imported child titles via tree lookups, and strengthens integration tests to cover SSE morphs and children fetches. Side A usefully centralizes base URL generation around `HOSTNAME`/current origin and adjusts staging deployment, but much of the patch is refactoring existing URL logic rather than introducing new application behavior.

Side B fixes an actual production bug (mislabeled unranked child titles and incorrect import wiring that bypassed ensure_path for Reddit children), with corresponding updates to integration tests validating the fix. Side A adds a new dev-only tool that is useful but non-critical infrastructure; it's larger in volume but doesn't fix any existing defect, whereas B delivers a real correctness improvement to shipped behavior.

B fixes real production bugs: Reddit children listing now uses apply_entity_under_parent so posts attach under the subreddit without ensure_path pulling /comments/ segments, and ranking_panel/unranked_list show entity titles via child_label instead of path stubs, with tighter integration coverage. A adds solid offline sorterc/compile-scan tooling and docs, but it is workspace-only dev infrastructure rather than correcting core import/UI behavior.

Side B fixes concrete functional issues: Reddit child imports now attach posts directly under the subreddit via a new `apply_entity_under_parent` path that avoids incorrect `ensure_path` behavior, and the ranking panel now shows imported entity titles instead of raw IDs for unranked children. It also updates integration tests to verify the import flow and SSE/UI behavior, whereas Side A mainly adds a developer-only offline compiler/linter tool without changing core runtime behavior.

Side A fixes real production behavior (Reddit child import bypassing ensure_path, ranking panel showing raw ids instead of titles) with corresponding reducer.rs API changes, while Side B only patches test-support mocks (regex-vs-string split, getRequestBody vs getInputStream, null-token guard). Both fix genuine bugs, but A's changes affect actual application logic in server/src, whereas B's impact is confined to test harness reliability.

A fixes production Reddit import behavior (apply_entity_under_parent so listings attach without ensure_path nesting, and ranking_panel/child_label so unranked children show real titles) plus integration coverage; B only repairs test mocks (query split, getRequestBody, null-safe token/state) and Playwright helpers with no app-code impact.

Side A fixes core application behavior by changing Reddit child imports to attach entities directly under the intended parent without path expansion, adds `apply_entity_under_parent` to preserve entity data, and updates the ranking panel to display imported child titles via the global tree instead of fallback IDs. It also extends integration tests to cover SSE updates and children imports, whereas Side B mainly repairs test mock infrastructure (query parsing, request handling, redirects, and Playwright selectors) so authentication E2E tests run again.

Side B removes ~1700 lines of a fragile, over-engineered keystroke-transition parser (with a race-condition test, JS debounce logic, and unused CSS) and replaces it with a small, robust paste-and-parse function plus simple UI, meaningfully reducing complexity and fragility while preserving functionality. Side A is a solid, correct bugfix (fixing child import wiring and unranked labels) but is smaller in scope and lower lasting impact than eliminating a large brittle subsystem.

B replaces an unreliable ~1.8k-line keystroke graph, parser_action types, race-prone JS, and Playwright race test with a small paste-and-go URL parser and redirect—lasting maintainability by deleting brittle subsystem code. A is a real, precise bugfix (apply_entity_under_parent vs ensure_path/link_child, title-based unranked labels, stronger import tests) but narrower in scope than removing the failed autocomplete architecture.

Side A fixes a concrete data-model bug by introducing `apply_entity_under_parent` so Reddit listing imports attach posts directly under the subreddit without path expansion, and updates the ranking panel to display imported child titles by looking them up in the global tree. It also adds integration coverage for the import and SSE behavior, whereas Side B mainly replaces a sophisticated autocomplete workflow with a simpler paste-and-go URL parser and removes substantial functionality rather than improving core project behavior.

B fixes a real bug (imported children mis-wired into the tree causing wrong parent attachment and unranked labels showing raw ids instead of titles) and updates integration tests to verify the fix, delivering concrete correctness value. A is a large but purely additive/refactoring scaffold (new /ui endpoint, template substitution system) with no bugfix, adding complexity without demonstrated necessity or bug resolution.

A adds lasting UI architecture: a tested form-template/hole filler, HtmlUiAction parsing, a unified POST /ui dispatcher, and progressive new-thread expand morphs with shared web_post runners. B is a real but narrower fix (Reddit children attach via apply_entity_under_parent without ensure_path side effects, title labels in unranked lists, test updates) and does not outweigh that foundational design.

Side B fixes concrete functional issues in Reddit imports by replacing the simple `link_child` path with `apply_entity_under_parent`, which imports entity data while avoiding incorrect `ensure_path` nesting of `/comments/...` segments. It also improves the ranking UI by showing imported child titles instead of raw IDs and adds integration tests covering children fetches, SSE morphs, and the corrected import behavior; Side A is a substantial architectural addition for a unified `/ui` endpoint, but much of it is infrastructure and refactoring rather than an immediately verified bug fix.

Side B introduces a real, tested feature (Reddit post thumbnails/full-image/link rendering via a new render::reddit module, CSS, and a fixture-backed unit test) that adds lasting UI/domain value, whereas Side A is a narrower bugfix wiring child imports correctly and adjusting integration tests. Side A's fix is legitimate and useful, but Side B's change is more substantial, well-structured (separate module, EntityData extension, tested parsing logic), and delivers durable functionality rather than just a targeted correction.

A fixes core import correctness: children attach via apply_entity_under_parent without ensure_path pulling intermediate Reddit comment-path segments, and ranking shows real titles via child_label, with integration coverage for children SSE. B adds lasting Reddit UI (thumbs, image_url/link_url, render module) but is presentation polish on top of that wiring, not a structural bugfix.

Side A fixes a core correctness issue by changing Reddit children imports to attach entities directly under the requested parent without `ensure_path` creating incorrect `/comments/...` hierarchy, and updates the ranking panel to show imported child titles by looking them up in the global tree. It also propagates the new API through UI rendering and adds integration tests covering SSE updates and child fetching, whereas Side B is primarily a feature enhancement adding richer Reddit-specific rendering (thumbnails, images, links, CSS) and parsing fields without addressing a fundamental data-model bug.

Side A consolidates duplicated room-route parsing logic into shared, validated helpers (room_route_segment/room_id_from_route_segment) used consistently across many endpoints and tests, and adds a substantive, well-tested URL-identity normalization layer (query sorting, YouTube canonicalization) that fixes real duplicate-identity bugs in the ontology system. Side B is a valid, narrower bugfix (Reddit child import wiring and unranked-label rendering) but touches far less surface area and adds less lasting infrastructure than A's DRY refactor plus new normalization module and its 20+ regression tests.

A adds lasting shared design: fixed-width room path encoding (`room_route_segment` / `room_id_from_route_segment`), route/nav/test alignment to `/r/{short}{slug}`, and external URL identity normalization (YouTube rewrites, sorted query pairs) used by `canonicalize_item`. B is a real but localized fix—Reddit children attach via `apply_entity_under_parent` without `ensure_path` nesting, plus title-based unranked labels—valuable for that import/UI path yet narrower lasting surface than A’s core routing and identity model.

Side A introduces a durable routing abstraction (`room_route_segment`/`room_id_from_route_segment` and `ROOM_SHORT_ID_LEN`), updates all server routes and URL generation to use a single encoded room path format, and adds URL normalization utilities (including canonicalization of external URLs such as YouTube links) with accompanying tests. Side B fixes a real Reddit import bug by attaching imported children directly under the fetched parent and improves unranked child labels using stored titles, but its impact is narrower and localized compared with Side A's project-wide API and URL consistency improvements.

Side A fixes a real bug (Reddit children not attaching correctly and unranked labels showing raw slugs instead of titles), with corresponding test coverage validating the fix. Side B is a broad but mechanical type-refactor (String -> CanonicalItemUrl, adding Deref impls) that improves type safety but doesn't fix a user-visible bug, and includes some risky churn (e.g., using ranked[i].item.as_str() while also pushing pairs, mixed use of parse vs direct newtype).

A fixes real product bugs: Reddit listing children no longer go through ensure_path (apply_entity_under_parent avoids /comments/ path pollution) and unranked items show stored titles via child_label, with expanded SSE/children integration tests. B is a solid type-hygiene refactor (CanonicalItemUrl through resolve_item, Deref on URL newtypes) that reduces String round-trips but adds no equivalent behavioral fix.

Side A fixes a concrete functional bug in Reddit child imports by introducing `apply_entity_under_parent` to attach imported children directly without `ensure_path` creating unwanted `/comments/...` hierarchy, and it updates the ranking panel to display imported child titles instead of raw IDs. It also adds integration tests covering SSE updates and Reddit child fetching, whereas Side B is primarily a broad type-safety/refactoring pass (moving from `String` to `CanonicalItemUrl`, adding `Deref`, and API signature changes) with little visible behavioral improvement.

Side B fixes a concrete functional bug (Reddit child imports bypassing ensure_path and mislabeled unranked children) with a small, well-targeted change plus new test coverage validating the corrected behavior. Side A is a large, backward-incompatible DSL syntax rework (trailing to leading explanation blocks) that adds real parser complexity but the bulk of its diff is mechanical fixture/test reformatting rather than fixing a defect, making its net lasting value less clear-cut than B's targeted correctness fix.

A redesigns the core sorter DSL (parser split into block-prefixed votes vs path-then-body items, pending-block handling, legacy rejection) so explanation-first votes become the lasting language contract project-wide. B is a real, precise fix—Reddit children attach via apply_entity_under_parent without ensure_path segment pollution, and unranked labels use entity titles—but it is scoped to import/UI wiring rather than the product’s primary syntax.

Side B fixes concrete functional issues: Reddit child imports now attach entities directly under the fetched parent via a new `apply_entity_under_parent` path instead of incorrectly invoking path expansion, and the ranking panel now displays imported child titles by consulting the global tree rather than raw path labels. Side A performs a sweeping DSL syntax redesign (moving vote explanations before comparisons and updating parser, UI, docs, and many tests), but much of the patch is ecosystem-wide migration and breaking syntax changes rather than an isolated correctness improvement.

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 A is a focused, well-scoped bugfix that corrects Reddit child-import path wiring and unranked-child labels, with matching integration test updates verifying the fix. Side B is a large, sprawling feature dump (room UI, cookies, web posting) that also includes an out-of-place AI-generated markdown file (plan2.md) with no clear relevance to the codebase, indicating noise and lower signal-to-substance ratio despite its size.

B restores lasting product surface: cookie sessions (optional_principal, slug_session), /post web ingest, and scoped room/thread UI (ThreadNav, ACL-gated /r/… routes, compose forms)—foundational multi-tenant web behavior. A is a precise, correct fix (apply_entity_under_parent vs link_child+ensure_path, child_label titles, tighter SSE tests) but narrower in impact; B’s plan2.md is noise yet does not outweigh the real auth and room wiring.

Side A fixes concrete correctness issues in Reddit imports by adding `apply_entity_under_parent` to avoid incorrect `/comments/` path nesting, preserving imported entity data, and updating the ranking panel to display child titles from the global tree instead of raw IDs. It also updates the affected UI call sites and adds integration tests covering SSE updates, child fetches, and import behavior, whereas Side B is a large UI/auth expansion with substantial architectural churn and documentation but a generic commit message and less clearly bounded, correctness-focused value.

Side B fixes a real bug (Reddit children being imported with wrong path/ensure_path semantics, causing incorrect tree structure) and adds/fixes integration tests covering the actual behavior, which is a concrete correctness improvement. Side A adds a new feature (pool-scoped voting) that is useful but more speculative/UI-driven, with less test coverage and more surface area for edge cases (e.g., empty pool handling, query param backward compatibility).

A adds an end-to-end pool-scoped voting path (optional pool query, pair pick from children, constrained next-pair nav, UI entry point, and pool threaded through VoteComparePost/success JS), which is lasting product design. B is a real but narrower fix: Reddit children attach via apply_entity_under_parent instead of ensure_path/link_child, titles in unranked labels, and test updates—correct and necessary, but smaller in scope than A’s full workflow.

Side B fixes a concrete data-model bug in Reddit child imports by introducing `apply_entity_under_parent`, avoiding incorrect path nesting while still storing entity data, and updates the ranking panel to display imported child titles instead of path-derived labels. It also expands integration tests to cover SSE updates and child fetching. Side A adds a useful new pool-scoped voting feature and threads pool context through navigation, but it is primarily a feature addition rather than a correctness fix to existing behavior.

B performs a substantial, coherent refactor centralizing path/URL logic into a shared `slug-types` crate with strongly-typed newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), improving correctness-by-construction and reducing duplicated string-formatting logic across server and RPC code, while preserving existing tests. A fixes a real bug (Reddit children not linked via ensure_path, causing unranked labels to show raw ids) with a small targeted change plus test coverage, which is valuable but narrower in scope and reach than B's broader architectural improvement that touches many call sites and eliminates fragile string-based path handling project-wide.

A fixes real import behavior by replacing link_child/ensure_path with apply_entity_under_parent so Reddit listings attach under the subreddit without pulling /comments/ path segments, and makes unranked children show entity titles via child_label plus tighter SSE/children integration tests. B mostly relocates existing canonicalization and URL helpers into slug-types (GardenItemUrl/ForumThreadUrl re-exports) with call-site renames—useful structure, but little new lasting behavior versus A’s functional tree and UI correctness fixes.

Side A fixes functional behavior: it changes Reddit children imports to use a dedicated `apply_entity_under_parent` path so subreddit listings no longer create unwanted `/comments/...` hierarchy, updates the ranking panel to display imported child titles instead of raw IDs by consulting the global tree, and adds integration tests covering SSE updates and children fetches. Side B is primarily a large refactor that centralizes path and URL types into `slug-types` and updates many call sites, improving organization and type safety but with little direct user-visible functionality.

Side B fixes a real XSS vulnerability by sanitizing untrusted Reddit HTML at render time with a well-scoped ammonia integration and includes targeted unit tests proving script/onerror stripping while preserving benign markup. Side A fixes a plausible bug in child-import path wiring and threads tree context for unranked labels, which is useful but more narrow and lower severity than closing a script-injection hole in rendered untrusted content.

B closes a lasting XSS hole by sanitizing untrusted Reddit body HTML with ammonia at render time (focused sanitize module + unit tests) instead of raw PreEscaped. A is a real functional fix (apply_entity_under_parent, title-based unranked labels, stronger import tests) but is feature/correctness work, not foundational safety like B.

Side B fixes a significant security issue by introducing HTML sanitization with the `ammonia` library and routing all Reddit `body_html` rendering through `entity_body_html`, preventing untrusted `selftext_html` from executing scripts while preserving benign markup with tests. Side A improves Reddit child import behavior by attaching imported posts directly under the subreddit and displaying child titles correctly, plus expands integration tests, but those are primarily functional correctness and UX improvements rather than a cross-cutting security hardening.

Side B fixes a real functional bug (Reddit children imports bypassing ensure_path and showing raw IDs instead of titles), threading tree context through several call sites and updating integration tests to verify the fix. Side A tightens validation constraints (0:0 handling, max 100) which is useful but more incremental/policy-level, with much of its diff being test churn and message-text changes rather than new behavior.

B fixes real Reddit import behavior by replacing incomplete link_child/ensure_path wiring with apply_entity_under_parent so listing children attach under the subreddit without comment-path segments, and makes unranked labels use entity titles via child_label/ranking_panel(tree). A only tightens vote-ratio validation (reject 0-sides and >100) across parser/UI/reducer with regression tests—useful invariants, but less product-critical than the import and display fix.

Side A closes a correctness gap by enforcing vote ratio constraints consistently across the DSL parser, browser POST handler, and reducer, preventing invalid zero-sided votes and oversized ratios while adding targeted unit and integration regression tests. Side B fixes Reddit child import attachment and improves unranked labels by importing children under the intended parent and passing tree context into the ranking panel, but its impact is narrower to the Reddit import/UI path compared with A's project-wide data validation and invariant enforcement.

Side B fixes a real logic bug (ghost items and mis-marked voted pairs from zero-ratio votes) with a small, precise reordering of a guard clause plus an updated unit test verifying the corrected invariant. Side A is a larger, more diffuse patch mixing a genuine parent-linking bugfix with unrelated signature churn (threading `tree` through multiple call sites) and integration test restructuring, making its net lasting value less clear-cut despite its size.

A fixes real import/model wiring (apply_entity_under_parent so listing children attach without ensure_path pulling Reddit comment segments) and lasting UI correctness (child titles in the ranking panel), with broader call-site and integration-test coverage. B is a sharp, necessary reducer invariant fix (drop zero-ratio votes before ensure_item/voted_pairs), but it is a narrower edge-case correction than A’s import-path and display design changes.

Side A fixes a functional integration issue in Reddit child imports by introducing `apply_entity_under_parent` to avoid incorrect path expansion, updates the ranking panel to display imported child titles via tree data instead of raw IDs, and adds end-to-end tests covering SSE updates and child fetching. Side B is a good correctness fix that moves the zero-ratio guard before `ensure_item` and `voted_pairs` mutation to prevent ghost items and stale voted pairs, but it is a narrower reducer bugfix with a smaller project-wide impact.

Side A removes dead demo-counter code and introduces a real architectural improvement: a batched settlement worker that persists votes, recomputes rankings once per batch, and caches scores instead of recomputing on every request (read lock instead of write lock in the hot path), which is a lasting design/performance improvement. Side B fixes a legitimate bug in Reddit child import and unranked labels, which is valuable but narrower in scope and specific to one integration quirk rather than a structural change.

A adds a lasting settlement worker (batched vote append + score recompute), ranking cache/read-path APIs, and drops disposable demo-counter surface area—structural concurrency and hot-path design. B is valuable but narrower: Reddit children attach via apply_entity_under_parent and unranked rows use child titles, plus test wiring. A’s design/cache/cleanup outlasts B’s localized import/label fixes.

Side A replaces synchronous vote handling with a dedicated settlement worker that batches event-log writes, computes and caches rankings once, adds startup cache warming, and switches ranking reads to use cached data with read locks instead of recomputation under a write lock. It also removes the temporary demo-counter feature and related code, while Side B is a focused functional fix that correctly attaches imported Reddit children under the parent and displays child titles in the unranked list, improving import behavior but with a narrower impact.