c_73d485b8085bb26059

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.

Commit A implements a substantial, functionally load-bearing feature: GitHub OAuth login, session cookies, identity/pseudonym events with uniqueness enforcement, trust-weight accrual, and integration with vote-gating across multiple modules plus new Clojure e2e tests, while cleanly extracting the durable crate to an external dependency. Commit B adds a self-contained dev-only CLI tool (sorterc) for offline DSL compilation and JSONL linting, which is useful tooling but narrower in scope and lower-stakes than A's core auth/identity infrastructure that the rest of the app now depends on.

A ships end-to-end GitHub OAuth, session cookies, pseudonym claiming, identity event projection into durable maps, and vote gating—core product auth with routes, schema, apply logic, and integration tests—while B only adds a small offline dev binary (sorterc) that reuses existing DSL/reducer code for compile/scan diagnostics without changing runtime behavior.

Side A introduces substantial product functionality: GitHub OAuth login, session management, pseudonym claiming, vote authorization, new identity events (`PrincipalCreated`, `OauthLinked`, `PseudonymClaimed`), projection logic, storage schema changes, routing, and integration tests. Although it also moves the `durable` crate out of the workspace, the lasting value comes from the new authentication and identity architecture, whereas Side B primarily adds an offline developer tool (`sorterc`) for compiling `.sorter` files and linting JSONL event logs without changing the core application behavior.

Side B ships a substantial, working feature: GitHub OAuth login, session management, pseudonym claiming, trust-weight identity events, projection/storage schema updates, route wiring, JS/UI changes, and new integration tests, plus it removes an in-tree crate in favor of a git dependency (real infra cleanup). Side A is purely a planning document plus a thin unfinished RouteContext wrapper that just delegates to existing ThreadNav methods with no call-site migration, providing far less concrete lasting value than the shipped auth system in B.

B lands a full GitHub OAuth/session/pseudonym stack, gates votes on real identity, projects PrincipalCreated/OauthLinked/PseudonymClaimed into durable maps, and extracts the in-tree durable crates to an external git dep—durable product and architecture. A mostly adds plan.md plus a thin RouteContext wrapper still delegating to ThreadNav/CanonicalItemUrl, so it stages a refactor rather than delivering lasting behavior.

Side B introduces substantive, lasting functionality: GitHub OAuth/session support, pseudonym claiming, new identity-related event types and projection logic, durable session storage, routing, UI integration, and accompanying tests. Side A mainly adds a detailed migration plan document plus a small `RouteContext` wrapper module and re-export, which is useful for future work but does not materially change project behavior.

Commit B delivers a substantial, real feature (GitHub OAuth login, session management, pseudonym claiming, identity event sourcing) plus a meaningful infra change (extracting durable into its own repo/dependency), backed by new integration tests and mock OAuth harness. Commit A is a smaller, well-scoped algorithmic refinement to pair-selection heuristics with good unit tests, but it's narrower in scope and impact compared to the auth system and repo restructuring in B.

B adds foundational multi-user auth (GitHub OAuth, sessions, pseudonym claims, identity event projection, and vote gating) plus integration tests, which the product needs for accountable votes. A is a strong but narrower improvement: better bridge/isolate priority and rank-zip pair selection in pair.rs with focused unit tests. Much of B’s diff is relocating durable out of tree (deletion noise), so A still earns solid weight, but auth is the larger lasting capability.

Side A makes a focused, lasting improvement to pair selection by introducing structured bridge/within-component prioritization, preferring attachment to established components, adding rank-aware 'zip' refinement once the pool is connected, and backing the behavior with targeted tests. Side B includes substantial functionality (GitHub OAuth, sessions, identity events) but the visible patch is dominated by moving the in-tree durable crate to an external Git dependency and large code deletion, making much of the apparent size repository reorganization rather than durable project logic.

A ships a complete invite product surface (mint RPC, /join redemption into grants, RoomAudit, multi-cap grants, CLI, timeline system rows, and an end-to-end invites.bb suite) that becomes real private-room UX. B’s lasting pieces are GitHub OAuth/session/pseudonym gating and projecting identity events, but a large fraction of the patch is relocating the in-tree durable crate (mass deletion + git dep) rather than new in-project capability.

Side B ships a fully wired GitHub OAuth/session/pseudonym system (auth module, event handling in projection_apply.rs, cookie sessions, gating votes) backed by unit and browser-integration tests, plus a clean extraction of the durable crate to its own repo. Side A's invite feature works for the basic mint/redeem/audit path but leaves substantial dead code: the new events.rs InviteMinted/InviteRedeemed variants and reducer ActiveInviteState/RoomTimelineEntry logic are never produced by any code path, and the entire new server/src/timeline.rs (merge_thread_rows, System items) is unreferenced, indicating incomplete integration despite the large diff.

Side A adds a complete invite workflow with server and CLI support: minting invite links, redeeming them through OAuth into room grants, room audit RPCs, thread timeline/system items, and end-to-end integration tests. Side B introduces GitHub OAuth, session handling, pseudonym claims, and moves the durable crate out of the repository, but a large portion of the patch is repository restructuring and dependency relocation rather than new project functionality, so A delivers slightly more lasting in-project value.

A lands a complete, carefully designed URL semantic graph (DFA traversal, absorb edges, builder validation, parse/normalize, generic fallback) with dense regression tests for Reddit/YouTube equivalence and encoding safety—core lasting domain logic. B’s OAuth/session/pseudonym gating and identity projection are valuable product work, but a large share of the patch is moving durable out-of-tree (mass deletion + lockfile/git dep churn) rather than net new in-repo design.

B adds core identity/auth (OAuth, sessions, pseudonyms, trust weights) plus event projection rules and cleans up by externalizing durable; these are lasting features. A performs a URL canonicalization refactor (new url_rules crate + mechanical string updates across tests) that improves design but is primarily churn without new user-visible capability.

B ships a complete, testable feature: GitHub OAuth login, durable sessions, pseudonym claiming, and trust-weight-based identity events wired into the projection and vote path, backed by new integration/E2E tests (mock OAuth server, Clojure auth flow test) — a substantial, load-bearing capability. A is a cleaner, more focused refactor (ephemeral Reddit content with TTL eviction, removing EntityStore) that fixes a real design/policy issue and is well tested, but its scope and impact are narrower than B's new identity/auth subsystem, even though B awkwardly bundles in an unrelated vendoring change (moving `durable` to a git dependency).

B adds foundational product infrastructure: GitHub OAuth, session cookies, pseudonym claims, identity events (PrincipalCreated/OauthLinked/PseudonymClaimed) projected into durable maps, and vote gating via resolve_vote_actor—real multi-user auth with e2e coverage. A is a strong, precise design fix (drop EntityImported/EntityStore, cache Reddit display ephemerally with 48h eviction, log NodeEnsured only), but narrower in scope; B’s durable out-of-tree move is mostly relocation noise and does not outweigh the auth subsystem’s lasting value.

Side A makes a substantive architectural change: it removes `EntityImported` events and the separate `EntityStore`, stores Reddit display data only as ephemeral projection state with TTL eviction, and updates replay/tests so the event log retains only durable structure (`NodeEnsured`, votes). Side B does add meaningful GitHub OAuth, sessions, identity events, and vote gating, but a large portion of the patch is repository restructuring that removes the in-tree `durable` crate and rewires dependencies, making the overall lasting contribution less concentrated than A's core persistence-model redesign.

Both are substantial feature PRs, but B adds foundational product infrastructure — real OAuth identity, durable sessions, trust-weighted votes with event-sourced invariant enforcement (pseudonym/oauth-link conflict checks) — validated by unit, integration, and browser tests, plus a legitimate cleanup extracting the generic `durable` KV crate out of the app repo into its own upstream project. A's GitHub external-resolver and URL-identity rework is well-tested and useful, but it leaves an inconsistency (the youtube 'external_source_href' embed-mapping logic targets a URL shape that the commit's own normalization no longer produces, making that code effectively dead), whereas B's core gating/trust logic is internally consistent even though it has one minor entropy bug in UUID generation that doesn't affect correctness of uniqueness in practice.

A delivers lasting product value via correct URL identity policy (strip query/fragment by default, GitHub/YouTube canonicalization), a full on-demand GitHub resolver wired through SystemIngest with cooldowns and durable synthetic posts, plus UI/tests. B’s OAuth/session/pseudonym gating is real infrastructure, but a large share of its diff is relocating the pre-existing durable crate out-of-tree and lockfile churn rather than net new design.

Side A adds substantial, lasting functionality: an extensible external URL foundation with GitHub resolvers, on-demand system ingests (`SystemIngest`), resolver cooldowns, URL normalization improvements, UI actions, and tests, creating reusable infrastructure rather than isolated features. Side B does introduce GitHub OAuth, pseudonym/session handling, and identity events, but a large portion of its patch is moving the `durable` crate out of the repository and deleting in-tree code, which is more project reorganization than enduring product capability.