c_0c466eea1ed4483730

Commit A implements a substantial, functionally load-bearing feature: GitHub OAuth login, session cookies, identity/pseudonym events with uniqueness enforcement, trust-weight accrual, and integration with vote-gating across multiple modules plus new Clojure e2e tests, while cleanly extracting the durable crate to an external dependency. Commit B adds a self-contained dev-only CLI tool (sorterc) for offline DSL compilation and JSONL linting, which is useful tooling but narrower in scope and lower-stakes than A's core auth/identity infrastructure that the rest of the app now depends on.

A ships end-to-end GitHub OAuth, session cookies, pseudonym claiming, identity event projection into durable maps, and vote gating—core product auth with routes, schema, apply logic, and integration tests—while B only adds a small offline dev binary (sorterc) that reuses existing DSL/reducer code for compile/scan diagnostics without changing runtime behavior.

Side A introduces substantial product functionality: GitHub OAuth login, session management, pseudonym claiming, vote authorization, new identity events (`PrincipalCreated`, `OauthLinked`, `PseudonymClaimed`), projection logic, storage schema changes, routing, and integration tests. Although it also moves the `durable` crate out of the workspace, the lasting value comes from the new authentication and identity architecture, whereas Side B primarily adds an offline developer tool (`sorterc`) for compiling `.sorter` files and linting JSONL event logs without changing the core application behavior.

Side A adds a substantial, reusable offline module (compile/scan logic in server/src/offline.rs) plus a new workspace CLI tool with documentation, enabling real dev workflows for validating DSL files and JSONL logs, with its own tests. Side B adds a single valuable but narrow test validating rank centrality convergence, which is useful for confidence but contributes far less lasting infrastructure or capability to the project.

A adds lasting offline infrastructure (server offline module, sorterc binary, docs, and tests) so .sorter compile and events.jsonl lint reuse real validator/reducer logic without a server. B only adds one ranking property test; useful as a correctness demo, but far narrower lasting impact than the reusable tooling.

Side A adds a new workspace tool (`sorterc`) plus a reusable `server::offline` module that compiles `.sorter` files, replays reducer state, scans `events.jsonl` for corrupt or unreplayable ingests, exposes a CLI, and includes documentation and tests. Side B adds a single regression test validating the ranking algorithm on a random spanning-tree case, which improves confidence but does not expand project functionality or architecture like the offline tooling does.

Side B adds a self-contained, well-tested offline dev tool (sorterc) with clear docs, a reusable offline module, and unit tests covering compile/scan behavior, providing durable developer tooling value. Side A's theme/room-URL commit is functional but is a large, plumbing-heavy diff threading CookieJar/Uri through many handlers plus room-URL prefixing logic with less test coverage relative to its surface area, making its long-term maintenance cost higher for the value delivered.

A lands production fixes and features: private-room wire URLs (`item_path_for_api_in_room`, `forum_thread_web_url`) across RPC rankings/threads/hints, plus durable server-side theming (cookie, `POST /theme`, layout/SSR). B adds a solid dev-only `sorterc`/`offline` compile+scan path with tests, but it does not change shipped product behavior.

Side A adds durable user-facing and API behavior: it implements persistent theme selection via validated cookies and a `/theme` endpoint, preserves theme across authentication, threads theme state through page rendering, and fixes room-aware URL generation throughout the RPC layer with dedicated helpers and tests. Side B introduces a useful developer-only offline `sorterc` tool for compiling `.sorter` files and scanning `events.jsonl`, but its impact is primarily on development workflows rather than the application's core runtime behavior.

Side A makes a precise, well-tested improvement to the core ranking/pair-selection algorithm used in production voting flow, adding clear sub-priority logic and multiple targeted tests validating the new behavior. Side B adds a useful but peripheral dev-only tool (new crate, CLI, docs) that reuses existing server logic without touching core algorithms, providing convenience rather than fixing or improving the product's central logic.

A improves core pair-suggestion logic (bridge sub-priorities and rank-zip refinement) that every vote UX depends on, with concrete tests for attach-over-isolate and adjacent-rank ordering. B adds useful but peripheral offline dev tooling (sorterc + offline.rs) that does not change product ranking behavior.

Side A improves the project's core pair-selection algorithm by introducing structured bridge and within-component prioritization, preferring attachment of isolates to established components and rank-adjacent refinement once the pool is connected, with multiple targeted tests covering the new behavior. Side B adds a valuable offline developer tool (`sorterc`) for compiling `.sorter` files and scanning JSONL logs, but it primarily enhances development workflow rather than changing the application's core ranking behavior.

Side A implements a concrete, integrated end-user feature (pool-scoped voting) with real logic changes in routing, next-pair selection, and UI, threading state correctly through the vote flow. Side B adds a useful but peripheral dev-only tool (sorterc) that duplicates existing server validation logic in a separate binary, providing convenience but no core product functionality or bugfix.

A adds end-to-end pool-scoped pairwise voting (optional pool query, first-unvoted pair selection, constrained next-pair nav, UI entry point, and form/JS threading), which deepens the core ranking product loop. B is solid reusable offline compile/scan tooling with tests and docs, but it is workspace dev infrastructure rather than a lasting user-facing capability, so it ranks slightly behind.

Side A implements a cohesive product feature by extending the vote flow to support pool-scoped comparisons: it adds a new `pool` query parameter, generates initial pairs from a parent's children, preserves pool context through vote submission and next-pair navigation, and exposes the feature with a new "vote on children" UI link. Side B adds valuable developer tooling (`sorterc`) for offline DSL compilation and JSONL validation, but it is workspace-only infrastructure rather than functionality that directly expands the application's behavior.

A performs a genuine, broad correctness refactor: it introduces validated room_route_segment/room_id_from_route_segment helpers (replacing brittle ad-hoc split_once calls across handlers, nav, search, and tests) and adds a real url_normalize module with tested YouTube-link canonicalization and query-sorting logic that improves external item identity handling. B adds a self-contained dev-only sorterc tool and offline module—useful for local iteration but isolated from core routing/product logic and lower-stakes than A's cross-cutting fixes to route parsing and canonical URL identity.

A delivers a lasting core design change: tightens private-room HTTP paths to a single `/r/{short}{slug}` segment with shared `room_route` encode/decode, wires it through routers/nav/path builders/tests, and adds durable external-URL identity normalization (YouTube rewrite, query sort). B only adds a workspace-only offline CLI plus `server` helper module for local .sorter compile/JSONL lint—useful developer friction reduction, but non-runtime and easy to recreate relative to A’s product-facing URL contract.

Side A introduces a lasting URL routing redesign by centralizing private-room path encoding/decoding (`room_route_segment`/`room_id_from_route_segment`), replacing ad hoc `split_once('/')` logic across routing, link generation, navigation, tests, and constants such as `ROOM_SHORT_ID_LEN`. It also improves canonical URL handling with reusable normalization utilities (including YouTube normalization and stable external URL canonicalization), whereas Side B primarily adds an offline developer tool (`sorterc`) that reuses existing validation and ranking logic without changing the application's core behavior.

Side A rips out a genuinely broken, overengineered keystroke-transition parser (1800+ lines of fragile graph/backtracking logic plus a Playwright race test) and replaces it with a small, correct, testable subreddit-URL parser and simple paste-and-go UI, net-simplifying the codebase while fixing real reliability issues. Side B adds a reasonable but purely auxiliary dev CLI (sorterc) that duplicates server logic for offline linting/compiling—useful tooling but lower-stakes and more speculative than fixing a broken core UX flow shipped to users.

A replaces an unreliable ~1800-line keystroke graph parser plus race-prone autocomplete UI/tests with a small correct paste-and-go URL extractor and redirect, deleting whole modules (parser_action, parser_race) and lasting tech debt. B adds useful but peripheral offline dev tooling (sorterc + offline.rs compile/scan) that does not change core product behavior.

Side B adds a substantial new offline capability: a reusable `offline` module plus a new `sorterc` workspace binary that compiles `.sorter` documents, replays JSONL event logs, reports malformed ingests, and includes tests and CLI integration. Side A mainly replaces a complex autocomplete/parser UI with a simpler paste-and-go flow by deleting the transition graph and related UI logic, which simplifies maintenance but also removes interactive functionality rather than adding broadly reusable project infrastructure.

Side B fixes real bugs (hardcoded hostnames breaking OAuth redirects on custom hosts/staging, wrong deploy branch triggers) by centralizing base-URL logic and using runtime env/window.location, delivering an actual correctness improvement across multiple integrations. Side A adds a substantial new dev-only tool, which is useful but purely additive tooling with no bug fix, and its value is more speculative/internal compared to B's concrete production-affecting fix.

A adds reusable offline compile/scan library code (offline.rs), a workspace binary, tests, and docs that permanently improve DSL validation without a running server. B is a real but narrower fix: centralize get-base-url/window.location.origin for OAuth redirects and flip Fly deploy to staging—correct lasting ops hygiene, but much less new project capability than A.

Side A adds substantial new functionality: a reusable server-side offline module plus a new `sorterc` workspace binary that compiles `.sorter` files, replays and validates `events.jsonl`, emits rankings, and includes tests and documentation. Side B is a valuable but narrower maintenance fix, centralizing base URL generation around `HOSTNAME`/`window.location.origin` and updating deployment to the `staging` branch to correct redirects and deployment behavior.

Side B fixes an actual production bug (mislabeled unranked child titles and incorrect import wiring that bypassed ensure_path for Reddit children), with corresponding updates to integration tests validating the fix. Side A adds a new dev-only tool that is useful but non-critical infrastructure; it's larger in volume but doesn't fix any existing defect, whereas B delivers a real correctness improvement to shipped behavior.

B fixes real production bugs: Reddit children listing now uses apply_entity_under_parent so posts attach under the subreddit without ensure_path pulling /comments/ segments, and ranking_panel/unranked_list show entity titles via child_label instead of path stubs, with tighter integration coverage. A adds solid offline sorterc/compile-scan tooling and docs, but it is workspace-only dev infrastructure rather than correcting core import/UI behavior.

Side B fixes concrete functional issues: Reddit child imports now attach posts directly under the subreddit via a new `apply_entity_under_parent` path that avoids incorrect `ensure_path` behavior, and the ranking panel now shows imported entity titles instead of raw IDs for unranked children. It also updates integration tests to verify the import flow and SSE/UI behavior, whereas Side A mainly adds a developer-only offline compiler/linter tool without changing core runtime behavior.

Side A introduces a genuinely new, well-scoped capability (a workspace-only sorterc tool with a documented CLI, reused validation/reducer logic, and unit tests) that provides ongoing developer value beyond this commit. Side B is a solid, real bugfix (fixing actual crashes like calling .getInputStream instead of .getRequestBody, and str/split with a string instead of a regex) that restores broken E2E auth tests, but its scope and lasting impact are narrower than A's new tool and test coverage.

A adds reusable offline compile/scan APIs (offline.rs ~300 LOC with ranking simulation, JSONL replay, and unit tests) plus a documented workspace binary that permanently improves DSL/CI workflows. B only repairs test doubles (regex split, getRequestBody, nil-safe state encode, try/catch) and a couple of Playwright helpers so E2E auth runs again—valuable but narrower and test-only.

Side A adds a substantial new offline tooling capability by introducing a reusable server-side `offline` module plus a `sorterc` CLI that compiles `.sorter` files, replays JSONL event logs, reports malformed ingests, and includes tests and documentation. Side B fixes important OAuth test infrastructure issues (query parsing, request body handling, redirects, null handling, and Playwright selectors), but those changes are confined to test mocks and restore existing E2E behavior rather than adding broadly reusable project functionality.

Side A ships a real user-facing feature (RoomList RPC + CLI command) with correct authorization filtering and integration tests that explicitly verify per-user isolation, directly touching core server/CLI/types code paths used by end users. Side B adds a useful but auxiliary dev-only offline tool (sorterc) that duplicates server logic for local linting/compiling, which is valuable for developer workflow but has narrower, non-production impact and less direct integration with the core product surface.

A ships a user-facing RoomList RPC, types, and CLI path plus isolation integration tests that only return grant-backed rooms—core product surface. B adds useful but secondary offline dev tooling (sorterc/offline compile+scan) that does not change runtime behavior for end users.

Side B introduces a substantial new offline tooling capability by factoring reusable server logic into an `offline` module, adding `compile_document`, JSONL replay/loading, diagnostics (`scan_jsonl`), a dedicated `sorterc` workspace binary, and unit tests. Side A adds a useful `RoomList` RPC, CLI subcommand, response type, and integration tests for per-user room visibility, but its scope is narrower than the reusable developer tooling and validation infrastructure added in Side B.

Side A ships a real, non-trivial architectural feature (a unified POST /ui endpoint with a generic form-template hole-filling mechanism, wired into the router and shared with existing web_post handlers, plus tests), directly improving the production HTML app. Side B adds a useful but purely dev-tooling side binary (sorterc) for offline DSL compile/lint, valuable for developer workflow but not part of the core product runtime, and largely reuses existing server logic rather than introducing new core capability.

A lands lasting product architecture: a reusable form_template hole-fill layer, HtmlUiAction parsing, a unified POST /ui handler, and shared run_* web_post paths that change how browser UI commands work. B adds a useful offline sorterc/compile-scan dev binary, but it is workspace-only tooling around existing server logic rather than core runtime design.

Side B introduces a reusable offline tooling layer (`server::offline`) plus a new `sorterc` workspace binary that reuses the server's parser, validator, reducer, and ranking code to compile `.sorter` files and diagnose `events.jsonl`, with tests and documented CLI workflows. Side A adds a useful `/ui` endpoint, HTML UI action framework, JSON form templating, and refactors web-post handlers for reuse, but its impact is primarily on browser interaction, whereas Side B creates broadly reusable developer infrastructure for validation, replay, and diagnostics that is likely to provide longer-term maintenance value.

Side B is a substantive type-safety refactor that replaces error-prone String/raw-string item ids with a proper CanonicalItemUrl newtype threaded through validation, RPC pairing, and rank-change computation, reducing a class of stringly-typed bugs and improving compile-time guarantees across core server logic. Side A adds a useful but peripheral dev-only CLI tool (sorterc) that wraps existing server logic for offline linting/compiling, which is valuable tooling but doesn't change or harden the core system's correctness or design the way B's refactor does.

A adds a real offline compile/scan path (server offline module, tests, workspace binary, docs) that reuses production validation and reducer logic for durable dev/CI workflows. B is a worthwhile type-safety cleanup (CanonicalItemUrl through resolve_item, Deref on href newtypes, fewer String round-trips) but remains mostly mechanical propagation without new behavior.

Side A adds a substantial new offline capability: a reusable server `offline` module plus a new `sorterc` workspace binary that compiles `.sorter` files, replays reducer state, scans `events.jsonl` for corrupt or malformed ingests, includes tests, and documents the workflow. Side B is primarily a type-safety refactor that replaces `String` paths with canonical URL newtypes and `Deref` implementations across existing code, improving clarity and reducing conversions but largely preserving existing behavior rather than adding new project functionality.

Side B ships real user-facing functionality (Reddit post thumbnails/images/link rendering with new fields, tests, and CSS) that improves the actual product experience, despite a vague commit message. Side A adds a dev-only offline tool with decent structure and tests, but it's auxiliary tooling with no direct product impact, making B's change more consequential despite A's cleaner presentation.

A adds a full offline compile/scan path (server offline module, dedicated binary, tests, and docs) that reuses core DSL validation and reducer replay—durable developer infrastructure for the project’s central artifactFormats. B only extends Reddit entity parsing/rendering (image_url/link_url, thumbnails, CSS) as a narrow UI specialization, so it is real product polish but less foundational and less reusable than A.

Side A introduces a new workspace tool (`sorterc`) plus reusable `server::offline` APIs to compile `.sorter` files, replay `events.jsonl`, detect malformed ingests, and validate reducer state offline, with CLI integration, documentation, and tests. Side B improves Reddit presentation by adding richer entity rendering, thumbnails, image/link extraction, and supporting tests/CSS, but it is primarily a UI enhancement whereas Side A adds broader development and validation infrastructure that is likely to benefit ongoing maintenance and correctness.

Side B implements a real, functional feature (a background Reddit fetch worker with OAuth, rate-limit handling, backoff, JSON parsing, and integration into the tree/state, backed by tests), delivering concrete user-facing value. Side A adds a useful but narrower dev-only CLI tool (compile/scan) that mainly wraps existing server logic for offline linting, which is helpful tooling but less impactful than shipping working product functionality.

B replaces a stub with a real Reddit fetch path (background broker, OAuth, rate-limit/backoff, URL mapping, JSON parsing, and wiring into browse/ensure_path), which is lasting product capability. A is solid, tested offline DSL/JSONL tooling, but it is workspace/dev-only support rather than core runtime behavior; B’s impact outweighs A’s polish despite A’s cleaner docs.

Side A adds a substantial, reusable offline tooling capability by introducing a new `sorterc` workspace binary plus shared `server::offline` APIs for compiling `.sorter` files, replaying JSONL event logs, diagnostics, and tests. Side B adds Reddit background fetching and request integration, but it is more specialized, includes a placeholder-style `todo` file, and introduces significant networking complexity without the same broadly reusable development and validation infrastructure.

Side A implements substantial real functionality: cookie-based web sessions, private room routing/authz, a compose/post form pipeline, and a full rewiring of forum HTML views to support both public and room-scoped threads—directly expanding the product's core feature set. Side B adds a useful but narrower dev-only offline linting/compiling tool (sorterc) for local .sorter validation, which is valuable tooling but affects a much smaller surface and doesn't touch the live product; A's changes also include a stray unpolished 'plan2.md' chat transcript which is noise, but the core code changes still outweigh B's scope in lasting user-facing value.

Side A ships lasting product surface: cookie-based web sessions, /login /logout /post, room-scoped ThreadNav, ACL-gated room pages/threads/compose forms, and full routing for public + private forum UI. Side B adds a useful but peripheral offline dev binary (sorterc + offline compile/scan) that does not change runtime behavior for users.

Side A adds substantial end-user functionality: browser session cookies, login/logout, authenticated web posting, room-aware thread views with access checks, new routes, and UI integration for private/public forums. Although it also includes a large non-functional planning document (`plan2.md`), the code changes reconnect the web UI and authentication flow, whereas Side B primarily adds an offline developer tool (`sorterc`) for compiling `.sorter` files and scanning `events.jsonl`, which is valuable but has a narrower operational impact.

Side A adds a self-contained, well-tested dev tool (offline compiler/linter) with clear docs and no risk to production code paths, reusing existing server logic cleanly via a new offline.rs module. Side B is a large, invasive refactor (scope->tree, settlement->journal rename, ItemId overhaul) that touches many core files simultaneously with a vague 'reconfigure' message, increasing risk despite adding real tree/breadcrumb functionality; its scope creep and rename churn (settlement->journal) reduce clarity of lasting value compared to A's precise, additive tool.

B rewrites the core domain from flat scope maps to a hierarchical GlobalTree/ItemId model (canonical URL paths, parent/child wiring, journal worker, UI breadcrumbs, vote/event replay), which permanently changes product behavior. A adds solid but auxiliary workspace tooling (offline.rs compile/scan + sorterc CLI) that validates DSL/JSONL without altering the runtime architecture.

Side A adds a substantial new offline tooling capability by introducing a reusable `offline` module plus a new `sorterc` workspace binary that compiles `.sorter` files, replays reducer state from JSONL, scans event logs for malformed ingests, and includes tests and documentation. Side B is a broad architectural reconfiguration toward hierarchical `ItemId`/tree-based state and UI changes, but much of it is scaffolding (placeholder Reddit fetch, renames, structural migration) whose completed value depends on later work, whereas A delivers immediately usable developer functionality built on existing server logic.

Side B fixes a real correctness/data-integrity gap (0-ratio votes silently defaulting to 1:1, unbounded ratios skewing scores) consistently across DSL parser, browser handler, and reducer, with regression tests and an updated integration test proving the fix; this is a genuine bugfix with lasting behavioral impact. Side A adds a sizable new dev-only binary and offline module, which is useful tooling but is additive, not fixing any existing defect, and its value is more speculative/convenience-oriented than a correctness guarantee.

B hardens a core domain invariant (vote ratios both ≥1 and ≤100) in the DSL parser, UI handler, and reducer, with unit/integration/browser coverage—preventing invalid graph edges in production ranking. A adds useful offline compile/scan tooling and docs, but it is workspace-only developer convenience and does not change runtime correctness the way B does.

Side B fixes a correctness issue by enforcing meaningful vote ratio bounds (both sides must be at least 1 and at most 100) consistently in the DSL parser, UI handler, and reducer, preventing zero-weight or extreme votes from creating invalid graph behavior. It also updates affected tests and adds parser, integration, and UI regression tests, whereas Side A primarily adds a useful developer-facing offline tool without changing core runtime correctness.

Side A performs a genuine architectural consolidation—moving path canonicalization/URL construction into a shared slug-types crate with correct-by-construction newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath), replacing scattered string-formatting helpers with typed APIs across server and RPC code, which reduces duplication and future URL-shape bugs. Side B adds a useful but auxiliary dev-only CLI tool (sorterc) for offline DSL compiling/linting, which is valuable tooling but doesn't touch core correctness or design of the production system. Both are solid, but A's refactor has broader lasting impact on the codebase's core type safety and maintainability.

A centralizes path canonicalization and room-aware href construction into shared slug-types newtypes (GardenItemUrl, ForumThreadUrl, TildeOntologyPath) and threads them through API/RPC response types, replacing ad-hoc string helpers with lasting domain structure. B adds a useful but peripheral workspace-only sorterc binary for offline DSL compile/JSONL lint that mostly wraps existing server logic. Core path-identity typing in the shared schema outweighs a dev-only tooling surface.

Side A consolidates canonicalization, path normalization, and room-aware URL generation into a shared `types::paths` module, replacing scattered string helpers with strongly typed `GardenItemUrl`, `ForumThreadUrl`, and `TildeOntologyPath` throughout RPCs and API types. This removes duplicated logic, makes wire formats correct-by-construction across many interfaces, and centralizes core path semantics, whereas Side B adds a useful developer-only offline compiler/linter (`sorterc`) without changing the project's core runtime design.

Commit A is a small, precise correctness fix that prevents ghost items and incorrect voted_pairs state from a real reducer bug, with an updated test verifying the fix. Commit B adds a large new dev-only tool (sorterc) which is useful but is auxiliary tooling rather than a core correctness fix, and its value is more speculative/utility-based than a guaranteed bugfix.

A is a precise core correctness fix: the zero-ratio early-return ran after ensure_item and voted_pairs.insert, leaving ghost index entries and false voted-pair marks; moving the guard before side effects and updating the test locks that in. B adds useful but optional dev-only offline compile/scan tooling (large surface, docs, binary) that does not repair production reducer state.

Side B adds a substantial offline tooling capability: a new workspace binary (`sorterc`) plus reusable `server::offline` APIs to compile `.sorter` documents, replay and lint `events.jsonl`, and accompanying tests and documentation. Side A fixes a real correctness bug by moving the zero-ratio guard before `ensure_item` and `voted_pairs.insert`, preventing ghost items and stale voted-pair state, but its scope is narrower than the enduring developer infrastructure introduced in Side B.

Side A converts a synchronous fetch action into a proper SSE streaming flow with progress states, error handling, retry/backoff via a oneshot result channel, and improved diagnostic logging in the reddit worker, while also cleaning up module structure (moving fetch UI code into its own module) — a real behavioral improvement with matching test updates. Side B adds a standalone dev CLI (sorterc) that reuses existing server logic for offline compile/lint; it's useful tooling but is additive/peripheral, mostly wrapping existing validate/ranking code without changing core system behavior or fixing bugs.

A redesigns a core user path: Reddit entity fetch becomes an awaited SSE stream with oneshot job results, progressive UI morphs, and richer failure handling in the worker—lasting product architecture—versus B’s solid but peripheral offline compile/scan binary. A’s gain is tempered by extra logging and some removed unit tests, so the margin is meaningful but not huge.

Side A introduces a substantive architectural change: entity fetching is converted from a fire-and-forget JS response into an SSE-based workflow with progress/completion events, coordinated via oneshot notifications from the Reddit worker, plus the necessary client-side stream handling and refactoring of fetch-related HTML into its own module. Side B adds a useful developer-only offline tool (`sorterc`) for compiling `.sorter` files and linting `events.jsonl`, but it primarily extends tooling rather than changing the runtime behavior of the application, so its long-term project impact is somewhat narrower.

Side B is a real, integrated change: it adds a working CLI `room create` command, simplifies the reducer's room model (removing dead ThreadVisibility complexity), updates RPC, events, docs, and multiple test suites consistently across the codebase. Side A adds a useful but purely additive dev-only tool (sorterc) that doesn't touch or improve existing production code paths, making its value more isolated and lower-stakes compared to B's cross-cutting simplification and feature completion.

B delivers lasting product and design value: a real CLI `room create` path plus simplifying the core model (drop ThreadVisibility/RoomState, rooms as HashSet, leaner RoomCreated/RPC), wired through server, types, tests, and GUIDE. A is solid offline tooling (offline.rs, sorterc binary, docs/tests) but is workspace-only developer ergonomics on existing compile/scan logic, not a core runtime feature.

Side A adds a substantial new offline development capability: a workspace tool (`sorterc`) with compile and JSONL scan commands, reusable server-side offline APIs (`offline.rs`), tests, and documentation, enabling validation, replay, and diagnostics without a running server. Side B usefully exposes room creation in the CLI and simplifies the room model by removing unused visibility state, but much of the patch is API cleanup and documentation updates rather than adding comparable long-term functionality.