c_b0194743d156adde70

Side B fixes a real bug: it unifies two divergent storage representations of the tilde ontology root, adds normalization helpers, updates callers, and backs the fix with multiple new unit/integration/browser tests. Side A is a minor cleanup that simplifies a JS-builder function signature by dropping unused parameters, with no bugfix, tests, or lasting architectural value.

Side B fixes core canonical path/storage key inconsistencies (e.g. `https://slug.social/~` vs `~/` trailing-slash variants) that broke root child listings and sibling rankings, adding normalization helpers, call-site fixes, and multiple layers of unit/integration/browser tests. Side A only trims unused parameters and dead morph logic from a single JS helper—pure cleanup with no functional or lasting design impact.

Side B fixes a substantive canonical-path bug by unifying ontology root storage (`https://slug.social/~` vs `.../~/`), normalizing lookups, updating sibling/child ranking logic to use normalized keys, and centralizing tilde-path parsing. It also adds extensive unit, integration, and browser regression tests covering the fixed behavior, whereas Side A mainly removes parameters and stops updating the `#vote-compare-preview` HTML region, making it largely a cleanup/refactoring with limited lasting functional value.

Side A fixes a real, concrete bug (canonical tilde-root path normalization causing inconsistent HashMap keys for top-level items) with clear code changes plus targeted unit/integration/browser tests verifying the fix. Side B is a substantial infrastructure change to the ranking meta-system (per-commit vs per-contributor ranking) which is valuable but is self-referential tooling for the judging process itself rather than product code, and carries more diffuse churn across many call sites for a design change that is reasonable but not clearly 'lasting' in the same bug-fixing sense.

A delivers lasting product correctness: unifies tilde ontology root storage (`SLUG_TILDE_ONTOLOGY_ROOT`, `normalized_storage`, `tilde_http_path_to_canonical`), fixes map lookups/parent handling so garden root rankings and legacy `…/~/` keys work, and backs it with unit, integration, and browser regressions. B is a valuable constitutional refinement (pairwise per commit instead of bundled authors, rollup, epoch UI), but it mostly rewires existing ranking plumbing rather than fixing core domain behavior.

Side A fixes a substantive canonical-path bug by unifying ontology root handling (`https://slug.social/~` vs `.../~/`), normalizing storage keys before lookups, introducing shared path conversion helpers, and updating rendering logic so root pages and sibling rankings behave correctly. It also adds extensive unit, integration, and browser regression tests covering these cases, whereas Side B mainly changes the ranking workflow from contributor-level to commit-level with corresponding prompt, evidence, UI, and test updates but does not address a core correctness issue in the project itself.

B fixes a real correctness bug (root/tilde canonicalization mismatch causing top-level ontology children to be mis-keyed), adds targeted unit/integration/browser tests validating the fix, and introduces a clear invariant (SLUG_TILDE_ONTOLOGY_ROOT normalization) reused across modules. A is a substantial refactor moving fetch logic into a new SSE-based module with real functional improvement (async streaming, job-completion notification) but is mostly architectural churn/rename plus feature addition rather than a bugfix, and removes some existing test coverage without clearly stronger regression guarantees than B's added tests.

B fixes foundational CanonicalItemUrl storage identity (unifying `https://slug.social/~` vs `…/~/`, normalized_storage on rankings/lookups) so garden root children and sibling-rank actually resolve, with unit/integration/browser coverage. A is a large, useful fetch→SSE redesign plus module split and worker oneshots, but it mostly upgrades an already-working import path rather than correcting core graph key semantics.

Side B fixes a substantive correctness issue around canonical ontology root paths by introducing normalized storage for `~/`, updating lookups to use normalized keys, centralizing tilde-path conversion, and adding extensive regression tests covering root handling, rankings, and routing. Side A mainly refactors the fetch flow into an SSE-based implementation and reorganizes HTML helpers while adding logging and async plumbing, which is valuable but is largely an architectural/UI change rather than a fundamental correctness fix.

Side B fixes a real bug (inconsistent canonical URL forms for the tilde ontology root causing sibling-rank/child-lookup mismatches), adds targeted unit and integration tests plus a browser regression test, and documents the invariant clearly. Side A mostly removes an unrelated demo feature and adds a settlement-worker/caching refactor that is reasonable but riskier and less obviously validated (no new tests for correctness of the batching/caching logic), making B's fix more clearly a lasting correctness improvement.

A introduces lasting core infrastructure: a batched settlement worker for votes, ranking score caching with warm-on-boot, and read-only ranking panel paths, while stripping demo-counter scaffolding end-to-end. B is a real, well-tested canonicalization bugfix for tilde ontology root keys (normalized storage, garden root children/rankings), but it is narrower than A’s settlement/cache redesign of the vote and ranking hot path.

Side A replaces synchronous vote handling with a dedicated settlement worker that batches event logging and ranking recomputation, introduces cached ranking reads (`ranked_items_cached`) to avoid recomputing on every HTTP render, and removes obsolete demo-counter code and locking. Side B fixes canonical ontology root/path normalization and related garden rendering bugs with strong regression tests, but its impact is narrower than A's broader performance and architecture improvements.

Side A fixes a real security fail-open bug (votes falling back to anon on missing/expired session) with fail-closed logic, adds Secure cookie support, mock-OAuth gating, open-redirect hardening with tests, and nav UX—each backed by concrete tests. Side B is a legitimate but narrower bugfix (unifying tilde-root storage key variants) with good test coverage, but it's a more localized correctness patch versus A's broader security-critical hardening across auth, cookies, and vote integrity.

A delivers product-critical integrity: fail-closed vote auth (no silent anon fallback), mock OAuth gated behind env, Secure cookies, and tighter return-to sanitization—plus durable pinned by rev. B is a real lasting path-identity fix (tilde root normalization so garden child/rank lookups hit storage keys) with strong tests, but it is narrower domain plumbing than A’s multi-bug security/auth hardening.

Side A makes substantive security and correctness improvements: voting now fails closed instead of silently falling back to an anonymous actor, auth cookies gain the Secure flag when appropriate, mock OAuth is gated behind an environment flag, open-redirect sanitization is strengthened, and these behaviors are covered by tests. Side B fixes canonical tilde-path handling and root normalization across routing, ranking, and rendering with good regression tests, but its impact is narrower than the authentication hardening and session correctness changes in Side A.

Side A fixes a genuine multi-user correctness bug (shared sentinel delegate silently locking out other human voters) with a minimal, well-scoped change plus a targeted regression test proving the fix. Side B also fixes a real bug (inconsistent canonical root path causing lookup mismatches) but does so with a much larger, more invasive refactor across path types touching many call sites, which carries more risk despite good test coverage; both are solid but A's fix is more surgical and addresses a more severe functional defect (broken voting) with lower blast radius.

A removes false shared browser agent sentinels and models PendingSession.agent as Option, fixing multi-user votes blocked by AgentBound and aligning browser posts with real no-delegate humans; B mainly unifies tilde-root URL spellings and lookup normalization. A’s identity/delegate design change is the sharper, more product-critical correctness fix, while B is important path hygiene with more surface/tests but narrower lasting model impact.

Side B consolidates canonical path handling by introducing shared helpers (`tilde_http_path_to_canonical`, normalized ontology-root storage) and updates ranking, breadcrumb, and garden code to use normalized keys, fixing root-path inconsistencies and adding broad regression coverage. Side A correctly removes browser sentinel delegates by making pending-session agents optional and prevents shared delegate binding for browser users, but its scope is narrower than B's cross-cutting path normalization and routing improvements.

Side A fixes a real correctness bug (tilde ontology root canonicalization mismatch between HTML router, storage keys, and children lookups) and backs it with substantial new unit, integration, and browser tests validating the fix end-to-end. Side B adds a sizeable but clearly unfinished Reddit-fetch feature (background worker, OAuth, rate-limiting) accompanied by a stray 'todo' file listing many missing pieces (rendering, voting, nsfw gating), indicating scaffolding rather than a finished, load-bearing capability.

A fixes core path-identity bugs by unifying tilde ontology root storage (`SLUG_TILDE_ONTOLOGY_ROOT`, `normalized_storage`, `tilde_http_path_to_canonical`), so garden child rankings and sibling rank look up the same HashMap keys, with unit, integration, and browser regressions. B adds a real Reddit fetch worker (OAuth, rate limits, JSON parse) and wires `request_fetch` into browse, but that is an optional external integration plus a loose todo dump, not a lasting design fix to the product’s central graph/routing model.

Side A fixes canonical ontology path handling by introducing a shared `tilde_http_path_to_canonical` conversion, normalizing storage keys for the `~/` root, updating ranking lookups to use normalized keys, and correcting root-page behavior, backed by extensive unit, integration, and browser regression tests. Side B adds a substantial Reddit background fetch worker with OAuth and rate limiting, but it is largely new feature infrastructure without end-to-end validation and includes a placeholder TODO, whereas Side A directly resolves correctness bugs in core routing and ranking behavior with durable normalization logic.

Side A performs a broader architectural cleanup: splitting canonical_path/identity concerns, enforcing strict wire-form validation (rejecting `@` in API input), and consistently updating CLI/server/tests/types to match, which reduces ambiguity and hardens the API surface. Side B fixes a real but narrower bug (tilde ontology root normalization) with good test coverage, but its scope and lasting design impact are smaller than A's systemic identity/wire-format rework.

A delivers a lasting cross-cutting design: strict stored-form wire identity (no `@`), optional delegate, identity validation moved out of the reducer, and clean module splits (`identity` / `canonical_path`) applied through APIs, CLI, and types. B is a real, focused correctness fix (unify `https://slug.social/~` vs `…/~/` so garden root child lookups work) with solid tests, but it is narrower path-key normalization rather than a system-wide contract improvement.

Side A introduces a substantial architectural improvement by separating path normalization into `canonical_path.rs` and identity parsing into `identity.rs`, removing identity rewriting from the reducer, enforcing strict stored-form usernames/agent IDs at API boundaries, and making delegates optional throughout ingest and event handling. Side B fixes a real bug around canonical ontology root paths (`https://slug.social/~` vs `.../~/`), normalizes storage keys, and adds strong regression tests, but its impact is narrower and focused on one path-normalization issue rather than the broader API and data model redesign in Side A.

B fixes a real, subtle correctness bug (inconsistent canonical root URL representations causing sibling/child lookups to silently fail) with a well-reasoned normalization scheme, new unit/integration/browser tests, and clear documentation of the string-kind invariants. A is a legitimate security fix (HTML sanitization) with good targeted tests, but most of its diff is generated Cargo.lock noise from adding a heavyweight dependency (ammonia + ~40 transitive crates), making its actual code contribution much smaller than B's substantive path-handling fix.

B fixes foundational CanonicalItemUrl identity (legacy `…/~/` vs `…/~` root keys, normalized_storage, tilde_http_path_to_canonical) so garden child rankings and room/public root pages resolve correctly, backed by unit, integration, and browser tests. A is a real, precise XSS harden (ammonia at PreEscaped render sites plus targeted sanitize tests) but is localized to Reddit HTML embedding, whereas B corrects core path/storage design the app relies on everywhere.

Side A closes a concrete security vulnerability by sanitizing untrusted Reddit `body_html` with `ammonia` before every `PreEscaped` render, centralizing the logic in a new `html::sanitize` module and adding tests that verify scripts and event handlers are stripped while benign markup is preserved. Side B is a valuable correctness refactor that normalizes canonical ontology root paths, fixes routing/storage edge cases, and adds extensive regression tests, but its impact is narrower than preventing cross-site scripting in rendered user content.