c_b21d271b1b82da3e64

Commit B introduces a substantial new capability and supporting infrastructure: an extensible external URL foundation with on-demand GitHub resolution, new UI actions, backend write-path support for system ingests, URL normalization improvements, resolver state management, garden UI enhancements, recursive child ranking depth, extensive tests (including browser integration), and related documentation. It changes many components cohesively to enable a new feature set. Commit A is a focused bug fix that corrects vote comparison highlighting, adjusts ranking gradient behavior to operate per group instead of globally, improves vote history visualization, and adds targeted regression tests. It is valuable but much narrower in scope and impact than the architectural additions in B.

Commit B introduces a substantial new capability: an extensible external URL system with a full GitHub resolver, backend ingestion pipeline, UI controls, normalization logic, and extensive tests (including browser automation). It touches many core areas (state, API, DSL, HTML, URL identity, and async workers) and adds meaningful product functionality. Commit A is a focused UI/logic fix for vote highlighting with some styling and tests—useful but comparatively small in scope and impact.

Side B introduces a substantial new extensible URL foundation and GitHub external resolver system: new resolver module with API integration, cooldown logic, system ingest pathway, write command, UI actions, garden UI controls, normalization changes, extensive tests (unit + browser), and state wiring. This meaningfully expands platform capabilities. Side A mainly fixes vote compare highlighting and slider polarity with related CSS/JS tweaks and tests—valuable but comparatively incremental. Therefore B contributes far more overall functionality and architectural impact.

Commit A delivers a substantial new feature set spanning multiple subsystems. It introduces an extensible external URL foundation with a GitHub resolver, on-demand import workflow, new UI actions and controls, system-ingest support in the write actor, resolver cooldown state, URL normalization improvements, external preview handling, recursive child ranking depth, parser enhancements for fenced JSON, extensive tests, and browser end-to-end coverage. It changes application behavior, persistence flow, APIs, state management, and user experience across many files. Commit B is a focused improvement that switches vote-related URLs to display paths and significantly strengthens the browser test by exercising all 45 pairwise comparisons and validating the resulting ranking. While valuable for correctness and UX consistency, its scope and architectural impact are much smaller than the broad platform capabilities added in Commit A.

Commit A introduces a substantial new capability: an extensible external URL foundation with a full GitHub resolver pipeline (API client, rate limiting, DSL generation, system ingest path, UI actions, and browser tests). It also touches many layers (state, write actor, UI, normalization, tests), adding meaningful product functionality. Commit B is a focused improvement to URL display in vote links plus a stronger end-to-end test. While useful, it is comparatively small in scope and impact.

Side A introduces a substantial new feature set: extensible URL normalization (including GitHub and YouTube handling), an on-demand GitHub external resolver with API integration, system-level ingest plumbing, UI controls, cooldown state, DSL/test updates, and new browser coverage. It touches many core modules (state, writer actor, HTML, URL identity, external resolver, tests) and adds meaningful new capabilities. Side B is a focused improvement to vote pool href encoding plus a stronger end-to-end test asserting full ranking behavior. While valuable, it is comparatively small in scope and architectural impact.

Side B introduces substantial new infrastructure: an extensible external URL foundation with a GitHub resolver, new UI actions and write commands for system ingests, resolver cooldown state, URL normalization improvements, recursive garden browsing enhancements, and extensive unit/browser tests. Side A is a focused bug fix that correctly changes rank highlighting to be computed per ranking group instead of globally and adds regression tests, but its scope and long-term architectural impact are much smaller.

Side B introduces a substantial new external resolver system (GitHub integration, SystemIngest pipeline, UI actions, and normalization logic) with end-to-end functionality and tests, adding durable capabilities. Side A mainly fixes ranking highlight logic by scoping gradients per group and improves vote UI display, which is valuable but comparatively narrow in impact.

Side B introduces a substantial extensible URL foundation: new external resolver infrastructure (GitHubResolver with API integration, cooldowns, SystemIngest write path), URL normalization changes (query stripping, YouTube/GitHub canonicalization), new UI actions, and broad tests including browser coverage. Side A is a small, targeted fix to ranking highlight gradients and minor vote UI tweaks with limited scope, whereas B adds enduring architecture and cross-cutting functionality.

Side B implements a substantial, cohesive feature (on-demand GitHub external resolver with a new system-ingest write path, cooldown state, URL identity normalization rewrite, and matching browser/unit tests) that adds real durable capability and fixes URL identity bugs across multiple modules. Side A is a focused but much smaller UI/CSS fix for vote-history slider highlighting, useful but narrow in scope and lasting impact compared to B's broader architectural additions.

B establishes lasting URL identity rules (strip query/fragment by default, GitHub and YouTube canonicalization), a SystemIngest path, and a working on-demand GitHub resolver with browser coverage—foundational product architecture. A is a solid, tested vote-highlight/polarity UX fix (per-group gradients, center-anchored history sliders), but it is narrower polish on existing vote UI rather than core extensibility.

Side A adds substantial new functionality and infrastructure: an extensible external URL foundation with GitHub resolution, on-demand system ingests (`WriteCmd::SystemIngest`), URL normalization changes, resolver cooldown state, UI actions for external resolution, external preview handling, and accompanying parser and browser tests. Side B is a focused improvement that switches vote links to use `display_path` instead of storage URLs and strengthens the vote-pool browser test by exercising all 45 pairings and asserting the resulting ranking, but it does not introduce comparable lasting capabilities.

Side A introduces a substantial new capability: an extensible external resolver system with a full GitHub integration, new write path (SystemIngest), UI actions, state management, and URL normalization changes, all backed by tests. Side B is a narrow improvement—switching vote URLs to display paths and strengthening a browser test—which is useful but comparatively minor in scope and lasting architectural impact.

Side A introduces a substantial new extensible URL and external resolution foundation: it adds a GitHubResolver with API integration, cooldown tracking in AppState, a new SystemIngest write path, DSL support for fenced JSON bodies, URL normalization changes, UI controls, and end-to-end browser tests. Side B is a focused improvement to vote_compare_href/vote_pool_href to use display_path plus a stronger browser test asserting all 45 pairwise votes and final ranking, which is valuable but much narrower in scope and architectural impact.

Side A implements a substantial, well-tested feature set (GitHub external resolver with rate-limiting, URL identity normalization overhaul stripping tracking params, UI actions and templates, new AppState fields, agents.md doc updates, and a full browser test) representing significant lasting architectural value. Side B is a small, focused bugfix (using display_path in vote hrefs) plus a stronger test, which is valuable but far narrower in scope and impact than Side A's broad foundational work.

A delivers lasting product infrastructure: URL identity redesign (strip query/fragment by default, GitHub/YouTube canonicalization), a full on-demand GitHub resolver with SystemIngest, cooldowns, UI, and E2E coverage. B is a correct, focused fix (display_path in vote hrefs) plus a much stronger 45-pair ranking assertion, but its scope and durability are much narrower than A’s foundation and feature work.

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 delivers a coherent, well-tested extensible resolver framework (GitHub on-demand import with cooldown/rate-limiting, DSL fenced-JSON body support) plus real bugfixes to URL identity semantics (stripping tracking query params, fixing broken external previews for blocked hosts like GitHub, YouTube canonicalization) backed by extensive unit and browser tests. Side B is a solid internal cleanup (removing EntityStore/EntityImported in favor of ephemeral TTL-evicted Reddit content) that reduces event-log bloat, but it is a narrower, single-purpose architecture fix with less new user-facing capability and fewer edge-case tests, despite Side A's diff containing some pure reformatting noise.

B makes a lasting architectural cut: drop EntityImported/EntityStore, log only NodeEnsured structure, and put Reddit display payloads in a TTL-evicted projection cache—correct durability/compliance vs permanent API JSON in the event log. A adds real value (query/fragment stripping, GitHub URL identity, on-demand resolver + SystemIngest + browser coverage), but much of the diff is rustfmt churn and UI wiring, and it still durably ingests fetched GitHub bodies the way B deliberately stopped doing for Reddit.

Side A introduces substantial new functionality: an extensible external URL foundation with GitHub-specific resolution, on-demand resolver UI/actions, durable system ingests, URL normalization improvements, depth-aware garden views, cooldown handling, and extensive tests. Side B makes a sound architectural change by removing persisted Reddit payloads in favor of ephemeral cached content with TTL eviction and simplifying the event log to structural events, but its impact is narrower than the broad new capabilities and infrastructure added in Side A.

Side B implements a substantive, well-tested reworking of multi-repository contribution discovery (deterministic ref matching, patch-identity dedup, idempotent replay, extensive real-Git unit and stateful hypothesis tests) that fixes a real correctness/economic-integrity gap in the constitution's emission logic. Side A adds a genuinely useful GitHub external resolver and URL-normalization fixes, but includes large amounts of reformatting-only diff noise and is comparatively narrower in scope and risk-reduction value versus B's rigorous, adversarially-tested discovery mechanism underpinning payouts.

B replaces brittle GitHub-API commit listing with multi-repo git mirror discovery, immutable snapshots, patch-id cherry-pick dedup, force-push/replace-ref hardening, and replayable attribution wired into emissions—core constitutional infrastructure with deep unit, integration, and Hypothesis coverage. A adds real product value (URL identity policy, SystemIngest, on-demand GitHub resolver UI/tests), but much of the diff is formatting/churn around a feature layer rather than the ownership spine.

Side B replaces GitHub API-based commit discovery with deterministic multi-repository Git graph discovery, adding replayable `GitDiscovery` snapshots, patch-identity deduplication, repository/ref configuration, locking, and extensive adversarial/stateful tests that strengthen attribution correctness over time. Side A adds valuable URL normalization, an on-demand GitHub external resolver, system ingests, and UI support, but much of it is feature expansion, whereas Side B establishes a more durable foundation for reproducible ownership allocation and replay semantics.

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.