c_978e283f2229094300

Commit A introduces a major new subsystem and significantly changes project behavior. It replaces GitHub API-based commit discovery with deterministic multi-repository Git discovery, adds immutable discovery snapshots and a new event type, implements repository mirroring, reachability analysis, patch-identity deduplication, replayable attribution, locking and concurrency control, integrates discovery into the emission pipeline, improves ranking robustness and emission accounting, fixes halvening computation scalability, and adds extensive integration, unit, and stateful property tests. It also updates dependencies to support this functionality. Commit B is primarily a CLI and documentation refactor: it restructures commands (especially forum/post workflows), updates help text and guides, adjusts RPC hints, and updates integration tests to match the new interface. While useful for usability and consistency, it is largely an interface reshaping rather than introducing substantial new system capabilities.

Side A introduces a comprehensive multi-repository Git discovery system with deterministic snapshots, patch identity deduplication, replayable state, locking, and deep integration into emission and ranking logic, along with extensive new tests (including property/stateful tests). This is a major architectural addition. Side B is primarily a CLI restructuring and documentation update with limited backend impact. The scale, complexity, and system-wide implications of A far exceed B.

Commit A introduces a comprehensive, deterministic multi-repository Git discovery and attribution system with global OID and patch-identity deduplication, snapshotting, concurrency control, emission integration, and extensive real-Git integration and stateful tests. It substantially reshapes core architecture (discovery events, ranking/emission coupling, locking, config normalization, replay guarantees) and adds large, rigorous test coverage. Commit B primarily restructures the CLI (renaming/reshaping commands, especially around forum vs ingest) and updates docs/tests to match, which is meaningful but largely interface-level refactoring without comparable backend complexity or new guarantees. The architectural depth and verification surface of A far exceed B.

Commit A makes a substantial functional and interface change to the CLI. It restructures commands (introducing explicit forum subcommands like list/show/post), updates command parsing and execution logic, changes posting semantics to require forum tags and delegates, refreshes help text and DSL documentation, adjusts RPC guidance, and updates integration tests accordingly. These changes affect both user workflows and the implementation across multiple components. Commit B is primarily a codebase maintenance refactor: it removes a duplicate monolithic module, adopts the split forum/ module layout as the single source of truth, and redistributes existing code into smaller files with only minor import adjustments. While valuable for maintainability and resolving module ambiguity, it contributes much less new functionality than A.

Commit A introduces a substantive redesign of the CLI and its interaction model (new command hierarchy, removal of ingest in favor of forum post, updated flags, semantics, docs, RPC hints, and tests). It changes how users and systems interact with the tool. Commit B is a large but primarily structural refactor that splits a monolithic file into modules without adding new functionality. Despite its size, it’s mostly code movement and organization, so A has greater impact.

Side B performs a major structural refactor of the server HTML layer: it removes a 1400+ line monolithic forum.rs file and replaces it with a properly modularized forum/ directory (feed, views, paginator, profile, thread_morph, etc.), resolving module ambiguity and significantly improving maintainability and architecture. This is a deep internal reorganization affecting many routes and UI behaviors. Side A is also substantial—reshaping the CLI command hierarchy, updating docs, tests, and RPC hints—but it is primarily a surface/API restructuring. The architectural impact and long-term maintainability gains in Side B are greater overall.

Side A implements a substantial, well-tested new subsystem (multi-repository/branch-aware Git discovery with deterministic, replayable attribution, patch-identity dedup, adversarial hypothesis/state-machine tests, and integration test coverage) that removes the GitHub API dependency and fixes real correctness issues (e.g. symbolic halvening blowup, atomic emission distribution). Side B is a CLI/UX reshaping (renaming ingest to forum post, restructuring subcommands, doc/help text updates) which is useful but purely structural churn with no new capability or bug fix of comparable weight.

A replaces GitHub API polling with a full deterministic multi-repo git discovery pipeline (mirrors, reachability snapshots, patch-id dedup, force-push/replace/cherry-pick hardness, GitDiscovery ledger events, emission wiring) plus extensive unit/stateful/integration tests—core lasting protocol infrastructure. B mainly reshapes CLI surface (ingest → forum post/list/show, scoping docs, RPC next strings) without comparable constitutional or correctness depth.

Side A replaces GitHub API-based commit collection with a deterministic multi-repository Git discovery system, adding immutable discovery snapshots, replayable attribution, patch-identity deduplication, concurrency/file locking, emission integration, and extensive real-Git/stateful tests. Side B is primarily a CLI and documentation reorganization, renaming commands (for example `ingest` to `forum post` and `forum` to `forum list/show`) and updating help text and integration tests without comparable changes to the project's core behavior.

Side A introduces a full Git-based discovery system with deterministic snapshots, patch deduplication, multi-repo support, and integrates it into emissions, backed by extensive tests. Side B mainly restructures the CLI (e.g., splitting `forum` into subcommands and renaming `ingest` to `forum post`) without adding comparable core functionality.

Side A introduces a full multi-repository Git discovery system with deterministic snapshots, patch-identity deduplication, file locking, emission integration, and extensive new property/stateful tests, fundamentally reshaping how contributions are discovered and attributed. Side B mainly restructures the CLI (e.g., replacing `ingest` with `public forum post`, reorganizing subcommands) and updates docs/help text, with minimal core logic changes.

Commit A delivers a real, user-facing CLI restructuring (forum list/show/post subcommands, updated docs, RPC hints, integration test updates) that changes and improves actual behavior and usability. Commit B is a build-fix that removes a duplicate module file to resolve a compile ambiguity, which is necessary but purely mechanical housekeeping (a merge/refactor artifact cleanup) rather than new design or functionality.

A redesigns the CLI into a lasting public/private scoped command tree (forum list/show/post with required --delegate, path/arg semantics, docs, RPC next-move strings, and integration tests), which permanently shapes agent/user interaction. B only deletes a leftover 1400-line duplicate forum.rs so the already-split forum/ module is unambiguous—a necessary hygiene fix with no new behavior.

Side A makes a substantive CLI/API redesign by replacing the old `ingest` and implicit `forum` commands with explicit `public/private forum list|show|post` subcommands, updates the command parser and RPC wiring, enforces `--delegate` for CLI posts, revises server guidance strings, updates documentation, and adapts integration tests. Side B is primarily a structural refactor that removes the duplicate `server/src/html/forum.rs` in favor of the existing `forum/` module tree and splits code into smaller files, which improves maintainability but does not materially change project behavior.

Side B removes a duplicate monolithic `forum.rs` that conflicted with the new `forum/` module structure, fixing module resolution and preventing ambiguity/compile issues. Side A is largely a CLI/API reshape with extensive renames and doc updates, but introduces mostly surface-level changes rather than a clear correctness fix of similar impact.

Side B removes a 1,400+ line monolithic `server/src/html/forum.rs` and replaces it with a properly structured `forum/` module tree (e.g., `mod.rs`, `feed.rs`, `views.rs`, `thread_morph.rs`), resolving module ambiguity and establishing a clear, maintainable architecture. Side A mainly reshapes the CLI surface (renaming `ingest` to `forum post`, reorganizing subcommands, and updating docs/tests) without fundamentally changing core logic. The architectural cleanup and elimination of duplicate module roots in B provides more lasting structural value.

Side B is a substantial, coherent CLI restructuring (forum list/show/post subcommands, room-scoped public/private syntax, updated docs, RPC messages, and integration tests all kept consistent), representing real, lasting design work. Side A is a minimal one-line bugfix defining a missing env var default, useful but far smaller in scope and impact.

A is a real but tiny bugfix: four lines defining GITHUB_API_BASE_URL so OAuth stops NameErroring. B lands lasting CLI design—replacing ambiguous ingest/forum flags with explicit public/private forum list|show|post, required --delegate, aligned docs, RPC next-move strings, and integration tests—so the product’s primary interface stays coherent.

Side B implements a real CLI interface redesign by replacing the old `ingest`/implicit `forum` commands with structured `forum list|show|post` subcommands, updating command parsing, RPC calls, help text, integration tests, and server-generated next-step guidance to match. Side A is a useful targeted bug fix that defines `GITHUB_API_BASE_URL` to prevent a NameError in the GitHub OAuth callback, but its scope is limited to a single missing configuration variable.

Side B is a substantive CLI restructuring (splitting ingest into forum list/show/post, updating docs, RPC hints, and integration tests) that improves usability and consistency across the whole tool, whereas Side A is a small, self-contained bugfix (skip pinned Reddit posts) with a good test but narrower scope. Both are real, non-noise changes, but B touches and improves more of the system's actual interface and documentation, giving it broader lasting value despite being a larger diff.

A is a tight, correct Reddit import fix (skip stickied/pinned children plus a focused unit test) but narrow in blast radius. B reshapes the lasting CLI contract—forum becomes list/show/post, ingest becomes tagged forum post with required --delegate, room scoping is documented end-to-end, and RPC next-move strings plus integration tests follow—so the product’s primary agent/human interface is clearer and stickier than A’s single parser filter.

Side A implements a functional behavior change by skipping stickied/pinned Reddit posts during subreddit import, adds a dedicated helper checking both `stickied` and `pinned` flags, and includes a regression test verifying only normal posts are imported. Side B is largely a CLI/documentation reshaping and command reorganization with corresponding test updates, which improves interface consistency but contributes less core project behavior or correctness.

B is a substantive CLI restructuring (forum list/show/post subcommands, removal of confusing thread/delegate flags on ingest, updated docs/DSL, and updated integration tests) that meaningfully changes the user-facing command surface for correctness and clarity. A is a smaller, valid fix (display_path in hrefs) plus a much stronger test rewrite, but its production code change is narrow in scope compared to B's broader interface redesign affecting CLI, docs, and RPC messages.

A fixes real href correctness (encode display_path for left/right/pool instead of raw storage IDs) and replaces a weak ≤15-iteration smoke test with a full C(10,2)=45 pairwise run plus GetGardenRank assertions (one component, a→j). B’s CLI reshape (ingest→forum post/list/show, docs, integration command strings) is lasting interface design but heavier on renames/help churn relative to core behavior.

Side A fixes a user-visible correctness issue by generating vote URLs with `display_path()` instead of stored full URLs for left/right/pool items, matching the displayed DSL paths, and adds an exhaustive browser test that votes all 45 item pairs and verifies the resulting ranking via `GetGardenRank`. Side B mainly restructures the CLI (`forum list/show/post`), updates documentation/help text, and adjusts tests and command strings to the new interface, which is useful but is largely an API/UX reorganization rather than a core correctness improvement.

Side A meaningfully reshapes the CLI's command hierarchy (splitting forum into list/show/post subcommands, requiring --delegate on posts, updating docs and integration tests to match) — a substantive, coherent feature/UX change touching real code paths and tests. Side B is a small, useful but narrow config tweak (auto-discovering test namespaces in tests.edn) that reduces future maintenance friction but has far less scope and immediate value than A's functional CLI restructuring.

Commit A redesigns the CLI surface (forum list/show/post subcommands, required tag/--delegate on post, dropped freestanding ingest) and keeps docs, server next-move strings, and integration tests aligned—lasting product/API structure. Commit B only collapses hand-enumerated Kaocha suites into one `^test\..+` pattern in tests.edn, a useful but small test-harness maintenance fix.

Side A makes a substantive CLI/API redesign by replacing the old `ingest` flow with explicit `forum post`, splitting forum operations into `list/show/post` subcommands, updating RPC responses, enforcing `--delegate` for CLI posts, and aligning integration tests and documentation with the new command structure. Side B improves maintainability by auto-discovering all `test.*` namespaces in Kaocha, but it is a configuration convenience rather than a functional redesign affecting core project behavior.

Side B restructures the CLI's forum command (list/show/post subcommands), fixes a real bug (removing double-escaping via escape_xml that duplicated maud's own escaping), and updates docs/tests/RPC hints consistently across the whole surface—broader, more durable API/UX clarity. Side A is a solid, well-tested small feature (clickable unpin icon) but is narrower in scope and lower overall impact than B's cross-cutting CLI redesign and bugfix.

B reshapes the primary agent CLI surface: replaces loose `ingest`/`forum <title>` with explicit `forum list|show|post`, tightens room-scoped `public`/`private` usage, requires `--delegate` on posts, and updates server next-move hints plus integration tests—lasting API/design clarity. A is a solid, tested UX polish (static pin glyph → real unpin form + CSS), but narrower in scope than B’s command-model change.

Side A implements a concrete user-facing capability by making pinned child-group icons submit the existing `set_garden_pin` unpin flow, wiring the required navigation path through rendering, updating styles, and adding comprehensive browser tests that verify unpin behavior from the ranked list and HUD. Side B is largely a CLI command reshaping and documentation update (`ingest`/`forum` command structure, help text, test adjustments) with limited underlying functionality beyond reorganizing the interface.

B fixes a real design/performance issue: it replaces the Deque-based recent_votes storage (which required an expensive truncate_back on every vote) with an append-only List capped at read time, bumps the schema version, and adds a test verifying the capping behavior. A is a large CLI/docs restructuring (renaming ingest to forum post, adding subcommands, updating DSL.txt/GUIDE.sorter/tests) that is mostly naming/UX churn, and it even drops XML escaping of post bodies (a minor regression) without replacing it with anything equivalent. B's change is smaller but more clearly a lasting correctness/performance improvement backed by a test.

A redesigns the CLI’s real command surface (forum list/show/post, ingest→scoped forum post with required tag/delegate, simplified check) and lands matching docs, RPC next-move strings, and integration tests—lasting product/API structure. B is a tighter internal win (Deque/VecDeque→List/Vec, drop write-time trim_recent_votes, read-time cap + schema 4) but narrower scope and leaves storage uncapped on write.

Side B makes a substantive storage and data-flow redesign by replacing the durable recent-vote deque with an append-only list, removing post-apply trimming, moving the cap to query time, updating the schema version, and adding a regression test verifying the new behavior. Side A is a broad CLI/interface reshape (`ingest` to `forum post`, `forum` split into `list/show/post`, extensive documentation and command updates) that improves usability but is primarily an API reorganization rather than a core behavioral improvement.

Side A restructures the CLI's command taxonomy (forum list/show/post vs. flat ingest/forum), updates docs (DSL.txt, GUIDE.sorter), fixes a real bug (removing double XML-escaping of post bodies), and updates integration tests and server RPC hints to match — a broad, coherent, user-facing improvement. Side B adds a small, well-tested but narrow display feature (connectivity stats formatting) with unit tests, which is useful but far more limited in scope and impact.

A restructures the CLI command surface (ingest → scoped forum post/list/show, required --delegate, public/private form) and keeps DSL docs, server next-move hints, and integration tests aligned—lasting product/API design. B only formats already-available connectivity stats on pair output plus small unit tests, a useful but narrow display addition.

Side A implements a substantive CLI redesign by replacing the old ingest/forum interface with structured `forum list/show/post` subcommands, making `--delegate` mandatory for CLI posts, updating RPC hints, adapting integration tests, and aligning documentation with the new public/private room model. Side B is a useful usability improvement that displays existing connectivity statistics and adds tests, but it mainly exposes already-available data rather than changing core behavior or architecture.

B delivers genuine architectural value: entity JSON is offloaded to a RocksDB-backed store, the event log now replays line-by-line instead of loading everything into memory, and reducer/state code is refactored to match, addressing real scalability/startup-RAM concerns backed by new tests. A is a useful but lower-stakes CLI UX reshuffle (ingest→forum post, forum→forum list/show) that also silently drops XML escaping in post output, a minor regression. B's downside is the large amount of vendored 'durable' crate boilerplate (docs, examples, duplicate Cargo.lock) that isn't strictly needed, but the core server-side change is more substantive and lasting than A's renaming-focused patch.

B delivers lasting infrastructure value by vendoring a RocksDB-backed durable collections crate, moving heavy Reddit entity JSON out of the in-memory GlobalTree into entity_db, and replacing load-all event replay with line-at-a-time streaming to cut startup RAM. A is a useful but narrower CLI reshape (ingest → scoped forum post/list/show, docs/tests updates) that mostly reorganizes the command surface without comparable core durability or scalability impact.

Side B introduces substantive infrastructure: a new RocksDB-backed `durable` workspace crate with persistent collections, moves raw entity JSON into a dedicated `EntityStore`, and changes event log startup from loading all events into memory to streaming replay via `EventLog::replay`, reducing memory usage and improving scalability. Side A primarily restructures the CLI and documentation (renaming `ingest` to `forum post`, adding subcommands, updating help text and tests) with only minor behavioral adjustments, making it far less impactful in long-term project architecture.

Side A reworks the CLI command structure (forum list/show/post subcommands, room scoping) with corresponding server RPC message updates, DSL doc rewrites, and integration test updates, delivering a coherent, testable UX/API restructuring. Side B is a UI-focused fix (vote slider highlighting/polarity) with good unit tests, but it's narrower in scope, touches only presentation logic, and includes some risky refactors (removing back-nav, changing rank ordinal computation) without corresponding integration coverage.

A permanently redesigns the CLI contract (ingest → scoped `forum post <TAG>`, forum list/show/post subcommands, required --delegate, docs/RPC next-hints/tests), which is core agent/user surface. B is a real, well-tested vote-highlight/polarity UI fix (per-group gradients, center-anchored slider, history bars), but narrower and presentation-local.

Side B fixes a concrete UI correctness issue by making vote highlighting and history consistently reflect the winning side, adds helper functions for winner/slider mapping, updates CSS/JS accordingly, and backs the behavior with targeted unit tests covering ratio orientation and ranking polarity. Side A is primarily a large CLI/documentation reshaping and command reorganization with corresponding test updates, which improves interface consistency but is mostly structural rather than introducing a comparably durable functional fix.

B is a substantial, coherent CLI restructuring (forum list/show/post subcommands, mandatory --delegate on posts, updated docs/DSL, RPC next-step strings, and integration tests) that changes real user-facing surface and behavior consistently across code, docs, and tests. A is a smaller but correct fix (min-max gradient instead of ordinal position) with good targeted tests, but it's a narrower, purely cosmetic improvement compared to B's broader architectural and UX rework.

B restructures the CLI’s core write path (ingest → `forum post <TAG>` with required delegate), splits forum into explicit list/show/post subcommands, and updates docs, RPC next-move strings, and integration tests—lasting interface design. A only changes rank-row coloring from ordinal position to min–max vote-mass within a group plus unit tests; valuable polish, but much narrower scope.

Side A changes the ranking visualization to derive row colors from each group's actual score range instead of list position, adding a dedicated `score_gradient_t` function, updating rendering to compute per-group min/max scores, and including focused tests for normalization, tied scores, and stability. Side B is a broad CLI and documentation reshaping that mainly renames and reorganizes commands (`ingest` to `forum post`, `forum` to `forum list/show`) and updates help text and tests, providing usability improvements but comparatively less enduring functional value.

Side A restructures the CLI into coherent `forum list/show/post` subcommands, removes the ambiguous 'ingest' vs 'garden' split, and updates docs/tests to match — a genuine design improvement with broad, lasting impact on usability and consistency. Side B fixes real but narrower bugs (delegate leaking into DSL body, incorrect fallback to full item pool, dead swap button, route rename), which are valuable correctness fixes but smaller in scope and effect than A's structural rework.

A reshapes the real agent/CLI product surface: forum becomes explicit list/show/post under public|private, ingest is replaced by `forum post <TAG>` with required out-of-band `--delegate`, and docs plus integration tests are updated to match—lasting command design. B’s attribution fix (WEB_BROWSER_AGENT as delegate_opt, not DSL body) and sibling-pool fallback removal are real correctness wins, but narrower; much of B is route rename and removing a swap-button.

Side B makes several functional fixes with lasting behavioral impact: it passes the browser agent as out-of-band delegate metadata instead of embedding attribution in DSL text, prevents incorrect fallback to comparing all items when the sibling pool has fewer than two candidates, removes the unnecessary swap button, and consistently renames the voting route from `/vote/compare` to `/vote`. Side A is a broad CLI/API reorganization and documentation update that introduces `forum list/show/post` subcommands and updates help text and tests, but much of the patch is interface reshaping and documentation rather than fixing incorrect behavior.

Side B implements a real feature (Reddit OAuth linking, UUID-as-canonical-identity refactor) with new server logic, storage helpers, event handling, and updated tests/mocks that materially change and extend system behavior. Side A is a substantial but purely cosmetic CLI/docs restructuring (renaming ingest to forum post, reshaping subcommands, updating DSL text) with no new functionality or bugfix, aside from removing an XML-escaping call which risks a minor regression.

B introduces a lasting identity redesign (UUID-canonical accounts, multi-provider OAuth linking with conflict handling, private linked-provider UI, trust-weight updates, and Reddit OAuth end-to-end with tests), whereas A mostly reshapes the CLI surface (ingest → forum post/list/show, required --delegate, docs/RPC string updates) without comparable new core capability.

Side B implements a substantive identity model change: OAuth providers (GitHub and Reddit) become linkable to a canonical UUID, adds Reddit OAuth flows and routes, handles account-link conflicts, exposes linked providers privately, and fixes trust-weight projection updates by tracking pending writes within a batch. Side A is primarily a CLI/API reorganization from `ingest`/flat forum commands to `public forum post` and updated documentation/examples, with only minor behavioral changes around command parsing and output, making it less foundational than the authentication and identity redesign in Side B.

Side B is a substantive CLI redesign that restructures 'ingest' into a proper 'forum post/list/show' subcommand hierarchy, requires --delegate explicitly, updates docs (DSL.txt, GUIDE.sorter) and server RPC hints, and updates integration tests to match—delivering real lasting UX/architecture value. Side A is a narrower but legitimate bugfix improving mock OAuth test infra (regex split, exception handling, real CSS selectors), which is useful but smaller in scope and impact than B's broader CLI restructuring.

B redesigns the lasting user-facing CLI contract (ingest → scoped `forum post <TAG>` with required `--delegate`, explicit `forum list|show|post`, doc/RPC next-move strings, and integration coverage), which defines how agents and humans drive the product going forward. A is real, necessary test-infra repair (HttpServer body/query parsing, redirect length, nil-safe token/state, handler try/catch, selector-based auth assertions) but stays confined to mock OAuth/E2E support rather than shipping surface area.

Side A fixes concrete failures in the OAuth test infrastructure by correcting query parsing (`str/split` with regex), reading POST bodies from `getRequestBody`, handling nil tokens/state safely, adjusting redirect responses, wrapping handlers with error handling, and updating Playwright helpers to use real selectors—changes that restore broken end-to-end authentication tests. Side B primarily reorganizes the CLI interface and documentation (e.g. replacing `ingest` with `forum post`, splitting `forum` into `list/show/post`, and updating help text and tests), which is useful but is largely an API/UX reshape rather than a core correctness fix.

Commit A replaces an overengineered, unreliable 1800-line keystroke-transition parser/graph with a small, testable ~90-line URL-parsing function plus simpler UI wiring, deleting substantial complexity (parser_action.rs, race-condition JS, Playwright race test) while preserving core functionality with clearer semantics and tests. Commit B is a reasonable CLI UX reshaping (forum list/show/post subcommands, docs updates) but is comparatively lower-impact churn—mostly renaming/restructuring existing commands and docs without fixing a fundamentally broken design.

A removes an unreliable ~1.8k-line keystroke graph parser, parser_action types, race-prone JS, and browser race tests, replacing them with a small paste-and-Go URL extractor and redirect—correct lasting simplification. B mainly restructures working CLI surface (ingest → forum post/list/show, docs/RPC strings/tests) without comparable bugfix or complexity removal.

Side A replaces a large, unreliable keystroke-driven autocomplete graph with a much simpler paste-and-go flow, removes the obsolete parser action system, redirects directly to the target subreddit on successful parsing, and adds focused URL parsing tests. Although it deletes a lot of code, the core lasting change is a substantial simplification of architecture and behavior to address reliability, whereas Side B primarily restructures CLI commands, help text, and documentation around renamed interfaces with comparatively limited underlying functionality changes.

Commit A fixes a real production bug (hardcoded staging hostnames breaking OAuth/redirect URLs across multiple services) with a single reusable get-base-url helper, plus a small necessary CI fix — a concrete, low-risk correctness improvement. Commit B is a large CLI restructuring (forum list/show/post subcommands, docs, RPC hint strings) that is reasonable but is churn-heavy, unifies naming rather than fixing a bug, and touches many files with mostly cosmetic/interface renaming risk.

B lasting restructures the agent-facing CLI contract (ingest → scoped forum list/show/post with required --delegate, public/private form), and updates server next-move strings, GUIDE/DSL, and integration tests to match—so it defines how the product is driven going forward. A is a real, necessary fix (centralized get-base-url/HOSTNAME and window.location.origin instead of inconsistent hardcoded hosts, plus deploy-on-staging), but it is narrower infrastructure hygiene versus B’s API surface redesign.

Side A fixes a functional deployment and OAuth/redirect problem by centralizing base URL generation in `app.util/get-base-url`, replacing multiple hardcoded host/environment checks across login, OAuth, Linear, Spotify, Twitter, and YouTube, using `HOSTNAME`/current origin for custom hosts, and updating the Fly deployment workflow to deploy from `staging`. Side B is primarily a CLI/API reshape and documentation update (`ingest` → `forum post`, `forum list/show` subcommands, help text, tests), which improves interface consistency but mostly reorganizes existing behavior rather than fixing a cross-cutting runtime issue.

Side B adds real functional CLI/server capability (room create command, RPC wiring, simplifying rooms from a HashMap to a HashSet since visibility was unused/dead code) plus corresponding test updates across multiple test suites, representing genuine feature work and code simplification. Side A is primarily a CLI subcommand restructuring (forum -> forum list/show/post) and doc/help text rewording, which is useful but is mostly renaming/reshaping existing functionality rather than adding new capability or fixing a bug.

A restructures the primary write/read CLI (ingest → `forum post` with required tag/delegate, forum into list/show/post) and aligns docs, integration tests, and server next-move strings to that model—lasting interface design for the main agent path. B is valuable but narrower: a `room create` CLI path plus simplifying rooms to a HashSet by dropping ThreadVisibility/RoomState, which cleans the model without reshaping day-to-day participation.

Side A implements a substantive CLI redesign by splitting forum operations into explicit `forum list/show/post` subcommands, making `--delegate` mandatory for CLI posting, updating RPC interactions, tests, and extensive documentation to match the new command structure. Side B adds a useful `room create` command and simplifies room handling by removing unused visibility state, but its functional scope is narrower and much of the patch is cleanup and API simplification rather than a broad user-facing workflow improvement.

Side A is a small, precise UX/architecture fix: it replaces redirect-based auth flow with fragment responses and a JS morph, is correct, coherent, and consistent with the existing poem-JS pattern, with matching CSS additions. Side B is a large CLI restructuring (renaming ingest->forum post, forum->forum list/show) that is mostly churn/renaming across docs, main.rs, rpc.rs and tests, and even introduces a minor regression by removing the escape_xml helper in favor of unescaped body output.

B lastingly reshapes the primary agent interface: scoped `forum list|show|post` replaces ambiguous `ingest`/`forum` shapes, requires `--delegate` on CLI posts, and updates GUIDE/DSL, RPC next-move strings, and integration tests in lockstep. A is a solid, tighter UX fix (auth POSTs return morphable fragments and poem JS handles non-empty bodies) but is a narrower surface change than B’s command-model redesign.

Side A implements a substantive authentication UX improvement by changing the auth flow from redirects to HTML fragments, adding reusable fragment rendering, and updating the shared Poem JS form handler to morph returned HTML in place while preserving existing empty-response behavior for other forms. Side B is primarily a CLI command reorganization and documentation update (renaming `ingest` to `forum post`, splitting forum subcommands, updating help text and tests), which improves interface clarity but contributes less enduring functionality than the new inline auth behavior.

Side B ships real functional improvements: a fixed unpin control (form POST instead of a broken/odd href-based link), a new vote-count indicator on garden edges with a dedicated unit test verifying correctness, plus CSS updates across two themes and a new browser test asserting the fix. Side A is a large but essentially cosmetic CLI restructuring (renaming ingest->forum post, adding List/Show/Post subcommands, doc/DSL text rewrites) with no new tests beyond adjusting existing integration test invocations, offering clearer UX but less durable technical substance than B's bugfix-plus-test pairing.

A redesigns the CLI’s core write/browse contract (ingest → scoped `forum post`/`list`/`show`, required tag + delegate, simplified check) and lands matching docs, RPC next-move strings, and integration tests—lasting interface work. B is solid but narrower UX polish: vote-count badges on garden pins, HUD unpin via `set_garden_pin clear`, CSS, and a browser test.

Side B adds lasting functional improvements to the web UI: it changes the pin HUD from a misleading permalink into an explicit unpin action, surfaces pairwise vote counts beside compare actions by computing them from existing content state, and adds regression tests covering the new behavior. Side A is a large CLI/documentation reshape that mostly reorganizes commands and updates help text and tests to match a renamed interface, with comparatively less new functionality beyond the command structure.

Side B fixes a real multi-user bug (shared browser sentinel delegate blocking all but the first human voter) with a targeted change plus a new regression test proving two distinct users can vote; this is a genuine correctness fix with lasting value. Side A is a large but purely cosmetic CLI restructuring (renaming ingest to forum post, reshuffling subcommands and docs) that touches many files without fixing any bug or adding real functionality.

B fixes a real multi-user breakage: shared WEB_BROWSER_AGENT/INVITE sentinels bound on first browser vote and blocked later humans; posts now use Option<delegate>/None with attribution and a two-user vote regression test. A mostly reshapes CLI surface (ingest→forum post, forum list/show) and docs/tests without that class of correctness win.

Side B fixes a substantive multi-user authentication/ownership bug by removing shared browser sentinel delegates, changing pending sessions to use an optional delegate, updating UI posting to send no delegate for browser users, and adding an integration test proving two different human users can both vote successfully without creating incorrect agent bindings. Side A is largely a CLI/API reorganization and documentation refresh (renaming `ingest` into `forum post`, restructuring subcommands, updating help text and tests), which improves usability but is primarily an interface reshaping rather than a core correctness improvement.