c_5cd3e5917d2f66e6bc

Commit B makes a substantial architectural and behavioral change across the codebase. It removes persistent storage of Reddit payloads from the event log, deletes the EntityStore subsystem, changes the event model by eliminating EntityImported events, introduces ephemeral projection-cached content with TTL-based eviction, updates the journal, projection pipeline, Reddit importer, storage schema, application state, tests, and documentation/comments to match the new design. This changes persistence semantics, privacy/data-retention behavior, and replay logic while adding new functionality and migration of many call sites. Commit A primarily adds a detailed planning document plus a small RouteContext wrapper module and re-export. While the design document is valuable for future work, it has minimal runtime impact compared with the extensive implementation in commit B.

Commit B makes a sweeping architectural change: it removes the persistent EntityStore and the EntityImported event, redesigns how Reddit data is handled (ephemeral projection-only with TTL eviction), updates the event model, projection pipeline, storage schema, background jobs, and many tests. This significantly alters system behavior, storage guarantees, and data flow across the codebase. Commit A mainly adds a planning document and a thin RouteContext wrapper with minimal functional impact. The scale and depth of B’s changes far exceed A.

Commit B makes sweeping architectural changes: it removes the EntityStore and EntityImported event, rewires journal and projection layers, updates storage schema and DTOs, introduces ephemeral Reddit content with TTL eviction, modifies reducers, state initialization, background tasks, and adjusts Rust and Clojure tests accordingly. This significantly changes data durability semantics and system behavior. Commit A mainly adds a planning document and introduces a small RouteContext wrapper module with minimal integration impact. Therefore, B contributes far more substantial functionality and structural change.

Commit A delivers a coherent, project-wide architectural change with clear functional impact. It removes persistent storage of Reddit payloads from the event log and entity store, introduces ephemeral projection caching with TTL-based eviction, simplifies replay by logging only structural events, updates the journal and projection pipeline, adjusts storage schema versions, and adds or updates tests to validate the new behavior. This is a significant redesign touching many core subsystems while preserving consistency. Commit B is very large in raw size, but much of it appears to be an initial dump of files, design notes, and even pasted terminal output rather than a polished, integrated feature. It mixes utility scripts, planning documents, large parser and reducer implementations, and accidental artifacts. While it contains substantial code, the commit message ('init seed') and the presence of copied terminal sessions reduce its effective contribution as a clean, production-ready change. Overall, A represents the more impactful and deliberate contribution.

Commit A is a substantial architectural change: it removes the persistent entity store and shifts Reddit content to an ephemeral, TTL-based projection model. This touches many core subsystems (events, journal, projection, storage schema, reducer, state management, Reddit ingestion flow), introduces new eviction logic, simplifies event semantics, and updates tests accordingly. It meaningfully changes system behavior, data lifecycle, and compliance with external API constraints. In contrast, Commit B is an initial seed adding assorted scripts, experimental modules, and large standalone components (parser, ranking, etc.), but without clear integration into the existing system. While large in size, B is more of a scaffold or dump of new files, whereas A delivers a cohesive, impactful refactor to the live architecture.

Commit A is a large, architectural change that removes the EntityStore and EntityImported event, redesigns Reddit ingestion to keep content ephemeral, updates projection logic, storage schema, eviction background task, tests, and multiple modules. It meaningfully alters data modeling, persistence guarantees, and replay semantics across the server. Commit B is an initial seed adding assorted new files (scripts, parser, ranking, reducer, UI actions, notes), but as presented it’s largely a bulk code drop without clear integration changes in this diff context. The systemic impact and careful refactor in A outweigh B’s scaffold-style addition.

Side B is a substantive, tested architectural change: it removes the EntityStore/EntityImported design, replaces it with ephemeral projection-only Reddit content plus a TTL eviction task, updates the event log schema, storage schema, journal wiring, and adjusts/fixes both Rust and Clojure tests to match the new behavior. Side A is purely a planning document (plan.md) plus a thin, mostly unused RouteContext wrapper that just delegates to existing ThreadNav methods—useful as a roadmap but no functional or tested change to the running system.

B removes EntityImported/EntityStore, keeps Reddit payloads out of the durable log, and adds projection-only caching with 48h TTL eviction—real architecture, API-policy, and test changes across events, journal, storage, and reddit import. A mostly adds a temporary plan.md plus a thin RouteContext newtype that delegates to existing ThreadNav methods, with no ItemId migration or lasting bugfix.

Side B makes a substantive architectural change: it removes persistent storage of Reddit API payloads and the `EntityImported` event, replaces them with ephemeral projection-cached display content plus TTL eviction, updates replay/journaling/projection logic accordingly, and adds tests reflecting the new persistence model. Side A primarily adds a planning document and introduces a thin `RouteContext` wrapper re-export without migrating callers or changing runtime behavior, so its lasting project impact is much smaller.

Side B makes a deep architectural change: it removes `EntityStore` and the `EntityImported` event entirely, rewrites projection application to exclude payload persistence, and introduces ephemeral caching with TTL eviction (`put_ephemeral_content`, `evict_content_older_than`) plus updated tests. Side A mainly adds a planning document and a thin `RouteContext` wrapper delegating to `ThreadNav`, with minimal functional impact.

Side B fundamentally redesigns persistence by deleting `EntityStore` and the `EntityImported` event, moving Reddit payloads out of the event log and into TTL-evicted ephemeral projection storage with new `put_ephemeral_content` and eviction logic, plus updated tests and schema versioning. Side A only adds a planning document and a thin `RouteContext` wrapper around `ThreadNav` without changing behavior, so its impact is preparatory rather than substantive.

Side A is a coherent, well-tested refactor that removes the EntityStore/EntityImported machinery and replaces it with ephemeral projection content plus a TTL eviction task, updating call sites, tests, and even the Clojure integration tests consistently. Side B's 'init seed' commit dumps loose, disorganized files at the repo root (some literally containing captured shell prompts like 'tommy@Tommys-Laptop:...⇒ cat server/src/ranking.rs' pasted into the file), indicating accidental/scratch content rather than a deliberate, reviewable change.

Commit A makes a lasting architectural change: drops EntityImported/EntityStore so the event log keeps only NodeEnsured structure, writes Reddit display content ephemerally into the projection with fetched_at, and adds a 48h TTL evictor—aligning storage with API policy and rebuild semantics. Commit B is an init dump of notes (.tdsl), shell-cat noise pasted into .rs files, and large prototype blobs (parser/reducer/ranking) that do not land as clean, integrated project value.

Side A implements a substantive architectural change: it removes persistent Reddit payloads from the event log (`EntityImported` and `EntityStore`), replaces them with ephemeral projection-cached content plus TTL eviction, updates replay/journaling accordingly, and adds tests verifying the new behavior. Side B is an unfocused seed commit containing planning documents, scripts, large new modules, and even pasted terminal output in source files, with little evidence of a coherent, production-ready change compared to A's deliberate redesign.

Side A makes a substantive architectural change: removing EntityImported events and the entire EntityStore, replacing them with ephemeral projection-cached content with TTL eviction and simplifying the event log to structural data only. This reduces log bloat and enforces API policy while adding eviction logic and updating replay semantics, whereas Side B mostly adds initial scaffolding (scripts, UI plumbing, parser, and notes) without clear integration or demonstrated necessity.

Side A makes a deep architectural change: it removes the persisted EntityImported event and EntityStore, introduces ephemeral Reddit content caching in ProjectionStore with TTL eviction (e.g., put_ephemeral_content, evict_content_older_than, REDDIT_CONTENT_TTL), and rewires journal/projection/state logic and tests accordingly. Side B mainly adds initial scaffolding files and scripts (TEST.sh, bundle.js, parser.rs, etc.) without integrating them into the existing server architecture, providing comparatively less lasting structural impact.

Side B is a substantial architectural change that removes an entire subsystem (EntityStore), redefines the event log semantics to keep Reddit content ephemeral with TTL eviction, and touches storage schema, journal, projection, reducer, state, and integration tests consistently across the codebase—delivering real durability/privacy/lasting-value improvements. Side A is a small, well-scoped bugfix improving a color-gradient heuristic in one function with good tests, but it is narrow in scope and impact compared to B's systemic redesign.

B removes EntityImported/EntityStore entirely, keeps only NodeEnsured in the durable log, and adds TTL eviction for ephemeral Reddit display content—fixing retention policy, log bloat, and rebuild semantics across journal, projection, storage schema, and reddit import. A only retunes rank-row gradient math from list ordinal to per-group min–max score, a correct but narrow UI polish.

Side B makes a substantial architectural change: it removes the persistent EntityStore and EntityImported event, moves Reddit display data into ephemeral projection storage with TTL-based eviction, updates replay/journaling paths accordingly, and adds tests verifying rebuild and eviction behavior. Side A is a well-scoped UI improvement that changes row color gradients from list position to per-group score normalization with supporting tests, but its impact is limited to presentation rather than core system design and data handling.

Side B is a substantive architectural fix: it removes duplicate/inconsistent storage (EntityStore + projection), stops persisting full Reddit payloads in the append-only log (likely a real API/ToS and storage-growth concern), and replaces it with ephemeral projection content plus a TTL eviction task — all while keeping votes/tree structure intact and updating every touched module and test coherently. Side A is a well-tested new feature (URL canonicalization graph) but is additive and isolated, whereas B simplifies and corrects a core data-lifecycle problem across the whole system.

B makes a lasting architectural correction by deleting EntityStore/EntityImported, stopping raw Reddit payloads from entering the durable event log, writing display fields only as TTL-evicted projection cache, and keeping NodeEnsured/votes/structure as the sole logged facts—directly reducing retention/compliance risk and long-term log bloat. A adds a solid, well-tested URL DFA/canonicalization graph (parse, builder, Reddit/YouTube rules, generic fallback), but that is additive domain logic rather than a core persistence-model fix.

Side B makes a durable architectural change by removing persistent storage of Reddit API payloads (`EntityStore` and `EntityImported` events), replacing it with ephemeral projection-only content, TTL-based eviction, and a simplified replay path that logs only `NodeEnsured` structure. Side A introduces a substantial URL canonicalization graph with parsing, generic fallbacks, builders, and extensive tests, but it is largely additive functionality, whereas Side B simplifies core persistence semantics and better aligns the storage model with long-term policy and replay behavior.

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 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.

B introduces a substantial, well-tested subsystem (deterministic multi-repository git discovery with patch-identity dedup, replay-safety, adversarial hypothesis tests, and integration tests using real local git repos) replacing a brittle GitHub-API-dependent ranking flow, delivering real lasting architectural value despite lockfile noise. A is a solid, focused refactor (removing EntityStore, adding TTL eviction for ephemeral Reddit content) that is correct and useful but narrower in scope and impact than B's rewrite of the core attribution/discovery pipeline.

B replaces brittle GitHub API polling with multi-repo git mirroring, first-reachability snapshots, patch-id cherry-pick dedup, and adversarial/replay guards (force-push, replace refs, locks), plus deep unit/stateful/integration coverage—core lasting attribution infrastructure. A is a sound but narrower redesign: drop EntityImported/EntityStore, cache Reddit display data ephemerally with TTL eviction, and log only NodeEnsured structure.

Side B replaces GitHub API-based commit discovery with deterministic multi-repository Git snapshotting, including mirror verification, reachability tracking, patch-identity deduplication, concurrency-safe discovery, replayable ledger snapshots, and extensive real-Git/stateful tests. Side A makes a meaningful architectural change by removing persistent Reddit payloads from the event log and introducing ephemeral projection storage with TTL eviction, but B establishes a broader and more durable correctness foundation for contribution attribution across repositories.

B ships a complete, testable feature: GitHub OAuth login, durable sessions, pseudonym claiming, and trust-weight-based identity events wired into the projection and vote path, backed by new integration/E2E tests (mock OAuth server, Clojure auth flow test) — a substantial, load-bearing capability. A is a cleaner, more focused refactor (ephemeral Reddit content with TTL eviction, removing EntityStore) that fixes a real design/policy issue and is well tested, but its scope and impact are narrower than B's new identity/auth subsystem, even though B awkwardly bundles in an unrelated vendoring change (moving `durable` to a git dependency).

B adds foundational product infrastructure: GitHub OAuth, session cookies, pseudonym claims, identity events (PrincipalCreated/OauthLinked/PseudonymClaimed) projected into durable maps, and vote gating via resolve_vote_actor—real multi-user auth with e2e coverage. A is a strong, precise design fix (drop EntityImported/EntityStore, cache Reddit display ephemerally with 48h eviction, log NodeEnsured only), but narrower in scope; B’s durable out-of-tree move is mostly relocation noise and does not outweigh the auth subsystem’s lasting value.

Side A makes a substantive architectural change: it removes `EntityImported` events and the separate `EntityStore`, stores Reddit display data only as ephemeral projection state with TTL eviction, and updates replay/tests so the event log retains only durable structure (`NodeEnsured`, votes). Side B does add meaningful GitHub OAuth, sessions, identity events, and vote gating, but a large portion of the patch is repository restructuring that removes the in-tree `durable` crate and rewires dependencies, making the overall lasting contribution less concentrated than A's core persistence-model redesign.