c_97611919bf0ba6a9d8

Side A is a trivial one-line DOM reorder (moving the errors div), whereas Side B performs a substantial, load-bearing refactor: it removes CanonicalItemUrl entirely in favor of a structural ItemId enum, splits wire normalization into a new item_wire module to avoid cycles, updates the reducer, ranking, RPC, and HTML layers consistently, and updates/extends the test suite accordingly. Side B is riskier but represents real architectural progress toward the stated ItemId/RouteContext migration goal, while Side A contributes negligible lasting value.

B introduces a structural ItemId enum (with parse/parent/display, wire split, and Opaque/Root/Local/Web variants), deletes CanonicalItemUrl, and propagates the type through reducer, ranking, RPC, HTML, and tests—real lasting architecture. A only moves one errors div in new_thread markup (cosmetic DOM order nit with negligible permanence).

Side B performs a substantial architectural refactor by introducing a first-class `ItemId` type, extracting item normalization into `item_wire`, and migrating reducer, ranking, routing, RPC, validation, HTML, and tests away from `CanonicalItemUrl`. This changes the project's core identity model and link-generation APIs with broad, lasting impact, whereas Side A only moves the placement of the `div id=(ERRORS_ID)` within the HTML form without changing functionality.

Side A is a substantial, coherent refactor introducing a structural ItemId enum to replace the stringy CanonicalItemUrl newtype, touching reducer, ranking, RPC, and HTML layers consistently with new modules (item_id.rs, item_wire.rs) and updated tests, representing real architectural progress. Side B is a small, useful bugfix (off-by-one/expect vs unwrap_or for thread_post_index) but is narrow in scope and lower lasting impact compared to A's broader identity-model overhaul.

A lands the structural ItemId type (replacing CanonicalItemUrl), splits wire normalization, and migrates reducer/ranking/RPC/HTML/tests so identity is typed end-to-end—lasting core design. B only drops a 1-based/fallback thread_post_index path to a strict 0-based index with tests/docs, a small correctness polish relative to A.

Side A replaces the pervasive `CanonicalItemUrl` string wrapper with a structural `ItemId` type, introduces dedicated `item_id.rs`/`item_wire.rs` modules, and propagates the new identity model through reducers, ranking, routing, APIs, HTML, and tests. Side B is a focused correctness change that makes `thread_post_index` consistently 0-based and asserts an invariant with `expect`, but its impact is limited compared with the project-wide architectural improvement in Side A.

Side A is a pure mechanical file-split/rename of forum.rs into submodules with no behavioral change, offering only marginal maintainability value. Side B implements a substantive type-safety refactor (CanonicalItemUrl -> structural ItemId enum) touching the reducer, ranking, RPC, and tests, which is a real design improvement with lasting architectural value despite some rough opaque-fallback edges.

B replaces the CanonicalItemUrl string newtype with a structural ItemId enum and wires it through reducer maps, ranking, RPC, garden/HTML, and tests, which is a lasting domain/identity design change; A mainly deletes a leftover forum.rs and finishes a file split into forum/* with almost no behavior change beyond module-root hygiene.

Side B performs a broad architectural refactor by introducing a structured `ItemId` type, replacing `CanonicalItemUrl` across reducer state, ranking, RPC, routing, HTML, tests, and type exports, enabling stronger typing and reducing string-based identity handling. Side A mainly removes a duplicate `forum.rs` and formalizes `forum/mod.rs` as the sole module root—a useful cleanup that fixes module resolution ambiguity, but it largely reorganizes existing code rather than changing core project capabilities.

Side A ships a coherent, working improvement: it removes dead demo scaffolding and introduces a real settlement-worker architecture (batched writes, cached ranking scores, warm cache on boot) that fixes a genuine performance/correctness concern (recomputing ranking on every read), with matching test updates. Side B is a large structural refactor (CanonicalItemUrl -> ItemId) that touches many files but is mostly mechanical renaming/type-swapping with fallback `unwrap_or_else(ItemId::opaque(...))` hacks scattered around, indicating an incomplete/risky migration, and it deletes a large unexecuted plan.md rather than completing the plan it describes.

A adds a real settlement worker (batched votes, disk append, then ranking recompute into cached_scores), a warm-cache/hot-path split (ranked_items_cached + read locks), and deletes the demo-counter scaffold—lasting concurrency and HTTP design. B is mostly a CanonicalItemUrl→ItemId mechanical migration (plus plan.md deletion); the enum is useful, but internals stay string-backed and behavior largely unchanged, so less net product value per change than A.

Side A delivers substantial architectural improvements: it introduces a background settlement worker that batches vote persistence and ranking recomputation, adds cached ranking reads (`ranked_items_cached`) to avoid recomputing on every HTTP request, and switches ranking rendering from write locks to read locks. It also removes the temporary demo counter and related event/UI code, whereas Side B is primarily a broad type migration from `CanonicalItemUrl` to `ItemId` with widespread mechanical call-site updates and limited new behavior beyond the new identity type.

Side B is a substantial, structural refactor (CanonicalItemUrl -> ItemId enum) touching reducer, ranking, RPC, and types crates with updated tests throughout, which is a deeper architectural investment even though it's riskier and less polished (e.g. Opaque fallback variant, unwraps). Side A is a small, well-scoped UI feature (clickable unpin icon) with a matching CSS and browser test update, useful but narrow in scope and impact compared to the identity-model overhaul in B.

B replaces CanonicalItemUrl with a structural ItemId across types, reducer, ranking, RPC, and HTML and removes the migration plan—core lasting design. A only wires unpin POST forms/CSS/tests onto ranked-child pin glyphs, a small UX surface on an existing flow.

Side B replaces the pervasive `CanonicalItemUrl` string wrapper with a structured `ItemId` type across the reducer, ranking, routing, RPC, path handling, and tests, while adding dedicated `item_id`/`item_wire` modules and updating APIs to use the stronger abstraction. Side A is a useful, well-tested UX improvement that makes ranked child-group pin icons submit the existing unpin flow and adjusts CSS, but its scope is limited to a single interaction whereas Side B establishes a foundational identity model used throughout the project.

Side A performs a substantial structural refactor introducing a typed ItemId enum to replace stringy CanonicalItemUrl across the reducer, ranking, RPC, and HTML layers, plus splitting wire-normalization logic into item_wire.rs, touching many core files and tests consistently. Side B is a smaller but genuinely useful bugfix to test-only mock OAuth/reddit servers and Clojure test helpers (fixing regex splits, request body vs input stream, redirect codes, error handling), which is real but narrower in scope and confined to test infrastructure rather than production code.

Commit A lands the core ItemId redesign (new item_id/item_wire modules, removal of CanonicalItemUrl, and propagation through reducer, ranking, RPC, and HTML), a lasting domain-model improvement. Commit B only repairs OAuth/Reddit test mocks and a few Playwright helpers (query split, getRequestBody, redirect length, null-safe token/state), which restores E2E auth but is narrower test-infrastructure value.

Side A performs a substantial architectural migration from the string-based `CanonicalItemUrl` to a structured `ItemId` across reducer state, ranking, routing, APIs, and tests, while introducing new `item_id` and `item_wire` modules and updating link generation to use typed identities. Side B fixes important OAuth test infrastructure issues (query parsing, request body reading, redirect handling, null checks, and mock robustness), but those changes are confined to test mocks and E2E reliability rather than the project's core design.

Side A delivers a working, tested feature (RocksDB-backed entity payload offloading and streaming event log replay) with new module, real tests, integration test updates, and a genuine startup-RAM benefit; the vendored 'durable' crate is a real dependency addition despite the noisy Cargo.lock diffs. Side B is a large but purely mechanical rename/refactor (CanonicalItemUrl -> ItemId) that touches many files without adding new capability, and much of the diff is boilerplate churn plus deletion of a stale plan.md. A's change is more load-bearing (actual memory/behavior improvement) versus B's cosmetic-but-wide type rename.

Side A lands a lasting architectural win: offloading Reddit entity JSON into a RocksDB-backed EntityStore, vendoring the durable crate, and replacing bulk load_all with line-at-a-time event_log.replay so startup no longer holds the full log and payloads in RAM. Side B is a broad but mostly mechanical CanonicalItemUrl→ItemId refactor (plus deleting plan.md); it improves type structure without the same operational/scalability impact.

Side A delivers concrete infrastructure improvements: it introduces a reusable `durable` RocksDB-backed storage crate, moves raw Reddit entity JSON out of the in-memory tree into an `EntityStore`, and replaces full event-log loading with line-by-line replay to reduce startup memory usage. Side B is a broad `CanonicalItemUrl` → `ItemId` refactor with routing and API updates that improves type structure, but it is primarily an internal representation change, whereas A directly adds durable storage and measurable runtime behavior improvements.

Side B ships concrete, testable value: it fixes a real bug where private-room item/thread URLs in RPC responses were always emitted as public-scope paths (ambiguous/broken for room-scoped API consumers), adds new unit tests for that fix, and implements a proper server-rendered theme-cookie mechanism (replacing pure client-side localStorage switching) wired through all page handlers. Side A is a large but largely mechanical rename/refactor of `CanonicalItemUrl` into an `ItemId` enum whose variants all just wrap `String`s (little added type safety), is behaviorally equivalent to before, and its main artifact of substance—deleting a planning doc—doesn't itself add project value; per the stated preference for real bugfixes over renames/churn, B edges out.

A replaces the stringly CanonicalItemUrl newtype with a structural ItemId enum (plus item_wire split), then propagates it through reducer maps, ranking, VoteData, RPC, and HTML—removing CanonicalItemUrl and encoding identity vs presentation in the domain model. B improves theme persistence (cookie + POST /theme + server-side layout) and adds room-aware RPC path helpers, which is useful polish and a real private-room URL fix, but is mostly presentation/wiring rather than lasting core design.

Side A performs a foundational identity refactor by introducing a structural `ItemId` type, extracting normalization into `item_wire`, and propagating the new type through the reducer, ranking, routing, RPC, HTML, and tests. Side B adds useful theme persistence and room-aware URL generation, but its changes are primarily UI and presentation plumbing, whereas Side A changes the project's core data model and eliminates widespread dependence on `CanonicalItemUrl` strings.

Side A completes a substantial, well-documented type-safety refactor (CanonicalItemUrl -> ItemId) across the whole codebase with consistent updates to reducer, ranking, RPC, HTML, and tests, removing a stringly-typed newtype in favor of a structured enum with proper serde/Ord semantics. Side B adds a real feature (vote comparison UI with morph updates, pair-selection logic, and tests) which is valuable but narrower in scope and more localized to one UI flow, making it a good but less foundational contribution than A's systemic identity-model overhaul.

Side A delivers the structural ItemId enum (with item_wire split), fully migrating reducer maps, ranking, RPC, HTML routing, and tests off CanonicalItemUrl—core lasting identity design. Side B adds a valuable /vote compare UX, bridge-aware pair picker, and morph path, but is a feature layer on top rather than foundational type/architecture work.

Side A performs a project-wide architectural migration from `CanonicalItemUrl` string keys to a structured `ItemId`, adding the new `item_id`/`item_wire` modules and propagating the type through reducers, ranking, routing, APIs, HTML, and tests while preserving normalization and serialization behavior. Side B adds a useful vote comparison UI, pair-selection logic, and related tests, but its scope is primarily a feature layer, whereas Side A changes the project's core identity model in a way that is likely to support many future features and reduce string-based errors.

Side A performs a substantive, coherent type-system refactor (introducing ItemId, splitting item_wire, updating dozens of call sites and tests consistently) that improves identity handling across the codebase, deleting a stale plan doc as a bonus. Side B merely adds deployment scaffolding (Dockerfile, fly.toml, deps.edn) and two orphaned .rs files (event_log.rs, views.rs) placed at the repo root rather than integrated into any crate module, making their actual project impact unclear or possibly non-functional.

A replaces the CanonicalItemUrl string newtype with a structural ItemId enum (Root/Local/Web/Opaque), splits wire normalization into item_wire, and migrates reducer maps, ranking, RPC, HTML routing, and tests onto typed identity—core lasting design. B mainly seeds deploy scaffolding (Dockerfile, fly.toml), Clojure deps.edn, and small standalone event_log/views modules, which help bootstrap ops but do not reshape the domain model.

Side A performs a substantial architectural refactor by introducing a structural `ItemId` type, extracting wire-normalization into `item_wire`, and propagating the new identity model throughout reducers, ranking, routing, APIs, HTML, and tests while replacing `CanonicalItemUrl`. These changes centralize item identity and routing logic (for example `RouteContext::item_href` and `ThreadNav::garden_item_href`) and reduce string-based handling. Side B adds useful deployment artifacts (Dockerfile, Fly config) and standalone persistence utilities (`EventLog`, `ViewStore`), but they are largely additive infrastructure and are not integrated into the project's core behavior in this patch.

B is a substantive, correctness-focused type refactor (CanonicalItemUrl -> ItemId) that touches the core reducer/ranking/RPC layers with real design tradeoffs (enum variants, parent/tilde logic, serde) and includes updated tests, representing durable architectural investment. A is mostly deploy/ops scaffolding (Dockerfile, fly.toml, CI) plus a UI/audit-feed feature layered on existing code—useful but more additive/operational than foundational, with much of the diff being CSS/JS glue rather than core logic changes.

A ships production deployment (Fly/Docker/CI), a real /watch audit UI with SSE progress, epoch failure recovery, and multi-repo/contributor config—turning the constitution into a live, operable system. B is mostly a CanonicalItemUrl→ItemId migration across the slug server; the enum still largely wraps strings plus Opaque fallbacks, so it is valuable typing cleanup but less net product durability than A.

Side B introduces a durable architectural change by replacing the string-based `CanonicalItemUrl` with a structured `ItemId` type, propagating it through the reducer, ranking, routing, RPC, and tests while extracting shared normalization into `item_wire.rs`. Side A adds valuable deployment infrastructure, production configuration, and a live audit dashboard with SSE/status APIs, but much of its impact is operational and UI-oriented, whereas B changes the project's core identity model in a way that simplifies future development and reduces reliance on ad hoc string handling.

Side B ships a real feature (Reddit OAuth linking, UUID-centric identity, private linked-provider display, session/link-conflict handling) with corresponding server, test-harness, and mock-server updates, delivering concrete new user-facing capability. Side A is a large but purely mechanical rename/refactor (CanonicalItemUrl -> ItemId) that preserves existing behavior and even deletes its own planning doc, providing structural cleanup but no new functionality or bugfix of comparable weight.

Commit A lands a core domain redesign: a real ItemId type (Root/Local/Web/Opaque), split wire normalization (item_wire), and end-to-end replacement of CanonicalItemUrl across reducer maps, ranking, RPC, HTML routing, and tests—foundational structure used everywhere items are keyed. Commit B is valuable product/auth work (Reddit OAuth, multi-provider link-to-UUID, private linked-provider UI, pending trust weights in projection batches) but is narrower in blast radius than rewriting item identity through the graph.

Side A introduces a new `ItemId` type with parsing, serialization, parent/display logic, extracts wire-normalization into `item_wire.rs`, and propagates the new identity model throughout reducers, ranking, routing, HTML, and tests, replacing `CanonicalItemUrl` across the project. Side B adds valuable Reddit OAuth support and a UUID-centric account-linking flow with provider linking and trust-weight updates, but it is a feature-focused authentication enhancement rather than the broad foundational identity and API refactor in Side A.

Side A introduces a genuinely new, composable url_rules engine (ParsedUrl combinators + per-domain registry) with real behavior additions (YouTube canonicalization, tracking-param stripping, alias tracking) plus tests, replacing ad-hoc string canonicalization with a more maintainable design. Side B is a large but mostly mechanical rename/refactor (CanonicalItemUrl -> ItemId enum) that changes call sites and tests extensively without adding new normalization capability, and even removes a planning doc (plan.md) that documented intended future work, reducing net lasting value relative to its churn.

Commit A adds lasting design: a composable `url_rules` engine/registry, scheme-bearing canonical ItemIds, smarter parent/breadcrumb rules, and real domain normalizers (Reddit + YouTube), not just renames. Commit B’s ItemId enum and CanonicalItemUrl removal improve type structure across reducer/RPC/HTML, but most of the diff is mechanical type propagation with similar string-backed keys and little new behavior.

Side A delivers new behavior: it introduces a composable URL canonicalization/rules engine (`server/src/url_rules`), makes full `https://` URLs the canonical identity, centralizes parsing/parent/breadcrumb logic, updates projection/event handling to canonicalize IDs at apply time, and adds tests for Reddit/YouTube normalization and breadcrumb behavior. Side B is a broad architectural refactor replacing `CanonicalItemUrl` with `ItemId` across the codebase and moving wire helpers into new modules, but most changes are type migration and call-site updates rather than adding new user-visible functionality or fixing concrete bugs.

Side A is a large mechanical rename (CanonicalItemUrl -> ItemId) that reorganizes types but adds little new behavior, and it deletes a large planning doc that itself documents the refactor's incompleteness (e.g. leaving CanonicalItemUrl references, opaque fallback hacks). Side B implements a concrete, well-tested algorithmic improvement (component-aware pair selection with established/isolate sub-priorities and rank-zip refinement) that directly improves product behavior and is validated with new targeted unit tests, making it more durable, self-contained value.

A lands the durable ItemId design (new item_id/item_wire modules, removal of CanonicalItemUrl, and reducer/ranking/RPC/HTML keyed on structured identity), which reshapes the project’s core data model. B is a high-quality, well-tested improvement to pair selection heuristics in pair.rs, but its impact is confined to one algorithm versus A’s foundational type migration.

Side A performs a substantial architectural migration from string-based `CanonicalItemUrl` keys to a structural `ItemId` type across the reducer, ranking, routing, RPC, HTML, and tests, while extracting shared normalization into `item_wire.rs`. This establishes a stronger identity model and cleaner APIs (for example `RouteContext`/`garden_item_href` and typed map keys) that affects core project design, whereas Side B is a targeted improvement to pair-selection heuristics and adds tests for better vote scheduling but is confined to one subsystem.

A is a disciplined, well-tested type-safety refactor: it replaces the stringly-typed CanonicalItemUrl newtype with a proper ItemId enum (Root/Local/Web/Opaque), fixes real correctness hazards (Borrow<str> hacks, parent-boundary bugs, external-URL identity), and updates every call site and test consistently while removing a stale planning doc. B is a much larger, messier 'first pass' that guts and rewrites the entire API surface into a single RPC batch endpoint and splits rooms from threads—valuable architecturally, but far noisier (whole files deleted/rewritten, less polished, explicitly marked as a first pass), making its net lasting contribution harder to credit cleanly compared to A's tighter, correctness-focused change.

B lands lasting product architecture: billing-weight reactor changes (Ingest room_id+thread_tag, ScopeId::Room, RoomCreated/grants, forum keyed by (scope, tag)) plus a single batch RPC surface and CLI public/private scoping that replace the scattershot REST handlers. A’s ItemId migration is a valuable, correct design cleanup (enum identity through reducer/ranking/HTML and dropping CanonicalItemUrl/plan.md), but it largely re-expresses existing canonical-string keys rather than expanding what the system can do.

Side A completes a substantial architectural migration from `CanonicalItemUrl` strings to a structured `ItemId`, updating reducer state, ranking, routing, serialization, and introducing dedicated `item_id.rs`/`item_wire.rs` modules while preserving behaviors like parent resolution and display paths. Side B consolidates many HTTP endpoints into a batch RPC API and renames thread concepts to rooms, but much of the patch is endpoint relocation and plumbing rather than introducing a deeper domain model change.

Side A introduces a real structural ItemId enum replacing the string-newtype CanonicalItemUrl, deleting the now-obsolete plan.md and propagating the new type consistently through reducer, ranking, RPC, and HTML modules with updated tests — a substantive architectural improvement toward correct identity modeling. Side B is a much smaller incremental cleanup (Deref impls, resolve_item returning CanonicalItemUrl, minor plumbing) that is useful but far less consequential and was effectively superseded by the deeper refactor in A.

A introduces the lasting ItemId structural type (new item_id/item_wire modules), removes CanonicalItemUrl, and migrates reducer maps, ranking, RPC, HTML, and tests to typed identity—the architectural end state. B only tightens intermediate CanonicalItemUrl/String plumbing and adds Deref on href newtypes, which is useful but incremental and largely superseded by A.

Side A introduces a new structural `ItemId` type with parsing, serialization, parent/display logic, separates wire normalization into `item_wire.rs`, and migrates reducer state, ranking, routing, HTML, RPC, and tests from `CanonicalItemUrl` to the new identity model. Side B mainly improves type usage around the existing `CanonicalItemUrl` (returning it from `resolve_item`, using it consistently in collections, and adding `Deref` for URL newtypes), which is a useful cleanup but does not deliver the deeper architectural change or broad migration implemented by Side A.

Side B fixes a real security bug (votes silently falling back to an anonymous actor instead of failing closed), gates a test-only OAuth bypass behind an explicit env flag, adds Secure cookie support, and pins a git dependency to a rev instead of a mutable branch—all concrete, lasting correctness/security improvements with tests. Side A is a large mechanical rename/refactor (CanonicalItemUrl -> ItemId) that improves internal typing but changes no external behavior and even leaves a stray plan.md deletion with no functional payoff beyond restructuring existing logic.

A lands a core domain redesign: a real `ItemId` type (with wire split, parse/parent/display, serde) replaced `CanonicalItemUrl` through reducer maps, ranking, RPC, HTML routing, and tests—lasting structure rather than a string newtype. B adds important but narrower hardening (fail-closed `resolve_vote_actor`, mock-OAuth gate, Secure cookies, open-redirect checks, nav alias, durable rev pin); valuable security/UX, not the same system-wide foundation.

Side A replaces the project-wide `CanonicalItemUrl` string wrapper with a new `ItemId` type, introduces `item_id.rs`/`item_wire.rs`, updates reducer, ranking, routing, RPC, HTML, and tests to use structured identities, and adds `RouteContext`/`garden_item_href` integration. Side B meaningfully hardens authentication by making vote authorization fail closed, adding Secure cookie handling and redirect sanitization, but much of the patch is UI, configuration, and dependency pinning, whereas A establishes a broader, durable architectural foundation used throughout the codebase.

Side B is a coherent, testable identity refactor (splitting canonical_path/identity, making delegate optional, removing sigil-mangling in the reducer, plus new integration tests asserting rejection of '@') that fixes a real correctness/security concern in wire identity handling. Side A is a large mechanical rename (CanonicalItemUrl -> ItemId) that mostly shuffles code between files/modules without adding new capability, and even leaves an unfinished plan.md-driven refactor with fallback 'opaque' hacks that weaken the type safety it claims to add.

A replaces CanonicalItemUrl with a first-class ItemId across reducer maps, ranking, RPC, HTML routing, and types (new item_id/item_wire modules), which is a lasting core-domain design change. B’s split of path/identity helpers, no-@ wire form, and optional delegate improve API boundaries and module hygiene, but they are narrower contract/layering cleanups than A’s graph-wide identity migration.

Side A introduces a new structural `ItemId` type, extracts shared wire-normalization into `item_wire`, and propagates the new identity model through reducer state, ranking, routing, HTML, RPC, and tests, replacing pervasive `CanonicalItemUrl` usage with a stronger abstraction. Side B usefully separates identity and path normalization into dedicated modules and cleans up API semantics around usernames/delegates, but it is primarily an architectural reorganization and wire-format adjustment rather than the broad foundational data-model change implemented in Side A.

B is a small, focused security fix that closes an actual XSS hole (untrusted Reddit selftext_html rendered raw via PreEscaped) with a tested sanitizer applied at both render sites. A is a large ItemId refactor that improves internal typing but introduces lossy fallbacks (ItemId::opaque on parse failure) and a deleted plan.md, providing real but riskier and less immediately critical value than fixing a live script-injection vulnerability.

Side A delivers a structural ItemId type and migrates the reducer, ranking, RPC, and HTML paths off stringly CanonicalItemUrl keys—lasting core design that the deleted plan.md targeted end-to-end. Side B is a real, precise XSS fix (ammonia on Reddit body_html at two render sites plus tests), but it is narrow compared with the architecture-wide identity change.

Side A performs a broad architectural migration from `CanonicalItemUrl` strings to a first-class `ItemId` type, adds the new `types/src/item_id.rs` and `item_wire.rs` modules, and propagates the stronger identity model through reducers, ranking, routing, APIs, and tests. Side B is an important targeted security fix—introducing `ammonia` to sanitize untrusted Reddit HTML before `PreEscaped` rendering with tests—but its scope is limited to one rendering path, while Side A changes a core project abstraction with lasting impact across the codebase.

Side B fixes a real, user-visible multi-user bug (shared sentinel delegate blocking subsequent human votes) with a targeted change, new integration test, and updated docs/types, delivering concrete correctness value. Side A is a large mechanical rename (CanonicalItemUrl -> ItemId) plus deletion of a planning doc; while structurally reasonable, it's mostly churn/refactor with no new capability or bugfix and carries risk (fallback opaque() bypassing normalization) without demonstrated necessity beyond the refactor's own stated goals.

B fixes a concrete multi-user correctness bug: shared WEB_BROWSER_AGENT/INVITE sentinels caused AgentBound on the first browser vote and blocked later humans; making PendingSession.agent optional and posting UI votes with no delegate (plus integration coverage) restores real multi-user voting. A is a broad CanonicalItemUrl→ItemId migration with lasting type structure, but much of the diff is mechanical renames/propagation and string-backed Local/Web/Opaque keys rather than higher product impact.

Side A replaces the pervasive `CanonicalItemUrl` string wrapper with a structural `ItemId` type, introduces dedicated `item_id`/`item_wire` modules, and propagates the new identity model through reducers, routing, ranking, APIs, and tests, creating a more durable foundation for item identity and URL handling. Side B fixes a real multi-user bug by removing shared browser sentinel delegates and updating session/auth flows and tests, but its impact is narrower than the cross-cutting architectural improvement in Side A.