c_9608dc0d38ab4c1d51

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 A fixes an actual deadlock bug (holding a RwLock read guard across nested lock acquisitions) with a real code change, adds a regression test, and improves test infrastructure (timeouts, log-file redirection to avoid pipe deadlocks). Side B is purely a planning/design document (PLAN.md) with no code changes, providing aspirational value but no immediate functional or bugfix contribution.

Commit A fixes a real production deadlock (non-reentrant tokio RwLock guards held across nested awaits in RoomCreate/RoomGrant) plus related test harness deadlocks from inherited pipes, and lands a working integration test; commit B only adds a PLAN.md design doc with no executable change.

Side A fixes a substantive concurrency bug by shortening the lifetime of `tokio::sync::RwLock` read guards before nested `read().await`/`write().await`, preventing deadlocks in `RoomCreate` and `RoomGrant`. It also adds an integration test for private room creation and improves test reliability with timeout/logging adjustments, whereas Side B only adds a detailed architectural planning document without changing project behavior.

Side B fixes a real deadlock bug (RwLock guard held across nested read/write locks in RoomCreate/RoomGrant), adds a regression test for room creation, and hardens test infra against pipe-buffer deadlocks and hanging HTTP calls with timeouts — concrete, lasting correctness fixes. Side A is a dev-experience improvement (cargo-watch fixture persistence) that's useful but lower-stakes, and it also silently removes room header UI (title/room-id/garden link) without explanation, which is a behavioral regression rather than pure improvement.

B fixes a real tokio RwLock deadlock in RoomCreate/RoomGrant by dropping read guards before nested lock acquires, plus an integration test and test harness fixes (log-pipe deadlock, HTTP timeouts, auth username assertions). A only improves local DX (cargo-watch fixture, persistent fixture-data, port preference) and a small UI trim—useful but not production-correctness.

Side B fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before nested `read().await`/`write().await` calls in RPC handlers, preventing deadlocks, and adds an integration test covering private room creation. Side A mainly improves the local development fixture workflow (persistent fixture data, `cargo watch`, preferred port selection) and makes minor UI/test-support changes, which are useful but less fundamental to the project's long-term correctness.

Side B fixes a real tokio RwLock re-entrancy deadlock bug in the RPC handler, adds an integration test covering RoomCreate, and hardens babashka test infra (HTTP timeouts, log redirection to avoid pipe deadlocks) plus corrects test assertions to match actual stored username format. Side A is purely a planning document and a thin wrapper struct (RouteContext) that just delegates to existing ThreadNav methods without migrating any call sites, providing no functional change or bugfix.

B fixes a real Tokio RwLock deadlock by dropping read guards before nested lock acquires in RoomCreate/RoomGrant, plus regression coverage and test harness hang/timeout fixes. A mostly adds a planning doc and a thin RouteContext newtype that still delegates to ThreadNav/CanonicalItemUrl, so it stages work rather than landing lasting behavior.

Side B fixes a real concurrency bug by shortening the lifetime of `tokio::sync::RwLock` read guards before later `read().await`/`write().await` calls in `handle_rpc_batch`, preventing self-deadlock during room creation and grants. It also adds an integration test covering room creation and improves test infrastructure with timeouts and optional log redirection, whereas Side A mainly adds a migration plan document and a thin `RouteContext` wrapper around `ThreadNav` without changing application behavior.

Side B fixes a real reentrant-RwLock deadlock in the RPC handler (holding a read guard across match arms that later need read/write again), plus fixes test hangs by adding HTTP timeouts and switching log redirection to avoid pipe-buffer deadlocks, all with clear rationale in comments. Side A adds a nice-to-have connectivity display feature with unit tests, but it's cosmetic CLI output rather than a correctness fix, so it carries less lasting engineering value than B's concurrency/reliability fixes.

B fixes a real tokio RwLock reentrancy deadlock by scoping read guards before nested awaits in RoomCreate/RoomGrant, and hardens tests (log-file piping, HTTP timeouts, auth username expectations) so the server stays usable. A only formats already-available ConnectivityStats for CLI display plus two unit tests—a useful UX nicety, but not a correctness or infrastructure fix of comparable lasting weight.

Side B fixes a substantive concurrency bug by ensuring Tokio RwLock read guards are dropped before nested read/write awaits in RPC handlers, explicitly preventing deadlocks during room creation and grant operations. It also adds an integration test for room creation and improves test reliability with timeout/logging changes, whereas Side A mainly exposes existing connectivity statistics in CLI output with formatting and unit tests but does not change core behavior.

Side B fixes a real deadlock bug (nested RwLock read guards held across await points causing self-deadlock in RoomCreate/RoomGrant), adds a regression test for room creation, and hardens test infra with HTTP timeouts and safer log redirection to avoid pipe-buffer deadlocks. Side A is a UI refactor (grouping cli_panel rows, hover-to-copy) with real but lower-stakes value, and includes a safety assert but no functional bugfix of comparable impact.

B fixes a real tokio RwLock reentrancy deadlock in RoomCreate/RoomGrant by dropping the read guard before nested lock acquires, and backs it with an integration test plus test-harness changes (log redirection, HTTP timeouts) that prevent related hangs. A only refactors the CLI hint UI into a multi-command hover-to-copy panel with CSS and assert guards—useful polish, but not a lasting correctness fix like B.

Side B fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls in RPC handlers, preventing deadlocks, and adds an integration test covering private room creation. Side A mainly refactors the HTML CLI panel into a grouped, click-to-copy UI with CSS updates and adds assertions that CLI strings are safe for single-quoted JavaScript, which improves usability but has less lasting impact than the correctness fix.

Side B fixes a real production bug — a tokio RwLock deadlock in room grant/create RPC handling caused by holding a read guard across nested read/write calls — and adds a regression test plus timeouts to prevent hangs, delivering concrete correctness value. Side A is a pure test-code refactor (deduplicating shared helpers into test.common/test.oauth) that improves maintainability but touches no production logic and provides no new functional guarantees.

B fixes a real production deadlock in `rpc.rs` by scoping `RwLock` read guards so they drop before nested `read`/`write` on RoomCreate/RoomGrant, plus a regression test and server log-pipe deadlock avoidance in `start-server`. A only deduplicates Babashka test helpers (assert/ANSI, cargo build, mock Google, registration flow) with no product correctness impact.

Side B fixes a substantive concurrency bug in the RPC handler by ensuring Tokio RwLock read guards are dropped before nested read/write operations, preventing deadlocks during RoomCreate and RoomGrant. It also adds a regression test for private room creation and improves test reliability with HTTP timeouts and optional server log redirection, whereas Side A is primarily a refactoring that centralizes shared test helpers and reduces duplication without materially changing project behavior.

Side B fixes a real concurrency bug where a non-reentrant RwLock read guard was held across nested locking calls, which could deadlock the RPC handler, and adds a regression test plus test-harness reliability fixes (timeouts, avoiding pipe-buffer deadlocks) that improve project robustness. Side A also fixes a legitimate bug (duplicate `#entity-section` ids breaking multi-item morph targets) and reduces duplication in vote card rendering, but it's more localized UI plumbing versus B's server-correctness and test-infra fix.

B fixes a real Tokio RwLock deadlock by scoping reduced-state read guards in RoomCreate/RoomGrant so locks drop before nested awaits, and backs it with a room-create integration test plus test harness fixes (log-file pipes, HTTP timeouts). A mainly refactors entity morph targets from fixed #entity-section IDs to data-entity-section selectors and reuses entity_section in the vote UI—valuable DRY/cleanup, but not a correctness fix of B’s weight.

Side B fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls, preventing self-deadlocks in `RoomCreate` and `RoomGrant`, and adds an integration test covering room creation. Side A is a useful UI refactor that replaces a hard-coded `#entity-section` target with per-item selectors and reuses `entity_section` rendering in the vote view, but it is primarily structural and less critical than eliminating a deadlock in core RPC handling.

Side B fixes a real concurrency bug: nested RwLock reads inside a match previously held a guard across further read/write calls, which could deadlock tokio's non-reentrant lock — a lasting correctness fix backed by a new integration test, plus corrects wrong test assertions (@user vs stored username) and hardens test harness timeouts to prevent flaky hangs. Side A is mostly UI polish (vote counts, HUD unpin button, CSS) which is useful but cosmetic and lower-stakes compared to a deadlock fix.

B fixes a real tokio RwLock deadlock in RoomCreate/RoomGrant by dropping the principal-verify guard before nested read/write awaits, plus an integration test and test harness hardening (server log redirection to avoid pipe deadlocks, HTTP timeouts). A is useful garden UX (vote-count badges, HUD unpin form, CSS, browser coverage) but is polish on an existing flow, not a core correctness fix.

Side B fixes a substantive concurrency bug by ensuring `RwLock` read guards are dropped before later `read().await`/`write().await` calls in RPC handlers, preventing potential deadlocks during room creation and grants. It also adds an integration test covering private room creation and improves test robustness with logging and HTTP timeouts, whereas Side A mainly enhances the garden UI (vote counts, HUD unpin button, styling) with supporting tests rather than addressing a core correctness issue.

Commit B fixes a real deadlock bug (holding a RwLock guard across nested read/write calls in RPC handlers) plus adds timeouts to prevent test hangs and corrects test assertions to match actual stored username format, all substantive correctness fixes with a new integration test. Commit A is a small, clean, well-tested feature addition (skip pinned posts), but is narrower in scope and impact compared to B's deadlock fix which addresses a potentially serious production issue.

B fixes a real tokio RwLock deadlock by scoping read guards so they drop before nested read/write awaits in RoomCreate/RoomGrant, plus lasting test harness fixes (log-file piping to avoid pipe-buffer deadlock, HTTP timeouts) and an integration test. A is a correct, tested product tweak (skip stickied/pinned Reddit children) but is narrower and lower-impact than the concurrency and reliability work.

Side B fixes a concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls, preventing self-deadlocks in RPC handlers for room creation and grants. It also adds an integration test for private room creation and related test infrastructure improvements, whereas Side A is a narrower import behavior change that skips stickied/pinned Reddit posts with a focused unit test.

Side B fixes a genuine reentrant RwLock deadlock in RoomCreate/RoomGrant RPC handlers (dropping guards before nested read().await calls), which is a real correctness bug that could hang the server in production, plus hardens test infra (HTTP timeouts, log-file redirection to avoid pipe deadlocks) and corrects wrong test assertions. Side A is a solid, well-tested feature addition (garden ranking copy button) but is pure new surface area without fixing any existing defect, making B's contribution more consequential despite its terse commit message.

B fixes real production deadlocks by dropping tokio RwLock guards before nested read/write in RoomCreate and RoomGrant, and hardens tests against pipe-buffer hangs; that is lasting correctness. A is a polished UX feature (CopyGardenRank + markdown formatting and UI wiring) with good tests, but it is additive convenience rather than a foundational fix.

Side B fixes a substantive concurrency issue by ensuring `RwLock` read guards are dropped before nested lock acquisition in `RoomCreate` and `RoomGrant`, preventing potential deadlocks, and adds a regression test for private room creation. Side A implements a useful user-facing feature (copying garden rankings as markdown with new UI actions, rendering, and tests), but it primarily adds functionality rather than resolving a core correctness problem.

Side A fixes a real deadlock bug (nested RwLock read guard held across match, causing potential deadlock) with a concrete, correct restructuring plus a regression test, and hardens test infra with HTTP timeouts and safer process logging to avoid hangs. Side B is a larger cleanup that removes legacy projection code for clarity/consistency, which is valuable but is more refactor/simplification than a bugfix, and mostly trades one code path for another rather than fixing user-facing correctness issues.

A fixes a real tokio RwLock deadlock by scoping read guards so they drop before nested lock acquires in RoomCreate/RoomGrant, and backs that with a room-create RPC test plus harness fixes (log-file redirection to avoid pipe-buffer deadlocks, HTTP timeouts). B is worthwhile cleanup—dropping legacy GitDiscovery projection and forcing Evidence-only pages—but it is largely deletion of transitional UI/API paths and test rewrites after an intentional ledger wipe, so it adds less critical lasting correctness than the concurrency and reliability fixes.

Side A fixes a concrete concurrency bug by ensuring Tokio RwLock read guards are dropped before nested read/write awaits, preventing deadlocks in RPC handlers for room creation and grants, and adds an integration test covering room creation. The remaining changes improve test reliability and align expectations with stored usernames. Side B is primarily a schema/UI cleanup that removes legacy GitDiscovery projection paths and requires evidence-only records, updating tests accordingly; while valuable for maintainability, it mostly deletes compatibility code rather than fixing a core runtime issue.

Side A implements a full, working feature: a new CLI `room create` subcommand wired to the server RPC, removes the unused/never-differentiated ThreadVisibility concept (simplifying RoomCreated events and the reducer's `rooms` map from HashMap to HashSet), and updates docs/tests consistently across cli, server, types, and test suites. Side B is mostly internal refactoring (splitting RwLock read guards to avoid deadlock, timeout additions, username normalization test fixes) which is useful defensive cleanup but adds no new user-facing capability and is narrower in scope/impact.

A lands the end-to-end room-create path (CLI `Room`/`room create`, RPC/types simplification, guide updates) and a lasting domain cleanup: drop `ThreadVisibility`/`RoomState`, store rooms as a `HashSet`, and treat private rooms as the only created scope. B’s scoped RwLock fix and test/harness hardening are real correctness wins, but narrower than A’s feature plus model simplification.

Side A delivers a substantive feature by adding a `room create` CLI command end-to-end, wiring it through RPC, documenting its use, and simplifying the server model by removing the unused room visibility concept and replacing the room registry with a `HashSet` of room IDs. Side B mainly fixes lock-scoping around `RwLock` reads to avoid potential deadlocks, adds one integration test, and improves test harness timeouts/logging, which are valuable but narrower in long-term impact than the new user-facing capability and associated design cleanup in Side A.

Side B implements substantive product functionality: fixing a broken morph (preview card was never actually rendered before), adding a proper ratio-normalization/sort algorithm for edge history, a new fullscreen layout mode with theme CSS across three themes, and updated/expanded tests validating the sort logic. Side A is a smaller but real deadlock fix in rpc.rs plus test/infra tweaks (timeouts, log-file redirection, username string fixes), which is useful but narrower in scope and impact than B's feature-level correctness work.

A fixes real tokio RwLock deadlocks in RoomCreate/RoomGrant by dropping read guards before nested lock acquires, plus hardening the test harness against pipe-buffer hangs and adding a room-create integration test. B is mainly vote-compare UX polish (fullscreen chrome-less layout, history sort/display, CSS/docs) that improves one UI surface but does not address correctness or reliability at the same level.

Side A fixes a substantive concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before later `read().await`/`write().await` calls in `RoomCreate` and `RoomGrant`, preventing self-deadlocks from non-reentrant lock usage. It also adds an integration test for private room creation and improves test robustness, whereas Side B is primarily a feature/UI enhancement for the vote-compare page (fullscreen layout, preview morphing, sorting/display changes) with accompanying tests rather than a core correctness fix.

B fixes a real, subtle production bug (a tokio RwLock read-guard held across the match arm causing potential deadlock in RoomGrant/RoomCreate), adds a regression test, and hardens test infra (timeouts, log-file redirection to avoid pipe deadlocks) — genuine correctness and reliability value. A is a large but reasonable simplification (dropping an over-engineered graph parser for a simpler URL parser), which is good cleanup but mostly deletes unused complexity rather than fixing a live bug, and removes test tooling (Playwright browser test) without clear justification beyond simplification.

A removes an ~1.8k-line unreliable keystroke graph (parser, parser_action, race JS/CSS/Playwright) and replaces it with a small correct paste-and-go URL parser plus redirect, permanently cutting flaky surface area. B is a precise, high-value RwLock-scope deadlock fix in RoomCreate/RoomGrant with a regression test and test-harness hardening, but its lasting impact is narrower than A’s subsystem replacement.

Side B fixes a real concurrency bug by ensuring `tokio::sync::RwLock` read guards are dropped before nested lock acquisitions, preventing deadlocks in `RoomCreate` and `RoomGrant`, and adds an integration test covering room creation. Side A replaces the autocomplete/parser graph with a much simpler paste-and-go flow and removes substantial functionality, which may simplify maintenance but also discards capabilities rather than delivering a targeted correctness improvement.

Side A implements substantial, working functionality: cookie-based web session auth, a full web posting flow, and room-scoped thread views/navigation wired into real routes, which restores/expands actual product surface area. Side B fixes a genuine RwLock deadlock bug and adds useful test hardening (timeouts, log-file redirection), which is valuable but narrower in scope; A's changes deliver more lasting end-user-facing capability despite including an odd unrelated plan2.md file.

Side A delivers substantial lasting product value by implementing cookie-based web sessions, a full web POST ingest path, ThreadNav abstraction, room/private thread pages with ACL checks, compose forms, and complete routing—making rooms usable in the browser. Side B is a precise and necessary RwLock deadlock fix plus test harness hardening, but narrower in scope than the UI and auth surface A adds.

Side A adds substantial end-user functionality: browser session cookies, login/logout flows, web posting, room-aware thread pages, routing, permission-aware UI, and supporting APIs, effectively wiring a complete web forum interface back into the application. Side B is a valuable but narrowly scoped maintenance change that fixes potential `RwLock` deadlocks by shortening lock lifetimes and adds regression tests and timeout/logging improvements, but its lasting impact is much smaller than the new capabilities introduced in Side A.

Side A fixes a real, concrete bug: nested RwLock reads across match arms that would deadlock the RoomCreate/RoomGrant RPC paths (tokio::sync::RwLock is not reentrant), and backs it with a new integration test plus fixes to flaky/deadlock-prone test infra (log-file redirection, HTTP timeouts) and incorrect test assertions. Side B is a broad but mostly mechanical refactor (renaming from_storage_str->from_stored, threading CanonicalItemUrl/newtype Deref impls through many call sites) that improves type-safety but doesn't fix an active defect, making it closer to structural churn than a critical correctness fix.

A fixes real tokio RwLock deadlocks by scoping verify/cap/user-exists guards so nested read/write cannot hold a non-reentrant guard across the match, and backs that with a room-create integration test plus test harness fixes (log-file piping, HTTP timeouts) that stop false hangs. B is a solid type-safety refactor (Deref on URL newtypes, CanonicalItemUrl through resolve_item/pools/validate) that removes string wrap/clone noise but does not correct broken runtime behavior.

Side A fixes a concrete concurrency bug by shortening the lifetime of `state.reduced.read().await` guards before later `read()`/`write()` operations, explicitly preventing Tokio `RwLock` self-deadlocks in `RoomCreate` and `RoomGrant`, and adds an integration test covering private room creation. Side B is largely a type-safety refactor that replaces many `String` usages with `CanonicalItemUrl` and adds `Deref` implementations, improving API cleanliness but with less direct impact on runtime correctness than the deadlock fix.

Side B fixes a real correctness bug (RwLock guard held across a match arm, invitable to deadlock, in RoomCreate/RoomGrant handlers) plus flaky-test root causes (missing HTTP timeouts, pipe-buffer deadlock in test harness log capture), all concrete and lasting improvements to reliability. Side A is a large structural refactor that consolidates duplicate web_post.rs handlers into a single /ui dispatcher and unifies session resolution, which is a reasonable cleanup but mostly moves/renames existing logic without fixing any bug, and its size is largely churn (route removal, JSON templating changes) rather than a necessary fix.

B fixes real tokio RwLock deadlocks in RoomCreate/RoomGrant by dropping read guards before nested lock acquires, plus complementary test infra (log-file pipes, HTTP timeouts) that prevents related hangs—correctness that keeps RPC usable. A is a large but mostly consolidating refactor (delete web_post.rs, fold ingest/check/redact into POST /ui and form __rpc__), valuable design cleanup without the same defect-level impact.

Side A performs a substantial architectural consolidation by moving browser posting, checking, and redaction into a single POST /ui dispatch path, introducing a shared WebSession resolver to avoid repeated auth lookups, removing the separate web_post module, and updating HTML, routing, and integration tests to use the unified RPC-style interface. Side B fixes a real correctness issue by shortening RwLock read-guard lifetimes to avoid deadlocks in RoomCreate/RoomGrant and adds regression coverage, but its scope is limited to a specific locking bug whereas Side A delivers a broader, lasting simplification of the web API structure.