c_59974b9da42af7cbb8

Side A fixes a real correctness bug (implicit feed cutoff using timestamps that can collide or move backwards) with a principled ingest-order anchor, adds a room field to prevent private-content leakage, and backs this with substantial multi-user permission integration tests. Side B is a pure refactor (splitting forum.rs into submodules) plus an unrelated dev tooling script, providing organizational value but no functional fix or new guarantees, and its diff even reintroduces some inline duplication it had previously factored out.

A fixes real feed correctness and privacy: implicit catch-up anchors on durable ingest index (not ms timestamps), keeps visibility checks so multi-user private rooms neither drop concurrent posts nor leak revoked content, and adds room on FeedPost plus targeted integration tests. B mostly splits forum.rs into modules, inlines a few RPC helpers, and adds a macOS sample-fixture script—organizational churn without comparable behavioral value.

Side A fixes core feed correctness by introducing a shared `rpc_feed` implementation that anchors implicit catch-up to durable ingest order instead of timestamps, enforces per-viewer visibility checks, includes room metadata, and adds extensive integration tests covering timestamp collisions, private-room permissions, and revoked access. Side B is primarily a code organization/refactoring change that splits forum code into new files and inlines some helper calls, with only a small auxiliary profiling script added; it does not materially change project behavior.

Side A adds a genuinely useful diagnostic script (sample-fixture) and cleanly refactors the monolithic forum.rs into cohesive submodules (access, ingest, nav, new_thread, room_members), improving maintainability with minimal behavioral risk. Side B merely deletes an entire feature (the tree view UI, its routes, and its well-covered test suite) with no replacement or migration path, which removes functionality and prior test coverage rather than adding lasting value.

A modularizes the live forum HTML stack into focused modules (nav, ingest, access, new_thread, room_members), which is lasting structure on core product code, plus adds a reusable sample-fixture helper. B only deletes the abandoned tree UI (~819 lines) and its exports—valuable cleanup, but pure subtraction without improving design of what remains.

Side A performs a substantial architectural refactor by splitting the forum code into focused modules (such as access, ingest, navigation, room members, and new-thread handling), while preserving behavior and introducing reusable helpers like ThreadNav and permission checks. It also adds a useful developer profiling script (`sample-fixture`) for diagnosing fixture processes, whereas Side B primarily removes the entire tree feature (`tree.rs`) and its exports, which is mostly feature deletion rather than an enduring improvement to the codebase.

Side B is an actual executed refactor that splits a monolithic forum.rs into focused modules (nav.rs, ingest.rs, new_thread.rs, room_members.rs, access.rs) plus a small useful debugging script, improving real code organization while preserving behavior. Side A is purely a planning document plus a thin, incomplete RouteContext wrapper that mostly just forwards to ThreadNav—useful as a roadmap but contributes no functional improvement yet and risks becoming stale/deleted per its own text.

A adds lasting architecture: a concrete RouteContext API (routing.rs + re-exports) and a detailed ItemId migration plan that defines identity vs href boundaries. B is mostly mechanical forum file-splitting plus a macOS sample-fixture helper—useful organization, but little new behavior or durable design compared with A’s scaffolding.

Side B performs a real codebase refactor by extracting forum functionality into focused modules (`access.rs`, `ingest.rs`, `nav.rs`, `new_thread.rs`, `room_members.rs`), introducing reusable components like `ThreadNav`, and moving existing UI logic without changing behavior, which improves maintainability. Side A mostly adds a detailed migration plan (`plan.md`) plus a thin `RouteContext` wrapper around `ThreadNav`; while useful as guidance, it leaves the underlying architecture largely unchanged.

Side A delivers a coherent, self-contained UX/code improvement (grouped CLI panel, single border, hover-to-copy) plus a genuine correctness fix (JS-safe-quote assertion preventing broken onclick handlers), all with a clean diff. Side B is a large mechanical refactor (splitting forum.rs into files) that mostly moves code verbatim, reintroduces some duplicated inline JSON templating instead of reusing helper functions (arguably a slight regression), and bundles an unrelated sampling script, making its net lasting value less clear-cut despite its size.

A ships a real product improvement: multi-command CLI panels with row click-to-copy, shared border/layout, theme CSS, and hard asserts that commands stay single-quote JS-safe—changing behavior call sites (e.g. room page three panels → one). B is mostly a forum.rs file split (nav/ingest/access/etc.) plus thin RPC inlining and an unrelated macOS sample-fixture script, so it is maintainability churn rather than lasting feature or bugfix value.

Side A delivers a functional UI improvement by redesigning `cli_panel` to support multiple commands in one panel, making each command directly clickable-to-copy, and adding assertions that prevent unsafe characters from being embedded in single-quoted JavaScript literals. Side B is largely a structural refactor that splits forum code into new files and inlines some helper calls, with an added macOS profiling script, but the shown changes introduce little new project behavior compared with A's concrete usability and safety improvements.

Side A performs a substantial modularization of forum.rs into cohesive submodules (nav.rs, ingest.rs, room_members.rs, new_thread.rs, access.rs), improving long-term maintainability and separation of concerns, even though it slightly regresses by inlining some duplicated RPC JSON calls. Side B is a much smaller, focused simplification that removes an unnecessary post-card render from the vote-compare success path, which is a real but minor and narrow improvement compared to the broader structural payoff of A.

A’s lasting value is the forum modularization—extracting coherent units (nav, ingest, access, new_thread, room_members) from a monolithic forum.rs and tightening RPC helpers—which improves long-term structure of core HTML UI. B is a correct but narrow cleanup: dropping unused vote_compare_post_success_js parameters and the preview morph, valuable hygiene with much smaller project impact (A’s sample-fixture addition is incidental noise).

Side A performs a substantial architectural refactor by splitting the large forum module into focused modules (`access.rs`, `ingest.rs`, `nav.rs`, `new_thread.rs`, `room_members.rs`) and adds a reusable `sample-fixture` development tool, while preserving the existing UI behavior by inlining or relocating RPC generation. Side B is a narrow cleanup that simplifies `vote_compare_post_success_js` by removing unused parameters and no longer morphing the `#vote-compare-preview` content, making it primarily a localized code simplification rather than a broad, lasting structural improvement.

Side A introduces substantial new functionality (rank-centrality ranking engine with regression tests, form-template substitution system, a URL parser/graph engine, and a large vote-comparison UI module) that provides lasting algorithmic and product value. Side B is a pure refactor (splitting forum.rs into submodules plus an unrelated macOS sampling script) that reorganizes existing code without adding new capability, and even reintroduces some inline duplication that the original had factored out.

Side A introduces substantial product systems—rank centrality with regression tests, the event reducer/state model, vote-compare UI, form-template/UI actions, and a large URL parser—whereas Side B mostly splits existing forum HTML into submodules and adds a small macOS sample-fixture helper. Even with noise (shell paste in forms.rs/ranking.rs, .tdsl notes), A’s lasting design and behavior far outweigh B’s organizational churn.

Side A introduces substantial new project capabilities: a parser graph with extensive tests, ranking and reducer infrastructure, UI action/form templating, vote handling, browser plumbing, and supporting test scripts. Although it includes some accidental terminal-output noise in files like `forms.rs` and `ranking.rs`, the commit still establishes core functionality, whereas Side B is primarily a code organization refactor that splits forum code into modules and adds a developer profiling script without introducing comparable new behavior.

Side B adds a genuine new browser test exercising pool-scoped voting behavior, giving lasting regression protection with clear assertions. Side A's refactor is mixed value: it does split forum.rs into modules, but it also inlines several previously-named RPC helper functions back into duplicated call sites (undoing prior DRY abstractions) and bundles in an unrelated sample-fixture bb script, diluting the refactor's focus and quality.

B adds a lasting E2E browser test that seeds a pool, drives the vote→next-pair loop, and asserts edge history and pool membership—real regression protection for core behavior. A is mostly a mechanical split of forum.rs into modules plus inlined RPC helpers and an unrelated macOS sample-fixture script, improving layout without changing product behavior.

Side A performs a substantial architectural refactor by extracting forum functionality into focused modules (such as access, navigation, ingest, room members, and new-thread handling) while preserving behavior, and also adds a reusable macOS profiling utility (`sample-fixture`) integrated into the build tasks. Side B adds a valuable end-to-end browser test for pool-scoped voting, but it is verification only and does not change the project's architecture or runtime behavior, making its lasting impact smaller.

Commit A performs a meaningful structural refactor, splitting a monolithic forum.rs into cohesive modules (nav, ingest, new_thread, room_members, access), reducing duplication (e.g. removing separate rpc-value helper functions) and adding a genuinely useful sample-fixture dev tool. Commit B is a small, focused CSS/markup tweak moving the delete button's position, which is a real but narrow UI fix with much less lasting architectural value.

A’s lasting value is the forum split into focused modules (nav, access, ingest, new_thread, room_members) that structure real domain boundaries; B only relocates the delete control into the meta row with flex CSS. Minor noise in A (sample-fixture script, RPC helper inlining) does not outweigh that architectural win over B’s small UI polish.

Side A performs a substantial architectural refactor by extracting forum functionality into focused modules (such as access, ingest, navigation, room members, and new thread handling) and centralizing reusable logic like URL helpers and permission checks, improving maintainability without changing behavior. It also adds a useful developer profiling script (`sample-fixture`) and removes redundant helper wrappers by inlining simple RPC generation, whereas Side B mainly repositions the delete button within the post metadata and adjusts CSS layout for that UI change.

Side A performs a substantive refactor of forum.rs into focused submodules (access.rs, ingest.rs, nav.rs, new_thread.rs, room_members.rs), improving code organization and maintainability of real application logic, plus adds a useful diagnostic tool (sample-fixture). Side B only edits documentation/plan text files (DSL.txt, GUIDE.sorter, plan.md) with no code changes, which is lower-impact churn on prose rather than lasting code structure improvement.

A lasting structural win: forum HTML is split into real modules (nav, access, ingest, room_members, new_thread) with clear seams, plus a useful sample-fixture helper—more than move churn despite inlined RPC helpers. B only realigns DSL/GUIDE/plan prose to the no-@ wire identity model; valuable correctness for readers, but docs-only and no runtime or architecture change.

Side A introduces substantial code organization by extracting forum functionality into dedicated modules (`access.rs`, `ingest.rs`, `nav.rs`, `new_thread.rs`, `room_members.rs`) and adds a reusable `sample-fixture` debugging tool integrated into the build tasks. Although some changes inline helper calls, the commit creates reusable navigation, access-control, rendering, and composition components that support future development, whereas Side B is limited to documentation updates aligning identity and wire-format conventions without changing project behavior.

Side A performs a genuine refactor, splitting a monolithic forum.rs into focused submodules (nav, ingest, room_members, new_thread, access) with clear responsibilities, which is a lasting structural improvement, plus adds a useful sample-fixture dev tool. Side B is almost entirely mechanical rustfmt churn across unrelated files (durable/*, server/*) with only a trivial CSS dedup and toolchain pin as real substance, offering little lasting design value beyond formatting consistency.

A modularizes the monolithic forum.rs into focused modules (nav, ingest, access, room_members, new_thread) with real structural clarity, plus a useful sampling fixture; B is almost entirely rustfmt churn across examples/libs plus minor toolchain/VS Code pins and one tiny CSS dedupe.

Side A performs a substantive architectural refactor by extracting major forum responsibilities into new modules (such as access, ingest, navigation, room members, and new-thread handling), introduces reusable helpers like ThreadNav and permission checks, and adds a useful profiling script for sampling fixture processes. Side B is overwhelmingly workspace-wide formatting plus tooling updates (pinning rustfmt/clippy, VS Code settings, minor CSS cleanup), with little functional impact beyond developer ergonomics.

B is a substantial, coherent refactor that splits a monolithic forum.rs into focused modules (nav, ingest, room_members, new_thread, access) plus adds a useful diagnostic script, improving maintainability across the codebase. A is a single, useful randomized test validating rank-centrality convergence, which adds real verification value but is much narrower in scope and impact than B's structural improvement.

A adds a focused correctness test that the rank-centrality path recovers true order from a minimal spanning-tree vote graph with perfect strength ratios—direct, lasting coverage of core ranking behavior. B is mostly a mechanical split of forum.rs into modules plus an unrelated macOS sample-fixture helper; it reorganizes existing UI code without fixing bugs or changing product semantics, so outweighing it by line count would reward churn over substance.

Side A adds a targeted regression test that exercises a key algorithmic property: with only 25 spanning-tree comparisons using perfect strength ratios, the ranking implementation recovers the full alphabetic order. Side B is primarily a structural refactor that extracts forum code into new modules and inlines/removes helper functions, plus adds a macOS profiling script; these improve organization and tooling but introduce little new core behavior.

Commit A fixes a real bug (unranked siblings being merged into a single nav group instead of one group per isolate) and adds a targeted regression test verifying the corrected grouping. Commit B is a large structural refactor splitting forum.rs into submodules plus an unrelated new sampling script, which is useful for maintainability but introduces no behavioral improvement and carries higher risk of noise/regressions without new tests.

A is a targeted behavioral fix: unranked siblings each become their own nav group (with an updated contract comment and a unit test), lasting product/design value. B mostly relocates existing forum code into submodules and inlines RPC helpers, plus a macOS sample-fixture script—useful structure/tooling churn, but little new correct behavior relative to patch size.

Side A changes the sibling navigation behavior so each unranked sibling becomes its own navigation group instead of all unranked siblings being merged together, matching the documented ranking model, and adds a focused regression test verifying the new grouping. Side B is primarily a structural refactor that moves forum code into new modules and inlines a few helper calls, plus adds a macOS profiling utility; while useful for maintainability, it introduces little new project behavior compared with A's concrete, tested functional improvement.

Side B is a genuine structural refactor extracting forum.rs logic into focused submodules (nav, ingest, new_thread, room_members, access) with clear separation of concerns, improving long-term maintainability. Side A is a dev-tooling improvement (persistent fixture data, cargo-watch) that's useful but more ephemeral/local-workflow-focused, and even includes an unrelated regression removing room title/breadcrumb markup from forum.rs without explanation.

B’s split of forum into focused modules (nav, ingest, access, room_members, new_thread) plus shared new-thread compose logic is a lasting structural improvement to core server UI code, whereas A mainly upgrades the fixture/dev workflow (cargo-watch, persistent fixture-data/, preferred port) and a small room_page markup trim. B’s modularization outranks A’s useful but narrower tooling changes; the added sample-fixture helper is incidental.

Side A substantially improves the developer workflow by replacing a release-build fixture with a persistent `cargo watch`-based server, adding preferred-port selection, reusing seeded `fixture-data/`, rebasing saved URLs, and extending health-check timeouts for reliable iteration. Side B is largely a structural refactor that moves forum code into new modules and inlines small helper functions without changing behavior, with the only notable functional addition being a macOS-specific `sample-fixture` profiling script.

B is a substantive refactor that splits a monolithic forum.rs into cohesive modules (nav, ingest, new_thread, room_members, access) plus adds a genuinely useful sampling script, improving maintainability at real scale. A is a small, useful but narrow config simplification (kaocha test discovery) that reduces boilerplate but touches only one file with modest lasting impact.

B’s split of forum HTML into focused modules (nav, ingest, access, room_members, new_thread) is a lasting structural improvement to core server code, despite some helper inlining and an ancillary sample-fixture script. A only rewrites tests.edn to a single ^test\\..+ suite—useful automation, but a narrow config change with far less enduring product impact.

Side A replaces a fragile hand-maintained list of test namespaces with a single auto-discovered `:all` Kaocha suite using `^test\..+`, so new `test.*` files are automatically executed without editing `tests.edn`, reducing ongoing maintenance and preventing missed tests. Side B is largely a structural refactor that moves forum code into new modules and adds a macOS-specific profiling helper (`sample-fixture`), which improves organization and tooling but introduces little new core project behavior.

A adds a small, well-defined feature (connectivity stats exposed in CLI output) with clear, testable behavior and unit tests verifying exact output format. B is billed as a refactor but mixes in an unrelated macOS sampling script, and in several spots it actually removes shared helper functions (set_room_members_expanded_rpc, etc.) and inlines duplicate template_json_compact calls in multiple places, trading a modest file-splitting benefit for reduced DRYness and unrelated scope creep.

A adds a focused product feature: surfacing existing connectivity stats in CLI pair output (with tests and clear formatting), so voters can see sparse/disconnected graphs before voting. B is mostly a mechanical split of forum.rs into modules plus helper inlining and an unrelated sample-fixture script—useful organization but little behavioral or user-facing lasting value versus A’s precise UX win.

Side B is a substantial, coherent refactor that extracts forum.rs into focused submodules (nav, ingest, room_members, new_thread, access) plus a useful new sampling script/task, improving maintainability without changing behavior. Side A is a small, valid bugfix/clarification (turning silent fallback into an explicit expect and fixing docs/tests for 0-based thread_post_index), which is correct but much narrower in lasting impact.

A fixes a real indexing bug/inconsistency: rank-history `thread_post_index` becomes required 0-based (aligned with `/t/tag/N`), drops silent `unwrap_or(0)`/`+1` and the conditional link UI, and locks behavior with integration asserts. B is mostly a file split/inline of forum helpers plus an unrelated macOS sample script—useful structure/tooling, but little lasting product semantics versus A’s correctness change.

Side A is a focused, coherent refactor that splits a large forum.rs file into cohesive submodules (access, ingest, nav, new_thread, room_members) plus a small unrelated sampling utility script, preserving existing behavior with no regressions. Side B is a large, messy commit that deletes a 1800-line legacy Reddit URL parser file only to recreate an almost-identical copy under a new name/module (renaming UIAction to ParserAction), adding speculative unfinished 'parser panel' UI/JS wiring that is unrelated to the project's actual forum domain, representing far more churn with much less lasting architectural value.

B integrates the legacy Reddit path parser into the live server (modules, ParseQuery UI action, morph panel, JS tab/debounce, and tests), restoring a core product capability rather than only reshuffling code. A’s forum split into access/ingest/nav/new_thread/room_members is a real maintainability win but mostly relocates existing markup/helpers (plus an unrelated sample-fixture script), so it adds less lasting product value than B’s functional revival.