c_3403e5929da7a13eab

Side A merely deletes speculative planning/design documents (markdown files never implemented as code), contributing no functional change to the codebase. Side B makes an actual, tested bugfix to sibling navigation grouping logic in production Rust code, correcting behavior for unranked items and adding a regression test to verify it.

B changes real product behavior in garden sibling nav (each unranked sibling becomes its own group, matching ranked-component separation), updates the comment, and adds a focused regression test. A only deletes completed plan markdown (plan.md/plan2.md) with no code, design, or runtime impact beyond repo cleanup.

Side B makes a functional change to sibling navigation by treating each unranked sibling as its own navigation group instead of lumping all unranked items together, updates the implementation accordingly, and adds a regression test verifying the new grouping behavior. Side A only deletes planning documents (`plan.md` and `plan2.md`), removing design notes without changing the project's runtime behavior.

Side A makes a real code change with a behavioral fix (each unranked sibling gets its own nav group instead of being lumped together) plus a new test verifying the behavior, providing lasting functional value. Side B only appends a one-line note to a personal notes file, which is not functional code or documentation of lasting project value.

A changes real product behavior: unranked siblings become separate nav groups (with doc update and a regression test), lasting UI/structure value. B only appends one personal TODO line to notes.tdsl with no code, tests, or user-facing effect.

Side A changes application behavior by altering sibling navigation so each unranked sibling becomes its own navigation group instead of all unranked siblings being lumped together, updates the documentation to match, and adds a regression test verifying the new grouping. Side B only appends a brief project note ('new public thread form needs fewer words') to a notes file without affecting the code or behavior.

Side B is a real, tested bugfix/behavior change: it changes sibling-group rendering so each unranked item forms its own group, backed by a new unit test verifying the exact grouping. Side A is purely a planning document plus a thin, unused wrapper struct (RouteContext) that duplicates existing ThreadNav methods without migrating any call sites, so it adds speculative scaffolding rather than shipped functionality.

B ships a concrete sibling-nav behavior fix (each unranked item becomes its own group) plus a focused regression test, which is lasting product logic. A mostly adds a long plan.md and a thin RouteContext wrapper around ThreadNav with no call-site migration, so it is scaffolding/docs rather than finished design or a bugfix.

Side B makes a functional change to sibling navigation by placing each unranked sibling into its own navigation group instead of combining all unranked items into one group, and it adds a regression test verifying the new grouping behavior. Side A primarily introduces a planning document and a thin `RouteContext` wrapper around `ThreadNav` with re-exports, which is useful scaffolding but does not materially change project behavior.

Commit A removes a redundant UI action/toolbar and duplicated form logic, unifying the compose flow with SSR consistency and deleting dead code plus its test, yielding a net simplification with clear lasting value. Commit B changes sibling grouping behavior (each unranked item its own group) with a test update, which is a reasonable but narrower, more speculative UX tweak whose correctness/value is less clearly justified in the diff.

A removes an entire UI RPC (ExpandNewThreadForm), its handler, and the home-only toolbar, SSRing #new-thread-ui-slot like room pages so compose is one consistent path. B only changes unranked sibling bundling into per-item groups plus a test—useful but a narrower nav tweak versus A’s lasting simplification of the public compose flow.

Side A simplifies the UI architecture by removing the `ExpandNewThreadForm` action and its server-side dispatch logic, and instead server-renders the collapsed compose/login state directly into `#new-thread-ui-slot` on the home page, eliminating duplicated flows and obsolete parsing/tests. Side B improves sibling navigation by placing each unranked sibling into its own group and adds a regression test, but it is a narrower behavioral adjustment compared with A's broader reduction of redundant code paths.

Side A is a focused, tested bugfix improving sibling nav grouping logic within the actual codebase, with a new test validating the change. Side B adds orphaned files (Dockerfile, fly.toml, deps.edn, event_log.rs, views.rs) sitting at the repo root outside any crate structure, with no integration, no tests, and no indication they are wired into the build—suggesting stray/unintegrated scaffolding rather than lasting value.

A is a precise, tested behavior fix: unranked siblings become one group each (aligned with the doc comment) instead of a single bulk group, with a regression test locking the layout. B is a diffuse “seed” dump (Dockerfile/fly.toml plus root-level event_log/views and a Clojure deps.edn) without evidence of integration or lasting design—more volume, less durable product substance.

Side B adds substantial new infrastructure with a persistent JSONL event log (append/load, directory creation, error handling), a durable view-count store with background flushing, and deployment/build configuration via Dockerfile and Fly.io files. Side A makes a targeted behavioral fix by changing sibling navigation so each unranked sibling is its own group and adds a regression test, which is valuable but much narrower in long-term impact than the foundational runtime and deployment capabilities introduced in Side B.

Side A fixes a real inconsistency (mixed 0/1-indexing between UI, RPC, and history rows), enforces an invariant with an explicit expect, and adds integration test assertions verifying the corrected index values, giving lasting correctness value. Side B is a smaller UI grouping refinement (splitting unranked siblings into separate groups) with a single unit test, useful but narrower in scope and impact.

A fixes real indexing inconsistency (1-based/unwrap_or(0) → 0-based expect aligned with /t/tag/N), updating RPC, types, HTML links, and integration asserts so rank-history URLs are correct. B only regroups unranked siblings into singleton nav groups plus a unit test—a narrower UI presentation tweak with less cross-cutting impact.

Side A changes the rank-history thread index from a silent fallback (`unwrap_or(0)` after converting to 1-based) to an enforced invariant with `expect`, aligns the value with the project's 0-based `/t/tag/N` URLs, updates documentation, always renders the link, and adds integration tests verifying the behavior. Side B is a localized UI improvement that groups each unranked sibling separately and adds a corresponding unit test, but it affects presentation rather than correcting a broader API/data consistency issue.

Side B introduces a substantive architectural change (SSE-based fetch pipeline with oneshot result signaling, structured FetchJobResult states, new fetch module, extensive tracing, and JS SSE consumer) that fixes a real UX gap (async fetch feedback) and is validated by an updated integration test. Side A is a small, focused UI grouping fix with a good regression test, but it's much narrower in scope and impact compared to B's cross-cutting feature work despite B's Cargo.lock noise and unrelated docstring removals.

B turns fire-and-forget entity fetch into a real SSE pipeline (oneshot FetchJobResult through the Reddit worker, dedicated fetch module, client SSE morph/error handling, and updated integration coverage)—lasting architecture and UX. A only splits each unranked sibling into its own nav group plus one unit test, a correct but narrow UI tweak.

Side B introduces a substantial architectural improvement by moving entity fetching to an SSE-based workflow, adding a dedicated fetch module, asynchronous streaming, completion/error signaling via oneshot channels, client-side SSE handling, and integration tests for the new behavior. Side A is a focused UI correctness fix that changes unranked siblings from a single group into one group per item and adds a regression test, but its scope and long-term impact are much smaller than the new fetch infrastructure.

Side A is a sprawling 'init seed' dump that pastes raw terminal output (including shell prompts like 'tommy@Tommys-Laptop:~/... ⇒ cat ...') into oddly-placed root-level files (forms.rs, parser.rs, vote.rs, etc.), which reads as an unstructured snapshot rather than a real, integrated contribution. Side B is a small, precise bugfix (splitting unranked siblings into individual nav groups) accompanied by a targeted regression test, representing clear, verifiable, lasting value despite its size.

A seeds core product surface: a tested Reddit path graph parser, event reducer/ranking (including issue #146 star-topology fix), form JSON hole-fill + HtmlUiAction, and the vote-compare page—durable architecture despite some .tdsl notes and terminal-paste noise in forms/ranking. B only tweaks sibling nav so each unranked isolate is its own group plus one regression test (#130), a correct but narrow UI fix on existing garden code.

Side B makes a focused behavioral improvement: it changes sibling navigation so each unranked sibling becomes its own navigation group instead of lumping all unranked items together, and adds a regression test verifying the new grouping. Side A is an enormous 'init seed' that mixes many unrelated additions and even includes accidental terminal transcript text in source files (e.g. `forms.rs` and `ranking.rs`), making it noisy and difficult to judge as a coherent, lasting contribution.

Side B fixes a real logic bug (unranked siblings were incorrectly lumped into one group instead of separated), and backs it with a new regression test verifying the corrected grouping behavior. Side A is a UI/CSS refactor (merging multiple copy buttons into one panel) with a defensive assert, which is useful but more cosmetic and lower-stakes than correcting sibling-grouping semantics.

A redesigns cli_panel into a multi-command grouped control with click-to-copy rows, JS single-quote safety asserts, call-site updates, and theme CSS—concrete lasting UX and hardening used across pages. B only splits unranked siblings into one-group-each (plus a unit test), a narrow nav semantic tweak with less project-wide impact.

Side A refactors the shared `cli_panel` into a reusable multi-command component, updates all call sites, adds click-to-copy rows, and introduces assertions preventing unsafe characters from being embedded in single-quoted JavaScript, improving both functionality and robustness. Side B makes a focused behavioral fix by splitting each unranked sibling into its own navigation group and adds a regression test, but its impact is narrower than the cross-cutting UI/API improvement in Side A.

Side B removes genuinely dead/redundant code with a clear rationale (guard is now unreachable given upstream validation) and updates the corresponding test to reflect the correct invariant, tightening the reducer's logic. Side A refactors sibling grouping in a UI-only helper (splitting unranked items into separate groups) with a matching test, which is a smaller, more cosmetic behavioral tweak with less systemic value than removing incorrect/dead logic in core reducer code.

A changes real sibling-nav behavior (each unranked item becomes its own group) with an updated contract and a dedicated regression test, which shapes lasting UI structure. B only deletes a redundant zero-ratio early-return already enforced upstream and retunes an existing test—useful hygiene, but no meaningful product or design effect.

Side A makes a functional change to sibling navigation by placing each unranked sibling into its own navigation group instead of one combined group, and adds a targeted regression test verifying the new grouping behavior. Side B mainly removes a redundant zero-ratio early return and updates the test to reflect that items are still registered while zero-weight edges are skipped, which is a worthwhile cleanup but has a narrower long-term impact.

Side A adds a genuinely new, useful CLI feature (connectivity/density stats display) with well-defined formatting logic and unit tests verifying exact output strings. Side B makes a small behavioral tweak (splitting unranked siblings into individual groups) with a supporting test, but it's a narrower, more incremental UI refinement with less lasting architectural value.

B fixes lasting sibling-nav structure by putting each unranked isolate in its own group (with matching docs and a reducer-backed test), aligning HTML garden navigation with the intended component/isolate model. A only formats and prints connectivity stats already on PairResponse in the CLI, a useful but shallower presentational add-on.

Side B changes the sibling navigation logic so each unranked sibling becomes its own navigation group instead of lumping all unranked items together, matching the documented behavior and adding a regression test that verifies the grouping. Side A mainly adds CLI presentation of already-existing connectivity statistics with a formatter and tests, improving visibility but not changing the underlying project behavior.

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.

Commit A fixes actual product logic (sibling nav grouping so each unranked sibling is its own group) with a targeted test verifying the behavior, directly affecting user-facing rendering correctness. Commit B is a dev-tooling improvement to the fixture script (persistent data dir, cargo-watch) plus an unrelated removal of room header markup in forum.rs that looks like accidental regression/noise, making it less clearly a net positive for lasting product value.

A fixes sibling nav grouping so each unranked isolate is its own group (with an updated doc comment and a focused regression test), which is lasting product behavior. B mainly improves local DX (cargo-watch, persistent fixture-data, preferred port) plus a small forum markup trim—useful but not core domain logic.

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 targeted regression test to lock in that behavior. Side B substantially improves the local development fixture workflow with persistent data, cargo-watch integration, preferred port selection, and summary reuse, but those changes primarily affect developer iteration rather than core product behavior.

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.

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 A meaningfully reduces duplication across four test files by extracting shared HTTP/mock-OAuth/assertion helpers into common.bb and oauth.bb, improving maintainability without changing behavior. Side B is a small, focused bugfix to sibling grouping logic with a new test, valuable but narrower in scope and impact compared to A's broader cross-file consolidation.

B changes real product behavior for sibling nav (each unranked item becomes its own group, matching component separation) and locks it in with a focused unit test, whereas A only deduplicates test helpers (assert/ANSI, cargo build, server env, mock OAuth) across bb suites without altering shipped design.

Side B changes application behavior by altering sibling navigation so each unranked sibling is rendered as its own navigation group instead of combining all unranked items into one group, and adds a focused regression test verifying the new grouping. Side A is primarily a refactor that consolidates duplicated test helpers into shared utilities and updates call sites, improving maintainability but leaving project functionality essentially unchanged.

Side A fixes real application behavior (correct sibling-grouping logic for unranked items) and adds a targeted regression test validating the new grouping semantics. Side B is a useful but narrow CI/test-config simplification (collapsing two enumerated kaocha suites into one glob-based suite) with no logic or test coverage changes, and even introduces a stray indentation inconsistency in the edn file.

A fixes real sibling-nav behavior (each unranked item becomes its own group) and locks it in with a focused regression test; that is lasting product/UI correctness. B only simplifies tests.edn from hand-listed suites to one ns-pattern—helpful DX, but config hygiene with less direct lasting impact than A’s behavior change.

Side A changes application behavior by treating each unranked sibling as its own navigation group instead of aggregating all unranked items together, matching the documented grouping semantics, and it adds a regression test covering the new behavior. Side B improves test configuration by auto-discovering all test namespaces, reducing maintenance overhead, but it does not change the project's runtime behavior.

Side A fixes a real correctness bug (duplicate `#entity-section`/`#entity-panel` IDs breaking morph targeting when multiple entity cards appear on the same page, e.g. vote compare) by switching to a per-item data-attribute selector, and it deduplicates significant logic by making vote_compare_item_card reuse entity_section instead of a parallel hand-rolled renderer. Side B is a smaller, well-tested UI tweak that changes sibling grouping semantics but has narrower impact and no bug being fixed.

A replaces single global #entity-section/#entity-panel IDs with per-item data-entity-section selectors and reuses entity_section in the vote compare UI, deleting duplicated markup/CSS—a lasting morph/SSE design fix. B only splits unranked siblings into singleton nav groups plus a unit test, a narrower UX tweak under #130.

Side A fixes a structural UI issue by replacing the hard-coded `#entity-section` target with per-item `data-entity-section` selectors, adds a reusable selector helper, and reuses the same `entity_section` component in the voting UI, reducing duplication and enabling correct morph/SSE updates for multiple entities. Side B changes sibling navigation so each unranked sibling becomes its own group and adds a focused test, but its impact is limited to one navigation behavior compared with A's broader architectural improvement and component reuse.

Side B implements a genuine behavioral fix (splitting unranked siblings into individual groups rather than one lumped group), updates the doc comment to match, and adds a new test verifying the corrected grouping logic. Side A is a minimal one-line bugfix (defining a missing env var) with no test coverage, addressing a narrower and less substantive issue.

B changes real sibling-nav behavior (each unranked item becomes its own group) and adds a focused regression test, which is lasting product logic. A only introduces a missing GITHUB_API_BASE_URL default—a correct but tiny config fix with no broader design or test depth.

Side B changes the sibling navigation logic so each unranked sibling is placed into its own navigation group instead of combining all unranked items into a single group, updates the documentation to match the behavior, and adds a regression test verifying the new grouping. Side A is a targeted fix that defines `GITHUB_API_BASE_URL` with a default value to prevent a `NameError`, but it is a much narrower configuration bugfix.

Side A performs a substantive architectural refactor of URL canonicalization, replacing an ad-hoc per-domain function engine with a more general DFA/graph-based approach, while preserving/adapting existing tests to validate correctness. Side B is a small, focused UI bugfix (splitting unranked siblings into separate groups) with a single new test, which is real but much smaller in scope and lasting impact.

A replaces the ad-hoc ParsedUrl combinator stack (engine.rs + host-specific normalize_* paths) with a graph/DFA-based canonicalization API, which is a lasting redesign of core ItemId URL identity. B only changes sibling nav grouping so each unranked item is its own group, plus one regression test—useful but localized UI behavior versus foundational URL rules.

Side A replaces the previous ad hoc URL normalization pipeline with a new graph-based canonicalization API (`graph`/`parse`), rewires `canonicalize_raw`, breadcrumbs, and parent resolution to use it, and updates the module structure and documentation to reflect the new semantic model. Side B is a focused UI behavior fix that changes sibling navigation so each unranked sibling becomes its own group and adds a regression test, but its impact is limited compared with the architectural replacement in the URL handling code.