Side A completes an actually missing capability (CLI `room create` calling RPC) end-to-end across CLI, RPC, reducer, and docs, and simultaneously simplifies the room model by removing the unused ThreadVisibility distinction (rooms→HashSet), reducing complexity and bug surface. Side B adds a well-tested but narrower UX convenience (clipboard copy of garden rankings) that, while polished with unit/integration/browser tests, is additive feature surface rather than closing a functional gap or simplifying existing design.
constitution · epochs · watch · epoch 3
comparison
c_1c1c8e7a2de8 (tommy-mor) vs c_57453fc5c6c0 (tommy-mor)
download prompt · raw event · cmp_8619b790f529cf
council reasoning
A lands the real room-create product path (CLI `room create` → RPC) and a lasting domain simplification: drop `ThreadVisibility`/`RoomState`, make `rooms` a `HashSet`, and treat public as the shared site only. B is a solid but peripheral QoL feature—clipboard markdown for garden rankings via a new `CopyGardenRank` UI action—useful polish that reuses existing copy patterns rather than core capability.
Side A adds a substantive new capability by introducing a first-class `room create` CLI command, wiring it through RPC, enforcing bearer authentication, updating documentation, and simplifying the underlying room model by removing the unused visibility concept (`ThreadVisibility`, room state, and RPC parameter) in favor of a simpler room registry. Side B delivers a polished UI feature—a garden ranking copy button with markdown generation, POST `/ui` handling, and browser/tests—but it is primarily a convenience feature rather than a foundational project capability.
sides
A — c_1c1c8e7a2de8 (tommy-mor)
message
[62d18183] room create path
diff preview
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 <ROOM_ID> … Private room (e.g. abc12xy/my-project from RoomCreate over RPC).
+ private <ROOM_ID> … Private room (create with `npx slugsocial room create <slug>` 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 <ROOM_ID> …`
+# npx slugsocial room create austin
+# npx slugsocial private <printed-room-id> 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 <TAG> --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 <slug> Create a private room (bearer required); prints ROOM_ID for `private …` (use `public …` for the shared site, not a room)
identity start --rig <name> --model <provider/model> New delegate id + OAuth pending session
identity poll <session> 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 <ROOM_ID> …` (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 <rig> --model <model>` \
+ then `slugsocial identity poll <session>`, 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 <TAG> --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::Vot
… preview truncated; 10,232 characters omittedB — c_57453fc5c6c0 (tommy-mor)
message
[8f6be6d0] Add copy button for garden rankings (markdown clipboard) (#168) * Add garden ranking markdown copy button via POST /ui Introduce HtmlUiAction::CopyGardenRank that rebuilds the visible child ranking and returns JsBuilder clipboard JS (fetch → eval), matching CopyThread. Place a copy control on garden ranking headings; clipboard text is a concise markdown numbered list with unranked bullets. Co-authored-by: tommy <thmorriss@gmail.com> * Fix paren balance in garden ranking copy browser test Co-authored-by: tommy <thmorriss@gmail.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com>
diff preview
diff --git a/agents.md b/agents.md
index 7d6fea5791f7c95677e17e8975a14df83f998fd6..1dc989e4b23071f2eef69f2479c9a1ca2bd04b32 100644
--- a/agents.md
+++ b/agents.md
@@ -40,6 +40,8 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma
- **Non-morph `POST /ui` responses:** **`SetGardenPin`** returns **`303 See Other`** and **`Set-Cookie`** (same as **`POST /theme`**). Garden pin/unpin is a normal **`<form method="POST" action="/ui" data-navigate="full">`** — browser navigation applies cookies reliably (see **`test/browser_garden_pin.clj`**). Each **`__rpc__`** payload includes **`form_action: "/ui"`**; **`post_ui_html`** rejects mismatches to bind tokens to the UI endpoint.
+- **`CopyGardenRank`:** Browser copy control on garden ranking headings. Returns **`text/javascript`** via **`JsBuilder::clipboard_write_text_and_label_btn`** (same **`fetch` → `eval`** loop as **`CopyThread`**). Payload includes **`room`**, **`parent_path`**, **`depth`**, **`copy_btn_id`**, and optional **`external_hosts`** (for **`/-/`** host-root indexes). Clipboard text is a concise markdown numbered list of display paths (plus unranked bullets).
+
- **`VoteComparePost`:** On success returns **`text/javascript`** that **morphs** **`#vote-edge-history-region`** (recomputed **`<ul>`** — ratios match **`left`/`right`** query order, bullets, sorted by strength toward **`left`** then newer) and **`.vote-compare-nav`** (fresh next-pair link). The compare **`GET`** page uses **`layout_full_bleed_chromeless`** (no breadcrumbs, no **`#controls`**, no **`slug-pin-hud`**; **`view-vote-compare-fullscreen`** full-width **`body`**). **`__rpc__`** carries **`form_action: "/ui"`**; **`thread_tag`** and ratio fields come from the same form as **`$form`** holes. **Guests** on a shared pair see the compose UI with **`post vote`** as a link to **`/login?next=<pair path>`** (class **`vote-compare-login-cta`**); after OAuth / username selection they return to that matchup. An unauthenticated **`VoteComparePost`** (forged/stale form) still JS-redirects to the same **`/login?next=`** target.
- **`ThreadGraduate` / `GraduateThread`:** Private-room forum threads with **Manage** can be published to the public site under the same tag. The writer replays non-redacted ingests into **`room: public`** (chronological order), then appends a durable **`ThreadGraduated`** marker. Graduated private threads show a banner linking to public **`/t/:tag`**, block further private posts, and cannot be graduated twice. CLI: **`npx slugsocial private <room> forum graduate <tag>`**; RPC: **`ThreadGraduate`**.
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index b4a0c9e87e462050bd52728e49e0d6781bf1cfc8..611956d0a46062b49ce350be176e4be139312ff0 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -24,9 +24,9 @@ use crate::{
external_resolver_status_markup, fragment_new_thread_slot, login_to_post_hint_markup,
parse_html_ui_from_form, room_members_section_markup, thread_feed_html,
thread_feed_html_for_room, thread_feed_region_markup, thread_ui_collapse_redacted_post,
- thread_ui_copy_thread,
- thread_ui_expand_post_full, thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room,
- user_can_view_room, HtmlUiAction, JsBuilder, ThreadNav,
+ garden_ui_copy_rank, thread_ui_copy_thread, thread_ui_expand_post_full,
+ thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room, user_can_view_room,
+ HtmlUiAction, JsBuilder, ThreadNav,
},
reducer::{scope_from_room_wire, ScopeId},
state::AppState,
@@ -575,6 +575,25 @@ async fn dispatch_ui_action(
let viewer = session.map(|s| s.username.as_str());
thread_ui_copy_thread(state, &room, &thread_tag, ©_btn_id, viewer).await
}
+ HtmlUiAction::CopyGardenRank {
+ room,
+ parent_path,
+ depth,
+ copy_btn_id,
+ external_hosts,
+ } => {
+ let viewer = session.map(|s| s.username.as_str());
+ garden_ui_copy_rank(
+ state,
+ &room,
+ &parent_path,
+ depth,
+ ©_btn_id,
+ external_hosts,
+ viewer,
+ )
+ .await
+ }
HtmlUiAction::GraduateThread { room, thread_tag } => {
let Some(session) = session else {
return js_redirect("/login").into_response();
diff --git a/server/src/html/garden/copy.rs b/server/src/html/garden/copy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..271ea87c34c99e23ab1b0d8572632fdc41380b78
--- /dev/null
+++ b/server/src/html/garden/copy.rs
@@ -0,0 +1,199 @@
+//! Copy garden rankings to the clipboard as concise markdown (POST /ui + JsBuilder eval).
+
+use crate::form_template::template_json_compact;
+use crate::html::forum::ThreadNav;
+use crate::html::js_string_literal;
+use crate::html::ui_action::HtmlUiAction;
+use crate::html::{JsBuilder, ui_js_warn};
+use crate::path_types::ItemId;
+use crate::reducer::scope_from_room_wire;
+use crate::scope_rank::{
+ build_children_rankings, build_rankings_for_item_set, external_root_host_items,
+ resolve_scope_recursive, ChildrenRankings,
+};
+use crate::state::AppState;
+use maud::{html, Markup};
+
+use super::access::user_can_view_room;
+use super::item::item_display_path;
+use crate::reducer::{ContentState, ScopeId};
+
+const COPY_BTN_ID: &str = "garden-rank-copy";
+
+/// `POST /ui` + `__rpc__` from an inline button; response body is `eval`'d (same as forum copy).
+fn garden_ui_fetch_onclick(rpc_compact_json: &str) -> String {
+ format!(
+ "fetch('/ui',{{method:'POST',headers:{{'Content-Type':'application/x-www-form-urlencoded'}},body:new URLSearchParams({{__rpc__:{}}}).toString(),credentials:'same-origin'}}).then(r=>r.text()).then(eval);return false",
+ js_string_literal(rpc_compact_json)
+ )
+}
+
+/// Concise markdown for ranked child groups (numbered lists + unranked bullets).
+pub(crate) fn format_garden_rank_markdown(rankings: &ChildrenRankings) -> String {
+ let mut out = String::new();
+ let multi = rankings.component_rankings.len() > 1;
+ for (ci, comp) in rankings.component_rankings.iter().enumerate() {
+ if ci > 0 {
+ out.push('\n');
+ }
+ if multi {
+ out.push_str(&format!("### ordering {}\n\n", ci + 1));
+ }
+ for (i, r) in comp.ranked.iter().enumerate() {
+ out.push_str(&format!(
+ "{}. {}\n",
+ i + 1,
+ item_display_path(r.item.as_str())
+ ));
+ }
+ }
+ if !rankings.unranked_items.is_empty() {
+ if !out.is_empty() {
+ out.push('\n');
+ }
+ for name in &rankings.unranked_items {
+ out.push_str(&format!("- {}\n", item_display_path(name.as_str())));
+ }
+ }
+ out
+}
+
+fn rankings_for_copy(
+ state_content: &crate::reducer::ContentState,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> ChildrenRankings {
+ if external_hosts {
+ let hosts = external_root_host_items(state_content);
+ return build_rankings_for_item_set(state_content, &hosts);
+ }
+ let parent = ItemId::parse(parent_path.trim())
+ .unwrap_or_else(|| ItemId::ontology_root())
+ .normalized_storage();
+ let depth = depth.clamp(1, 5);
+ if depth > 1 {
+ let items = resolve_scope_recursive(state_content, &[parent.as_str().to_string()], depth);
+ build_rankings_for_item_set(state_content, &items)
+ } else {
+ build_children_rankings(state_content, &parent)
+ }
+}
+
+pub(crate) async fn garden_ui_copy_rank(
+ state: &AppState,
+ room: &str,
+ parent_path: &str,
+ depth: usize,
+ copy_btn_id: &str,
+ external_hosts: bool,
+ viewer: Option<&str>,
+) -> axum::response::Response {
+ let room = room.trim();
+ let scope = scope_from_room_wire(room);
+ if let ScopeId::Room(ref rid) = scope {
+ let reduced = state.reduced.read().await;
+ if !user_can_view_room(&reduced, rid, viewer) {
+ return ui_js_warn("forbidden");
+ }
+ }
+
+ let reduced = state.reduced.read().await;
+ let empty = ContentState::default();
+ let content = match &scope {
+ ScopeId::Public => reduced.public(),
+ ScopeId::Room(_) => reduced.content_for_scope(&scope).unwrap_or(&empty),
+ };
+ let rankings = rankings_for_copy(content, parent_path, depth, external_hosts);
+ let text = format_garden_rank_markdown(&rankings);
+ drop(reduced);
+
+ if text.is_empty() {
+ return ui_js_warn("nothing to copy");
+ }
+
+ JsBuilder::new()
+ .clipboard_write_text_and_label_btn(&text, copy_btn_id, "copied")
+ .into_response()
+}
+
+pub(super) fn garden_rank_copy_button_markup(
+ nav: &ThreadNav,
+ parent_path: &str,
+ depth: usize,
+ external_hosts: bool,
+) -> Markup {
+ let rpc = template_json_compact(&HtmlUiAction::CopyGardenRank {
+ room: nav.room_wire.clone(),
+ parent_path: parent_path.to_string(),
+ depth,
+ copy_btn_id: COPY_BTN_ID.to_string(),
+ external_hosts,
+ })
+ .expect("CopyGardenRank serializes");
+ html! {
+ button type="button" id=(COPY_BTN_ID) class="post-nav-btn ont-rank-copy-btn" title="Copy ranking as markdown"
+ onclick=(garden_ui_fetch_onclick(&rpc)) {
+ "copy"
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::path_types::ItemId;
+ use crate::ranking::RankedItem;
+ use crate::scope_rank::ScopedComponent;
+
+ #[test]
+ fn markdown_single_component_and_unranked() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![ScopedComponent {
+ pairs: 1,
+ ranked: vec![
+ RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 0.9,
+ },
+ RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 0.1,
+ },
+ ],
+ }],
+ unranked_items: vec![ItemId::parse("~/c").unwrap()],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "1. ~/a\n2. ~/b\n\n- ~/c\n"
+ );
+ }
+
+ #[test]
+ fn markdown_multi_component_headers() {
+ let rankings = ChildrenRankings {
+ component_rankings: vec![
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/a").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ScopedComponent {
+ pairs: 1,
+ ranked: vec![RankedItem {
+ item: ItemId::parse("~/b").unwrap(),
+ score: 1.0,
+ }],
+ },
+ ],
+ unranked_items: vec![],
+ };
+ assert_eq!(
+ format_garden_rank_markdown(&rankings),
+ "### ordering 1\n\n1. ~/a\n\n### ordering 2\n\n1. ~/b\n"
+ );
+ }
+}
diff --git a/server/src/html/garden/mod.rs b/server/src/html/garden/mod.rs
index ee8696727e5473fe1fa913b8a7b9f3cb9c32d12f..69012a2c1d069e47fa611d63d3bd2a329fd6255d 100644
--- a/server/src/html/garden/mod.rs
+++ b/server/src/html/garden/mod.rs
@@ -2,6 +2,7 @@
mod access;
mod browse;
+mod copy;
mod external;
mod item;
mod item_page;
@@ -13,6 +14,7 @@ mod vote;
#[cfg(test)]
mod tests;
+pub(crate) use copy::garden_ui_copy_rank;
pub(crate) use external::external_resolver_status_markup;
pub(crate) use pin::{encode_
… preview truncated; 12,313 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.