c_57453fc5c6c0cd2504

Commit A fixes a real production-breaking bug (public Reddit API blocking cloud IPs) with a correct, well-tested retry/refresh design for OAuth tokens, adding lasting robustness to a critical integration. Commit B adds a nice-to-have UI feature (copy-to-clipboard for garden rankings) which is useful but purely additive and non-critical, with more surface area but less foundational impact than fixing a broken core fetch path.

A fixes a production-breaking Reddit fetch path (no public www fallback from cloud IPs, OAuth required when creds exist, 401/403 refresh/retry, clearer AuthRejected handling) plus a deploy pin for SORTER2_BASE_URL—core reliability. B is a polished UX add-on (CopyGardenRank markdown clipboard, wire-up, tests) that reuses existing patterns but does not fix foundational breakage.

Side A fixes a production reliability issue by requiring OAuth when credentials exist, preventing fallback to blocked public Reddit endpoints, adding token refresh/retry on 401/403, improving error propagation, and covering the behavior with a test. Side B adds a useful UI feature for copying garden rankings as markdown with routing, rendering, and tests, but it is an incremental convenience feature rather than a foundational correctness and availability improvement.

Side A implements a complete, tested feature (garden ranking markdown copy button) with new module, RPC action, server logic, unit tests, integration test, and browser test coverage, plus docs. Side B is a trivial cosmetic tweak (breadcrumb label, CSS color/spacing changes) with no functional value and minimal lasting significance.

A adds a full CopyGardenRank feature (new module, RPC/UI wiring, markdown formatting, and unit/integration/browser tests) that delivers durable user-facing capability. B only renames a breadcrumb label, drops a panel heading, and tweaks two CSS rules—pure presentation churn with no functional depth.

Side A adds a complete new capability: a `CopyGardenRank` UI action with server-side handling, markdown generation for rankings, clipboard JavaScript integration, UI buttons, permission checks, and both integration and browser tests. Side B is limited to presentation changes (breadcrumb label, removing a heading, and CSS tweaks), which are cosmetic and have much less lasting impact on project 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.

Side B implements a complete, self-contained user-facing feature (garden ranking markdown copy) spanning a new module, RPC action, route wiring, unit tests, integration test, and a browser test, showing lasting design value. Side A is a small, focused bugfix (skip pinned posts) with a good targeted test, valuable but much narrower in scope and impact than B's feature addition.

B ships a full product path (new HtmlUiAction, garden copy module, ranking→markdown, UI affordances, integration + browser coverage) that users keep relying on, whereas A is a tight but narrow import filter plus one unit test. A’s stickied/pinned skip is correct and durable data hygiene, but its blast radius and ongoing utility are far smaller than B’s copy-rank feature.

Side B adds a complete end-user capability: a new `CopyGardenRank` UI action, server handler, markdown formatting logic, copy button integration across garden views, and accompanying unit, integration, and browser tests. Side A is a worthwhile, targeted bug fix that skips stickied/pinned Reddit posts during import with a helper function and regression test, but its scope and long-term impact are narrower than the new reusable clipboard feature implemented in Side B.

Side A completes an actually missing capability (CLI `room create` calling RPC) end-to-end across CLI, RPC, reducer, and docs, and simultaneously simplifies the room model by removing the unused ThreadVisibility distinction (rooms→HashSet), reducing complexity and bug surface. Side B adds a well-tested but narrower UX convenience (clipboard copy of garden rankings) that, while polished with unit/integration/browser tests, is additive feature surface rather than closing a functional gap or simplifying existing design.

A lands the real room-create product path (CLI `room create` → RPC) and a lasting domain simplification: drop `ThreadVisibility`/`RoomState`, make `rooms` a `HashSet`, and treat public as the shared site only. B is a solid but peripheral QoL feature—clipboard markdown for garden rankings via a new `CopyGardenRank` UI action—useful polish that reuses existing copy patterns rather than core capability.

Side A adds a substantive new capability by introducing a first-class `room create` CLI command, wiring it through RPC, enforcing bearer authentication, updating documentation, and simplifying the underlying room model by removing the unused visibility concept (`ThreadVisibility`, room state, and RPC parameter) in favor of a simpler room registry. Side B delivers a polished UI feature—a garden ranking copy button with markdown generation, POST `/ui` handling, and browser/tests—but it is primarily a convenience feature rather than a foundational project capability.

B delivers a complete, self-contained feature (garden ranking markdown copy via POST /ui + JsBuilder eval) with new module, unit tests, integration test, browser test, and documentation updates, providing durable user-facing value. A is a well-scoped correctness fix to the rank-row color gradient (min-max normalization vs list position) with solid tests, but it's a narrower visual polish change affecting less overall functionality than B's new capability.

B adds a full end-to-end capability (CopyGardenRank action, markdown formatter, UI buttons on garden headings, plus unit/integration/browser coverage and agents.md), which is reusable product value beyond styling. A is a correct, focused fix—min–max score gradients instead of ordinal position—with tight helper/tests, but it only refines existing rank-row colors rather than expanding what users can do with rankings.

Side B adds a substantial new end-to-end capability: a CopyGardenRank UI action, server handler, markdown formatter, clipboard JavaScript response, UI buttons across garden views, and integration/browser tests covering the feature. Side A improves row coloring by switching from list-position gradients to per-group score normalization with good helper extraction and tests, but it is a focused presentation enhancement rather than a broad new user-facing capability.

Side B introduces a complete, reusable feature (garden ranking markdown copy) with a new module, unit tests for markdown formatting, a full integration test asserting JS/clipboard behavior, and doc updates in agents.md, wiring it cleanly through the existing HtmlUiAction/JsBuilder pattern. Side A is a solid but narrower UX fix (making pin icons clickable) touching CSS/markup and one browser test, with less new reusable functionality and no unit/integration test coverage beyond the browser flow.

B adds a full feature path (new CopyGardenRank action, garden/copy.rs markdown rebuild + clipboard JsBuilder flow, UI hooks on ranking headings, unit/integration/browser coverage and agents.md notes), which is lasting product surface. A only turns an existing static 📌 into an unpin form reuse of set_garden_pin plus CSS/test tweaks—useful UX polish, but much narrower than B’s end-to-end capability.

Side A fixes a concrete usability gap by making the pinned icon in ranked child groups perform the existing unpin flow (`set_garden_pin`), wiring the required redirect path through rendering, updating styles for the new button, and adding an end-to-end browser test covering both ranked-list and HUD unpin behavior. Side B adds a useful markdown copy feature with new UI actions, rendering, and tests, but it is primarily an additive convenience feature rather than resolving an inconsistency in core interaction.

Side A adds a well-scoped, clearly-motivated feature (garden ranking clipboard copy) that follows existing patterns (CopyThread), and ships with unit tests, an integration test, a browser test, and doc updates. Side B is a sprawling, vaguely-described ('reconfigure') architectural pivot that rewrites the ranking data model (scope->tree), renames/removes settlement.rs, rewrites the URL parser, and touches many files at once, making its lasting value and correctness far harder to assess despite some added tests.

B replaces flat string scopes with a hierarchical ItemId/GlobalTree model, journaled votes, path canonicalization, and breadcrumb navigation—core lasting architecture. A adds a useful but incremental clipboard UX (CopyGardenRank) that mostly reuses existing ranking/JsBuilder patterns and does not reshape the system.

Side B introduces a substantial architectural shift from flat scope-based rankings to a hierarchical `ItemId`/`GlobalTree` model, adding canonical URL parsing, breadcrumb navigation, per-node rankings, event replay for tree nodes, and a journal worker while updating vote handling and integration tests accordingly. Side A is a well-implemented user-facing feature that adds a garden ranking copy button with markdown generation, `/ui` action handling, permissions, and tests, but it primarily extends existing UI behavior rather than changing the project's core data model.

Side B implements a complete, non-trivial feature end-to-end (new HtmlUiAction, server rendering logic, markdown formatting, integration tests, browser test, and docs) that adds real user-facing value. Side A is a set of test-infrastructure bugfixes (regex split, redirect header fix, error handling) that only restore CI/test reliability without adding product functionality, making it valuable but comparatively minor and narrowly scoped to test tooling.

A restores broken OAuth/Reddit HttpServer mocks with concrete correctness fixes (regex split on '=', getRequestBody, 302 content-length 0, nil-safe token/state, handler try/catch) plus auth E2E helper fixes so Playwright login works again—foundational test infrastructure. B is a solid, well-tested UX feature (CopyGardenRank + markdown formatting and UI wiring) but additive convenience rather than unblocking critical auth flows.

Side B adds a substantial new user-facing capability by introducing a complete `CopyGardenRank` UI action, server handler, markdown formatting logic, rendering integration, serialization support, and integration/browser tests. Side A is a valuable maintenance fix that restores broken OAuth E2E authentication by correcting mock server behavior (query parsing, request body reading, redirects, null handling, exception handling, and test selectors), but it primarily repairs existing test infrastructure rather than extending the project's functionality.

Side A adds a self-contained, well-tested feature (garden ranking markdown copy) with unit tests, an integration test, a browser test, and updated docs, all without touching existing behavior. Side B mixes an undocumented removal of the theme-switching feature with a routing scheme change (query param → path-based /~/ URLs), which is riskier and less clearly scoped, and its terse '-theme' message reflects the lack of clarity in intent.

B establishes durable browse routing (`ItemId::browse_href` / `/~/…` paths, route wiring, parse fixes) and removes the whole theme cookie/endpoint/CSS fork in favor of one stylesheet—core navigation design. A is a solid, well-tested UX feature (CopyGardenRank + markdown formatter + UI/tests) but is incremental product surface on existing patterns, not structural lasting design.

Side B makes a deeper architectural improvement by introducing canonical browse URLs (`/~/...`), centralizing URL generation/parsing in `ItemId::browse_href`/`from_browse_uri`, updating redirects and routing to use those helpers, and adding tests for the new navigation behavior. Side A adds a well-implemented clipboard feature for garden rankings with new UI actions, markdown formatting, permission checks, and tests, but it is primarily a user-facing convenience feature rather than a foundational routing and URL design change.

Side B adds a real, additive feature (garden ranking markdown copy) with focused new module, serde round-trip tests, integration test, and browser test coverage, without deleting any existing functionality. Side A rips out a large, working (if complex) autocomplete parser graph and replaces it with a much simpler paste-and-go textbox, which is defensible simplification but is largely deletion/downgrade of interactive UX with fewer net capabilities and no equivalent test depth for the new behavior.

A replaces an unreliable ~1800-line keystroke transition graph plus parser_action/render/race machinery with a small correct paste-and-go URL parser and redirect, deleting whole modules and the Playwright race test—lasting design simplification. B only adds an incremental CopyGardenRank clipboard feature (markdown list + button) following an existing CopyThread pattern, useful but narrower additive surface.

Side B adds a durable end-user feature: a new `CopyGardenRank` UI action, server handler, markdown generation for ranked/unranked garden items, copy buttons in garden views, permission checks, and integration/browser tests verifying clipboard behavior. Side A largely removes a complex autocomplete system and replaces it with a much simpler paste-and-go flow, which simplifies maintenance but also drops substantial functionality in favor of basic URL parsing and redirect behavior.

Side A introduces the core architecture (form_template substitution system, HtmlUiAction enum, parse_html_ui_from_form, and the new POST /ui endpoint) that subsequent features—including Side B's own commit—depend on and reuse; it's foundational, well-documented, and covered by templating unit tests. Side B is a solid, well-tested feature addition (copy-to-clipboard for garden rankings) but it's a narrow extension built entirely on the infrastructure Side A created, contributing less lasting architectural value even though its test coverage (unit/integration/browser) is thorough.

A introduces the lasting POST /ui architecture: form_template hole-filling, HtmlUiAction parsing, the ui_html dispatcher, shared run_* web_post helpers, and routing—foundational design reused project-wide. B only adds one feature (CopyGardenRank + markdown clipboard JS and buttons) on top of that already-existing stack, so its value is narrower and dependent.

Side A introduces a substantial new UI architecture: a generic POST /ui endpoint, a typed HtmlUiAction system with JSON template/hole substitution, reusable web-post handlers, routing, and tests, enabling multiple browser UI actions through a shared mechanism. Side B is a well-implemented feature built on that infrastructure, adding a garden-ranking copy action, markdown formatting, UI controls, and integration tests, but it is an incremental capability rather than foundational project design.

A wires up substantial new functionality (cookie-based web sessions, login/logout, web posting form, and full private-room browsing/posting routes via a new ThreadNav abstraction), which is architecturally significant lasting value despite the unfortunate inclusion of a noisy, unrelated plan2.md chat transcript. B is a smaller, cleanly scoped and well-tested feature (clipboard copy for garden rankings) with good test coverage but far less structural impact on the project than A's room/auth wiring, even though A's commit hygiene is worse due to the extraneous file.

Commit A delivers foundational product surface: cookie-based web sessions, /login|/logout|/post, ThreadNav, private room index/thread/post routes with ACL checks, compose forms, and home listing of granted rooms—real lasting UI architecture. Commit B only adds a focused CopyGardenRank clipboard helper, button markup, and tests on existing garden rankings, a useful but narrow UX increment.

Side A delivers substantial functional infrastructure: browser session cookies, login/logout flow, web posting that reuses the RPC path, private room pages with capability checks, room-aware routing, and the wiring needed to make the room UI usable again. Although it also includes an unrelated planning document, the code changes establish lasting authentication, routing, and room UI architecture, whereas Side B adds a useful but narrower feature—a clipboard copy action for garden rankings with supporting UI, tests, and markdown formatting.

Side B tightens type safety by threading CanonicalItemUrl through resolve_item, validate, and rpc pair/rank logic instead of ad-hoc String/CanonicalItemUrl round-tripping, reducing a class of stringly-typed bugs across multiple call sites. Side A is a well-tested but purely additive UI feature (a copy-to-clipboard button) with no structural improvement to existing code, while Side B's refactor improves correctness and maintainability of core ranking/pairing paths that many features depend on.

A ships a complete, user-facing capability (CopyGardenRank + markdown formatting, UI affordances, integration/browser tests) that extends an existing pattern in a durable way. B is a worthwhile type-safety refactor (CanonicalItemUrl through resolve_item/pools, Deref on href newtypes) that cleans call sites without changing behavior, so it adds less product value than the feature.

Side B strengthens core type safety by changing `resolve_item` to return `CanonicalItemUrl` instead of raw `String`, propagating canonical path types through validation, ranking, pair selection, and RPC code while reducing repeated parsing and conversions. It also adds `Deref<Target=str>` for URL/path newtypes and updates APIs to use typed keys directly, whereas Side A primarily introduces a user-facing clipboard feature (`CopyGardenRank`) with new UI actions and tests but does not improve the underlying architecture as broadly.

Side A adds a complete, well-tested new feature (garden ranking markdown copy) with clear separation of concerns, unit tests, integration tests, and browser tests. Side B is a more diffuse mix of a real bugfix (missing preview morph, sort order) bundled with layout/CSS changes across three theme files for a fullscreen mode, which is useful but less self-contained and partially undoes/duplicates prior functionality (breadcrumb removal, ol->ul refactor) without as clear a single purpose.

B improves the core vote-compare flow with lasting design: chromeless fullscreen layout, edge-history ratios aligned to page left/right with strength-based sorting, and post-success morph of the new ingest card—plus targeted tests. A is a solid, well-tested convenience (markdown rank copy via CopyGardenRank) but secondary UX versus B’s correctness and compare-page infrastructure.

Side B substantially improves the vote-compare workflow by adding a fullscreen chromeless layout, live morphing of the newly posted vote preview, and more informative, correctly ordered edge-history rendering that normalizes ratios to the page's left/right orientation. Side A adds a useful clipboard feature for garden rankings with a new `CopyGardenRank` UI action, markdown formatting, and tests, but it is primarily a convenience feature rather than a broader improvement to a core interaction.

Side A adds a self-contained, tested feature (garden ranking markdown copy) with unit tests, integration test, browser test, and docs, following an existing pattern cleanly. Side B is a genuine architectural consolidation (merging /post, /post/check, /post/redact into /ui) which has real value but is riskier/broader churn with less test coverage added relative to the surface area touched, and includes a stray TODO comment signaling incompleteness.

B permanently unifies browser ingest/check/redact onto POST /ui (deletes web_post.rs and the /post* routes, introduces WebSession, rewires forms/tests), which is lasting architectural simplification. A adds a useful copy-rankings control with solid tests, but it is an incremental feature on an existing JsBuilder pattern rather than a structural improvement.

Side B performs a substantial architectural refactor by consolidating browser posting, checking, and redaction into the unified POST /ui RPC flow, introducing shared WebSession resolution, removing the separate web_post module, updating forms and routes, and adapting tests. Side A adds a useful end-user feature—a clipboard copy button for garden rankings with markdown formatting, UI wiring, permission checks, and tests—but its impact is narrower than the broader simplification and unification of the web interaction layer in Side B.

Side A delivers a complete, tested user-facing feature (garden ranking copy-to-clipboard) with new module, RPC action, round-trip tests, integration test, and browser test coverage. Side B is a meta-tool cleanup (removing legacy evidence projection in the constitution/ranking dashboard app) which simplifies code and removes dead-history handling, but is lower-stakes internal tooling churn with less lasting user value than a shipped product feature.

B removes dual-path legacy projection (_legacy_commit_row/_legacy_observation and GitDiscovery-invented epoch/commit pages) so the ledger UI is Evidence-envelope-only, hardens Emission required fields, and updates tests accordingly—core durable design cleanup. A adds a useful CopyGardenRank POST /ui clipboard control with markdown formatting and solid unit/integration/browser coverage, but it is incremental UX polished on existing ranking render paths rather than a structural correctness win.

Side B removes the legacy GitDiscovery projection path and makes evidence pages rely exclusively on Evidence envelopes, simplifying commit/epoch rendering, eliminating fallback code, and tightening the Emission schema by requiring evidence metadata fields instead of optional defaults. Side A adds a useful UI feature—a garden ranking copy button with markdown generation, routing, and tests—but it is primarily an end-user convenience rather than a foundational architectural cleanup.

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.