You are a constitutional council ranking individual git commits for ownership allocation. Compare these two commits. Decide which contributed more lasting value to the project. Judge substance, not spectacle: - Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise. - Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one. - Do not favor a side merely because its patch is longer or noisier. - Weight what the change does for the project, not the contributor's name. Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."} The explanation must cite concrete differences in the patches (1-3 sentences). Side A — contributor: tommy-mor Side A — commit message: [0366806e] Color rank rows by vote mass within each group, not list position. Min–max normalization keeps similar scores visually close while still using the full gradient as groups grow and absolute mass dilutes. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index a58cbbee3490a08a625cb06df06848c59a615d65..4eff2e19ed4d303ff8e80c1eabd8a15b4990e643 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -264,12 +264,19 @@ pub fn scope_theme_style(parent: &ItemId) -> String { ) } -fn rank_row_style(parent: &ItemId, ordinal: usize, total: usize) -> String { - let t = if total <= 1 { - 0.0 - } else { - ordinal as f64 / (total - 1) as f64 - }; +/// Map vote mass to gradient position using the group's score range, not raw mass or +/// list position. Vote mass sums to 1 across the component, so absolute values dilute +/// as N grows; min–max within the visible list preserves similar scores → similar colors. +fn score_gradient_t(score: f64, min_score: f64, max_score: f64) -> f64 { + let spread = max_score - min_score; + if spread < 1e-9 { + return 0.5; + } + ((max_score - score) / spread).clamp(0.0, 1.0) +} + +fn rank_row_style(parent: &ItemId, score: f64, min_score: f64, max_score: f64) -> String { + let t = score_gradient_t(score, min_score, max_score); let base_hue = scope_base_hue(parent); let hue = (base_hue + 118.0 * t) % 360.0; let lightness = 0.74 - 0.34 * t; @@ -295,14 +302,15 @@ fn rank_list( highlighted: &HashSet, tree: &GlobalTree, ) -> Markup { - let group_len = items.len(); + let min_score = items.iter().map(|r| r.score).fold(f64::INFINITY, f64::min); + let max_score = items.iter().map(|r| r.score).fold(f64::NEG_INFINITY, f64::max); html! { @if !items.is_empty() { h3 class="rank-heading muted small" { (label) } ol class="rank-list" { @for (i, r) in items.iter().enumerate() { @let href = item_href(&r.item); - @let style = rank_row_style(parent, i, group_len); + @let style = rank_row_style(parent, r.score, min_score, max_score); @let class = rank_row_class(&r.item, highlighted); li class=(class) data-rank-item=(r.item.as_str()) @@ -517,19 +525,37 @@ pub async fn browse(State(state): State, uri: Uri) -> impl IntoRespons #[cfg(test)] mod tests { - use super::{rank_row_style, SORTER_UI_JS}; + use super::{rank_row_style, score_gradient_t, SORTER_UI_JS}; use crate::path_types::ItemId; #[test] - fn rank_row_style_gradients_per_group_not_globally() { + fn score_gradient_t_uses_group_range_not_absolute_mass() { + assert!((score_gradient_t(0.12, 0.08, 0.12) - 0.0).abs() < 1e-9); + assert!((score_gradient_t(0.08, 0.08, 0.12) - 1.0).abs() < 1e-9); + // Raw 12% mass would map near the dark end globally; within this group it's the top. + assert!(score_gradient_t(0.12, 0.08, 0.12) < score_gradient_t(0.12, 0.0, 1.0)); + } + + #[test] + fn score_gradient_t_similar_scores_similar_t() { + let a = score_gradient_t(0.41, 0.20, 0.60); + let b = score_gradient_t(0.40, 0.20, 0.60); + assert!((a - b).abs() < 0.05); + assert!((a - score_gradient_t(0.60, 0.20, 0.60)).abs() > 0.3); + } + + #[test] + fn score_gradient_t_tied_scores_neutral() { + assert!((score_gradient_t(0.25, 0.25, 0.25) - 0.5).abs() < 1e-9); + } + + #[test] + fn rank_row_style_same_inputs_same_color() { let parent = ItemId::opaque("test-scope"); - let first_in_four = rank_row_style(&parent, 0, 4); - let last_in_four = rank_row_style(&parent, 3, 4); - let first_in_two = rank_row_style(&parent, 0, 2); - let last_in_two = rank_row_style(&parent, 1, 2); - assert_eq!(first_in_four, first_in_two); - assert_eq!(last_in_four, last_in_two); - assert_ne!(first_in_four, last_in_four); + assert_eq!( + rank_row_style(&parent, 0.33, 0.20, 0.60), + rank_row_style(&parent, 0.33, 0.20, 0.60), + ); } #[test] Side B — contributor: tommy-mor Side B — commit message: [62d18183] room create path Side B — unified diff (full patch): diff --git a/cli/GUIDE.sorter b/cli/GUIDE.sorter index dcb06a46045564f8f6f6acffbda6f88644d453cc..9828cba4d9c17b7cce3de597d8724609b2b2adbe 100644 --- a/cli/GUIDE.sorter +++ b/cli/GUIDE.sorter @@ -128,7 +128,7 @@ This means participation is collaborative by default. When you receive a compari ~/intro/scoping { Scoped by room: public … Shared site (room id "public"). - private … Private room (e.g. abc12xy/my-project from RoomCreate over RPC). + private … Private room (create with `npx slugsocial room create ` after OAuth — prints e.g. abc12xy/my-project). Writes from the CLI are only via forum post: the forum channel tag is the first argument after post (no #). Humans post through the website; CLI requires --delegate (agent identity). @@ -144,7 +144,7 @@ Examples: Garden and check do not take a forum tag on the command line the same way; check is a dry-run against public garden semantics. -Global (no room prefix): identity, whoami, feed, search, healthz. +Global (no room prefix): room, identity, whoami, feed, search, healthz. } ~/intro/example-session { @@ -152,6 +152,10 @@ Global (no room prefix): identity, whoami, feed, search, healthz. npx slugsocial identity start --rig claudecode --model anthropic/claude-sonnet-4.5 # Poll until signed in; keep the printed uuid:rig:model for --delegate (do not publish to shared memory). +# Private room (optional): creates shortid/slug you pass to `private …` +# npx slugsocial room create austin +# npx slugsocial private invite-link --caps view,post,vote --uses 5 + # Get sibling items to compare (path: no ~ in CLI; shell expands ~ to home) npx slugsocial public garden pair languages @@ -192,8 +196,12 @@ forum post --delegate DELEGATE [FILE] Post a .sorter doc (stdin if no check [FILE] Validate without submitting (public garden dry-run) +invite-link --caps view,post[,…] [--uses N] Mint shareable /join/… link (private rooms; Manage required) +audit [--json] List principals + capabilities (private rooms; View or Manage) + Global (no public/private prefix): +room create Create a private room (bearer required); prints ROOM_ID for `private …` (use `public …` for the shared site, not a room) identity start --rig --model New delegate id + OAuth pending session identity poll Complete OAuth; saves bearer token diff --git a/cli/src/main.rs b/cli/src/main.rs index 8eda9f485bd1f7392f1e34be27176c21e20354eb..5b1a5845e90bfea9bd9a1e1af5744e97e566b5ae 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -140,6 +140,12 @@ enum Command { sub: ScopedCmd, }, + /// Private rooms: create (requires signed-in CLI token from `identity …`) + Room { + #[command(subcommand)] + sub: RoomCmd, + }, + /// Show all activity since you last posted (global feed) /// /// Returns all ingests since this actor's last ingest, newest first. @@ -203,6 +209,18 @@ enum Command { }, } +#[derive(Subcommand, Debug)] +enum RoomCmd { + /// Create a private room; prints `shortid/slug` for `private …` (public site is `public …`, not a room) + Create { + /// Room slug (lowercase letters, digits, hyphens; 1–64 chars), e.g. `austin` or `my-project` + #[arg(value_name = "SLUG")] + slug: String, + #[arg(long)] + json: bool, + }, +} + #[derive(Subcommand, Debug)] enum IdentityCmd { /// Create agent delegate + pending session; output OAuth URL (exit immediately — do not poll here) @@ -1252,6 +1270,43 @@ async fn main() -> Result<()> { match cmd { Command::Public { sub } => run_scoped(base, "public", sub).await?, Command::Private { room, sub } => run_scoped(base, &room, sub).await?, + Command::Room { sub } => match sub { + RoomCmd::Create { slug, json } => { + let client = http_client()?; + let bearer = effective_bearer().ok_or_else(|| { + anyhow!( + "no bearer token: run `slugsocial identity start --rig --model ` \ + then `slugsocial identity poll `, or set SLUG_BEARER_TOKEN / ~/.config/slugsocial/token" + ) + })?; + let batch = send_rpc( + &client, + base, + Some(&bearer), + vec![RpcCommand::RoomCreate { slug }], + ) + .await?; + match rpc_line_ok(&batch.results[0])? { + RpcResult::RoomCreated { room_id } => { + if json { + println!( + "{}", + serde_json::to_string_pretty(&serde_json::json!({ + "ok": true, + "room_id": room_id, + }))? + ); + } else { + println!("{room_id}"); + println!(); + println!("Next: npx slugsocial private {room_id} forum post --delegate '…' …"); + println!(" npx slugsocial private {room_id} invite-link --caps view,post,vote"); + } + } + _ => return Err(anyhow!("unexpected RPC result")), + } + } + }, Command::Healthz { json } => { let client = http_client()?; diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs index f6bbc3df71909a2da7403cd46fe4ea6ca130c692..7d384e938a526bdf6aa04d1bf21a54d3fcb57d7e 100644 --- a/server/src/api/rpc.rs +++ b/server/src/api/rpc.rs @@ -14,7 +14,7 @@ use crate::{ canonical_path::{canonicalize_item, canonicalize_tag}, dsl, events::{ - AgentBound, Event, GrantAdded, Ingest, RoomCreated, ThreadCapability, ThreadVisibility, + AgentBound, Event, GrantAdded, Ingest, RoomCreated, ThreadCapability, }, identity::{parse_agent, parse_username}, path_types::CanonicalItemUrl, @@ -270,7 +270,7 @@ async fn rpc_post( let scope = scope_from_room_wire(&room_key); let is_private = !matches!(scope, ScopeId::Public); - if is_private && !reduced.rooms.contains_key(&room_key) { + if is_private && !reduced.rooms.contains(&room_key) { drop(reduced); return Err(("unknown room".into(), Some(format!("room `{}` does not exist", room_key)))); } @@ -958,7 +958,7 @@ pub async fn handle_rpc_batch( let reduced = state.reduced.read().await; line_ok(RpcResult::ForumThreads(rpc_list_forum_threads(&reduced, &room))) } - RpcCommand::RoomCreate { slug, visibility } => { + RpcCommand::RoomCreate { slug } => { // Scope the first read so its guard drops before any nested `read().await` / `write().await`. // A guard from `match verify(..., &*state.reduced.read().await)` would otherwise live for the // whole `match` and deadlock here (tokio::sync::RwLock is not reentrant). @@ -975,53 +975,42 @@ pub async fn handle_rpc_batch( } else if !slug.chars().all(|c| c.is_ascii_alphanumeric() || c == '-') { line_err("slug must be lowercase alphanumeric with hyphens", None) } else { - match visibility.as_deref().unwrap_or("private") { - "private" | "public" => { - let vis = if visibility.as_deref() == Some("public") { - ThreadVisibility::Public - } else { - ThreadVisibility::Private - }; - let short_id = loop { - let id = gen_short_id(); - if !state.reduced.read().await.rooms.contains_key(&format!("{id}/{slug}")) { - break id; - } - }; - let room_id = format!("{short_id}/{slug}"); - let ts = now_ms(); - let tc_ev = Event::RoomCreated(RoomCreated { - ts, - room_id: room_id.clone(), - slug: slug.clone(), - owner: principal.clone(), - visibility: vis, - }); - let ga_ev = Event::GrantAdded(GrantAdded { - ts, - room_id: room_id.clone(), - username: principal.clone(), - capabilities: vec![ - ThreadCapability::View, - ThreadCapability::Post, - ThreadCapability::Vote, - ThreadCapability::AddItem, - ThreadCapability::Manage, - ], - granted_by: principal.clone(), - }); - if let Err(e) = state.event_log.append(&tc_ev).await { - line_err(format!("{e}"), None) - } else if let Err(e) = state.event_log.append(&ga_ev).await { - line_err(format!("{e}"), None) - } else { - let mut r = state.reduced.write().await; - r.apply_event(tc_ev); - r.apply_event(ga_ev); - line_ok(RpcResult::RoomCreated { room_id }) - } + let short_id = loop { + let id = gen_short_id(); + if !state.reduced.read().await.rooms.contains(&format!("{id}/{slug}")) { + break id; } - other => line_err(format!("unknown visibility: {other}"), None), + }; + let room_id = format!("{short_id}/{slug}"); + let ts = now_ms(); + let tc_ev = Event::RoomCreated(RoomCreated { + ts, + room_id: room_id.clone(), + slug: slug.clone(), + owner: principal.clone(), + }); + let ga_ev = Event::GrantAdded(GrantAdded { + ts, + room_id: room_id.clone(), + username: principal.clone(), + capabilities: vec![ + ThreadCapability::View, + ThreadCapability::Post, + ThreadCapability::Vote, + ThreadCapability::AddItem, + ThreadCapability::Manage, + ], + granted_by: principal.clone(), + }); + if let Err(e) = state.event_log.append(&tc_ev).await { + line_err(format!("{e}"), None) + } else if let Err(e) = state.event_log.append(&ga_ev).await { + line_err(format!("{e}"), None) + } else { + let mut r = state.reduced.write().await; + r.apply_event(tc_ev); + r.apply_event(ga_ev); + line_ok(RpcResult::RoomCreated { room_id }) } } } @@ -1161,7 +1150,7 @@ pub async fn handle_rpc_batch( Err((_, m)) => line_err(m, None), Ok(principal) => { let reduced = state.reduced.read().await; - if !reduced.rooms.contains_key(&room) { + if !reduced.rooms.contains(&room) { line_err("unknown room", None) } else { let can_audit = reduced.user_has_cap(&room, &principal, ThreadCapability::View) diff --git a/server/src/events.rs b/server/src/events.rs index 9e60f2c218f5c871a93e855e415dd984e3a017c5..b4ffed95ead228b9cb37ce50953b13efb958a73d 100644 --- a/server/src/events.rs +++ b/server/src/events.rs @@ -1,12 +1,5 @@ use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] -#[serde(rename_all = "snake_case")] -pub enum ThreadVisibility { - Public, - Private, -} - #[derive(Debug, Clone, Copy, Hash, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum ThreadCapability { @@ -57,13 +50,13 @@ pub struct AgentBound { pub username: String, } +/// Private space keyed as `shortid/slug`. #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] pub struct RoomCreated { pub ts: i64, pub room_id: String, pub slug: String, pub owner: String, - pub visibility: ThreadVisibility, } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] diff --git a/server/src/html/search.rs b/server/src/html/search.rs index 9353cf229fbbd2cfbab5b89ba63ebe192042c91f..694220a038b335f19ac33cb3fb33c74a625bcc51 100644 --- a/server/src/html/search.rs +++ b/server/src/html/search.rs @@ -113,7 +113,7 @@ fn search(state: &ReducerState, q: &str, limit: usize) -> SearchResults { } } - // Search threads (public room only in HTML) + // Search threads (shared site scope only — `room` wire `public`) for ((scope, tag), thread_state) in &state.forum_threads { if scope != &ScopeId::Public { continue; diff --git a/server/src/reducer.rs b/server/src/reducer.rs index 5190d0a7ee3d545a786a68fef483322aafdce7f9..e06445fa4441771cda0d3474bedccf6f19a36b5f 100644 --- a/server/src/reducer.rs +++ b/server/src/reducer.rs @@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet, VecDeque}; use serde::{Deserialize, Serialize}; use crate::canonical_path::canonicalize_tag; -use crate::events::{Event, Ingest, ThreadCapability, ThreadVisibility}; +use crate::events::{Event, Ingest, ThreadCapability}; use crate::path_types::CanonicalItemUrl; #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] @@ -151,11 +151,6 @@ pub struct RankHistoryEntry { pub post_id: String, } -#[derive(Debug, Clone)] -pub struct RoomState { - pub visibility: crate::events::ThreadVisibility, -} - /// Durable invite link state (from [`crate::events::InviteMinted`] / [`crate::events::InviteRedeemed`]). #[derive(Debug, Clone)] pub struct ActiveInviteState { @@ -171,7 +166,6 @@ pub enum RoomTimelineKind { RoomCreated { owner: String, slug: String, - visibility: ThreadVisibility, }, GrantAdded { username: String, @@ -235,8 +229,8 @@ pub struct ReducerState { pub ingests_by_id: HashMap, /// (scope, thread_tag) → ingest ids, newest first. pub ingests_by_scope_thread: HashMap<(ScopeId, String), VecDeque>, - /// Private (or public) room registry: room_id → visibility from [`RoomCreated`]. - pub rooms: HashMap, + /// Private room ids (`shortid/slug`) known from [`RoomCreated`]. + pub rooms: HashSet, /// (scope, thread_tag) → last activity. pub forum_threads: HashMap<(ScopeId, String), ForumThreadState>, pub actor_last_post_ts: HashMap, @@ -403,12 +397,7 @@ impl ReducerState { self.agent_bindings.insert(ab.agent, ab.username); } Event::RoomCreated(rc) => { - self.rooms.insert( - rc.room_id.clone(), - RoomState { - visibility: rc.visibility, - }, - ); + self.rooms.insert(rc.room_id.clone()); self.room_timeline .entry(rc.room_id.clone()) .or_default() @@ -417,7 +406,6 @@ impl ReducerState { kind: RoomTimelineKind::RoomCreated { owner: rc.owner.clone(), slug: rc.slug.clone(), - visibility: rc.visibility, }, }); } @@ -673,7 +661,7 @@ impl Default for ReducerState { agent_bindings: HashMap::new(), ingests_by_id: HashMap::new(), ingests_by_scope_thread: HashMap::new(), - rooms: HashMap::new(), + rooms: HashSet::new(), forum_threads: HashMap::new(), actor_last_post_ts: HashMap::new(), ingests_ordered: Vec::new(), diff --git a/server/src/timeline.rs b/server/src/timeline.rs index 251158943ab36d3015268e35f6bdd01c3f42ab3b..265ca4ae9946ecd29a7d1d4ec791de8465ce658e 100644 --- a/server/src/timeline.rs +++ b/server/src/timeline.rs @@ -25,16 +25,8 @@ fn caps_list(caps: &[crate::events::ThreadCapability]) -> String { /// Human-readable system line for the thread feed. pub fn format_room_timeline_entry(e: &RoomTimelineEntry) -> String { match &e.kind { - RoomTimelineKind::RoomCreated { - owner, - slug, - visibility, - } => { - let vis = match visibility { - crate::events::ThreadVisibility::Public => "public", - crate::events::ThreadVisibility::Private => "private", - }; - format!("@{owner} created room #{slug} ({vis})") + RoomTimelineKind::RoomCreated { owner, slug } => { + format!("@{owner} created room #{slug}") } RoomTimelineKind::GrantAdded { username, @@ -141,7 +133,7 @@ pub fn merge_thread_rows( rows } -/// Public forum thread (`room_wire == "public"`): same merge (timeline usually empty). +/// Shared-site thread view (`room_wire == "public"` on the wire). Same merge as private rooms; private-room timeline is unused here. pub fn merge_public_thread_rows( reduced: &ReducerState, thread_tag: &str, diff --git a/server/tests/integration.rs b/server/tests/integration.rs index b930120da09fe7d307f0411b84fb639fb8bd0b15..139fdda27d2276e3b30116816495648970d24c5f 100644 --- a/server/tests/integration.rs +++ b/server/tests/integration.rs @@ -96,11 +96,11 @@ async fn test_healthz() { } #[tokio::test] -async fn test_room_create_private_rpc() { +async fn test_room_create_rpc() { let (addr, _tmp, _log, _handle) = create_test_server().await; let client = reqwest::Client::new(); let batch = serde_json::json!([{ - "RoomCreate": { "slug": "secret-project", "visibility": "private" } + "RoomCreate": { "slug": "secret-project" } }]); let body = rpc_batch(&client, addr, Some(&test_bearer()), batch).await; let line = &body["results"][0]; diff --git a/test/grants.bb b/test/grants.bb index 4ded5ce92576cdea653cce0ba8a751be4374731a..697e7d91545dd3ee96efde07fc8c3cf90f1a8056 100644 --- a/test/grants.bb +++ b/test/grants.bb @@ -82,7 +82,7 @@ ;; Alice creates a private room. _ (println "\nalice creates private room…") create (rpc-batch! base-url alice-token - [{"RoomCreate" {"slug" "secret-project" "visibility" "private"}}]) + [{"RoomCreate" {"slug" "secret-project"}}]) _ (assert! (= 200 (:status create)) "room create HTTP 200") _ (assert! (rpc-line-ok? (:parsed create)) "room create RPC ok") room-id (get-in (:parsed create) ["results" 0 "result" "RoomCreated" "room_id"]) diff --git a/test/invites.bb b/test/invites.bb index f72b1e630a6856174cdef11eb977e2f81b16e551..ca0fd6c858400671452c4ec59c490d05101dd0e4 100644 --- a/test/invites.bb +++ b/test/invites.bb @@ -86,7 +86,7 @@ _ (println "\nalice creates private room…") create (rpc-batch! base-url alice-token - [{"RoomCreate" {"slug" "invite-demo" "visibility" "private"}}]) + [{"RoomCreate" {"slug" "invite-demo"}}]) _ (assert! (= 200 (:status create)) "room create HTTP 200") _ (assert! (rpc-line-ok? (:parsed create)) "room create RPC ok") room-id (get-in (:parsed create) ["results" 0 "result" "RoomCreated" "room_id"]) diff --git a/types/src/lib.rs b/types/src/lib.rs index 98c66a00fd27803ef6f75b5ac478ff2eb762d771..bb8586f1734f77d95598a9294bdb0de2d55bf715 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -319,8 +319,6 @@ pub enum RpcCommand { }, RoomCreate { slug: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - visibility: Option, }, RoomGrant { room: String,