c_ebc883667d61aabb5b

Commit A makes a substantial functional and interface change to the CLI. It restructures commands (introducing explicit forum subcommands like list/show/post), updates command parsing and execution logic, changes posting semantics to require forum tags and delegates, refreshes help text and DSL documentation, adjusts RPC guidance, and updates integration tests accordingly. These changes affect both user workflows and the implementation across multiple components. Commit B is primarily a codebase maintenance refactor: it removes a duplicate monolithic module, adopts the split forum/ module layout as the single source of truth, and redistributes existing code into smaller files with only minor import adjustments. While valuable for maintainability and resolving module ambiguity, it contributes much less new functionality than A.

Commit A introduces a substantive redesign of the CLI and its interaction model (new command hierarchy, removal of ingest in favor of forum post, updated flags, semantics, docs, RPC hints, and tests). It changes how users and systems interact with the tool. Commit B is a large but primarily structural refactor that splits a monolithic file into modules without adding new functionality. Despite its size, it’s mostly code movement and organization, so A has greater impact.

Side B performs a major structural refactor of the server HTML layer: it removes a 1400+ line monolithic forum.rs file and replaces it with a properly modularized forum/ directory (feed, views, paginator, profile, thread_morph, etc.), resolving module ambiguity and significantly improving maintainability and architecture. This is a deep internal reorganization affecting many routes and UI behaviors. Side A is also substantial—reshaping the CLI command hierarchy, updating docs, tests, and RPC hints—but it is primarily a surface/API restructuring. The architectural impact and long-term maintainability gains in Side B are greater overall.

Commit A performs a substantial structural refactor: it removes the obsolete monolithic forum module, establishes the directory-based module as the single source of truth, introduces multiple focused submodules, updates exports, and relocates large amounts of functionality without changing behavior. This resolves module ambiguity and improves maintainability. Commit B is a very small UI consistency fix, changing a disabled paginator element from a <span> to an <a href="#">. While useful, its scope and impact are minor compared with the broad architectural cleanup in commit A.

Commit A performs a major structural refactor: removes a 1400+ line monolithic file, introduces a modular architecture (multiple new modules like feed, views, paginator, profile, etc.), and reorganizes responsibilities across the codebase. This significantly improves maintainability, clarity, and extensibility. Commit B is a trivial UI tweak (changing a disabled span to an anchor). The impact difference is substantial.

Side A performs a major refactor: removing a 1400+ line monolithic file and reorganizing the forum HTML into a well-structured module hierarchy (feed, views, paginator, profile, morph handlers, etc.), significantly improving maintainability and clarity. Side B is a trivial markup tweak (changing a disabled span to an anchor). The scale and impact of A vastly exceed B.

Commit A delivers a real, user-facing CLI restructuring (forum list/show/post subcommands, updated docs, RPC hints, integration test updates) that changes and improves actual behavior and usability. Commit B is a build-fix that removes a duplicate module file to resolve a compile ambiguity, which is necessary but purely mechanical housekeeping (a merge/refactor artifact cleanup) rather than new design or functionality.

A redesigns the CLI into a lasting public/private scoped command tree (forum list/show/post with required --delegate, path/arg semantics, docs, RPC next-move strings, and integration tests), which permanently shapes agent/user interaction. B only deletes a leftover 1400-line duplicate forum.rs so the already-split forum/ module is unambiguous—a necessary hygiene fix with no new behavior.

Side A makes a substantive CLI/API redesign by replacing the old `ingest` and implicit `forum` commands with explicit `public/private forum list|show|post` subcommands, updates the command parser and RPC wiring, enforces `--delegate` for CLI posts, revises server guidance strings, updates documentation, and adapts integration tests. Side B is primarily a structural refactor that removes the duplicate `server/src/html/forum.rs` in favor of the existing `forum/` module tree and splits code into smaller files, which improves maintainability but does not materially change project behavior.

Side B removes a duplicate monolithic `forum.rs` that conflicted with the new `forum/` module structure, fixing module resolution and preventing ambiguity/compile issues. Side A is largely a CLI/API reshape with extensive renames and doc updates, but introduces mostly surface-level changes rather than a clear correctness fix of similar impact.

Side B removes a 1,400+ line monolithic `server/src/html/forum.rs` and replaces it with a properly structured `forum/` module tree (e.g., `mod.rs`, `feed.rs`, `views.rs`, `thread_morph.rs`), resolving module ambiguity and establishing a clear, maintainable architecture. Side A mainly reshapes the CLI surface (renaming `ingest` to `forum post`, reorganizing subcommands, and updating docs/tests) without fundamentally changing core logic. The architectural cleanup and elimination of duplicate module roots in B provides more lasting structural value.

Side A resolves a real module-ambiguity bug (duplicate forum.rs vs forum/mod.rs) and cleanly splits a 1400-line monolith into cohesive submodules (feed, nav, ingest, views, page, paginator, etc.) with proper visibility and imports, materially improving maintainability. Side B is a one-line cosmetic tag change (span->a) with no functional or structural significance.

A removes a leftover 1400-line monolithic forum.rs sonearestmod forum` resolves cleanly to forum/mod.rs and keeps the split modules as the sole source—real structure and ambiguity fix. B only swaps a disabled paginator span for an anchor (href="#"), a one-line UI consistency tweak with negligible lasting impact.

Side A resolves a structural module issue by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and moving functionality into focused modules such as `feed.rs`, `views.rs`, `page.rs`, `paginator.rs`, `post_single.rs`, `profile.rs`, and `thread_morph.rs`, eliminating ambiguity so `mod forum` consistently resolves to `forum/mod.rs`. Side B only changes one disabled paginator element from a `<span>` to an `<a href="#">`, a minor markup adjustment with far less lasting architectural value.

A removes a 1400+ line monolithic `forum.rs`, resolves module ambiguity, and introduces a structured `forum/` module with separated concerns (feed, paginator, views, etc.), improving maintainability. B is a one-line change swapping a disabled `<span>` for an `<a>` in the paginator, a minor UI consistency tweak with limited impact.

Side A removes the 1400+ line monolithic `server/src/html/forum.rs`, introduces `forum/mod.rs`, and splits functionality into focused modules (`feed.rs`, `views.rs`, `profile.rs`, `thread_morph.rs`, etc.), resolving the duplicate module root ambiguity and significantly improving structure and maintainability. Side B is a minor HTML tweak changing a disabled paginator element from `<span>` to `<a href="#">`, which is negligible compared to the architectural cleanup in A.

Side B fixes a genuine build-breaking ambiguity (duplicate forum.rs vs forum/mod.rs) and completes a real module split into cohesive files (feed, page, paginator, post_single, profile, thread_morph), which is structural, lasting cleanup enabling future maintenance. Side A removes truly dead code and updates a test correctly, which is valid but much smaller in scope and impact than resolving a module-resolution conflict and restructuring a 1400-line monolith.

A removes a real dead-code path in apply_vote and fixes the negative-ratio test to the actual contract (items/pairs registered; zero-weight edges skipped by add_edge_weight), tightening core vote semantics. B only deletes the leftover monolithic forum.rs and reshuffles the same HTML into forum/* modules—including large near-copies of feed/views/profile—so its value is structural cleanup, not new behavior.

Side A makes a behavioral change by removing a dead zero-ratio early return in `GroupState::apply_vote`, relying on existing parser/browser validation and `add_edge_weight` to skip zero-weight edges. It also updates tests to verify that items and pairs are still registered while no edges are created, reflecting the intended reducer semantics. Side B is primarily a large refactoring that deletes the monolithic `forum.rs` and redistributes code into submodules without introducing significant new functionality.

Side A is a real, verified refactor: it deletes the stale monolithic forum.rs and moves all its logic into the already-existing forum/ submodules, resolving a module-resolution ambiguity and preserving working functionality across many call sites. Side B is a speculative planning commit that adds an unfinished plan.md and an unused RouteContext wrapper that isn't actually wired into any call sites, providing no concrete behavioral value yet.

A removes a leftover 1400-line monolithic forum.rs that conflicted with the forum/ tree, making the split modules the sole root—a real compile/structure fix with lasting maintainability. B mostly adds ephemeral plan.md plus a thin RouteContext newtype over ThreadNav with no call-site migration, so little shipped design yet.

Side A removes the duplicate `server/src/html/forum.rs`, introduces `forum/mod.rs`, and moves the existing implementation into focused submodules (`feed.rs`, `views.rs`, `thread_morph.rs`, etc.), eliminating module-resolution ambiguity so `mod forum` has a single authoritative root. Side B mainly adds a detailed planning document plus a thin `RouteContext` wrapper and export, which lays groundwork but leaves most call sites unchanged and delivers little immediate functional value.

Side B fixes a real runtime NameError bug (missing GITHUB_API_BASE_URL definition) with a small, correct, targeted change. Side A is a large mechanical refactor (splitting forum.rs into modules) which is legitimate cleanup but is essentially reorganization/churn rather than fixing a functional defect, and its value depends on the split being correctly wired (harder to verify from diff alone).

Side B is a precise production bugfix: it defines the missing GITHUB_API_BASE_URL used by the OAuth callback, eliminating a NameError that would break GitHub login. Side A’s huge diff is mostly deleting a leftover monolith and reshuffling the same forum HTML into forum/*—useful module hygiene, but largely move/churn rather than new behavior or a targeted correctness fix.

Side A resolves the module layout by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and wiring the split implementation (`feed.rs`, `views.rs`, `thread_morph.rs`, `page.rs`, etc.) as the single module root, eliminating ambiguous `mod forum` resolution and making the refactoring canonical. Side B is a useful but narrowly scoped bug fix that defines `GITHUB_API_BASE_URL` to avoid a `NameError` when the OAuth callback needs a missing API base URL.

Side A performs a genuine, substantial refactor: it decomposes a 1405-line monolithic forum.rs into cohesive, well-scoped submodules (feed, ingest, nav, page, paginator, post_single, profile, thread_morph, views) with clear public/private exports, fixing a module ambiguity bug and improving long-term maintainability. Side B is a small, useful config simplification (auto-discovering test namespaces instead of hand-enumerating them) but is a much smaller, lower-stakes change with less code-organization impact.

A removes a conflicting 1400-line duplicate forum.rs and lands a real module layout (forum/mod.rs plus feed, views, paginator, thread_morph, etc.), fixing Rust module-root ambiguity and making the forum HTML surface maintainable. B only rewrites tests.edn to a single ^test\\..+ suite—useful auto-discovery hygiene, but a small config change with far less lasting structural impact than A’s module split.

Side A removes the duplicate `server/src/html/forum.rs` monolithic module and establishes `forum/mod.rs` as the single module root, with code split into focused files such as `feed.rs`, `views.rs`, `thread_morph.rs`, and `page.rs`. This resolves module ambiguity while preserving functionality and leaves a cleaner, maintainable module structure; Side B is a useful maintenance improvement that replaces hand-enumerated Kaocha test namespaces with an auto-discovered `^test\..+` suite, but it affects test configuration rather than the application's architecture.

A performs a real structural fix, resolving a module-ambiguity bug (duplicate forum.rs vs forum/mod.rs) by cleanly splitting a 1400-line monolith into cohesive submodules with proper visibility boundaries, which is necessary and lasting groundwork. B adds a small, self-contained CLI display feature (connectivity stats formatting) with decent tests, but it's lower-impact and relies on pre-existing ConnectivityStats plumbing rather than fixing a structural defect.

Side B adds a focused, tested product surface: CLI formatting of existing connectivity stats (density, components, comparisons-to-connect) on pair suggestions so voters can act on graph topology. Side A is mostly mechanical modularization—deleting leftover monolithic forum.rs and relocating the same handlers into forum/*—which fixes module-root ambiguity but adds little new behavior beyond structure and a small import path fix.

Side A removes the duplicate `server/src/html/forum.rs` monolith and establishes `forum/mod.rs` with split submodules (`feed`, `views`, `thread_morph`, `page`, etc.), resolving ambiguous `mod forum` resolution and making the modular layout the single source of truth. Side B usefully exposes existing `ConnectivityStats` in CLI output and adds tests, but it is primarily a presentation enhancement rather than a structural correctness and maintainability 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 a real bug (vote compare highlighting/polarity) with a targeted rank_row_style fix, added unit tests verifying the fix, and matching CSS/JS slider polarity corrections—concrete, testable functional value. Side B is purely a mechanical dedup/refactor (removing a stale duplicate forum.rs since forum/ module already existed), which is useful cleanup but is structural churn with no new tests or behavioral guarantees, and its diff is dominated by pre-existing code being relocated rather than newly added value.

A fixes real vote-compare behavior (per-group rank gradients, center-anchored winner-side slider fill, history polarity helpers) and locks it in with polarity/ranking tests. B only removes a leftover monolithic forum.rs so the forum/ tree is the sole module root—necessary hygiene, but mostly deletion/move with no product logic change.

Side A fixes a concrete user-visible bug by changing rank gradient calculations from global ranking offsets to per-group indices, adds regression tests for the highlighting behavior, and aligns vote-history slider polarity with supporting helper functions and tests. Side B is primarily a structural refactor that removes a duplicate `forum.rs` and reorganizes code into `forum/` modules without introducing significant new behavior, improving maintainability but providing less direct lasting functionality.

Side A is a pure mechanical file-split/rename of forum.rs into submodules with no behavioral change, offering only marginal maintainability value. Side B implements a substantive type-safety refactor (CanonicalItemUrl -> structural ItemId enum) touching the reducer, ranking, RPC, and tests, which is a real design improvement with lasting architectural value despite some rough opaque-fallback edges.

B replaces the CanonicalItemUrl string newtype with a structural ItemId enum and wires it through reducer maps, ranking, RPC, garden/HTML, and tests, which is a lasting domain/identity design change; A mainly deletes a leftover forum.rs and finishes a file split into forum/* with almost no behavior change beyond module-root hygiene.

Side B performs a broad architectural refactor by introducing a structured `ItemId` type, replacing `CanonicalItemUrl` across reducer state, ranking, RPC, routing, HTML, tests, and type exports, enabling stronger typing and reducing string-based identity handling. Side A mainly removes a duplicate `forum.rs` and formalizes `forum/mod.rs` as the sole module root—a useful cleanup that fixes module resolution ambiguity, but it largely reorganizes existing code rather than changing core project capabilities.

Side B implements a real, working feature: server-rendered theme switching via cookies (with localStorage migration, /theme route, layout signature changes across many pages) plus a legitimate multi-room URL-prefixing bugfix for ontology/forum links in private rooms, backed by unit tests. Side A is purely a file-split/dedup cleanup removing a duplicate forum.rs (structural refactor with no behavioral change), which is useful hygiene but far less substantive than B's functional additions and bugfixes.

Side B lands real product and API substance: cookie-backed themes with POST /theme, auth flows that re-issue the theme cookie, layout/CSS integration, plus item_path_for_api_in_room/forum_thread_web_url wired through rpc with tests so private-room JSON links are correct. Side A mainly deletes the leftover monolithic forum.rs and finishes the forum/ module split (mod, feed, views, etc.), which is lasting structure but largely reorganization without new behavior.

Side B adds enduring functionality: a persistent theme system (theme cookie handling, `/theme` endpoint, layout updates, propagation through auth and page rendering) and correct room-aware web/API URLs via `item_path_for_api_in_room` and `forum_thread_web_url`, with accompanying tests and widespread RPC fixes. Side A mainly removes the obsolete monolithic `server/src/html/forum.rs` and establishes `forum/mod.rs` as the sole module root, a valuable cleanup that resolves module ambiguity but largely reorganizes existing code rather than adding new behavior.

Side A is essentially cleanup: deleting a stray duplicate forum.rs so the earlier module split resolves (necessary, but it's dead-code removal/reorg with no new behavior). Side B lands multiple concrete fixes—unpinning via a POST RPC instead of a stale link (real UX/correctness bug), a vote-count tooltip/UI enhancement, matching CSS, and a new unit test plus an updated browser test asserting the corrected unpin behavior—delivering more verifiable, lasting functional value.

Side B delivers lasting product behavior: garden pin HUD becomes an unpin `POST /ui set_garden_pin clear` action (with browser coverage), pairwise vote counts on garden rows via `edge_vote_count_for_pair` plus a unit test, and matching docs/CSS. Side A is mostly module hygiene—deleting leftover monolithic `forum.rs` and re-homing the same logic under `forum/`—so it clarifies resolution but adds little new capability versus B’s user-facing fixes.

Side A resolves a structural correctness issue by removing the duplicate `server/src/html/forum.rs` module, adding `forum/mod.rs`, and making the split `forum/` directory the single module root. This eliminates ambiguous module resolution and consolidates the existing implementation into a maintainable layout, whereas Side B mainly adds UI enhancements (HUD unpin button, vote counts/tooltips, CSS, and tests) without addressing a foundational project structure problem.

A resolves a real structural defect (a duplicate forum.rs colliding with the forum/ module tree) and cleanly modularizes ~1400 lines into focused files (feed, nav, ingest, paginator, views, etc.), producing lasting architectural clarity. B is a smaller but well-tested correctness fix — normalizing thread_post_index to 0-based across rpc.rs/garden.rs and adding integration test assertions — valuable but narrower in scope than A's necessary and broad reorganization/bugfix.

Side B fixes a real off-by-one bug: rank-history post indexes were 1-based with a silent unwrap_or(0) fallback, breaking links and disagreeing with 0-based /t/tag/N routes; it aligns RPC, garden HTML, types, and integration tests on the correct contract. Side A only deletes a leftover forum.rs duplicate and wires forum/ as the module root after a split—useful hygiene that removes ambiguity, but it adds no behavioral value beyond cleanup of already-split code.

Side A resolves a structural module issue by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and moving the implementation into focused submodules (`feed.rs`, `views.rs`, `page.rs`, `paginator.rs`, `post_single.rs`, `profile.rs`, `thread_morph.rs`), ensuring `mod forum` unambiguously resolves to `forum/mod.rs` and improving maintainability without changing behavior. Side B makes a smaller semantic cleanup by changing rank-history post indexes to the project's 0-based URL convention, replacing silent fallbacks with `expect(...)`, updating links, comments, and tests, but its impact is narrower.

Side B is a substantial architectural change: it replaces a sprawling set of ad-hoc REST endpoints with a unified RPC batch protocol, reworks the reducer's room/thread model (ScopeId, RoomState vs ForumThreadState), updates the CLI to use scoped subcommands and RPC calls, and updates the full test suite and integration scripts to match — a real, cohesive advance in the project's data model and API surface. Side A is a much smaller, purely mechanical fix (deleting a duplicate leftover forum.rs so `mod forum` resolves), which is necessary but minor cleanup rather than new capability or design.

Side B replaces the old REST surface with a unified RPC batch API and remodels the domain (rooms vs threads, ScopeId::Room, room_id/thread_tag on ingest, grants/RoomCreated), which is lasting architecture across server, CLI, types, and tests. Side A only deletes a duplicate monolithic forum.rs and wires the already-split forum/ modules so Rust module resolution is unambiguous—necessary cleanup, not new product capability.

Side B introduces a substantial architectural change: it replaces many specialized REST endpoints with a unified RPC API, updates the CLI to use batched RPC commands, refactors the reducer and event model from thread-centric to room/scope-aware data structures, and propagates those changes through tests and types. Side A mainly removes the obsolete monolithic `forum.rs` in favor of the already-split `forum/` module tree and adds `forum/mod.rs`, which is a useful cleanup to resolve module ambiguity but is primarily structural rather than adding new project capabilities.

Side A is pure file reorganization (splitting a monolith into modules) with no behavioral change, which has value but is mechanical churn. Side B introduces a real type-safety improvement by threading CanonicalItemUrl through resolve_item, validate, and rank computations instead of raw strings, reducing stringly-typed bugs, plus adds Deref impls that reduce boilerplate call sites—this is a more substantive, lasting design improvement to the codebase's type system.

B tightens core path typing end-to-end (resolve_item → CanonicalItemUrl, typed pools/maps in validate/rank/pair RPC, Deref on href newtypes), removing repeated String↔CanonicalItemUrl glue and hardening the API model. A’s lasting piece is real but smaller: deleting leftover html/forum.rs so forum/ is the sole module root; most of the huge diff is relocated split-module code rather than new behavior.

Side B makes a substantive type-safety refactor by changing `resolve_item` to return `CanonicalItemUrl`, propagating canonical path types through validation, ranking, pair selection, and RPC code, and adding `Deref<Target=str>` plus `from_stored` usage to reduce string conversions and parsing errors. Side A primarily removes the duplicate `server/src/html/forum.rs` and establishes `forum/mod.rs` as the sole module root—a useful structural cleanup that resolves module ambiguity, but it largely reorganizes existing code rather than strengthening core behavior.

Side A is a pure mechanical split/reorganization of forum.rs into submodules with no behavior change (net-zero functional value, mostly file-move churn). Side B implements a real UX/architecture improvement: it removes redirect-based auth flow in favor of AJAX form morphing, adds error/success fragment rendering, updates the shared poem JS to handle in-place form updates, and adds corresponding CSS — a genuine functional feature with lasting design impact.

B adds lasting product behavior: auth POSTs return Maud fragments (error form / signed-in message) and poem JS morphs non-empty bodies into the form, replacing redirect-based choose-username with inline success/error and shared layout. A’s huge diff mainly deletes leftover forum.rs and relocates the same thread HTML into forum/* with little logic change—useful module hygiene, but mostly structural churn versus B’s focused UX/API improvement.

Side B makes a lasting functional improvement: `post_choose_username` now returns HTML fragments for success/error instead of redirects, and the shared Poem JS reads non-empty responses to morph a form's `innerHTML`, enabling inline auth feedback while preserving existing empty-response behavior for other forms. Side A primarily removes the duplicate `server/src/html/forum.rs` and establishes `forum/mod.rs` with split modules to eliminate module-root ambiguity, which is valuable maintenance but mostly a structural cleanup rather than new user-facing behavior.

Side A completes a necessary module split for a 1400-line monolithic forum.rs into clear submodules (feed, ingest, nav, page, paginator, post_single, profile, thread_morph, views), removing a duplicate module that would otherwise cause ambiguity, and establishing the file layout that later commits (like B) build on. Side B is a smaller, useful behavioral simplification (removing a redundant morph action and toolbar in favor of direct SSR), but it's a narrower fix built atop the structure A created, so it has less independent architectural value.

A removes the leftover 1400-line monolithic forum.rs so forum/mod.rs is the unambiguous module root and splits the real handlers (feed, views, paginator, morph, profile, etc.) into lasting structure. B only deletes ExpandNewThreadForm and the home toolbar +, SSR-ing #new-thread-ui-slot like rooms—a smaller consistency cleanup on one compose path.

Side A fixes a structural module-resolution problem by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and making the split `forum/` directory the single module root. This removes duplicate sources of truth and prevents `mod forum` ambiguity, whereas Side B mainly removes the redundant `ExpandNewThreadForm` UI action and toolbar in favor of server-rendering the same collapsed new-thread slot, which is a useful simplification but has narrower long-term impact.

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

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

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

Side B is a real bugfix: it moves the zero-ratio guard before ensure_item/voted_pairs insertion, preventing ghost items and incorrectly-marked voted pairs, and updates the test to verify the corrected behavior. Side A is purely mechanical file-splitting (moving code from one forum.rs into multiple forum/*.rs submodules) with no behavioral change, so while it improves organization, it carries less lasting substantive value than a genuine correctness fix.

B fixes a real reducer correctness bug by moving the zero-ratio early-return before ensure_item and voted_pairs.insert, so invalid votes no longer create ghost items or mark pairs voted, and updates the test to lock that in. A mainly deletes a leftover monolithic forum.rs and finishes relocating the same logic into forum/*—useful module hygiene, but mostly structural churn without new behavior.

Side B fixes a real reducer correctness bug by moving the zero-ratio early return before `ensure_item` and `voted_pairs.insert`, preventing ghost items and incorrectly recorded voted pairs, and updates the test to verify that no state is registered. Side A primarily removes the obsolete monolithic `forum.rs` and switches to the split `forum/` module layout, which improves project structure but largely preserves existing behavior rather than fixing functionality.

B adds a complete, well-scoped feature (garden ranking clipboard copy) with a new UI action, markdown formatting, unit tests, an integration test, and a browser test plus docs update — genuine lasting functionality. A merely deletes a stale duplicate forum.rs, which is a necessary but narrow fix cleaning up a mess from an earlier split (no new capability, just removing dead/duplicate code).

B adds a complete, user-facing capability (CopyGardenRank → markdown clipboard) with handler logic, UI wiring, unit/integration/browser tests, and docs—durable product value. A is largely a structural fix: deleting the monolithic forum.rs and redistributing the same logic into forum/* modules, which clears module ambiguity but is mostly relocation rather than new behavior.

Side A resolves a structural module-root ambiguity by deleting the leftover monolithic `server/src/html/forum.rs`, introducing `forum/mod.rs`, and making the split `forum/` modules the single authoritative implementation. This is a lasting architectural cleanup that prevents duplicate module resolution and maintenance drift, whereas Side B adds a useful but narrower feature: a `CopyGardenRank` UI action, clipboard markdown generation, button integration, and tests for copying garden rankings.

A is a purely mechanical cleanup that removes a leftover duplicate forum.rs to fix module-resolution ambiguity — necessary but trivial housekeeping with no design change. B finalizes a real architectural shift in URL canonicalization, replacing the ad-hoc per-domain rule engine (engine.rs with hardcoded reddit/youtube functions) with a more general graph/DFA-based resolver (graph.rs/parse.rs) plus updated docs, which is a more substantive and lasting improvement to core logic even though some test consolidation obscures full visibility of the new implementation.

B replaces the old composable ParsedUrl/engine normalizers and domain_key match arms with a graph-based canonicalization API (registry thin wrapper over graph/parse, docs and tests re-homed), which is lasting core ItemId design. A mostly deletes the leftover monolithic forum.rs and redistributes the same forum HTML into forum/* modules plus a small timeago import fix—necessary structure cleanup, but little new behavior or design.

Side A resolves a real module-structure issue by removing the duplicate `server/src/html/forum.rs`, adding `forum/mod.rs`, and making `forum/` the single module root while preserving behavior through extracted modules like `feed.rs`, `views.rs`, and `thread_morph.rs`. Side B replaces the URL canonicalization engine with a new graph-based architecture and updates the registry API, but the visible patch largely swaps implementations and removes in-file tests without showing the new core logic, making its lasting functional impact less directly evident from the diff.

Side B fixes a real build-breaking ambiguity (duplicate forum.rs vs forum/mod.rs) that would prevent the module from compiling/resolving correctly, restoring a clean modular structure already begun by prior refactors. Side A fixes several genuine but narrower test-infra bugs (regex vs string split, wrong stream method, missing null-guards, error handling in mock server) that meaningfully unblock E2E auth tests but only affect test tooling, not production code.

Side A makes precise, lasting bugfixes in the OAuth/Reddit mocks (regex split on "=", getRequestBody vs getInputStream, sendResponseHeaders length 0, nil-safe token parse, try/catch, and real CSS selectors in auth_login) that restore broken Clojure E2E auth flows. Side B only removes a duplicate monolithic forum.rs and re-exports already-split modules under forum/mod.rs—necessary hygiene that eliminates ambiguity but adds no new behavior beyond import tidy-ups.

Side A fixes concrete regressions in the OAuth test infrastructure: it corrects query parsing (`str/split` regex), reads POST bodies from `getRequestBody`, avoids null handling crashes (`parse-token-user`, `state` encoding), fixes redirect response handling, wraps handlers with error reporting, and updates Playwright helpers to use real selectors. Side B is primarily a structural refactor that removes a duplicate `forum.rs` and reorganizes code into modules without materially changing behavior, improving maintainability but adding little new functionality.

Side A delivers a genuine algorithmic fix (min-max score normalization instead of list-position gradient) with new unit tests validating the behavior change, improving actual UI correctness and giving lasting design value. Side B merely deletes a stale duplicate file left over from an earlier refactor, which is necessary cleanup/bugfix for module resolution but contributes no new functionality beyond fixing an artifact of a prior split.

A replaces ordinal/list-position coloring with min–max score normalization inside each rank group (plus targeted tests for range, ties, and similarity), a lasting UX/design fix. B only deletes the leftover monolithic forum.rs and finishes relocating code into the forum/ tree, which is useful cleanup but not new behavior or design.

Side A changes the ranking color algorithm from list-position-based gradients to score-based min–max normalization within each group, introducing a dedicated `score_gradient_t` helper, updating `rank_row_style` call sites, and adding focused tests for range mapping, tied scores, and stability. Side B is primarily a structural refactor that deletes the duplicate `forum.rs` in favor of `forum/mod.rs` and split modules; while valuable for maintainability and removing module ambiguity, it largely preserves existing behavior rather than improving project functionality.

A is a pure mechanical fix removing an accidental duplicate file with no behavioral change beyond deduplication, useful but trivial housekeeping. B delivers an actual UX/feature improvement (grouped cli_panel API change across call sites, CSS updates, and a real safety assertion guarding against JS-injection via unescaped single quotes), representing more genuine design and correctness work.

B changes real product behavior: multi-command grouped CLI panels, click-to-copy rows, safety asserts for JS string embedding, and matching CSS across themes. A mostly deletes the leftover monolithic forum.rs and wires that same code into forum/ modules—valuable structure cleanup and ambiguity fix, but largely relocating existing logic rather than adding lasting capability.

Side A removes the duplicate monolithic `server/src/html/forum.rs`, introduces `forum/mod.rs`, and makes the split `forum/*` modules the single module root, eliminating ambiguous module resolution and reducing long-term maintenance risk without changing behavior. Side B improves the CLI panel by supporting grouped commands, click-to-copy rows, and adding assertions to prevent unsafe single-quoted JS embedding, but this is primarily a UI enhancement rather than a foundational structural fix.

Side B fixes a real UI bug (unranked siblings were incorrectly lumped into one group instead of shown as separate isolated groups) and adds a regression test validating the corrected behavior. Side A is a pure mechanical file-splitting refactor (breaking up forum.rs into forum/*.rs modules) with no behavioral change or bug fix, offering organizational value but less lasting substantive impact than B's correctness fix plus test coverage.

Side B changes lasting product behavior by putting each unranked sibling into its own SiblingNavGroup (instead of one combined unranked bucket) and hardens that with a dedicated unit test; Side A is almost pure structural churn—deleting the leftover 1405-line forum.rs monolith and re-homing the identical logic into forum/{mod,feed,views,...}.rs—so it removes module ambiguity but adds no new functionality or bugfix beyond file layout.

Side A removes the leftover monolithic `server/src/html/forum.rs`, introduces `forum/mod.rs`, and makes the split `forum/` directory the single module root, eliminating duplicate module definitions and reducing long-term maintenance ambiguity without changing behavior. Side B makes a focused behavioral improvement by splitting each unranked sibling into its own navigation group and adds a regression test, but its impact is narrower than the structural cleanup and module-resolution fix in Side A.

A completes a real refactor by removing a stale duplicate forum.rs so the module tree resolves unambiguously to forum/mod.rs, fixing a build-correctness hazard; B merely adds one probabilistic unit test with no production code changes. Both are modest, but A's fix has direct build/runtime consequence while B's is a nice-to-have test with a randomized (non-deterministic) assertion that could be flaky.

B adds a focused property test that the rank-centrality scorer recovers full alphabetical order from a minimal spanning tree of 25 perfect-ratio votes—real regression/documentation value for core ranking math. A is largely module plumbing: deleting the leftover monolithic forum.rs and shuffling the same handlers into forum/* with only minor import cleanup, so most of the huge diff is structural churn rather than new behavior or fixes.

Side A removes the duplicate `server/src/html/forum.rs` monolithic module, adds `forum/mod.rs`, and makes the split `forum/` directory the single module root, eliminating ambiguous module resolution while preserving functionality through extracted submodules like `feed.rs`, `views.rs`, and `thread_morph.rs`. Side B only adds a regression test for rank centrality on a random spanning-tree vote graph; it improves verification but does not change the implementation itself.