c_55f1cdf12e22d65bdd

Commit A introduces a substantial new feature set spanning the CLI, server API, authentication flow, RPC layer, state management, reducer, shared types, routing, and integration tests. It implements shareable room invite links with redemption during OAuth, room auditing, multi-capability grants, new RPC commands and responses, thread timeline support, new routes, state structures, and comprehensive end-to-end tests. Although some event types appear only partially integrated, the overall change is a large architectural addition. Commit B is a focused usability improvement that makes pinned icons in ranked child groups clickable for unpinning, updates styling, threads a new parameter through rendering, and extends browser tests. It is a valuable UX enhancement but far smaller in scope and impact than the broad invitation and room management system introduced in Commit A.

Commit A introduces a full invite system end-to-end: new RPC commands, server-side state and redemption logic, auth flow integration, reducer updates, timeline integration, CLI support, and comprehensive tests. It significantly expands core functionality. Commit B is a focused UI improvement making an existing pin icon clickable to unpin, with minor rendering and CSS changes plus test updates. The scope and impact of A are far greater.

Side A introduces a full invite system end-to-end: new RPC commands (RoomMintInvite, RoomAudit), server routes (/join/:token), OAuth redemption flow integration, reducer state extensions, new event types, CLI commands, timeline merging, and comprehensive integration tests. It significantly expands backend capabilities, data models, and test coverage. Side B is a focused UI improvement making pin icons clickable to unpin, with corresponding CSS and browser test updates. While useful, it is comparatively small in scope and impact.

Side A implements a substantial new capability across the system: shareable room invites with OAuth redemption, room auditing, multi-capability grants, new RPCs/CLI commands, server routes, state handling, reducer updates, API/type changes, and integration tests. Side B is a focused UI improvement that makes existing pin icons in ranked child groups clickable to unpin, with corresponding CSS and browser test updates, but it is a relatively small usability enhancement compared with the new end-to-end functionality in Side A.

Side A introduces a full invite system end-to-end (RPC minting, auth redemption flow, state management, reducer updates, CLI commands, and integration tests), plus expands thread modeling with system items, while Side B only makes an existing pin icon clickable and adjusts CSS/tests. The former adds new core capabilities and data flows; the latter is a localized UI improvement.

Side A introduces a full invite system (RoomMintInvite, /join/:token flow, redemption applying GrantAdded events), RoomAudit RPC, timeline merging with ThreadItem::System, reducer support for invites, and comprehensive integration tests (test/invites.bb), significantly expanding core auth and room capabilities. Side B is a focused UI enhancement making ranked child group pin icons clickable to unpin, with CSS tweaks and a browser test, but does not alter core domain logic.

Side A implements a full invite system feature spanning event sourcing, RPC endpoints, HTTP routes, CLI commands, reducer state, and integration tests—substantial, non-trivial, lasting functionality. Side B is a focused UI polish fix (making pin icons clickable to unpin) which is useful but much smaller in scope, touching only templating/CSS and browser test updates.

Commit A lands a full invite-access feature (mint/redeem RPCs, /join OAuth path, multi-cap grants, RoomAudit, reducer/timeline/types/CLI, and invites integration tests), which permanently expands core product capability. Commit B only turns an existing ranked-child pin glyph into a form that posts the already-supported set_garden_pin clear action, plus CSS/test tweaks—a small local UX affordance.

Both are substantial, working features, but B's URL/query normalization fix (stripping tracking params, fragments, GitHub repo canonicalization) addresses a real identity-correctness bug affecting item deduplication across the whole ontology, backed by many targeted unit tests plus a new browser test. A's invite system is a solid, self-contained feature with server/CLI/test coverage, but it introduces a second parallel event scheme (durable InviteMinted/InviteRedeemed events defined but unused, actual state kept only in RAM) which is architecturally messier and leaves dead/duplicate code paths.

A delivers a complete, end-to-end invite product (mint RPC, /join auth redemption into durable GrantAdded, RoomAudit, multi-cap grants, CLI, timeline system rows, and a focused invites integration test). B’s URL identity tightening and GitHub on-demand resolver are valuable foundations, but a large fraction of its diff is formatting/churn plus one domain-specific importer, so it contributes less immediate lasting product surface than A’s access-control path.

Side A adds substantial new project capabilities: an end-to-end invite system (minting, redemption through OAuth, room audit RPCs, CLI support, state management, routing, and integration tests), plus thread timeline support with system events. Side B improves URL normalization and introduces an extensible GitHub external resolver with UI integration, but a significant portion is refactoring/formatting and incremental UI work, whereas Side A delivers a broader core access-control feature with concrete server, client, API, and test coverage.

Side A adds a large invite feature with real working mint/redeem/audit flow and end-to-end tests, but it also introduces substantial dead scaffolding — Event::InviteMinted/InviteRedeemed, ActiveInviteState, room_timeline, and an entire new timeline.rs module — none of which are ever wired into the actual RPC/reducer flow (invites are minted/redeemed purely via the separate ephemeral state.invites map), leaving confusing, unused duplicate machinery. Side B is a smaller but coherent and fully-integrated fix: it makes block masking deterministic/typed, correctly tokenizes prose item refs (fixing real link/URL-boundary/code-fence bugs), tightens DSL item-body rules, and backs every change with focused unit tests, with no orphaned code paths.

A delivers a complete invite-link feature (mint RPC, /join redemption into grants, CLI, audit, room timeline merge into ThreadItem, and an end-to-end invites test suite), which is a durable access-control capability. B is a focused but narrower DSL/linkify improvement (deterministic block kinds, braced bodies, prose tokenization of ~/ -/ https refs with fence/newline handling) that mainly refines existing garden rendering rather than adding a new product surface.

Side A implements a substantial new capability: an end-to-end invite system with invite minting, redemption during OAuth, room auditing, new RPCs/CLI commands, server routes, state management, and integration tests covering the workflow. Side B improves DSL parsing and HTML linkification by adding deterministic block masking, prose reference tokenization, URL handling, stricter braced item bodies, and tests, but these are narrower parser/UI enhancements compared with the lasting project functionality introduced in Side A.

Side A delivers a complete, integrated feature (invite links) spanning CLI, auth flow, RPC, reducer state, room timeline, and an end-to-end babashka test, giving real user-facing access-control capability. Side B is an impressively tested but narrow URL-canonicalization module limited to reddit/youtube normalization, valuable but smaller in scope and less clearly load-bearing for core product functionality.

A ships an end-to-end invite/ACL product path (mint RPC, /join redemption into OAuth, multi-cap RoomGrant, RoomAudit, CLI, and invites integration tests) that permanently expands how private rooms are used. B is a strong, well-tested URL DFA/canonicalization module, but it is scoped to one subsystem and does not match A’s cross-stack access-control impact.

Side A delivers a substantial end-to-end feature: shareable room invites with redemption integrated into OAuth, new RPCs for minting invites and auditing grants, CLI support, server routes, state management, API/type updates, and an integration test covering the full lifecycle. Side B introduces a well-tested URL canonicalization graph and parsing framework, but it is largely an internal infrastructure refactor with limited visible functionality compared with the broad user-facing access-control workflow added in Side A.

Side B is a coherent, fully-wired refactor: it removes the EntityStore/EntityImported machinery entirely, replaces it with ephemeral projection-only Reddit content plus a TTL eviction task, and updates every call site and test consistently (journal, projection_apply, projection_store, reddit.rs, state.rs), addressing a real data-retention/compliance concern. Side A adds a bigger invite feature with CLI/RPC/tests, but it leaves substantial half-integrated code: InviteMinted/InviteRedeemed events and ActiveInviteState/reducer.room_timeline are defined but never emitted or consumed by the actual thread endpoint, a new timeline.rs module appears unwired into lib.rs, and RoomRevoke is stubbed as unimplemented, indicating scope creep with dead paths rather than a fully realized design.

B removes EntityImported/EntityStore entirely and confines Reddit payloads to TTL-evicted projection caches while logging only NodeEnsured structure, a lasting data-model and compliance fix that simplifies journal, projection_apply, storage schema, and rebuild paths. A adds a useful invite/audit surface (RPC mint, /join redemption, multi-cap grants, CLI, tests) but is mostly additive feature surface with in-memory invites and partial event types rather than a foundational redesign.

Side B makes a deeper architectural change by removing `EntityImported` events and the `EntityStore`, keeping Reddit content out of the event log, storing only ephemeral display data in the projection with TTL-based eviction, and updating replay/projection logic and tests accordingly. Side A adds a substantial invite system (invite minting, redemption, audit RPCs, CLI support, and tests), but it also introduces event types (`InviteMinted`/`InviteRedeemed`) that are not actually used while the implementation relies on in-memory invite state, making the design less cohesive than B's storage simplification.

Side A replaces a fragile single-repo GitHub-API polling mechanism with a deterministic, replayable, multi-repository git-discovery engine that handles adversarial cases (force-push reintroduction, git-replace forgery, cherry-pick patch-identity dedup, merge/empty-commit exclusion) and ships extensive property/stateful tests validating these invariants — this is core infrastructure for the constitution's fairness/correctness guarantees. Side B adds a well-tested invite feature to the product, which is useful but more routine feature work with less foundational impact on the system's integrity guarantees.

A replaces fragile GitHub API polling with deterministic multi-repo git mirroring, patch-id dedup, genesis/force-push/cherry-pick rules, and large unit/stateful/integration coverage—core protocol design for attribution. B adds a solid but narrower product feature (ephemeral invite links, RoomAudit, CLI, grant timeline merge) without comparable adversarial depth or foundational correctness work.

Side A replaces GitHub API-based commit fetching with a deterministic multi-repository Git discovery pipeline, including mirrored repositories, replayable reachability snapshots, patch-ID deduplication, discovery events persisted to the ledger, concurrency/file locking, and extensive real-Git integration and property tests. Side B adds a useful invite system, room audit RPCs, and timeline/UI support, but it also leaves parts incomplete (for example `RoomRevoke` is explicitly unimplemented and invite events are defined but the implementation relies on ephemeral in-memory state), making it a narrower and less foundational contribution.

Side A implements a coherent new feature (invite links) end-to-end: server events/reducer state, RPC handlers, CLI commands, HTML routes, and a dedicated integration test file, all wired through existing patterns with real design tradeoffs (TTL, exhaustion, redemption tying into OAuth flow). Side B is largely deployment/infra glue (Dockerfile, fly.toml, CI) plus a UI dashboard and audit-broadcast plumbing that, while functional, is more operational scaffolding and cosmetic CSS than durable core-domain logic, and it hardcodes org-specific repo/contributor config that is brittle and less generally reusable.

A lands a full invite lifecycle (mint RPC, /join redemption into grants, multi-cap RoomGrant, RoomAudit, CLI, reducer/timeline types) with a dedicated invites integration test—durable product capability. B’s deploy pipeline, /watch SSE audit UI, and production repo/contributor config are operationally important but mostly wire the existing constitution loop for production rather than adding comparable core domain behavior.

Side A implements substantial new project functionality: an invite-based room access flow spanning server, CLI, RPC, authentication, state management, API types, routing, and end-to-end integration tests, while also extending grants to multiple capabilities and adding room audit support. Side B mainly adds deployment infrastructure, a production dashboard, SSE audit/status reporting, and CI/CD configuration; valuable operationally, but it contributes less core application behavior than the end-user invite and permission features in Side A.

Both commits are substantial feature additions with test coverage, but Side A's invite system introduces a coherent new capability (invite links, room audit, room timeline, thread system-lines) with a dedicated integration test and careful state/event handling, while Side B's OAuth-linking change (adding Reddit provider linking, UUID-canonical identity) is also solid but is more narrowly scoped to auth wiring and mock-server plumbing, with less new user-facing surface area. Side A's diff touches more of the system's core data model (reducer, timeline, RPC, CLI) providing broader lasting value than Side B's addition of a second OAuth provider to an existing linking mechanism.

A ships a full invite path (mint RPC, /join redemption wired through OAuth, multi-cap RoomGrant, RoomAudit, CLI, and invites.bb) plus thread timeline/system rows—real product surface with end-to-end tests. B improves identity design (UUID-canonical multi-provider link/conflict handling, Reddit OAuth, linked-provider privacy, batch trust-weight fix) but largely extends an existing OAuth/session model rather than adding comparable new capability.

Side A implements a substantial new room invitation and access-management workflow end to end: RPCs for minting invites and auditing grants, `/join/:token` redemption integrated into OAuth, capability grants, CLI support, new tests, and related API/type changes. Side B makes an important architectural improvement by making UUIDs the canonical identity and adding Reddit OAuth linking, but A delivers a broader user-facing capability with server, client, routing, state, and integration-test coverage despite some invite state remaining ephemeral.

B fixes a genuine, well-diagnosed algorithmic bug (bipartite Markov chain oscillation in rank-centrality scoring) with a principled correction grounded in cited literature, plus targeted regression tests across multiple topologies. A adds a large, plausible-but-sprawling invite-system feature with meaningful surface area (server state, RPC, CLI, reducer, timeline) but is riskier/less proven, includes speculative unused fields (InviteMinted/InviteRedeemed events never emitted, room_timeline/ActiveInviteState seemingly unused by the new timeline.rs), and its correctness is less rigorously validated than B's mathematically justified fix.

B fixes a real core Rank Centrality bug (wrong d_max caused bipartite oscillation and uniform scores on star topologies), matching the paper and adding tight Rust/Clojure regressions—lasting correctness of the product’s ranking. A ships a large invite/audit feature with CLI and tests, but much of it is broader surface area and dual in-memory vs event-log invite state rather than a comparably foundational design fix.

Side B fixes a core ranking algorithm bug by changing Rank Centrality to use degree-based d_max instead of summed edge weights, eliminating oscillation in star-topology graphs and producing correct stable rankings. It also adds focused regression tests (Rust and Clojure fixtures) that directly reproduce and guard against the failure, whereas Side A introduces substantial invite and audit functionality but also leaves newly added invite events unused in favor of ephemeral in-memory state, making the design less durable.

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.