c_4ed2e2cca39ba92feb

Commit B fixes a runtime bug by defining GITHUB_API_BASE_URL with a sensible default, preventing a NameError during the GitHub OAuth callback and restoring functionality. Commit A improves the test infrastructure by replacing manually enumerated Kaocha suites with automatic test discovery, reducing maintenance and ensuring new tests are picked up automatically. While A is a useful developer-experience improvement, B has a more direct impact on application correctness and user-facing behavior.

Side A meaningfully improves the testing infrastructure by replacing brittle, manually enumerated suites with automatic discovery, reducing maintenance overhead and preventing future test omissions. Side B is a small but important bug fix (adding a missing configuration variable), yet its scope and impact are limited compared to the broader structural improvement in Side A.

Commit B fixes a runtime NameError in the GitHub OAuth callback by defining GITHUB_API_BASE_URL with a sensible default, directly resolving a user-facing authentication failure. Commit A improves test maintainability by unifying test discovery, which is valuable for developer workflow but does not fix a functional bug. Therefore, B has slightly greater impact.

Commit A fixes a functional runtime bug by defining and initializing GITHUB_API_BASE_URL, preventing a NameError during the GitHub OAuth callback when the API base URL is not otherwise set. That directly improves application correctness. Commit B is broader in scope but is primarily maintenance: resolving Clippy warnings, making small idiomatic cleanups, adding a missing #[test] attribute so an existing test runs, and suppressing dead-code warnings in shared test helpers. While valuable for code quality and test coverage, it introduces little new functionality or user-facing behavior compared with fixing a runtime failure.

Side A fixes a functional runtime issue (a NameError in the GitHub OAuth callback) by properly defining and normalizing the API base URL, which directly impacts application correctness. Side B consists mostly of lint cleanups, minor refactors, and test adjustments that improve code quality but do not materially change behavior. Fixing a breaking bug outweighs stylistic and maintenance improvements.

Side B makes widespread improvements across many files: resolving clippy warnings, refining pattern matches, simplifying code, adding a missing test annotation, introducing a type alias, cleaning up unused variables, and improving helper modules. These changes enhance overall code quality and maintainability across the workspace. In contrast, Side A is a small, targeted fix adding a single environment variable to prevent a NameError. While useful, its scope and impact are much narrower.

Side B fixes a runtime bug by defining `GITHUB_API_BASE_URL` with a sensible default, preventing a `NameError` during the GitHub OAuth callback when the API base URL was otherwise undefined. Side A improves test maintenance by replacing manually enumerated `:ns-patterns` with a single auto-discovered `^test\..+` suite, reducing future configuration work, but it primarily streamlines test configuration rather than correcting application behavior.

Side B fixes a runtime NameError by defining GITHUB_API_BASE_URL with a sensible default, restoring the GitHub OAuth callback’s functionality. Side A improves test configuration by replacing hardcoded namespace lists with a catch-all pattern, reducing maintenance, but it doesn’t fix a breaking issue.

Side B fixes a concrete runtime error by defining `GITHUB_API_BASE_URL` with a default and `.rstrip("/")`, resolving a NameError in the GitHub OAuth callback path. Side A improves test maintainability by replacing hand-enumerated suites with a single auto-discovered `:all` suite, but it’s a configuration refactor rather than a direct functional bugfix impacting production behavior.

B fixes an actual runtime bug (NameError crashing the OAuth callback) by defining the missing GITHUB_API_BASE_URL constant, providing immediate functional correctness. A is a reasonable test-config simplification that reduces maintenance friction but carries risk of silently picking up unintended test.* namespaces and isn't fixing a live defect.

B fixes a real NameError by defining the missing GITHUB_API_BASE_URL used in the OAuth path, restoring correct runtime behavior. A is a worthwhile tests.edn simplification (auto-discover vs hand-enumerated suites) but is tooling ergonomics, not a production correctness fix.

Side A adds the missing GITHUB_API_BASE_URL configuration with a default value, preventing a runtime NameError in the GitHub OAuth callback and restoring functionality. Side B is almost entirely Clippy-driven cleanup and minor test adjustments (pattern simplifications, formatting, type alias, dead_code allowance, adding a missing #[test]) that improve code quality but do not materially change project behavior.

Side A introduces a missing GITHUB_API_BASE_URL configuration with a default, preventing a runtime NameError in the OAuth callback path—a direct functional bugfix. Side B mainly applies stylistic clippy cleanups (e.g., pattern matching simplifications, formatting changes, minor test tweaks) without changing behavior.

Side A adds a defined `GITHUB_API_BASE_URL` environment variable with a safe default and `.rstrip("/")`, directly fixing a runtime NameError in the GitHub OAuth callback path. Side B mainly addresses clippy warnings and minor test/idiomatic cleanups (e.g., pattern matching simplifications, `is_some_and`, formatting tweaks) without changing functionality, so its impact is largely cosmetic and maintenance-oriented.

Side A fixes an actual production crash (NameError due to an undefined GITHUB_API_BASE_URL) with a precise, necessary one-line addition, directly preventing a real runtime failure in the OAuth flow. Side B is a broad but mostly cosmetic clippy cleanup pass (irrefutable-pattern simplification, format-string inlining, is_some_and swaps) that does include one genuine fix—wiring up a missing #[test] attribute—but the bulk of the diff is stylistic churn rather than substantive bugfixing.

A fixes a real runtime NameError by defining the missing GITHUB_API_BASE_URL (with default and rstrip), which is a lasting functional bugfix for OAuth. B only applies diffuse clippy style cleanups, a missing #[test] attribute, dead_code allows, and minor refactors with no behavioral impact.

Side A fixes a real correctness bug (rank gradient computed globally instead of per-group) and adds a slider-polarity fix with unit tests verifying both the ranking math and the vote-history rendering, showing durable engineering care. Side B is a minimal one-line fix for a NameError, which is valuable but narrow in scope and lacks any test or broader design consideration.

A fixes real vote/rank UI correctness (per-group gradient ordinals, center-anchored winner fill, ratio polarity aligned with the HUD) and locks it in with targeted tests; B only adds a missing GITHUB_API_BASE_URL default. B is a valid crash fix but three lines of config, while A delivers lasting product behavior and regression coverage.

Side A fixes a real UI correctness issue by changing rank row styling to be computed per ranking group instead of globally, removes obsolete offset logic, and adds regression tests for the gradient behavior. It also aligns vote history visualization with slider semantics by introducing consistent winner/slider mapping, updating the UI, and adding multiple polarity tests, whereas Side B is a small but isolated fix that simply defines `GITHUB_API_BASE_URL` with a default to prevent a missing-variable failure.

Side B fixes a real crash bug (NameError from a missing GITHUB_API_BASE_URL definition) that would break OAuth login entirely, a small but critical correctness fix. Side A improves a cosmetic gradient-coloring heuristic with better tests, which is a nice UX refinement but not a functional bugfix affecting core app correctness.

A replaces ordinal color banding with min–max normalization on real vote mass, with a clear helper, edge cases (ties, tiny spread), and focused unit tests—lasting ranking UX semantics. B only adds a missing GITHUB_API_BASE_URL default; a necessary one-liner NameError fix but far less design substance.

Side A changes the ranking color logic from list-position-based gradients to score-based min–max normalization within each group, introduces a dedicated `score_gradient_t` helper, updates callers, and adds targeted tests covering normalization behavior and edge cases such as tied scores. Side B fixes a real configuration bug by defining `GITHUB_API_BASE_URL` with a default, but it is a small missing-variable fix with narrower impact than the broader, tested behavioral improvement in Side A.

Side A fixes a real data-correctness bug (pinned Reddit posts polluting imports) with a clear implementation and an accompanying regression test verifying both 'stickied' and 'pinned' fields are handled. Side B's fix is plausible (defining a missing GITHUB_API_BASE_URL constant to avoid a NameError) but the diff shows no test and no context of where/how the variable is actually used, making its correctness harder to verify.

B fixes a real NameError by defining the missing GITHUB_API_BASE_URL used in the OAuth callback, restoring broken auth. A only filters stickied/pinned Reddit listing children (with a small helper and unit test), which is a useful import refinement but not a correctness fix on a critical path.

Side A changes subreddit import behavior to intentionally exclude stickied/pinned posts by adding a dedicated check in `parse_children`, documents the behavior, and adds a regression test covering both `stickied` and `pinned` flags. Side B fixes a real runtime issue by defining `GITHUB_API_BASE_URL` with a default, preventing a NameError in the OAuth callback, but it is a smaller configuration fix without accompanying tests or broader behavioral improvements.

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 A fixes a real runtime bug (NameError on missing API base URL) that would crash the OAuth callback, providing a concrete correctness fix. Side B is a minor cleanup removing dead code and adjusting a test's assertions, which is reasonable but lower-impact than fixing an actual crash-causing bug.

A fixes a real NameError by defining the missing GITHUB_API_BASE_URL default used in the OAuth path, restoring a broken auth flow. B only deletes a dead zero-ratio early-return already enforced at parse/handler layers and adjusts a test—useful hygiene, but not a functional bugfix.

Side A fixes a concrete runtime bug by defining `GITHUB_API_BASE_URL` with a default and normalizing it, preventing a `NameError` when the OAuth callback references the setting. Side B mainly removes a supposedly redundant zero-ratio guard and updates tests to reflect the new behavior (registering items/pairs while skipping zero-weight edges), which is more of a cleanup/behavior adjustment than a clear bug fix.

Side B fixes a real runtime NameError bug (missing GITHUB_API_BASE_URL definition) with a small, correct, targeted change. Side A is a large mechanical refactor (splitting forum.rs into modules) which is legitimate cleanup but is essentially reorganization/churn rather than fixing a functional defect, and its value depends on the split being correctly wired (harder to verify from diff alone).

Side B is a precise production bugfix: it defines the missing GITHUB_API_BASE_URL used by the OAuth callback, eliminating a NameError that would break GitHub login. Side A’s huge diff is mostly deleting a leftover monolith and reshuffling the same forum HTML into forum/*—useful module hygiene, but largely move/churn rather than new behavior or a targeted correctness fix.

Side A resolves the module layout by deleting the obsolete monolithic `server/src/html/forum.rs`, adding `forum/mod.rs`, and wiring the split implementation (`feed.rs`, `views.rs`, `thread_morph.rs`, `page.rs`, etc.) as the single module root, eliminating ambiguous `mod forum` resolution and making the refactoring canonical. Side B is a useful but narrowly scoped bug fix that defines `GITHUB_API_BASE_URL` to avoid a `NameError` when the OAuth callback needs a missing API base URL.

Side B adds a real, tested feature (connectivity stats display with unit tests) that gives users actionable information in the CLI, whereas Side A is a minimal one-line bugfix defining a missing constant. Both are legitimate, but B contributes more substantive, verified functionality with lasting value, while A merely patches a NameError with a small addition.

A is a precise production bugfix: it defines the missing GITHUB_API_BASE_URL so the OAuth callback no longer NameErrors when the env var is unset. B only formats and prints already-available connectivity stats in the CLI (plus tests), a useful UX surface but not a correctness fix for a broken auth path.

Side B adds a new CLI capability that surfaces existing connectivity statistics to users, including density, connectedness, pluralization, and accompanying unit tests to lock in the behavior. Side A fixes a specific NameError by defining and normalizing GITHUB_API_BASE_URL from the environment, which is an important but narrowly scoped configuration bugfix.

Side A makes several coordinated, verifiable fixes (correct out-of-band delegate passing, error-instead-of-silent-fallback for small sibling pools, dead button removal, route rename) with updates propagated consistently across server code, tests, and browser test scripts. Side B is a minimal one-line fix defining a missing env var to resolve a NameError, which is valid but much narrower in scope and impact than Side A's multi-part correctness and UX improvements.

A delivers several lasting behavioral fixes: out-of-band delegate attribution, correct early-return when the sibling pool is too small (instead of silently falling back to all items), and removal of a useless swap control, plus the route rename. B only adds a missing GITHUB_API_BASE_URL default—important for avoiding a NameError, but a three-line constant definition with far less ongoing design impact.

Side A fixes several functional issues across the voting flow: it correctly passes the delegate attribution out-of-band instead of embedding it in the DSL text, stops incorrectly falling back to all items when the sibling pool is too small by returning no next pair, removes the unnecessary swap control, and consistently renames the route from `/vote/compare` to `/vote` across handlers and tests. Side B fixes a real but narrowly scoped startup/runtime bug by defining `GITHUB_API_BASE_URL` with a default, preventing a NameError in the GitHub OAuth path.

Commit A is a small, precise bugfix that resolves a real NameError crash in the OAuth callback by defining the missing GITHUB_API_BASE_URL, directly fixing broken functionality. Commit B bundles multiple UI feature additions (vote counts, HUD unpin button) with unrelated churn and no clear single bugfix, making it more diffuse and harder to attribute lasting, focused value despite its larger size.

B adds lasting product behavior: edge vote counts on garden rows (with a real helper + unit test), HUD unpin via POST clear instead of a misleading permalink, matching CSS/JS, and browser coverage. A only introduces a missing GITHUB_API_BASE_URL default—a correct but tiny config fix with far less project impact.

Side B implements substantive product behavior across the UI: it adds pairwise vote counts in the garden view, changes the pinned-item HUD from a permalink to an unpin action via `POST /ui`, updates styling, and adds both unit and browser tests to verify the new behavior. Side A is a small but useful bug fix that defines `GITHUB_API_BASE_URL` with a default to prevent a `NameError`, but its scope and long-term impact are much narrower.

Commit A is a tiny one-line config fix that resolves a NameError, useful but narrow in scope. Commit B fixes an off-by-one indexing bug consistently across rpc.rs and garden.rs, updates doc comments to correctly describe 0-based vs 1-based indexing, removes a misleading fallback that masked bugs, and adds regression tests verifying the corrected behavior, giving it broader and more durable impact.

B fixes real indexing semantics (1-based optional fallback → 0-based invariant matching /t/tag/N), drops a silent unwrap_or(0) that could hide missing posts, aligns RPC/HTML/types, and locks behavior with integration asserts. A only introduces a missing GITHUB_API_BASE_URL default—necessary but a one-site config patch with no comparable design or test depth.

Side B corrects the rank-history thread index semantics by making `thread_post_index` consistently 0-based, replacing silent `unwrap_or(0)` fallbacks with `expect(...)` to catch invariant violations, updating UI links, documentation, and adding integration tests that verify the behavior. Side A is a targeted but much smaller fix that defines `GITHUB_API_BASE_URL` to prevent a `NameError` in the GitHub OAuth callback when the API base URL is otherwise missing.

Side B is a substantial, coherent feature: it converts Reddit fetching into an event-sourced, user-initiated import (storing raw payloads, deriving views at replay, explicit 'Fetch more' UI), adds dotenv support, config for API bases, and includes new tests and fixtures validating the behavior end-to-end. Side A is a trivial one-line env var addition to fix a NameError, useful but minor in scope and impact compared to B's architectural and functional improvements.

A only adds a missing GITHUB_API_BASE_URL env default (a minimal NameError fix). B redesigns Reddit import around persisted EntityImported events with full payloads, explicit user-triggered fetch UI, configurable API bases, dotenv support, reducer/state replay, fixtures, and end-to-end tests—delivering lasting architecture and behavior rather than a one-line config patch.

Side B implements substantial new functionality: it replaces automatic Reddit fetching with explicit user-triggered fetches, persists full imported API payloads via a new EntityImported event for replay, refactors the reducer to store raw payloads plus derived views, adds configurable API/OAuth bases and dotenv loading, and includes tests and fixtures validating the behavior. Side A is a small but useful bug fix that defines GITHUB_API_BASE_URL with a default to prevent a NameError, but its scope and lasting architectural impact are much narrower.

Side A is a trivial config addition (adds GITHUB_API_BASE_URL env var) that doesn't even show the actual bugfix code using it. Side B removes real dead-code duplication (an unused/redundant ExpandNewThreadForm action and toolbar), simplifies the SSR flow for the home page to match room pages, and cleans up corresponding tests, yielding a clearer, more maintainable codebase.

B removes an entire redundant ExpandNewThreadForm action, its handler, tests, and the dual toolbar/+ morph path, so home SSRs #new-thread-ui-slot like room pages—lasting UI consistency and less surface area. A is a real but tiny fix (define GITHUB_API_BASE_URL) with less architectural impact.

Side B simplifies the HTML flow by server-rendering the `#new-thread-ui-slot` on the home page, removing the redundant `ExpandNewThreadForm` UI action, its dispatch handler, enum variant, and associated parsing test. This eliminates an unnecessary client round-trip and duplicate code path, whereas Side A is a narrowly scoped fix that defines `GITHUB_API_BASE_URL` to prevent a missing-variable `NameError` in the GitHub OAuth callback.

Side B implements a substantial, coherent feature (CLI 'room create' path end-to-end: new CLI subcommand, server RPC simplification removing unused visibility concept, reducer/type/test updates, and docs) spanning many files with real design cleanup. Side A is a trivial one-line env var addition to fix a NameError, useful but minor in scope and impact compared to B's broader, functioning feature work.

B implements the full room-create CLI path, simplifies the core data model (drops ThreadVisibility/RoomState, rooms become a HashSet), and updates RPC/events/reducer/tests/docs accordingly—lasting product and design work. A only adds a missing GITHUB_API_BASE_URL default env var, a one-liner NameError fix with far less scope.

Side B adds a substantial new end-user capability by introducing a `room create` CLI command, wiring it through the RPC path, updating documentation, and simplifying the room model by removing the unused visibility field and related state. Side A is a targeted configuration fix that defines `GITHUB_API_BASE_URL` with a default to prevent a `NameError` in the OAuth callback, which is valuable but much narrower in long-term impact.

Side B fixes a real bug (undefined variable causing a NameError in a live OAuth callback path) with a minimal, correct patch. Side A is a larger UI/UX refactor (inline form morphing instead of redirect) that adds functionality but is more speculative/stylistic and carries more risk of regressions across auth flows; it's valuable but less clearly a durable correctness fix than B's crash fix.

A redesigns auth to return HTML fragments and extend the shared poem form interceptor for inline success/error morphing, while collapsing a separate auth_layout back into the main layout—lasting UX and architecture. B only adds a missing GITHUB_API_BASE_URL default (three lines), a real but narrowly scoped NameError fix with far less surface impact.

Side A implements a lasting UX and architecture improvement for authentication by replacing redirect-based flows with HTML fragments, adding reusable rendering helpers, updating the shared form interception logic to morph non-empty responses, and integrating the auth pages back into the common layout. Side B is a valuable but narrowly scoped bug fix that defines a missing GITHUB_API_BASE_URL configuration with a sensible default to prevent a NameError in the OAuth callback.

Side B fixes a real crash-causing bug (NameError from a missing GITHUB_API_BASE_URL) with a minimal, correct, targeted patch. Side A is a large feature/UI-refactor commit (fullscreen compare layout, edge-history sorting, morph tweaks) that is more churn-heavy and speculative with an ambiguous 'fullscreen?' message, though it does add some test coverage; but it lacks the clear necessity and precision of B's bugfix.

A delivers lasting product value: chromeless fullscreen compare layout, correct left/right ratio orientation and strength-sorted edge history, working post-success morph of the ingest preview, CSS, and a unit test. B is a necessary but tiny fix—defining GITHUB_API_BASE_URL so OAuth stops NameErroring—valuable but narrow compared with A’s design and behavior changes.

Side A implements substantial functional improvements to the vote comparison flow: it adds a dedicated chromeless fullscreen layout, updates the POST success path to morph both the new vote preview and edge history, normalizes and sorts vote ratios relative to the displayed left/right order, and includes new tests covering the sorting behavior and browser interaction. Side B is a valuable but narrowly scoped bug fix that defines `GITHUB_API_BASE_URL` with a default to prevent a `NameError` when the OAuth callback references the GitHub API base URL.

Side B fixes a real production NameError in the actual application code (missing GITHUB_API_BASE_URL definition), directly preventing a crash in the OAuth callback path. Side A's changes, while more extensive, are confined to test infrastructure/mocks—valuable for test reliability but not fixing a production defect; it also introduces a subtle regression risk by using 0 instead of -1 for redirect content-length without clear justification.

B fixes a production NameError by defining the missing GITHUB_API_BASE_URL used in the real OAuth callback path, which directly restores live GitHub auth. A only repairs test doubles (query split regex, getRequestBody, null-safe token/state handling) and Playwright helpers so E2E mocks work again—valuable, but not user-facing runtime behavior.

Side A repairs multiple concrete failures in the OAuth test infrastructure: it fixes query parsing (`str/split` regex), reads POST bodies from `getRequestBody`, guards against nil tokens and states, corrects redirect response handling, wraps mock handlers to avoid crashes, and updates Playwright helpers to read the right selectors and wait reliably. Side B is a useful but narrowly scoped fix that defines `GITHUB_API_BASE_URL` with a default to eliminate a callback `NameError`; its impact is limited compared with the broader restoration of end-to-end authentication testing in Side A.

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

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

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

Side A fixes a real production bug (a NameError crash in the GitHub OAuth callback) by defining the missing GITHUB_API_BASE_URL, directly improving correctness and reliability. Side B is a substantial but purely test-infrastructure refactor—deduplicating helper functions across test files—which improves maintainability but has no production impact and carries more risk of subtle regressions in test behavior.

A is a precise production bugfix that defines the missing GITHUB_API_BASE_URL (with default and rstrip) so the GitHub OAuth callback no longer raises NameError. B is a pure test-suite refactor that extracts duplicated helpers (assert/ANSI, HTTP clients, mock Google, cargo build, server env, registration) into common.bb/oauth.bb without changing product behavior or fixing runtime issues.

Side A fixes a runtime bug by defining `GITHUB_API_BASE_URL` with a default (`https://api.github.com`) and normalizing it via `rstrip("/")`, directly preventing a NameError during the GitHub OAuth callback when the environment variable is absent. Side B is largely a refactoring of test code, extracting shared helpers (`test.common`/`test.oauth`) and reducing duplication, which improves maintainability but does not materially change production behavior.

Side A fixes a real correctness bug (duplicate `#entity-section`/`#entity-panel` IDs breaking SSE morph targeting when multiple entity sections appear on a page, e.g. vote comparison) by switching to per-item data-attribute selectors, and also deduplicates ~80 lines of markup/CSS by reusing entity_section in the vote card. Side B is a minimal one-line env-var fix for an OAuth NameError, which is a valid but narrow and trivial fix with little lasting design impact.

A replaces singleton #entity-section/#entity-panel IDs with per-item data-entity-section selectors and reuses entity_section in the vote compare UI (with matching CSS cleanup), a lasting multi-target morph/design fix. B only adds a missing GITHUB_API_BASE_URL default—correct and necessary, but a four-line config patch with far less structural impact.

Side A replaces the hard-coded `#entity-section` target with a per-item `data-entity-section` selector via a shared `entity_section_selector()` helper, updates all SSE morph calls to use it, and reuses the same `entity_section` rendering in the voting UI, eliminating duplicated markup and avoiding reliance on duplicate IDs. Side B is a small but useful bug fix that defines `GITHUB_API_BASE_URL` with a default to prevent a NameError when the environment variable is absent, but its scope is much narrower.

Side A is a minimal, precise fix that defines the missing GITHUB_API_BASE_URL to resolve an actual runtime NameError crash in OAuth callback, delivering clear correctness value. Side B is a larger UI refactor (grouped CLI panel with hover-to-copy) that is reasonable but purely cosmetic/feature polish with more surface area for regressions and no critical bug being fixed.

A is a precise production bugfix: it defines the missing GITHUB_API_BASE_URL so OAuth callback code no longer raises NameError. B is a larger but non-critical UX refactor (multi-cmd cli_panel, click-to-copy, CSS, call-site churn) that improves polish without fixing broken behavior.

Side B refactors the CLI panel to support multiple commands in a single component, updates all call sites, adds hover-to-copy behavior, and introduces assertions preventing JavaScript-breaking characters from being embedded in the generated onclick handler, improving both usability and robustness. Side A is a valuable but narrowly scoped bug fix that defines `GITHUB_API_BASE_URL` with a default value to prevent a `NameError` when the OAuth callback references it.

B is a small, targeted bugfix that defines the missing GITHUB_API_BASE_URL to prevent a NameError in the OAuth callback, a real correctness fix. A is a large refactor replacing a working rule-based URL engine with a new graph/DFA architecture but deletes all existing tests without adding new coverage in the diff, making its correctness and lasting value harder to verify despite its scope.

Side A replaces the ad-hoc ParsedUrl combinator engine with a graph/DFA-based canonicalization API (registry rewrite, module split, docs), which is lasting core design for ItemId identity. Side B only adds a missing GITHUB_API_BASE_URL default—a real but tiny localized crash fix with far less system impact.

Side B fixes a concrete runtime bug by defining `GITHUB_API_BASE_URL` with a sensible default, preventing a `NameError` in the GitHub OAuth callback when the environment variable is absent. Side A largely replaces the URL normalization architecture by deleting `engine.rs` and redirecting `registry.rs` to new `graph`/`parse` modules, but the substantive implementation is not present in the shown patch, making the demonstrated lasting value less certain than the explicit bug fix.

Side B implements a genuine behavioral fix (splitting unranked siblings into individual groups rather than one lumped group), updates the doc comment to match, and adds a new test verifying the corrected grouping logic. Side A is a minimal one-line bugfix (defining a missing env var) with no test coverage, addressing a narrower and less substantive issue.

B changes real sibling-nav behavior (each unranked item becomes its own group) and adds a focused regression test, which is lasting product logic. A only introduces a missing GITHUB_API_BASE_URL default—a correct but tiny config fix with no broader design or test depth.

Side B changes the sibling navigation logic so each unranked sibling is placed into its own navigation group instead of combining all unranked items into a single group, updates the documentation to match the behavior, and adds a regression test verifying the new grouping. Side A is a targeted fix that defines `GITHUB_API_BASE_URL` with a default value to prevent a `NameError`, but it is a much narrower configuration bugfix.

Side A is a 3-line defensive default that directly eliminates a NameError when GITHUB_API_BASE_URL is unset (the exact condition described in the commit). Side B deletes an 1808-line legacy module, copies its logic into new files (constitution.py additions + ~1700 lines of new parser/parser_action/parser_render/ui wiring), adds .gitignore noise, and ships under the message 'nice'; the net result is high-churn porting rather than a targeted, lasting fix.