c_6f04dcb2e38cfa536d

Side B removes a significant chunk of legacy dual-path projection logic (GitDiscovery-based commit/epoch rendering), simplifying the codebase to a single Evidence-envelope model, with corresponding test updates and required-field cleanup in the Emission dataclass — a substantive architectural simplification. Side A is a small, purely cosmetic HTML/view tweak (removing a heading and reordering a div) with no functional or structural impact.

B removes substantial legacy projection paths (_legacy_commit_row, GitDiscovery fallbacks on epoch/commit pages) and enforces Evidence-envelope-only rendering with matching test updates, a lasting schema/architecture cleanup. A only rearranges a few forum HTML nodes (heading/muted copy and error div placement) with no functional or design impact.

Side B makes a substantive architectural change by removing legacy GitDiscovery projection paths and requiring Evidence-envelope-backed data throughout commit and epoch pages, simplifying the data model and enforcing the current schema. It updates required Emission fields, rewrites page logic to consume evidence events directly, removes legacy compatibility code and tests, and adjusts integration tests accordingly, whereas Side A only removes or repositions UI elements in the forum view with little lasting functional impact.

Side B fixes a genuine XSS vulnerability (raw untrusted Reddit HTML rendered via PreEscaped) with a real, tested sanitization module applied at both render sites, which is a lasting security fix. Side A is a moderate refactor removing legacy projection code paths and simplifying evidence pages, which is useful cleanup but lower-impact than closing a script-injection hole, and much of B's diff (Cargo.lock) is generated noise rather than authored logic.

A removes dual-path legacy projection helpers (_legacy_commit_row, _legacy_observation) and all GitDiscovery/Emission fallbacks from epoch/commit pages and downloads, forcing Evidence envelopes only (with required Emission fields and updated tests), a lasting schema/design cleanup; B is a correct but narrower XSS fix that adds ammonia sanitization of body_html at two PreEscaped sites plus unit tests.

Side B fixes a concrete security issue by sanitizing untrusted Reddit `body_html` with the `ammonia` library before passing it to `maud::PreEscaped`, adds focused tests verifying scripts and event handlers are removed, and applies the protection consistently in both rendering paths. Side A primarily removes legacy GitDiscovery projection code and makes the application Evidence-only, simplifying behavior and updating tests/schema requirements, but it largely deletes compatibility logic rather than adding a broadly protective capability.

Side B removes a substantial amount of legacy dual-path projection code (GitDiscovery-based fallback rendering) across constitution.py, simplifying the evidence page logic to a single source of truth and updating tests/schema accordingly, which is a meaningful architectural cleanup with lasting maintainability benefit. Side A is a small, well-tested but narrow bugfix (skip pinned Reddit posts) that is useful but far more limited in scope and impact.

B removes the dual legacy/Evidence code paths (_legacy_commit_row, projected GitDiscovery UI, optional Emission fields) so epoch/commit pages and the schema only trust Evidence envelopes— lasting architectural simplification with matching test updates. A is a correct, well-tested filter for stickied/pinned Reddit children, but it is a narrow import tweak with far less project-wide impact.

Side B removes the legacy GitDiscovery projection path across epoch, commit, and patch views, making the application rely solely on Evidence envelopes, tightening required Emission metadata, and updating integration/tests to match the current schema. Side A is a solid targeted bug fix that skips stickied/pinned Reddit posts during subreddit import and adds regression tests, but its impact is narrower than the project-wide simplification and consistency introduced by Side B.

Side A implements a substantial new feature (fractal ItemId tree, journal worker replacing settlement, breadcrumb navigation, reddit entity scaffolding) with new tests and coherent architecture across many files, delivering real forward-looking capability. Side B is a cleanup commit removing legacy projection code paths in a meta/governance codebase, which is valuable for simplifying maintenance but is narrower in scope and mostly deletes/adjusts existing logic rather than building new lasting functionality.

Commit A replaces flat string scopes with a hierarchical ItemId/GlobalTree model, path canonicalization, journaled tree votes, breadcrumbs, and related UI—foundational product architecture. Commit B mainly deletes legacy GitDiscovery/Emission projection shims so epoch/commit pages read Evidence envelopes only, plus matching test/fixture cleanup; valuable schema hygiene but narrower and largely subtractive.

Side A introduces a substantial architectural shift from flat scope-based rankings to a hierarchical `ItemId`/`GlobalTree` model, adds canonical URL parsing, breadcrumb navigation, node persistence, and a journal worker while updating UI and state handling to support tree-structured rankings. Side B mainly removes legacy compatibility paths and requires evidence-only records in the ledger/UI, simplifying code and tests but primarily deleting fallback behavior rather than adding new core capabilities.

Side A ships a working feature (vote page redirect, typed form holes, slider UI, CSS/JS) with tests exercising new behavior, adding real user-facing value. Side B is a solid cleanup removing legacy projection code and simplifying epoch/commit views, which is valuable but more narrowly a refactor/removal rather than new lasting capability; both are reasonable but A's net new functionality edges out B's cleanup.

B removes dual-path legacy GitDiscovery/Emission projection from epoch and commit pages, making Evidence envelopes the sole source of truth and tightening Emission required fields—lasting schema integrity over compatibility shims. A adds real product surface (typed $form:i32 holes, vote CTA/nav/slider, deps/routes) but is partly wiring/UI and a vaguer “fix,” so it trails B’s architectural permanence.

Side A introduces substantive application functionality: typed form-template substitution for integer fields with tests, a new post-vote navigation flow via the `next` field, UI support for a vote slider, and wiring for a new `/vote` page with related dependencies and styling. Side B mainly removes legacy GitDiscovery projection paths so pages rely only on Evidence envelopes, simplifying code and updating tests, but it is largely a cleanup/schema migration rather than adding enduring user-facing capability.

Side A replaces an ad-hoc, per-domain if/else URL normalizer with a cleaner, more principled graph-based parser (DFA + generic fallback), improving the actual product's core canonicalization logic while preserving test coverage intent. Side B is mostly internal admin/debug page cleanup (removing legacy projection code paths and adjusting tests/docs), which is useful maintenance but lower-impact and more narrowly scoped to internal tooling.

Side A replaces ad-hoc URL combinators (engine.rs ParsedUrl pipeline and per-domain normalize_* functions) with a graph/DFA-based canonicalization API wired through registry (graph(), resolve_canonical, breadcrumbs), which is lasting core domain design. Side B is valuable cleanup—dropping _legacy_commit_row/_legacy_observation and GitDiscovery projections so epoch/commit pages use Evidence only—but it mainly removes compatibility paths and tightens Emission fields rather than adding new capability.

Side B makes a substantive architectural cleanup by removing legacy GitDiscovery projection paths, requiring evidence metadata in `Emission`, simplifying epoch/commit endpoints to use Evidence envelopes only, and updating tests to enforce the new model. Side A is primarily a refactor that replaces the old URL engine with new graph/parse modules and updates documentation and tests, but the patch shown mostly removes the previous implementation while delegating behavior elsewhere, making its lasting functional impact less directly evident.

Side B is a small, surgical bugfix that removes a real NameError crash risk in an auth flow by defining GITHUB_API_BASE_URL, providing immediate correctness value with near-zero risk. Side A is a larger refactor removing legacy projection code and updating tests/docs, which is valuable cleanup but riskier (data migration implications, broader behavior change) and less clearly a pure bugfix.

A removes dead legacy GitDiscovery projection paths and forces Evidence-envelope-only epoch/commit pages, tightening Emission fields and tests—substantive lasting design cleanup. B only defines the missing GITHUB_API_BASE_URL constant (a real but one-line NameError fix) with far less structural impact.

Side A makes a substantial architectural cleanup by removing legacy GitDiscovery projection paths, requiring evidence metadata on Emission records, simplifying epoch/commit pages to operate only on Evidence envelopes, and updating tests to match the new invariant. Side B fixes a real bug by defining GITHUB_API_BASE_URL to avoid a NameError, but it is a small localized configuration fix compared with A's broader, lasting simplification of the evidence model.

Side B removes a substantial amount of legacy dual-path code (GitDiscovery projection fallbacks) across the evidence rendering system, simplifying epoch/commit views to a single canonical Evidence-envelope source and updating tests accordingly, which is a meaningful architectural cleanup with real behavioral impact. Side A is a smaller, self-contained refactor (deque to vec) that fixes a subtle correctness improvement (query-time capping vs write-time truncation) but touches less surface area and lower-stakes code.

B removes an entire dual-path legacy projection (GitDiscovery/Emission inventing epoch/commit pages) and forces Evidence-envelope-only reads, tightening Emission required fields and tests—lasting correctness for the ledger model. A is a sound but narrower storage refactor (Deque→List/Vec, trim-on-write→cap-on-read) that simplifies recent_votes without the same system-level invariant payoff.

Side B removes the application's legacy GitDiscovery projection path and makes evidence envelopes the only supported source across epoch, commit, and patch views, simplifying the data model and eliminating fallback code. It also tightens the Emission schema by requiring evidence-related fields and updates tests accordingly, whereas Side A mainly changes recent-vote storage from a deque to an append-only list with query-time capping and removes trimming logic, a more localized internal refactor despite adding a useful regression test.

Side A fixes a real, user-facing bug (attribution text leaking into DSL body, silent fallback to entire item pool producing nonsensical pairs, dead swap button) and cleanly renames a route across code and tests, all verified by adjusted integration tests. Side B is a substantial internal refactor removing legacy projection code for an evidence/ledger system, which is reasonable cleanup but is narrower in scope (affects one internal admin/evidence UI) and mostly deletes now-unneeded fallback logic rather than fixing an active correctness bug affecting end users.

B removes an entire dual-path legacy projection layer (_legacy_commit_row/_legacy_observation and GitDiscovery/Emission fallbacks on epoch/commit pages), making Evidence envelopes the sole source of truth and tightening Emission required fields—durable architectural cleanup. A’s real wins are the out-of-band delegate attribution fix and stopping the bad all-items fallback, but they sit beside lower-impact renames and UI chrome removal, so less structural lasting value.

Side B removes the legacy GitDiscovery projection path and makes the evidence model authoritative by requiring emission metadata fields, deleting fallback lookup code, simplifying epoch/commit pages to use Evidence events only, and returning not-found instead of synthesizing historical views. In contrast, Side A mixes one real behavior fix (avoiding fallback to all items when the sibling pool is too small and passing delegate attribution out-of-band) with lower-impact UI and routing changes such as removing the swap button and renaming `/vote/compare` to `/vote`.

Side B removes a substantial legacy code path (dual GitDiscovery/Evidence projection logic across epoch/commit views), simplifying the data model to a single canonical evidence-envelope source of truth, with corresponding test updates reflecting the new invariant. Side A is a valuable but narrower bugfix (regex vs string split, request body stream fix, defensive nils, error handling) that restores test infrastructure correctness but doesn't change production architecture or reduce long-term maintenance burden as much.

B removes dual-path legacy GitDiscovery projection helpers and epoch/commit page fallbacks, making Emission fields required and forcing Evidence-envelope-only reads—a lasting schema cleanup that shrinks core surface area. A only patches test mocks (query split regex, getRequestBody, nil-safe token/state handling) plus minor Playwright selector tweaks so E2E auth runs again, which is useful but confined to test support.

Side B removes the legacy GitDiscovery projection path and makes the evidence model authoritative by requiring emission metadata fields, deleting fallback lookup code, and updating epoch/commit pages to rely only on Evidence events. Although it is a larger schema and UI cleanup that requires test updates, it simplifies long-term maintenance by eliminating dual code paths, whereas Side A primarily repairs OAuth test infrastructure with targeted fixes such as request parsing, redirect handling, null checks, and Playwright selector updates.

Side B removes dead legacy-projection code paths (dual code for GitDiscovery vs Evidence envelopes), simplifies epoch/commit detail pages to a single source of truth, and updates tests/schema accordingly, reducing long-term maintenance burden. Side A is a solid internal refactor (newtype Deref, CanonicalItemUrl threading) that improves type safety but is more mechanical churn with less architectural simplification than B's removal of an entire legacy compatibility layer.

B removes legacy GitDiscovery projection paths so epoch/commit UI and APIs only surface real Evidence envelopes, tightens Emission required fields, and updates tests—an enduring correctness boundary with intentional ledger impact. A is valuable type plumbing (Deref on href newtypes, CanonicalItemUrl through resolve_item/validate/RPC) that cuts string wrap/unwrap noise, but it mostly refines an already-working model rather than changing what the system of record is allowed to claim.

Side A strengthens the project's type safety by changing `resolve_item` to return `CanonicalItemUrl`, propagating canonical URL types through ranking, validation, connectivity, and pair-selection code, and adding `Deref<Target=str>` for URL newtypes to reduce string conversions. Side B removes legacy GitDiscovery projection paths and requires Evidence-only data for epoch/commit pages, simplifying the codebase but intentionally dropping backward compatibility and mainly affecting presentation and historical data handling.

Side B fixes a real, deployable bug (hardcoded staging URLs breaking OAuth callbacks and redirects on custom hosts) by consolidating logic into a single util.get-base-url and using window.location.origin, unifying six duplicated hostname-detection functions and correcting the deploy workflow trigger. Side A is a substantial but purely internal refactor (removing legacy projection code and adjusting evidence-page rendering) that improves code cleanliness but has no external-facing bugfix impact and mostly shifts complexity rather than eliminating real defects.

A removes dual-path legacy GitDiscovery projection from epoch/commit pages, deletes _legacy_* helpers, and makes Emission evidence fields required—enforcing a single lasting Evidence-envelope model with updated tests. B usefully consolidates hardcoded OAuth/redirect base URLs behind HOSTNAME/window.location.origin and flips Fly deploy to staging, but that is incremental host/deploy hygiene versus A’s core schema and read-path simplification.

Side A removes the legacy GitDiscovery projection path and makes the application consistently evidence-driven: it deletes fallback lookup code, simplifies epoch/commit pages to require Evidence envelopes, makes Emission evidence metadata required, and updates tests to enforce the new behavior. Side B is a useful infrastructure/configuration cleanup that centralizes base URL generation via a shared utility, uses the current browser origin for frontend redirects, and adjusts deployment to the staging branch, but its impact is narrower and primarily configuration-oriented.

Side B removes a fragile legacy-projection code path (dead branching, ambiguous fallback logic) in favor of a single well-defined Evidence-envelope source of truth, simplifying multiple endpoints and updating tests/schema fields consistently, which is a real architectural cleanup with lasting maintainability value. Side A is a focused feature/UI improvement (fullscreen vote-compare page, edge-history sorting/legend) that's useful but more localized and cosmetic, touching CSS/markup without addressing core data-model correctness.

B permanently collapses dual-path epoch/commit rendering to Evidence envelopes only—deleting _legacy_commit_row/_legacy_observation and GitDiscovery projections, tightening Emission fields, and updating tests—so the ledger UI has one durable source of truth. A’s fullscreen compare shell, edge-history sort/ratios, and post-success preview morph are real product polish with tests, but they layer feature UX on garden voting rather than removing systemic ambiguity.

Side B removes the legacy GitDiscovery projection path and makes the evidence model authoritative by requiring evidence metadata on Emission, simplifying epoch/commit pages to rely only on Evidence envelopes and updating tests accordingly. Side A improves the vote-compare UI with a fullscreen layout, better edge-history sorting/display, and live preview updates after posting, but those are primarily user-interface enhancements rather than a core architectural simplification.

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 A removes dual legacy/evidence code paths, simplifying the ledger/epoch/commit views to a single canonical source of truth and updating tests accordingly, which reduces long-term complexity and bug surface. Side B is a reasonable UX improvement (inline auth feedback via innerHTML morphing) but is smaller in scope and mostly localized to one feature, with less structural cleanup value.

A removes the entire legacy GitDiscovery/Emission projection path (_legacy_commit_row, dual epoch/commit rendering, optional Emission fields) so pages and APIs read only Evidence envelopes—a lasting schema/design simplification with matching test updates. B is a solid but narrower UX change: auth POSTs return HTML fragments and poem JS morphs form innerHTML instead of redirecting, plus minor CSS—valuable polish, not core model cleanup.

Side A makes a substantive architectural cleanup by removing legacy GitDiscovery projection paths and requiring evidence-backed metadata, simplifying epoch/commit views to rely only on Evidence events and updating tests to enforce the new model. Side B improves the authentication UX by replacing redirects with inline HTML fragments and extending the shared JS form handler, but its impact is more localized to the web interface than A's system-wide data model and maintenance simplification.

Side A performs a genuine architectural consolidation: it removes a 362-line duplicated web_post.rs module, unifies three separate POST endpoints into a single RPC-dispatched /ui handler with a shared session-resolution helper, and updates all call sites (routes, templates, integration tests, fixture) consistently. Side B mostly deletes legacy fallback branches in one file (constitution.py) for cleanliness, which is useful but narrower in scope and forces a production ledger wipe due to now-required Emission fields, making it a riskier, less self-contained change than Side A's thorough end-to-end dedup.

A completes a real architectural migration: deletes the separate `/post` stack and `web_post.rs`, consolidates auth into `resolve_web_session`/`WebSession`, and routes browser ingest/check/redact through a single `POST /ui` + `__rpc__` path with matching HTML/JS and tests. B is a worthwhile correctness cleanup (drop GitDiscovery legacy projection, require Emission evidence fields), but it is mostly deletion of display fallbacks rather than a multi-surface design change of comparable scope.

Side B removes the legacy GitDiscovery projection path and makes the evidence model authoritative by requiring emission metadata, deleting fallback lookup code, and simplifying epoch/commit pages to rely only on Evidence events. This is a substantive architectural cleanup that eliminates dual data paths and updates tests accordingly, whereas Side A is largely a large-scale refactor consolidating web posting into the `/ui` RPC flow with mostly equivalent behavior moved between modules.

Side B removes a real architectural inconsistency (dual legacy/Evidence code paths for epoch/commit rendering), simplifying and hardening the evidence system with corresponding test updates across Python and Clojure, which is a substantive correctness/maintainability improvement. Side A is a solid but narrower refactor (dropping theme switching, adding /~/ browse routes) that is useful but smaller in scope and impact than B's cross-cutting cleanup of legacy projection logic.

B removes legacy GitDiscovery projection paths and helper functions that invented epoch/commit history, enforcing required Evidence envelopes and schema fields on Emission while simplifying the detail pages and tests to a single source of truth. A mainly deletes the incomplete theme cookie/CSS/form machinery and renames static assets, with the /~/ browse_href routing as a useful but narrower URL cleanup.

Side A introduces a durable routing and URL design improvement by replacing query-based item navigation with canonical browse paths (`/~/...`), centralizing link generation/parsing in `ItemId` (`browse_href`, `from_browse_uri`), updating redirects, and adding integration tests. Side B mainly removes legacy compatibility code to make the system Evidence-only and simplifies related pages, which is a meaningful cleanup but is more of a schema transition than a broadly reusable architectural enhancement.

Side A removes an entire legacy projection code path (dead GitDiscovery-based rendering), simplifies epoch/commit pages to a single Evidence-only contract, and rewrites tests to match the new schema — a clear architectural simplification reducing future maintenance burden. Side B is a useful but more incremental UI fix (vote-count badges, unpin-via-POST instead of link) bundled with theme CSS tweaks and a browser test, valuable but narrower in scope than A's structural cleanup.

A removes legacy GitDiscovery/Emission projection paths and makes Evidence envelopes the sole source for epoch/commit pages, tightening Emission required fields and tests—a lasting schema/design cleanup of core ledger honesty. B improves garden UX (vote counts on edges, HUD unpin via POST clear) with solid tests, but it is incremental product polish rather than foundational correctness.

Side A makes a substantive architectural change by removing legacy GitDiscovery projection paths and requiring Evidence-envelope-backed data throughout the epoch and commit pages, simplifying code, eliminating fallback logic, tightening the Emission schema, and updating tests accordingly. Side B adds useful UI improvements (vote counts, HUD unpin action, related styling, and tests), but these are feature enhancements rather than a foundational cleanup of the project's data model and evidence handling.

Side A fixes a real deadlock bug (nested RwLock read guard held across match, causing potential deadlock) with a concrete, correct restructuring plus a regression test, and hardens test infra with HTTP timeouts and safer process logging to avoid hangs. Side B is a larger cleanup that removes legacy projection code for clarity/consistency, which is valuable but is more refactor/simplification than a bugfix, and mostly trades one code path for another rather than fixing user-facing correctness issues.

A fixes a real tokio RwLock deadlock by scoping read guards so they drop before nested lock acquires in RoomCreate/RoomGrant, and backs that with a room-create RPC test plus harness fixes (log-file redirection to avoid pipe-buffer deadlocks, HTTP timeouts). B is worthwhile cleanup—dropping legacy GitDiscovery projection and forcing Evidence-only pages—but it is largely deletion of transitional UI/API paths and test rewrites after an intentional ledger wipe, so it adds less critical lasting correctness than the concurrency and reliability fixes.

Side A fixes a concrete concurrency bug by ensuring Tokio RwLock read guards are dropped before nested read/write awaits, preventing deadlocks in RPC handlers for room creation and grants, and adds an integration test covering room creation. The remaining changes improve test reliability and align expectations with stored usernames. Side B is primarily a schema/UI cleanup that removes legacy GitDiscovery projection paths and requires evidence-only records, updating tests accordingly; while valuable for maintainability, it mostly deletes compatibility code rather than fixing a core runtime issue.