c_552f408ae0da285ca2

Side B adds a complete, self-contained feature (RoomList RPC + CLI subcommand + types) with a thorough new integration test proving per-user isolation, providing clear lasting value and coverage. Side A fixes a real bug in Reddit child import wiring and adjusts a signature threaded through several call sites, which is valuable but narrower in scope and partly consists of test-shuffling rather than new capability.

A fixes core data-model wiring (replacing link_child + ensure_path with apply_entity_under_parent so listing imports do not pull Reddit comment-path segments) and makes unranked children show real titles via the tree—lasting correctness in import and UI. B adds a useful RoomList RPC/CLI with solid isolation tests, but the server logic is a straightforward grants filter, so the higher-impact design fix is A.

Side A fixes a core correctness issue in Reddit imports by introducing `apply_entity_under_parent` so imported listing children are attached directly without `ensure_path` creating incorrect `/comments/...` hierarchy, and it also improves the ranking UI by showing imported child titles instead of raw IDs. It updates the rendering pipeline and adds integration tests covering SSE morphs and children fetch behavior, whereas Side B primarily adds a useful but incremental `RoomList` RPC/CLI feature with access-control tests.

Side B delivers a substantial, load-bearing feature (GitHub OAuth login, session cookies, pseudonym claiming, trust-weight identity events, projection schema bump) plus a significant architectural cleanup (extracting durable to its own repo/dependency), backed by new unit tests, integration tests, and Playwright flows. Side A adds a useful but narrow RPC endpoint (RoomList) with good test coverage, but it's a much smaller, more isolated contribution compared to B's broad, foundational auth system and dependency restructuring.

B introduces foundational GitHub OAuth, sessions, pseudonym claims, vote gating, and identity-event projection into durable maps (plus extracting the durable crates out-of-tree), which reshapes how the product attributes trust and identity; A only adds a single RoomList RPC/CLI path with isolation tests on top of existing grants. The auth and identity work is far more lasting core design than one discoverability endpoint.

Side A adds a complete, focused capability: a new authenticated `RoomList` RPC, CLI `room list` command, shared response types, and thorough integration tests that verify per-user room isolation and grant behavior. Side B mixes substantial authentication work with a massive removal of the in-tree `durable` crate in favor of an external Git dependency, making much of the patch repository restructuring rather than durable project functionality, so the lasting value visible in this commit is harder to attribute and less self-contained.

Side B adds a complete, end-to-end feature (RPC command, CLI subcommand, response type, and a real integration test proving per-user isolation) that delivers concrete, testable functionality. Side A is a more intricate refinement of an internal heuristic with good unit tests, but it's a narrower, single-file tweak to an existing algorithm rather than new user-facing capability, making B's contribution more broadly useful and durable.

A redesigns core pair selection with lasting structure (established-component bridges before isolate pairs, then rank-gap/zip_index within a fully connected pool) plus targeted unit tests for attach and 1v2-before-2v3 behavior. B adds a useful RoomList vertical slice (RPC filter on grants, CLI, isolation integration tests), but it is straightforward grant membership plumbing rather than deeper ranking design.

Side A changes the core pair-selection algorithm by introducing structured priority keys, preferring attachment of unranked items to established components, and refining comparisons using rank-adjacent 'zip' ordering once the graph is connected, with multiple targeted tests covering the new behavior. Side B adds a useful RoomList RPC, CLI command, response type, and integration tests, but it is primarily a new convenience feature rather than an improvement to the project's central ranking logic.

Side A ships a complete, well-scoped feature (RoomList RPC + CLI + types) with integration tests that explicitly verify per-user grant isolation, giving clear lasting value and confidence in correctness. Side B ('progress') introduces a speculative and fairly complex new abstraction (form-template hole-filling, a generic /ui JSON-in-hidden-field dispatch) whose own doc comments flag it as a potential authorization footgun, and the vague commit message signals unfinished, exploratory work rather than a settled design contribution.

B introduces a lasting UI architecture (form_template hole substitution, HtmlUiAction enum, unified POST /ui handler) plus shared runners extracted from web_post and on-demand thread-form expansion, whereas A only adds one straightforward RoomList RPC/CLI path and its isolation tests.

Side A adds a complete user-facing capability: a new RoomList RPC, CLI `room list` subcommand, shared request/response types, server implementation that filters rooms by authenticated grants, and integration tests verifying per-user isolation and grant behavior. Side B is primarily architectural refactoring to introduce a `/ui` dispatch path, shared web handler helpers, and form-template infrastructure, but it does not deliver a comparably complete, validated feature and lacks end-to-end coverage in this patch.

Side A is a substantial architectural migration (converting the entire REST API surface to a batched RPC model, room/thread scoping refactor, reducer state redesign, and extensive test rewrites) that establishes the foundation the rest of the codebase builds on. Side B is a small incremental feature (RoomList command) built entirely on top of A's RPC infrastructure, useful but narrow in scope and lasting impact by comparison.

Commit A is a foundational redesign: REST endpoints collapse into a batch RPC API, events/reducer split permission boundaries (rooms) from forum channels (thread tags), and the CLI gains public/private scoping— lasting structural value across server, types, tests, and client. Commit B only adds a RoomList RPC + CLI subcommand with isolation tests, a useful but narrow feature that sits on top of that architecture.

Side A introduces a new batched RPC architecture (`/api/v0/rpc`), refactors the CLI to use typed RPC commands, separates room and forum concepts, migrates event and reducer data from thread IDs to room/thread metadata, and centralizes validation into reusable modules. Side B is a useful incremental feature—adding a `RoomList` RPC command, CLI subcommand, and integration tests for per-user room visibility—but it builds on the infrastructure established by Side A rather than changing the project's core design.

Side B adds a small, well-contained feature (RoomList RPC + CLI subcommand) with correct server-side per-principal filtering and thorough integration tests proving isolation, providing real lasting value. Side A deletes a large, over-engineered but functional graph-based parser and replaces it with a much simpler paste-and-go implementation—this is a reasonable simplification, but it's largely destructive churn (removing thousands of test lines and features like live suggestions) rather than adding new lasting capability, and the net value is more about reducing complexity than building durable functionality.

A replaces an unreliable ~1.8k-line keystroke graph (plus parser_action, race-prone JS, and Playwright harness) with a small correct URL/path parser and paste-and-Go redirect, a lasting design simplification. B adds useful RoomList RPC/CLI with solid isolation tests, but is a smaller additive surface on existing grants rather than fixing a core broken approach.

Side B adds a new, coherent capability: a `RoomList` RPC, matching CLI subcommand, shared request/response types, and integration tests that verify authenticated per-user room visibility and isolation. Side A largely replaces a sophisticated autocomplete/parser system with a much simpler paste-and-go textarea and redirect, deleting substantial functionality and tests while simplifying URL parsing, making it a tradeoff rather than a clear lasting improvement.

Commit A fixes a real routing/identity design issue (single opaque `/r/{short}{slug}` segment with validated round-trip helpers plus updated route wiring and tests) and adds a genuinely useful URL-identity normalization layer (query sorting, YouTube canonicalization) with substantial test coverage across multiple call sites (nav, search, write_actor, integration tests). Commit B is a clean, well-tested feature addition (RoomList RPC + CLI + isolation tests) but is narrower in scope and lower architectural impact than A's cross-cutting correctness fix.

A lands lasting core design: centralized room path encode/decode (`room_route_segment` / `room_id_from_route_segment`), a real HTTP identity normalizer (YouTube + sorted query), and wires both through routes, URL builders, and tests. B adds a useful but narrow RoomList RPC/CLI with isolation tests—solid product surface, smaller architectural footprint than A’s URL/identity layer.

Side A introduces a cross-cutting URL routing refactor by centralizing room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), updating all server routes and link generation to use a single canonical representation, and adding URL normalization logic (including canonicalization of external URLs such as YouTube links). Although broad, these changes reduce duplicated parsing logic and establish reusable infrastructure, whereas Side B adds a useful but self-contained `RoomList` RPC/CLI feature with good authorization-aware tests but limited architectural impact.

Side A ships a real user-facing feature (RoomList RPC + CLI command) with correct authorization filtering and integration tests that explicitly verify per-user isolation, directly touching core server/CLI/types code paths used by end users. Side B adds a useful but auxiliary dev-only offline tool (sorterc) that duplicates server logic for local linting/compiling, which is valuable for developer workflow but has narrower, non-production impact and less direct integration with the core product surface.

A ships a user-facing RoomList RPC, types, and CLI path plus isolation integration tests that only return grant-backed rooms—core product surface. B adds useful but secondary offline dev tooling (sorterc/offline compile+scan) that does not change runtime behavior for end users.

Side B introduces a substantial new offline tooling capability by factoring reusable server logic into an `offline` module, adding `compile_document`, JSONL replay/loading, diagnostics (`scan_jsonl`), a dedicated `sorterc` workspace binary, and unit tests. Side A adds a useful `RoomList` RPC, CLI subcommand, response type, and integration tests for per-user room visibility, but its scope is narrower than the reusable developer tooling and validation infrastructure added in Side B.

Side B implements a real DSL syntax change (explanation-first votes) with careful parser rework, backward-compat rejection logic, and updates across docs, fixtures, server tests, and browser tests, showing broad, consistent propagation of a design decision. Side A adds a useful but narrow RPC/CLI feature (RoomList) with good test coverage, but it's a smaller, more contained addition compared to B's cross-cutting language/parser change that touches core DSL semantics used throughout the system.

B redesigns the core sorter DSL so vote explanations lead and verdicts trail, with real parser/UI changes (dsl.rs, ui_html vote formatting, editor placeholder) that redefine how judgments are authored. A adds a useful RoomList RPC/CLI path with solid isolation tests, but it is incremental surface API work versus B’s lasting language-level design shift (even though much of B’s diff is fixture propagation).

Side A adds a new end-to-end capability: a RoomList RPC, CLI `room list` subcommand, shared request/response types, server implementation that filters rooms by authenticated principal's grants, and integration tests verifying per-user isolation and grant behavior. Side B primarily changes DSL syntax from trailing to leading vote explanations, updating the parser, UI generation, documentation, and many fixtures/tests to match; while substantial, it is largely a syntax migration rather than introducing comparable new functionality.

Side A adds a complete, well-scoped feature (RoomList RPC + CLI subcommand) with explicit type definitions and a thorough integration test suite proving multi-user isolation, plus wiring into the test runner and bb.edn tasks. Side B ('nice') is a reasonable feature (Reddit post image/link rendering) with one unit test, but has a vague commit message and less rigorous testing/isolation guarantees compared to A's dedicated multi-scenario integration test.

A adds a core RPC/CLI capability (RoomList) with types, auth-gated server logic, and integration tests that lock in per-user grant isolation—lasting product and security surface. B improves Reddit-specific display (image/link fields, render helpers, CSS) with a focused unit fixture, which is real UX value but narrower presentation polish than a multi-user room discovery API.

Side A adds a new end-to-end capability: a RoomList RPC, CLI subcommand, shared request/response types, server authorization logic that filters rooms by the authenticated principal's grants, and comprehensive integration tests verifying per-user isolation. Side B improves Reddit rendering with richer HTML, image/link extraction, CSS, and a parsing test, but it is primarily a UI enhancement, whereas Side A introduces a broadly useful API feature with security-sensitive behavior validated by integration tests.

Side B adds a full vertical feature (RPC command, CLI subcommand, types) backed by a genuinely new integration test suite that verifies security-relevant per-user isolation, giving durable, independently verifiable value. Side A adds a useful UI feature (pool-scoped voting) with real logic changes but only updates one pre-existing unit test's call site rather than adding new test coverage for the new pool behavior, making its correctness less verified despite touching more files.

B adds a complete, lasting capability (RoomList RPC + CLI) with clear isolation semantics and a dedicated integration test suite proving users only see granted rooms. A’s pool-scoped voting is useful product work and carefully threads pool through hrefs/UI/JS, but much of the diff is parameter plumbing and call-site updates, with no new tests covering the pool path beyond a signature change.

Side A adds a substantial end-user capability by extending the voting flow with pool-scoped navigation, allowing `/vote?pool=...` to automatically select child pairs, preserving pool context through vote submission, and exposing the feature in the UI with supporting query handling. Side B cleanly adds a useful `RoomList` RPC, CLI command, shared types, and thorough integration tests, but it is a relatively self-contained API addition compared with Side A's deeper integration across routing, UI, navigation, and voting logic.

Side B fixes a real production bug (cloud IPs getting blocked by Reddit's public API, requiring OAuth with proper 401/403 retry-and-refresh logic) plus adds a unit test and config fix, directly improving reliability. Side A adds a new feature (RoomList) with solid test coverage, but it's incremental scope addition rather than fixing an existing correctness/reliability issue, making B's fix marginally more consequential to production stability.

B fixes a load-bearing production failure: when Reddit credentials exist it never falls back to www.reddit.com (blocked from cloud IPs), adds AuthRejected handling with forced token refresh/retry, and hardens OAuth error paths—directly keeping core fetch working. A adds a useful but thin RoomList vertical slice (grant filter + CLI + isolation tests) that expands the API without the same operational necessity.

Side B fixes a production reliability issue by requiring OAuth when credentials exist, retrying once after 401/403 with a forced token refresh, improving error propagation, and avoiding fallback to blocked public Reddit endpoints; it also adds a focused test for error truncation. Side A adds a useful RoomList RPC, CLI subcommand, response type, and comprehensive integration tests, but it is primarily a new feature, whereas Side B addresses a deeper operational correctness problem that prevents fetch failures in deployed environments.

Side A adds a clean, well-scoped feature (RoomList RPC + CLI subcommand) with a comprehensive integration test proving per-user isolation, and updates the test runner/bb.edn accordingly—clear, self-contained, verifiable value. Side B is a large, messy web-UI wiring commit that includes a stray AI-generated design essay (plan2.md) accidentally committed, mixes cookie-auth, routing, and room-view logic without any tests, and has questionable production hygiene (committing chat transcripts) that undermines its lasting value despite larger scope.

Side A ships a complete, correctly scoped feature (RoomList RPC + types + CLI + isolation tests that prove users only see granted rooms), which is lasting API surface. Side B restores substantial room UI (cookie sessions, /r/* pages, web post, ACL checks in forum.rs) but dilutes value with a 190-line speculative plan2.md and more diffuse wiring without equivalent new tests.

Side A adds a complete, focused capability: a new authenticated RoomList RPC, matching CLI subcommand, shared RPC types, and integration tests verifying per-user room visibility and grant isolation. Side B contains a very large UI wiring change, but it also introduces an unrelated planning document (`plan2.md`) and broad routing/auth refactoring without accompanying tests in this patch, making its lasting, verified value less clear than A's precise, well-tested feature.

A fixes a real correctness gap (RPC/HTML links for private-room items previously always resolved to public `/~/...` or `/t/...` URLs, breaking room-scoped navigation) via `item_path_for_api_in_room`/`forum_thread_web_url` with unit tests, plus reworks theme handling to be cookie-based (fixing FOUC/flash and enabling SSR-consistent rendering) across many pages. B is a clean, well-tested but narrower feature (RoomList RPC + CLI) with good integration coverage, but lower overall impact than the correctness fix and broader theming rework in A.

A ships lasting platform fixes: cookie/SSR theme plumbing (POST /theme, auth cookie re-issue so login does not drop theme) plus room-correct wire URLs via item_path_for_api_in_room/forum_thread_web_url wired through RPC rank/pair/forum responses with unit tests. B adds a useful RoomList RPC/CLI with solid isolation integration tests, but is a single narrow endpoint versus A’s API correctness and cross-surface design work.

Side A delivers broad, lasting functionality by introducing persistent theme handling (cookie-backed theme selection that survives authentication), propagating theme context through page rendering, and fixing room-aware URL generation across the RPC/API with dedicated helper functions and tests for private-room paths. Side B adds a useful but narrowly scoped RoomList RPC/CLI command with integration tests that simply enumerates rooms granted to the authenticated user, making it a smaller feature with less architectural impact.

B is a substantial refactor that centralizes duplicated path/URL logic (canonicalize_item, item_path_for_api_in_room, forum_thread_web_url) into a single shared slug-types::paths module with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), reducing duplication between server and types and tightening type safety across many call sites, with tests preserved. A adds a legitimate small feature (RoomList RPC + CLI + integration test) which is useful but narrower in scope and lower architectural impact than B's cross-cutting consolidation.

A adds a genuine new RPC (RoomList) plus CLI and thorough isolation tests that enforce grant-scoped room visibility; B mostly relocates existing canonicalization/helpers into slug-types newtypes and rewires call sites without new behavior or bugfixes.

Side B performs a broad architectural refactor by moving canonicalization and path/URL identity into a shared `slug_types::paths` module, replacing ad hoc string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and related types across RPCs, validation, and API responses. Side A adds a useful `RoomList` RPC, CLI subcommand, and thorough integration tests for per-user room visibility, but it is a localized feature, whereas Side B establishes reusable infrastructure that reduces duplication and makes path handling consistent project-wide.

B adds a genuine new capability (RoomList RPC + CLI subcommand) with real access-control semantics (per-user grant filtering) plus a thorough integration test proving isolation, giving durable end-user and security value. A is a solid internal tooling improvement (faster scan, better error surfacing, ingest replay) but is more niche dev-tooling churn without new user-facing functionality or security-relevant guarantees.

B adds a core product RPC (RoomList) plus CLI and integration tests that lock in per-principal grant isolation—lasting API surface the app needs. A is strong offline DX (fast parse-only scan, richer parse_error, compile --ingest) but remains tooling around logs rather than new user-facing capability; B’s value is thinner code-wise but more central and durable for the system.

Side A delivers deeper tooling improvements by redesigning JSONL scanning into a fast parse-only pass, surfacing detailed DSL parse errors, and adding `compile --ingest` that reconstructs prior reducer state for single-event replay, with corresponding API changes and tests. Side B adds a useful `RoomList` RPC, CLI subcommand, response types, and integration tests for access isolation, but it is a relatively self-contained feature compared with Side A's broader performance, diagnostics, and developer workflow improvements.

B fixes a real correctness bug (ghost items and falsely-marked voted pairs from zero-ratio votes) with a minimal, precise change and updates the test to verify the corrected invariant. A adds a legitimate new feature with good test coverage, but B's change addresses actual data-integrity bugs in core reducer logic that could silently corrupt state, which has more lasting correctness value than an additive feature.

B fixes a real correctness bug in core reducer logic: the zero-ratio guard ran after ensure_item and voted_pairs.insert, leaving ghost items and false voted-pair marks; moving the check before side effects permanently stops that corruption, with the unit test updated to match. A adds a useful RoomList RPC/CLI surface plus solid isolation tests, but it is additive API wiring over existing grants state rather than repairing flawed core behavior.

Side A adds a new end-to-end capability: a RoomList RPC, CLI `room list` subcommand, shared request/response types, server implementation, and integration tests verifying authenticated per-user room isolation. Side B fixes a real reducer bug by moving the zero-ratio early return before `ensure_item` and `voted_pairs` mutation, preventing ghost items and stale voted-pair state, but it is a localized correctness fix compared with A's broadly useful, fully tested feature.