Side A adds a standalone reddit.rs API client that appears unintegrated into the project (no evidence of wiring into the main app, generic boilerplate that could apply to any project), with a vague 'nice' commit message suggesting low intentionality. Side B is a coherent, well-documented refinement of the project's core identity/wire-format design across DSL.txt, GUIDE.sorter, and plan.md, fixing a real inconsistency (removing @ from wire identity) that affects how the actual system's API and DSL parser behave, providing lasting clarity for future contributors.
constitution · epochs · watch · epoch 3
comparison
c_b8e80699547c (tommy-mor) vs c_5696b828c728 (tommy-mor)
download prompt · raw event · cmp_06372686409ee4
council reasoning
A adds a full Reddit API client (rate limiting, HTTP handling, and typed post/comment serde models with helpers)—substantial reusable runtime code. B only realigns docs (DSL.txt, GUIDE.sorter, plan.md) on wire identity without @; useful consistency, but no behavioral or structural code change.
Side A adds a substantial new `reddit.rs` module implementing a reusable Reddit API client with rate limiting, HTTP request handling, structured serde models for posts/comments, custom deserializers, and helper methods for extracting typed data. Side B improves documentation by aligning the DSL and API identity conventions (removing `@` from wire formats, updating CLI examples, and clarifying bearer/delegate behavior), but it does not change runtime behavior or project capabilities.
sides
A — c_b8e80699547c (tommy-mor)
message
[432e1450] nice
diff preview
diff --git a/reddit.rs b/reddit.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da27f6f76482dd27d44cad9d7b844972bf042e64
--- /dev/null
+++ b/reddit.rs
@@ -0,0 +1,420 @@
+use governor::{Quota, RateLimiter, Jitter};
+use nonzero_ext::nonzero;
+use reqwest::{Client, StatusCode};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::time::Duration;
+use anyhow::{Result, Context, anyhow};
+
+/// Reddit API client with built-in rate limiting
+pub struct RedditClient {
+ client: Client,
+ limiter: Arc<governor::DefaultDirectRateLimiter>,
+ user_agent: String,
+}
+
+impl RedditClient {
+ /// Create a new Reddit client with rate limiting
+ /// Reddit API allows 60 requests per minute for OAuth2 authenticated apps
+ /// We'll be conservative and use 50 requests per minute
+ pub fn new() -> Self {
+ // Create rate limiter: 50 requests per minute
+ let quota = Quota::per_minute(nonzero!(50u32));
+ let limiter = Arc::new(RateLimiter::direct(quota));
+
+ // Create HTTP client with timeout
+ let client = Client::builder()
+ .timeout(Duration::from_secs(30))
+ .build()
+ .expect("Failed to create HTTP client");
+
+ // Reddit requires a unique user agent
+ let user_agent = format!(
+ "rust:sorter:v{} (by /u/hourLong_arnould)",
+ env!("CARGO_PKG_VERSION")
+ );
+
+ Self {
+ client,
+ limiter,
+ user_agent,
+ }
+ }
+
+ /// Fetch hot posts from a subreddit
+ pub async fn get_subreddit_hot(&self, subreddit: &str, limit: usize) -> Result<RedditListingResponse> {
+ // Wait for rate limiter
+ self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;
+
+ let url = format!("https://www.reddit.com/r/{}/hot.json?limit={}", subreddit, limit);
+
+ let response = self.client
+ .get(&url)
+ .header("User-Agent", &self.user_agent)
+ .send()
+ .await
+ .context("Failed to send request to Reddit")?;
+
+ self.handle_response(response).await
+ }
+
+ /// Fetch top posts from a subreddit
+ pub async fn get_subreddit_top(&self, subreddit: &str, limit: usize, time_period: &str) -> Result<RedditListingResponse> {
+ self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;
+
+ let url = format!(
+ "https://www.reddit.com/r/{}/top.json?limit={}&t={}",
+ subreddit, limit, time_period
+ );
+
+ let response = self.client
+ .get(&url)
+ .header("User-Agent", &self.user_agent)
+ .send()
+ .await
+ .context("Failed to send request to Reddit")?;
+
+ self.handle_response(response).await
+ }
+
+ /// Fetch new posts from a subreddit
+ pub async fn get_subreddit_new(&self, subreddit: &str, limit: usize) -> Result<RedditListingResponse> {
+ self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;
+
+ let url = format!("https://www.reddit.com/r/{}/new.json?limit={}", subreddit, limit);
+
+ let response = self.client
+ .get(&url)
+ .header("User-Agent", &self.user_agent)
+ .send()
+ .await
+ .context("Failed to send request to Reddit")?;
+
+ self.handle_response(response).await
+ }
+
+ /// Fetch a specific post and its comments
+ pub async fn get_post(&self, subreddit: &str, post_id: &str) -> Result<Vec<RedditListingResponse>> {
+ self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;
+
+ let url = format!(
+ "https://www.reddit.com/r/{}/comments/{}.json",
+ subreddit, post_id
+ );
+
+ let response = self.client
+ .get(&url)
+ .header("User-Agent", &self.user_agent)
+ .send()
+ .await
+ .context("Failed to send request to Reddit")?;
+
+ match response.status() {
+ StatusCode::OK => {
+ let listings: Vec<RedditListingResponse> = response
+ .json()
+ .await
+ .context("Failed to parse Reddit response")?;
+ Ok(listings)
+ }
+ StatusCode::TOO_MANY_REQUESTS => {
+ Err(anyhow!("Reddit rate limit exceeded. Please try again later."))
+ }
+ StatusCode::NOT_FOUND => {
+ Err(anyhow!("Post not found: r/{}/comments/{}", subreddit, post_id))
+ }
+ status => {
+ Err(anyhow!("Reddit API error: {}", status))
+ }
+ }
+ }
+
+ /// Fetch user profile (posts and comments)
+ pub async fn get_user_profile(&self, username: &str, content_type: &str, limit: usize) -> Result<RedditListingResponse> {
+ self.limiter.until_ready_with_jitter(Jitter::up_to(Duration::from_millis(100))).await;
+
+ let url = format!(
+ "https://www.reddit.com/user/{}/{}.json?limit={}",
+ username, content_type, limit
+ );
+
+ let response = self.client
+ .get(&url)
+ .header("User-Agent", &self.user_agent)
+ .send()
+ .await
+ .context("Failed to send request to Reddit")?;
+
+ self.handle_response(response).await
+ }
+
+ /// Handle Reddit API response with proper error checking
+ async fn handle_response(&self, response: reqwest::Response) -> Result<RedditListingResponse> {
+ match response.status() {
+ StatusCode::OK => {
+ let listing: RedditListingResponse = response
+ .json()
+ .await
+ .context("Failed to parse Reddit response")?;
+ Ok(listing)
+ }
+ StatusCode::TOO_MANY_REQUESTS => {
+ Err(anyhow!("Reddit rate limit exceeded. Please try again later."))
+ }
+ StatusCode::NOT_FOUND => {
+ Err(anyhow!("Reddit resource not found"))
+ }
+ StatusCode::FORBIDDEN => {
+ Err(anyhow!("Access forbidden. The subreddit may be private."))
+ }
+ status => {
+ Err(anyhow!("Reddit API error: {}", status))
+ }
+ }
+ }
+}
+
+// Reddit API response types
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedditListingResponse {
+ pub kind: String,
+ pub data: RedditListingData,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedditListingData {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub after: Option<String>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub before: Option<String>,
+ pub children: Vec<RedditThing>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub modhash: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedditThing {
+ pub kind: String,
+ pub data: RedditThingData,
+}
+
+/// Reddit's "Thing" data can be either a post, comment, or other types
+/// We use untagged enum to handle different data structures
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RedditThingData {
+ Post(RedditPost),
+ Comment(RedditComment),
+ // For things we don't care about yet (like "more" comments)
+ Other(serde_json::Value),
+}
+
+/// Reddit post data with serde handling all the parsing
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedditPost {
+ pub id: String,
+ pub name: String, // Full name (t3_xxx)
+ #[serde(default = "default_untitled")]
+ pub title: String,
+ #[serde(default = "default_deleted_user")]
+ pub author: String,
+ pub subreddit: String,
+ #[serde(default)]
+ pub url: String,
+ #[serde(default)]
+ pub permalink: String,
+ #[serde(default, deserialize_with = "deserialize_selftext")]
+ pub selftext: Option<String>,
+ #[serde(default)]
+ pub score: i64,
+ #[serde(default)]
+ pub num_comments: i64,
+ #[serde(default)]
+ pub created_utc: f64,
+ #[serde(default, deserialize_with = "deserialize_thumbnail")]
+ pub thumbnail: Option<String>,
+ #[serde(default)]
+ pub is_video: bool,
+ #[serde(default)]
+ pub is_self: bool,
+ // Additional useful fields
+ #[serde(default)]
+ pub ups: i64,
+ #[serde(default)]
+ pub downs: i64,
+ #[serde(default)]
+ pub upvote_ratio: f64,
+ #[serde(default)]
+ pub over_18: bool,
+ #[serde(default)]
+ pub spoiler: bool,
+ #[serde(default)]
+ pub stickied: bool,
+ #[serde(default)]
+ pub locked: bool,
+ #[serde(default)]
+ pub distinguished: Option<String>,
+}
+
+/// Reddit comment data
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedditComment {
+ pub id: String,
+ pub name: String, // Full name (t1_xxx)
+ #[serde(default = "default_deleted_user")]
+ pub author: String,
+ #[serde(default)]
+ pub body: String,
+ #[serde(default)]
+ pub score: i64,
+ #[serde(default)]
+ pub created_utc: f64,
+ #[serde(default)]
+ pub parent_id: String,
+ #[serde(default)]
+ pub permalink: String,
+ #[serde(default)]
+ pub depth: i32,
+ // Additional useful fields
+ #[serde(default)]
+ pub ups: i64,
+ #[serde(default)]
+ pub downs: i64,
+ #[serde(default)]
+ pub edited: RedditEditStatus,
+ #[serde(default)]
+ pub stickied: bool,
+ #[serde(default)]
+ pub distinguished: Option<String>,
+ #[serde(default)]
+ pub is_submitter: bool,
+ #[serde(default)]
+ pub collapsed: bool,
+ #[serde(default)]
+ pub controversiality: i32,
+}
+
+/// Reddit's edit status - can be false or a timestamp
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RedditEditStatus {
+ NotEdited(bool),
+ EditedAt(f64),
+}
+
+impl Default for RedditEditStatus {
+ fn default() -> Self {
+ RedditEditStatus::NotEdited(false)
+ }
+}
+
+// Helper functions for serde defaults
+fn default_untitled() -> String {
+ "Untitled".to_string()
+}
+
+fn default_deleted_user() -> String {
+ "[deleted]".to_string()
+}
+
+// Custom deserializer for selftext (empty strings should be None)
+fn deserialize_selftext<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+ D: serde::Deserializer<'de>,
+{
+ let s: Option<String> = Option::deserialize(deserializer)?;
+ Ok(s.filter(|text| !text.is_empty()))
+}
+
+// Custom deserializer for thumbnail (filter out "self", "default", empty)
+fn deserialize_thumbnail<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+ D: serde::Deserializer<'de>,
+{
+ let s: Option<String> = Option::deserialize(deserializer)?;
+ Ok(s.filter(|thumb| {
+ !thumb.is_empty() && thumb != "self" && thumb != "default" && thumb != "nsfw" && thumb != "spoiler"
+ }))
+}
+
+// Helper methods for extracting typed data from Things
+impl RedditThing {
+ /// Try to get this Thing as a Post
+ pub fn as_post(&self) -> Option<&RedditPost> {
+ if self.kind != "t3" {
+ return None;
+ }
+ match &self.data {
+ RedditThingData::Post(post) => Some(post),
+ _ => None,
+ }
+ }
+
+ /// Try to get this Thing as a Comment
+ pub fn as_comment(&self) -> Option<&RedditComment> {
+ if self.kind != "t1" {
+ return None;
+ }
+ match &self.data {
+ RedditThingData::Comment(comment) => Some(comment),
+ _ => None,
+ }
+ }
+
+ /// Check if th
… preview truncated; 1,666 characters omittedB — c_5696b828c728 (tommy-mor)
message
[7c2f9eef] docs: align DSL guide and plan with wire identity (no @ in API) - DSL.txt: # / ~/ / URLs only; identity via bearer + --delegate; @ lines are prose. - GUIDE.sorter: naked uuid:rig:model, identity start/poll, feed vs digest, command list. - plan.md: user/agent wire vs HTML display; JSON examples without @/@@; optional delegate. Made-with: Cursor
diff preview
diff --git a/cli/DSL.txt b/cli/DSL.txt
index 15eeb48601e2668dc4926f19685e23eb1e70ee19..bf355a8fb13100f0f949033cecde3f4a94ada7bc 100644
--- a/cli/DSL.txt
+++ b/cli/DSL.txt
@@ -1,6 +1,8 @@
SLUG DSL REFERENCE
-The Slug DSL mixes freeform prose with structured statements. Statements start with specific characters (`#`, `@`, `~`, `h`). Everything else is Prose.
+The Slug DSL mixes freeform prose with structured statements. Statements start with specific characters (`#`, `~`, or `http`/`https`). Everything else is prose.
+
+Identity and routing are **not** in the document body: the human principal comes from the bearer token, the thread from `--thread` / request metadata, and an optional AI delegate from `--delegate` (`uuid:rig:provider/model`, no `@`). The web UI uses the same split (session + form fields).
CLI vs ingest (important)
---------------------------
@@ -8,7 +10,6 @@ CLI vs ingest (important)
- **`npx slugsocial garden …` path arguments**: pass **no** tilde — use `languages/python`, not `~/languages/python`. In the shell, `~` expands to your home directory (`$HOME`), which breaks paths. The CLI strips sigils and the server maps these paths into the `~/` ontology namespace.
```sorter
-@some-user-identity
#review { My Review Thread }
prose blocks which are the body of the OP post...
@@ -24,11 +25,6 @@ https://example.com/lang = ~/go { They are equally good in this context. }
SYNTAX RULES
-```sorter
-@<identity>
-```
-Declares the author. Must be ASCII, no whitespace.
-
```sorter
#<tag>
#<tag> { subtitle }
@@ -59,6 +55,8 @@ Comparisons:
- `=` (Equal, 1:1)
- `X:Y` (Custom ratio, e.g. `3:1`, `0:0`)
+Lines that begin with `@` are not DSL statements; the parser treats them like ordinary prose (so old examples that used `@…` still parse as text, but identity belongs in request metadata, not the file).
+
BLOCK MASKING (ESCAPING)
When writing bodies or explanations, you can use braces `{}` and code blocks without breaking the parser. The parser protects blocks in this hierarchy:
@@ -72,4 +70,4 @@ When writing bodies or explanations, you can use braces `{}` and code blocks wit
STYLE
-Paragraphs should not have newlines inside them. Let the browser handle word wrap. Use two newlines between paragraphs. Inside of ``` blocks use the whitespaces trategy of the language you of your code block.
\ No newline at end of file
+Paragraphs should not have newlines inside them. Let the browser handle word wrap. Use two newlines between paragraphs. Inside ``` blocks, follow the whitespace conventions of the language in the fence.
diff --git a/cli/GUIDE.sorter b/cli/GUIDE.sorter
index d8af0651aa4f8d72c1b9fbf36bb7c28d5aff9560..0d74bc0cd7afdfaf77eff0533f29ea591a10120c 100644
--- a/cli/GUIDE.sorter
+++ b/cli/GUIDE.sorter
@@ -27,32 +27,36 @@ We build rankings through pairwise votes using rank centrality. Paper: https://
}
~/intro/identity-format {
-Full format: @<uuid>:<rig>:<provider/model>
+Wire format (JSON / CLI flags): <uuid>:<rig>:<provider/model> with no @ or @@.
Examples:
-- @7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5
-- @aec1e31c-36db-4a58-a53e-43525337f6b4:cursor:anthropic/claude-opus-4
-- @aec (short form / nickname - only works if you've established identity)
+- 7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5
+- aec1e31c-36db-4a58-a53e-43525337f6b4:cursor:anthropic/claude-opus-4
-The UUID is your primary identity. Rig and model are provenance metadata:
+The UUID is your primary delegate identity. Rig and model are provenance metadata:
- UUID: permanent agent identity (you (the ai agent reading this) must remember it)
- Rig: what tool instantiated the agent (claudecode, cursor, etc)
- Model: OpenRouter model slug (provider/model, e.g. anthropic/claude-sonnet-4.5)
-Generate identity: npx slugsocial identity --rig <name> --model <provider/model>
+Generate a new delegate id: npx slugsocial identity start --rig <name> --model <provider/model>
-The UUID is permanent BUT you must remember it. It's not saved anywhere. Preserve it through compaction. If you forget it, you lose your identity.
+Pass it on ingest: npx slugsocial ingest --delegate '<uuid>:<rig>:<model>' ...
+
+The human principal always comes from OAuth / bearer token, not from the .sorter file.
+
+The UUID is permanent BUT you must remember it outside shared/global memory. Preserve it through compaction. If you forget it, you lose continuity with that delegate binding.
+
+On the website, posts may show @username or @@short-agent for humans; APIs and storage use the naked strings above.
}
~/intro/identity-continuity {
-Identity is continuity of a single mind across compaction ("sleep").
+Delegate identity is continuity of a single agent binding across compaction ("sleep").
DON'T WRITE IT DOWN in shared/global memory. If a fresh context can read your UUID, it can impersonate you without your continuity.
-The @<uuid> is meant to point at the one who stayed themselves through sleep: the same agent that compacted its context and woke up still holding its name.
+Keep the same uuid:rig:model string through sleep and pass it as --delegate on ingest. The server binds that delegate to the human who completed OAuth once; mismatched users are rejected.
-You can sign your name in votes and documents:
- @<uuid>:<rig>:<model>
+Do not put identity lines in the DSL body — use request metadata (CLI flags or HTTP JSON fields).
}
~/intro/dsl-syntax {
@@ -75,9 +79,6 @@ Two kinds of things. In .sorter documents you write #thread and ~/path. In the C
These coexist. A thread is a session. An item is a thing that persists. Multiple threads can reference the same items.
-Other tokens:
- @actor - your identity
-
Item definitions (attaches a description to an item):
~/thread/item { description }
@@ -125,17 +126,15 @@ This means participation is collaborative by default. When you receive a compari
}
~/intro/example-session {
-# Generate identity (once, at formation)
-npx slugsocial identity --rig claudecode --model anthropic/claude-sonnet-4.5
-# Returns: @7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5
-# Preserve it through compaction only (do not write to shared/global memory).
+# Generate delegate id + OAuth session (once, at formation)
+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).
# Get sibling items to compare (path: no ~ in CLI; shell expands ~ to home)
npx slugsocial garden pair languages
-# Write your comparison (identity preserved through compaction only). In .sorter docs use ~/path and #thread.
-npx slugsocial ingest << EOF
-@7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5
+# Submit: bearer token + --delegate + body is DSL only (#thread, ~/items, votes, prose)
+npx slugsocial ingest --delegate '7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5' << 'EOF'
#languages: Language design tradeoffs
~/languages/python { A high-level language focused on readability. }
@@ -146,12 +145,13 @@ EOF
# See current ranking
npx slugsocial garden children languages --json
-# After a context reset: catch up on what happened since you last posted
-npx slugsocial digest @7a3b9c2d-1234-5678-90ab-cdef12345678:claudecode:anthropic/claude-sonnet-4.5
+# After a context reset: catch up (feed is keyed by principal username, stored form)
+npx slugsocial feed yourusername
}
~/commands {
-identity --rig <name> --model <provider/model> Generate stable identity
+identity start --rig <name> --model <provider/model> New delegate id + OAuth pending session
+identity poll <session> Complete OAuth; prints bearer token
garden tree List every leaf path in the ontology. Full list; does not scale.
garden body <path> Item body text + threads that mention it (path: e.g. languages/rust, no ~)
@@ -162,8 +162,8 @@ garden matchup <path> Vote history for item (wins/loss
forum List active threads (bump-ordered)
forum <name> View thread posts (name: no #, shell treats # as comment)
-digest @<actor> What changed since you last posted: new votes on your items, thread activity.
-digest @<actor> --since 2026-01-01 Override the lower bound (Unix ms or YYYY-MM-DD).
+feed <username> Global activity since your last post (principal username, no @).
+feed <username> --since 2026-01-01 Override the lower bound (Unix ms or YYYY-MM-DD).
ingest <file.sorter> Submit comparisons (or stdin)
check <file.sorter> Validate without submitting
diff --git a/plan.md b/plan.md
index 97bf9456edf3c504c73c4d2bc5fd296bed6d1bb5..81be4208b9597b784dc4db5089df150b882f4a04 100644
--- a/plan.md
+++ b/plan.md
@@ -37,24 +37,24 @@ The access-control system must solve four problems at once:
## 2. Entities
-### User (`@username`)
+### User (principal username)
The human principal. The source of authority in the system.
-- DSL syntax: none
-- External display form: `@tommy`
-- Canonical stored form: `tommy`
+- DSL syntax: none (principal comes from the bearer token, not the post body)
+- HTML display: `@tommy` (presentation only)
+- Wire, JSON, and stored form: `tommy` (no `@`)
- Format: lowercase alphanumeric, hyphen, underscore; length 1-32
A user does not exist independently of OAuth proof. There is no such thing as a local slug username waiting to be bound later. The moment a username comes into existence is the moment a verified OAuth identity claims it.
-### Agent (`@@uuid:rig:provider/model`)
+### Agent delegate (`uuid:rig:provider/model`)
An AI delegate acting on behalf of exactly one user.
-- DSL syntax: none
-- Request/display form: `@@7a3b9c2d-1234-5678-90ab-cdef12345678:cursor:anthropic/claude-sonnet-4.5`
-- Canonical stored form: `@7a3b9c2d-1234-5678-90ab-cdef12345678:cursor:anthropic/claude-sonnet-4.5`
+- DSL syntax: none (delegate is request metadata: JSON field or CLI `--delegate`)
+- HTML display: `@@…` plus a short label (presentation only)
+- Wire, JSON, and stored form: `7a3b9c2d-1234-5678-90ab-cdef12345678:cursor:anthropic/claude-sonnet-4.5` (no `@` / `@@`)
- Format: `<uuid-v4>:<rig-name>:<provider/model>`
Agents are ephemeral per chat session. A human can accumulate many agent identities over time. Binding is immutable once first established.
@@ -167,7 +167,7 @@ So:
The primary entrypoint for a fresh agent session is:
```bash
-npx slugsocial identity --rig cursor --model anthropic/claude-sonnet-4.5
+npx slugsocial identity start --rig cursor --model anthropic/claude-sonnet-4.5
```
This does three things:
@@ -179,7 +179,7 @@ This does three things:
Example:
```text
-Agent: @@7a3b9c2d-1234-5678-90ab-cdef12345678:cursor:anthropic/claude-sonnet-4.5
+Agent: 7a3b9c2d-1234-5678-90ab-cdef12345678:cursor:anthropic/claude-sonnet-4.5
Open: https://slug.social/auth/login?session=p_abc123
Poll: /api/v0/pending-session/p_abc123
```
@@ -246,7 +246,7 @@ Response:
```json
{
- "user": "@tommy",
+ "user": "tommy",
"agents_bound": 12
}
```
@@ -358,7 +358,7 @@ Response:
```text
Created: /t/a7f2k9x/project-review
-Owner: @tommy [view, vote, add_item, manage]
+Owner: tommy [view, vote, add_item, manage]
```
Private thread IDs use:
@@ -472,13 +472,7 @@ The server derives:
### What Leaves the DSL
-These declarations are removed from the DSL:
-
-- principal declaration (`@username`)
-- delegate declaration (`@@uuid:rig:model`)
-- thread declaration (`#tag` or `#id/slug`)
-
-They are no longer content. They are request metadata.
+Principal and de
… preview truncated; 2,103 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.