c_b7cc673004778efc1c

Side A adds a substantial, reusable offline module (compile/scan logic in server/src/offline.rs) plus a new workspace CLI tool with documentation, enabling real dev workflows for validating DSL files and JSONL logs, with its own tests. Side B adds a single valuable but narrow test validating rank centrality convergence, which is useful for confidence but contributes far less lasting infrastructure or capability to the project.

A adds lasting offline infrastructure (server offline module, sorterc binary, docs, and tests) so .sorter compile and events.jsonl lint reuse real validator/reducer logic without a server. B only adds one ranking property test; useful as a correctness demo, but far narrower lasting impact than the reusable tooling.

Side A adds a new workspace tool (`sorterc`) plus a reusable `server::offline` module that compiles `.sorter` files, replays reducer state, scans `events.jsonl` for corrupt or unreplayable ingests, exposes a CLI, and includes documentation and tests. Side B adds a single regression test validating the ranking algorithm on a random spanning-tree case, which improves confidence but does not expand project functionality or architecture like the offline tooling does.

Side B fixes a real reentrant-RwLock deadlock in RoomCreate/RoomGrant RPC handling, corrects a username normalization bug in tests (@user vs stored form), and adds HTTP timeouts to prevent test hangs plus a new integration test—concrete bugfixes with lasting operational impact despite the terse commit message. Side A merely adds one additional test for already-existing ranking logic, which is useful but far narrower in scope and risk mitigated.

B fixes real tokio RwLock deadlocks by scoping principal/capability reads so guards drop before nested lock acquires in RoomCreate/RoomGrant, plus hardens the test harness against pipe-buffer deadlocks and hangs. A only adds an illustrative ranking unit test; useful, but not a production bugfix or design change.

Side B fixes a substantive concurrency bug by shortening the lifetime of Tokio RwLock read guards before later read/write operations, preventing deadlocks in RPC handlers, and adds an integration test covering room creation. It also improves test infrastructure with process/logging and HTTP timeout changes and updates authentication expectations, whereas Side A only adds a randomized test validating existing ranking behavior without changing production functionality.

Side B adds a concrete, well-reasoned test verifying that the rank-centrality algorithm recovers the true order from a random spanning tree of votes, directly strengthening confidence in core ranking logic. Side A dumps several new files (Dockerfile, fly.toml, deps.edn, event_log.rs, views.rs) that aren't wired into any existing module (no mod declarations or call sites shown), making it look like speculative scaffolding of uncertain integration value rather than a tested, functional addition.

A adds lasting production pieces: EventLog (JSONL append/load with corrupt-line handling), ViewStore (persisted counts with coalesced flushes), plus Dockerfile and fly.toml for deployable runtime. B only adds one ranking property test; valuable as a correctness check, but narrower and non-runtime compared with A’s core modules and ops surface.

Side A adds substantial new project infrastructure and functionality: a persistent JSONL event log with append/load logic and error handling, a view-count store with asynchronous disk flushing, plus Docker and Fly.io deployment configuration. Side B adds a single regression/property-style test that exercises the ranking algorithm on a random spanning tree with perfect ratios, which improves verification but does not change runtime behavior or architecture.

Side A fixes an actual UI/logic bug in sibling navigation grouping (each unranked sibling now gets its own group instead of being lumped together), with an updated doc comment and a targeted regression test verifying the new behavior. Side B only adds a randomized statistical test for existing rank centrality logic without changing any production code, providing validation but no functional improvement or bugfix.

A changes production behavior: unranked siblings become separate nav groups (one link each) instead of one shared group, with an updated doc comment and a focused regression test. B only adds a demo property test for existing rank-centrality behavior and touches no production code, so it adds less lasting product value.

Side A changes production behavior by grouping each unranked sibling into its own navigation group instead of combining all unranked siblings, aligning the implementation with the documented design, and adds a regression test verifying the new grouping. Side B adds only a randomized test for the ranking algorithm without changing functionality, so while it improves validation, it contributes less lasting project behavior.

Side B adds a focused, meaningful test verifying the rank-centrality algorithm correctly recovers order from a random spanning-tree of votes, adding real regression coverage for core ranking logic. Side A's commit, while improving dev tooling (persistent fixture data, cargo-watch), also silently removes UI elements from the room page unrelated to its stated purpose, mixing dev-script improvements with an unexplained regression.

B adds a focused regression test of core rank-centrality behavior (26-item spanning tree with perfect strength ratios recovers true order), which permanently guards product-critical ranking logic. A improves local DX (cargo-watch fixture, persistent fixture-data/, preferred port) and trims redundant room-page markup, but that is peripheral tooling rather than lasting correctness of the main system.

Side A substantially improves the developer workflow by replacing a one-shot release build with a persistent cargo-watch server, reusing seeded fixture data across runs, preferring a stable port with fallback, and rebasing saved URLs so the fixture remains usable after restarts. Side B adds a useful regression test for rank centrality on a random spanning-tree input, but it only increases test coverage and does not change the project's runtime behavior or architecture.

Side A is a focused, meaningful test that validates rank-centrality correctness on a random spanning tree, adding real regression coverage with minimal footprint. Side B is a disorganized 'init seed' dump containing shell prompts and terminal artifacts pasted into .rs files, notes/tdsl scratch files, and bundled source files that appear to be copy-pasted snapshots rather than a coherent, reviewable commit.

A adds a clean, targeted unit test that locks in core rank-centrality behavior (perfect-ratio spanning tree recovers alphabetical order), directly protecting a lasting invariant. B is a noisy “init seed” dump whose volume is mostly exploratory notes, scripts, and corrupted files (shell prompts and cat output embedded in forms.rs/ranking.rs), so far less durable substance despite the line count.

Side A adds a focused regression test that exercises rank centrality on a minimal random spanning tree with perfect vote ratios, verifying the algorithm recovers the expected alphabetic ordering and protecting a core ranking property. Side B is a large seed commit mixing many unrelated files, design notes, and even terminal transcript text embedded in Rust source (e.g. `forms.rs` and `ranking.rs`), making it noisy and of questionable build quality despite its size.

Side A refactors cli_panel into a single grouped, hover-to-copy UI with an explicit safety assertion against JS-breaking characters, fixing a real bug (unescaped single quotes breaking onclick) and improving UX/CSS across themes and call sites. Side B adds a single randomized unit test for existing ranking logic, which is useful but narrower in scope and doesn't change or fix any production behavior.

A redesigns production cli_panel to accept multiple cmds in one bordered panel, makes each row click-to-copy (dropping a separate copy control), and adds JS single-quote safety asserts, with call-site and theme CSS updates across forum/garden/search. B only adds one property test for rank centrality on a 25-edge spanning tree and does not change ranking behavior or other production code.

Side A redesigns the reusable `cli_panel` to support multiple commands in a single panel, simplifies several call sites, adds click-to-copy rows, and introduces explicit assertions preventing unsafe characters from being embedded into single-quoted JavaScript, improving both functionality and robustness. Side B adds a useful regression test for the ranking algorithm, but it does not change production behavior or fix a bug by itself.

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.

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.

B removes genuinely dead/redundant code and correctly updates the test to reflect actual reducer behavior, providing a small but real simplification and behavioral clarification. A merely adds a randomized (non-seeded) test that risks flakiness and mainly demonstrates existing functionality rather than fixing or clarifying behavior.

A adds a non-trivial property test that the core rank-centrality path recovers true order from a minimal spanning-tree of perfect-ratio votes, locking in lasting algorithmic behavior. B only deletes a dead zero-ratio early-return and retunes an existing test to the already-enforced contract, which is useful hygiene but much smaller enduring impact.

A deletes 1808-line legacy/parser.rs and adds a fully integrated parser (server/src/parser.rs + parser_action.rs + parser_render.rs + ui_html.rs changes + JS event wiring + integration tests) that wires the Reddit graph into live /ui morphs and primary_completion handling. B only appends one 40-line test in ranking.rs exercising an already-working spanning-tree scenario. The refactor+integration in A produces durable structure and behavior; B is incremental verification.