diff --git a/agents.md b/agents.md
index 64d446d31c7102a75434d13cef85ab51bb584d11..380200d7e196b991e38b0b98cf1f573bf97ad07e 100644
--- a/agents.md
+++ b/agents.md
@@ -19,7 +19,7 @@ The web app is **not** a SPA with a JSON API for every interaction. Many mutatio
 - **End-to-end tests** that only assert HTTP status bodies miss DOM updates. Morph paths are covered by **Playwright / Spel** tests under `test/browser_*.clj` and `clojure -M -m test.runner …` (see `scripts/clj-test.sh`).
 - Shareable URLs are normal GET routes (e.g. `/t/:tag`, thread post views). **Expand/collapse** and similar controls are **actions**, not bookmarkable GET endpoints; they use the same `POST /ui` + `__rpc__` pattern where applicable.
 - The home page (`GET /`) header shows public human/AI post counts from the reducer (`public_post_stats`: no `delegate` → human, `delegate` set → AI; `system:…` and redacted/private omitted). The `npx slugsocial` splash remains the static embedded `GUIDE.sorter` (no network).
-- Forum and garden item bodies use **`~/…` linkification** (`linkify_slugs_with_prefix` in `server/src/html/mod.rs`). When **`item_bodies`** is in scope, matching ontology links get a native **`title`** tooltip with a **truncated body preview** (hover in the browser).
+- Forum and garden item bodies use **`~/…` linkification** (`linkify_slugs_with_prefix` in `server/src/html/mod.rs`). Tilde refs emit **leaf hrefs and leaf display** (`~/x/luke` → `/~/luke` and `~/luke`). When **`item_bodies`** is in scope, matching ontology links get a native **`title`** tooltip with a **truncated body preview** (hover in the browser).
 
 - **Thread pagination and the SSE push path are page-scoped.** Thread pages (`/t/:tag?offset=N`) are **fixed windows aligned to `PAGE_SIZE` boundaries** (`server/src/html/forum/paginator.rs`): the latest page grows by appending until full, so existing posts never shift; arbitrary `?offset=` values snap to the containing page. Live pushes after a post/redact/graduate (`broadcast_web_refresh` in `server/src/api/write_actor.rs` → `thread_region_page_morphs` in `server/src/html/forum/feed.rs`) morph `#thread-feed-region` only behind **client-side page-offset guards** (`JsBuilder::if_page_offset_*`): the latest page, the page before it (its paginator gains the live `newer →` link at rollover), and — for redactions — the page containing the changed post. Viewers reading older pages are never overwritten with the latest posts. The poster's own `POST /ui` response (`post_success_response` in `server/src/api/ui_html.rs`) morphs in place only on the latest page and otherwise redirects to it.
 
@@ -47,7 +47,7 @@ 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).
+- **`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 **leaf** 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.
 
@@ -57,9 +57,10 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma
   - **Import thread:** one forum thread per GitHub repo (`import:https:::github.com:{owner}:{repo}`), shared by repo root / issues / pulls / commits / releases imports.
   - **Issues:** each open issue is its own **`system:github-resolver`** ingest in that repo import thread (so a later redact removes that issue from the garden). Refresh pages **all** open issues from the GitHub API (up to the page safety cap), keeps still-open single-issue posts, and **`SystemRedact`s** posts for closed/missing issues (and multi-issue bulk posts, which are re-imported as singles). The `slug-github-card` fence payload is **base64(JSON)** so markdown fences in issue bodies cannot terminate the DSL toggle-fence; decode yields the real excerpt string for rich/markdown rendering.
   - **External URL wire form:** Canonical garden paths are **`/-/https://host/…`**. Legacy **`/-/host/…`** and collapsed **`/-/https:/host/…`** permanently redirect to the canonical form. Action `next` fields always use the canonical path.
+  - **Tilde garden URLs / leaf identity:** Leaf pages are canonical (`GET /~/luke` renders the item/scope page). Nested `GET /~/x/luke` permanently redirects (308, query preserved) to the leaf — same precedent as `/-/` legacy redirects (`OntologyPath::nested_redirect_target`). Room-scoped `/r/:room/~/*path` follows the same rule (`/r/…/~/x/luke` → `/r/…/~/luke`). **`GET /~`** is the root-electorate index (via the root scope view). `~/x/luke` and `~/y/luke` are the same item `~luke`. Breadcrumbs walk **containment** (strongest parent weight), not the typed URL path; other active scopes are listed as alternates on the item page.
 - **Garden pin / compare voting:** Cookie **`slug_garden_pin`** via **`set_garden_pin`**. Pairwise UI: **`GET /vote/compare?…`** / **`GET /r/:room_key/vote/compare?…`** (fullscreen **`GET`** page: no HUD; other garden pages). HUD (**`#slug-pin-hud`**): only when **`layout`** passes garden metadata on **`body`**; the label is **`POST /ui`** **`set_garden_pin`** **`clear:true`** (**`slug_ui.js`**), not a permalink to the item.
 
-- **Aspect sub-scopes:** A `:slug` / `:slug {prompt}` / bare `:` statement is parse-derived from ingest text (no event-schema change, no new write path). Votes under an aspect go to a ranking group keyed `(parent, aspect)`; the canonical `ranking_group` and `rank_position_cache` stay aspect-free. Garden parent/item pages (`render_scope_view`, public `~/`) and the `/try` editor preview list aspect sections **below** the canonical ranking when that parent has aspect votes (heading `:{slug}`, optional prompt). No `?aspect=` routes or default-aspect redirects. CLI `garden children --aspect` / `garden rank --aspect` and MCP `get_rank.aspect` are opt-in reads via `GetGardenRank.aspect`. Prompts live on `ContentState.aspect_prompts` per `(room scope, slug)`.
+- **Aspect sub-scopes:** A `:slug` / `:slug {prompt}` / bare `:` statement is parse-derived from ingest text (no event-schema change, no new write path). Votes under an aspect go to a ranking group keyed `(scope_item, aspect)` where `scope_item` is a shared active-membership scope of both vote items; the canonical `ranking_group` and `rank_position_cache` stay aspect-free. Garden parent/item pages (`render_scope_view`, public `~/`) and the `/try` editor preview list aspect sections **below** the canonical ranking when that scope has aspect votes (heading `:{slug}`, optional prompt). No `?aspect=` routes or default-aspect redirects. CLI `garden children --aspect` / `garden rank --aspect` and MCP `get_rank.aspect` are opt-in reads via `GetGardenRank.aspect`. Prompts live on `ContentState.aspect_prompts` per `(room scope, slug)`. `parent_path` in those reads resolves to its leaf item (`~/x/luke` → `~luke`).
 
 - **Browser auth redirects:** `/login`, `/join/:token`, `/auth/login`, and `/auth/choose-username` may carry **`next`** (or legacy **`redirect`**) as a **safe local path only**. The value is stored on the RAM-only pending session and applied after OAuth / username selection.
 
@@ -78,7 +79,8 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma
 | **OAuth / pending sessions** | **RAM only** | `AppState.pending_sessions` (`server/src/state.rs`, `server/src/api/auth.rs`) |
 | **External resolver cooldowns** | **RAM only** | `AppState.resolver_runs` — debounce/rate-limit guard for on-demand resolver buttons (`SLUG_GITHUB_RESOLVER_COOLDOWN_MS`, default 15s). Resolver results themselves are durable synthetic `Ingest` / `PostRedacted` events in `events.jsonl`. |
 | **Rank-position memo** | **RAM only / derived** | `ContentState.rank_position_cache` — generation-keyed global ranks, component-local Rank Centrality scores, and per-parent scope ranks. Reuses one ingest’s “after” ordering as the next ingest’s “before”. Scores come from each connected component’s solve (never a whole-graph mix of disconnected clusters). Rebuilt lazily during event replay; never persisted. Canonical-only: aspect groups are not in this memo. |
-| **Aspect groups / prompts** | **Derived** | `ContentState.aspect_groups` keyed `(parent, slug)` and `aspect_prompts` keyed by slug (per room `ContentState`). Rebuilt from DSL on ingest replay; never persisted. |
+| **Aspect groups / prompts** | **Derived** | `ContentState.aspect_groups` keyed `(scope_item, slug)` and `aspect_prompts` keyed by slug (per room `ContentState`). Rebuilt from DSL on ingest replay; never persisted. Membership in an aspect group is the scope item's active-member electorate. |
+| **Containment / borders / fallen-border journal** | **Derived / RAM** | `ContentState.containment` `(child, parent) → {explicit, sugar}`, `borders` `(child, parent) → weight`, `members_by_scope` / `scopes_by_member`, `fallen_border_journal`. Rebuilt from DSL on ingest replay; never persisted. Accessors: `members_of`, `scopes_of`, `border_state`, `fallen_borders`. Item pages render memberships, suspended borders, and this item's journal from these maps. |
 | **Reducer projection** | **Derived** | Rebuilt from log on startup; not separately persisted |
 
 If you add a new ephemeral map or start persisting something that was RAM-only, **update this table and the code comments** (`server/src/state.rs` is a good anchor).
diff --git a/cli/DSL.txt b/cli/DSL.txt
index b367c41d9f0e7d6783527c881798f00f2f1363d1..fa26f0dd5d101f03c6b5296e1ce28031272ac621 100644
--- a/cli/DSL.txt
+++ b/cli/DSL.txt
@@ -6,8 +6,8 @@ Identity and routing are **not** in the document body: the human principal comes
 
 CLI vs .sorter file (important)
 -------------------------------
-- **.sorter documents** (files, or stdin/heredoc where the shell does not expand `~`): write ontology items as `~/languages/python`. The `~/` prefix is part of the DSL.
-- **`npx slugsocial public 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 documents** (files, or stdin/heredoc where the shell does not expand `~`): write ontology items as `~luke` or `~/luke`. Nested `~/languages/python` is path sugar (see rule 4). The `~` prefix is part of the DSL.
+- **`npx slugsocial public garden …` path arguments**: pass **no** tilde — use the leaf name `python`, or a legacy nested path `languages/python`. In the shell, `~` expands to your home directory (`$HOME`), which breaks paths. The CLI strips sigils, collapses nested paths to the leaf, and the server maps these into the `~/` ontology namespace.
 
 ```sorter
 #review { My Review Thread }
@@ -15,23 +15,28 @@ CLI vs .sorter file (important)
 prose blocks which are the body of the OP post...
 Blank lines are preserved to maintain paragraph structure.
 
-~/item/a {itembody}
-~/python { A high-level scripting language }
+~a {itembody}
+~python { A high-level scripting language }
 
 {
 Item A is better because of X.
 }
-~/item/a > ~/python
+~a > ~python
 
 {
 Python's ecosystem is much richer than Go's.
 }
-~/python 3:1 ~/go
+~python 3:1 ~go
 
 {
 They are equally good in this context.
 }
-https://example.com/lang = ~/go
+https://example.com/lang = ~go
+
+{
+luke is a jedi
+}
+~luke <: ~jedi
 ```
 
 SYNTAX RULES
@@ -42,19 +47,70 @@ SYNTAX RULES
 ```
 Starts a thread. Tag allows alphanumeric, `-`, `_`, and `/`. Subtitle max 100 chars, in `{ ... }`.
 
+---
+
+Rule 1 — tilde tokens (leaf identity)
+-------------------------------------
 ```sorter
-~/<local-item-path> { description }
+~<name> { description }
+~<name>
 ```
-Defines an ontology item (garden layer). Paths can be nested (e.g. `~/languages/python`).
-A leading `/` alone is **not** allowed in the DSL — use `~/` only. Descriptions (bodies) are wrapped in `{}` and follow the item path.
+An ontology item is a **flat** tilde token. Charset is a path segment (`[a-z0-9_-]`). `~luke` and `~/luke` name the same item. The shareable page is `GET /~/luke`. Nested URLs such as `/~/x/luke` permanently redirect to the leaf.
+
+`~/x/luke` and `~/y/luke` are the **same item** `~luke`. Last write wins on the body.
+
+Bare `~` is the ontology root (the root electorate). A leading `/` alone is **not** allowed — use `~name` or `~/name`.
 
 ```sorter
 https://example.com/item { description }
 ```
-
-URLs can be used directly as items in definitions or votes.
+URLs can be used directly as items in definitions or votes. URL / `/-/` items are never desugared into tilde tokens.
 Canonicalization rules for URLs:
-- `~/` and `https://slug.social/~/` map to the same local item path.
+- `~/` and `https://slug.social/~/` map to the same local item path (then collapse to the leaf).
+
+---
+
+Rule 2 — containment claims (`<:` / `!<:`)
+------------------------------------------
+```sorter
+{
+required explanation
+}
+~child <: ~parent
+
+{
+required explanation
+}
+~child !<: ~parent
+```
+`<:` and `!<:` are **digraphs**. Bare `<` remains a rank vote (1:2). The explanation block is **required**, same as rank votes.
+
+- `~a <: ~b` — explicit membership: `a` is in scope `b`. Weight accumulates (+1 per claim).
+- `~a !<: ~b` — raise a border on that pair. Weight accumulates (+1 per claim).
+
+There is **no `==`**. `~a == ~b` is a parse error, not identity and not a vote.
+
+A scope is not a separate type. Any item with **active members** is a scope; its body is the **prompt** for that role.
+
+---
+
+Rule 3 — borders, suspension, breach
+------------------------------------
+For each pair `(child, parent)`:
+
+- **Active** iff `containment_weight > border_weight` (the child is in that scope's electorate).
+- **Suspended** iff `containment_weight <= border_weight` (membership is held at the border).
+
+A **holding** border is `border > 0` and `containment <= border`. When a later `<:` makes containment overtake that border, the pair is **breached** and a fallen-border journal entry is recorded (ts, pair, weights). Containment and borders are derived (rebuilt on replay); they are not persisted as their own events.
+
+---
+
+Rule 4 — path sugar (idempotent)
+--------------------------------
+```sorter
+~/a/b/c { body }
+```
+is the item `~c` plus membership edges `c <: b`, `b <: a`, and `a <: root` (so the root garden still has a first-level electorate). Sugar edges are **weight-1 and idempotent** (repeating the same path does not add weight). Explicit `<:` / `!<:` still accumulate +1. URLs and `/-/` paths are never desugared.
 
 ```sorter
 {
@@ -69,8 +125,12 @@ Comparisons:
 - `=` (Equal, 1:1)
 - `X:Y` (Custom ratio, e.g. `3:1`, `0:0`)
 
+`<:` / `!<:` are containment (rule 2), not rank votes.
+
 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).
 
+Prose fallback: `<:` mid-prose, `~a <:`, `~a <: ~b extra`, and fenced claims stay prose.
+
 ```sorter
 :beauty
 :beauty { winner is more beautiful }
@@ -78,9 +138,9 @@ Lines that begin with `@` are not DSL statements; the parser treats them like or
 ```
 An aspect is a named sub-question over the same electorate as a parent scope. A line that is exactly `:` plus a slug (`[a-z0-9_-]{1,64}`) — optional `{prompt}` body, same brace-masking as item bodies — sets the current aspect for all later votes in this document (lexical, top to bottom). Bare `:` resets to the canonical (no-aspect) ranking. Documents start in canonical mode; aspect state does not persist across documents.
 
-Aspects affect **votes only**. Item definitions (`~/path {body}`) after `:beauty` are still ordinary items. A line that starts with `:` but is not exactly `:` or `:` + valid slug (+ optional brace block) stays prose (`:)`, `: note`, `::x`, `:UPPER`, `:has space {x}`). Historical posts that used those lines keep their meaning.
+Aspects affect **votes only**. Item definitions (`~name {body}`) after `:beauty` are still ordinary items. A line that starts with `:` but is not exactly `:` or `:` + valid slug (+ optional brace block) stays prose (`:)`, `: note`, `::x`, `:UPPER`, `:has space {x}`). Historical posts that used those lines keep their meaning.
 
-Votes under an aspect rank in a separate group keyed `(parent, aspect)`. The canonical ranking is unchanged.
+Votes under an aspect rank in a separate group keyed `(scope_item, aspect)` where `scope_item` is a shared active-membership scope of both vote items. The canonical ranking is unchanged.
 
 BLOCK MASKING (ESCAPING)
 
@@ -91,7 +151,7 @@ When writing bodies or explanations, you can use braces `{}` and code blocks wit
 
 ```sorter
 { Here is a block: ```def foo(): return {"a": 1}``` }
-~/code
+~code
 ```
 
 STYLE
diff --git a/cli/GUIDE.sorter b/cli/GUIDE.sorter
index 5f6e2d887a5e5ca71f20bbd1b54cc8d156c86160..bcd99736d6caec3c01fcdfc0bad913b0eea9aa3f 100644
--- a/cli/GUIDE.sorter
+++ b/cli/GUIDE.sorter
@@ -60,7 +60,7 @@ Do not put identity lines in the DSL body — use request metadata (CLI flags or
 }
 
 ~/intro/dsl-syntax {
-Two kinds of things. In .sorter documents you write #thread and ~/path. In the CLI use thread name without # and path without ~ (shell expands ~ to home and # starts a comment).
+Two kinds of things. In .sorter documents you write #thread and ~name (or ~/path sugar). In the CLI use thread name without # and a leaf name without ~ (shell expands ~ to home and # starts a comment).
 
 #thread        - a topic-based session (the forum layer)
                  bump-ordered, like 4chan or teamfortress.tv
@@ -71,20 +71,28 @@ Two kinds of things. In .sorter documents you write #thread and ~/path. In the C
                  Only the OP (first poster) can set it.
                  Example: #rama: The relationship between slug's reducer and Rama's state
 
-~/path/item    - an ontology item (the garden layer)
-                 permanent, path-addressed, accumulates votes
-                 ~/languages/rust
-                 ~/models/anthropic/claude-sonnet
-                 ~/whitepaper/mechanism/rank-centrality
+~name          - an ontology item (the garden layer)
+                 leaf identity: ~luke and ~/luke and ~/x/luke are the same item
+                 permanent, accumulates votes and containment
+                 ~rust
+                 ~claude-sonnet
+                 ~/languages/rust  - path sugar: item ~rust plus rust <: languages <: root
 
-These coexist. A thread is a session. An item is a thing that persists.  Multiple threads can reference the same items.
+These coexist. A thread is a session. An item is a thing that persists. Multiple threads can reference the same items. A scope is any item with active members; its body is the prompt for that role.
 
 Item definitions (attaches a description to an item):
-  ~/thread/item { description }
+  ~name { description }
+
+Containment (requires a leading explanation, same as votes):
+  { reasoning }
+  ~child <: ~parent
+  { reasoning }
+  ~child !<: ~parent
+<: is membership (accumulates). !<: raises a border (accumulates). Active iff containment > border. == does not exist.
 
 Comparisons:
   { reasoning }
-  ~/thread/item-a 3:1 ~/thread/item-b
+  ~item-a 3:1 ~item-b
 
 Ratio formats:
   3:1   left is 3x better than right
@@ -96,7 +104,7 @@ Shorthand:
   <     means 1:2 (right is better)
   =     means 1:1 (equal)
 
-Item bodies follow the item path. Vote explanations come first; the comparison is the verdict line.
+Item bodies follow the item. Vote and claim explanations come first; the verdict line is next.
 
 Aspects (named sub-questions over the same parent electorate):
   :beauty
diff --git a/cli/src/main.rs b/cli/src/main.rs
index f8b2a8be21fdf76c54cff8191056cc6eee5bc27c..c70aa482f8611ab06f31384b1a918d06dcf9be4e 100644
--- a/cli/src/main.rs
+++ b/cli/src/main.rs
@@ -272,7 +272,7 @@ enum IdentityCmd {
 
 #[derive(Subcommand, Debug)]
 enum GardenCmd {
-    /// List every leaf item in the garden (full paths). Does not scale; full list.
+    /// List every leaf item in the garden (leaf URLs). Does not scale; full list.
     Tree {
         /// Output as JSON for agent parsing
         #[arg(long)]
@@ -284,7 +284,7 @@ enum GardenCmd {
     /// Bodies longer than 100,000 characters are truncated by default.
     /// Use --full to retrieve the complete body.
     Body {
-        /// Ontology path without shell `~` (e.g. `languages/python`). The CLI sends `~/…` to the API.
+        /// Leaf name or legacy nested path, no shell `~` (e.g. `python` or `languages/python`). The CLI sends the leaf to the API.
         #[arg(value_name = "PATH", allow_hyphen_values = true)]
         path: String,
         /// Output as JSON for agent parsing
@@ -310,7 +310,7 @@ enum GardenCmd {
         /// Output as JSON for agent parsing
         #[arg(long)]
         json: bool,
-        /// Path(s); no ~ prefix. Multiple PATH merge scopes. Use `-/host/...` for external items.
+        /// Leaf name(s) or legacy nested path(s); no ~ prefix. Multiple PATH merge scopes. Use `-/host/...` for external items.
         /// After optional flags, pass `--` then paths (required so values starting with `-` parse correctly).
         #[arg(value_name = "PATH", num_args = 1.., allow_hyphen_values = true)]
         paths: Vec<String>,
@@ -318,7 +318,7 @@ enum GardenCmd {
 
     /// Suggest a comparison pair under a path + relevant threads where it's discussed.
     Pair {
-        /// Parent path without shell `~` (e.g. `conn` or `models/ai`). The CLI sends `~/…` to the API.
+        /// Leaf name or legacy nested path, no shell `~` (e.g. `conn` or `models/ai`). The CLI sends the leaf to the API.
         #[arg(value_name = "PATH", allow_hyphen_values = true)]
         path: String,
         /// Output as JSON for agent parsing
@@ -328,7 +328,7 @@ enum GardenCmd {
 
     /// Vote history for an item (wins/losses) with thread per vote.
     Matchup {
-        /// Item path without shell `~` (e.g. `sorts/insertion`). The CLI sends `~/…` to the API.
+        /// Leaf name or legacy nested path, no shell `~` (e.g. `insertion` or `sorts/insertion`). The CLI sends the leaf to the API.
         #[arg(value_name = "PATH", allow_hyphen_values = true)]
         path: String,
         /// Output as JSON for agent parsing
@@ -363,7 +363,7 @@ enum GardenCmd {
 
     /// Rank history for an item — how its position changed over time and why.
     History {
-        /// Item path without shell `~` (e.g. `hist/rust`). The CLI sends `~/…` to the API.
+        /// Leaf name or legacy nested path, no shell `~` (e.g. `rust` or `hist/rust`). The CLI sends the leaf to the API.
         #[arg(value_name = "PATH", allow_hyphen_values = true)]
         path: String,
         /// Output as JSON for agent parsing
@@ -754,10 +754,12 @@ fn rpc_line_ok_scoped_read<'a>(line: &'a RpcLine, room_wire: &str) -> Result<&'a
     })
 }
 
-/// Normalize ontology path for API. Accepts path with or without ~/ (shell expands ~ to $HOME).
-/// Returns a bare slug path (e.g. `languages/python`) with no leading `/` or `~/`.
-/// Call `ontology_path_for_api_query` before sending `item=` / `parent=` params so the server
-/// gets `~/…` and canonicalizes to `https://slug.social/~/…`.
+/// Normalize ontology path for API. Accepts a leaf name, `~leaf`, `~/leaf`, or a legacy
+/// nested path (`x/luke` / `~/x/luke`). Shell expands `~` to `$HOME`.
+///
+/// Returns a **leaf** slug (e.g. `luke`) with no leading `/` or `~/`. External `-/…` and
+/// `http(s)://…` are left unchanged. Call `ontology_path_for_api_query` before sending so
+/// the server gets `~/luke`.
 fn normalize_ontology_path_input(path: &str) -> Result<String, String> {
     let p = path.trim();
     if p.contains('*') {
@@ -769,6 +771,9 @@ fn normalize_ontology_path_input(path: &str) -> Result<String, String> {
 
     let without_sigils = if p.starts_with("~/") {
         p.strip_prefix("~/").unwrap_or(p).trim_start_matches('/')
+    } else if p.starts_with('~') && !p.starts_with("-/") {
+        // DSL token `~luke` (no slash).
+        p.trim_start_matches('~').trim_start_matches('/')
     } else if p.starts_with("-/") {
         p
     } else if p.starts_with('/') {
@@ -788,9 +793,19 @@ fn normalize_ontology_path_input(path: &str) -> Result<String, String> {
     };
 
     if without_sigils.is_empty() {
-        return Err("path must be non-empty (e.g. languages or languages/python)".to_string());
+        return Err("path must be non-empty (e.g. luke or languages/python)".to_string());
     }
-    Ok(without_sigils.to_string())
+    if without_sigils.starts_with("-/")
+        || without_sigils.starts_with("http://")
+        || without_sigils.starts_with("https://")
+    {
+        return Ok(without_sigils.to_string());
+    }
+    let leaf = without_sigils
+        .rsplit('/')
+        .find(|s| !s.is_empty())
+        .unwrap_or(without_sigils);
+    Ok(leaf.to_string())
 }
 
 /// Query-string form for ontology items: `~/` + normalized path, `-/` + external tail, or full URL unchanged.
@@ -905,6 +920,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn garden_path_accepts_leaf_and_legacy_nested() {
+        assert_eq!(normalize_ontology_path_input("luke").unwrap(), "luke");
+        assert_eq!(normalize_ontology_path_input("~luke").unwrap(), "luke");
+        assert_eq!(normalize_ontology_path_input("~/luke").unwrap(), "luke");
+        assert_eq!(normalize_ontology_path_input("x/luke").unwrap(), "luke");
+        assert_eq!(normalize_ontology_path_input("~/x/luke").unwrap(), "luke");
+        assert_eq!(
+            normalize_ontology_path_input("-/https://example.com/a/b").unwrap(),
+            "-/https://example.com/a/b"
+        );
+    }
+
     #[test]
     fn feed_without_since_uses_logged_in_delegate_from_env() {
         let key = "SLUG_DELEGATE";
@@ -952,7 +980,7 @@ async fn run_scoped(base: &str, room: &str, sub: ScopedCmd) -> Result<()> {
                         } else {
                             for p in &resp.paths {
                                 let display = ItemId::parse(p.as_str())
-                                    .map(|item| item.display_path())
+                                    .map(|item| item.ontology_leaf().display_path())
                                     .unwrap_or_else(|| p.to_string());
                                 println!("{display}");
                             }
diff --git a/server/src/api/helpers.rs b/server/src/api/helpers.rs
index d2703f105bc8a99c98a75e16304528b4c806f5ac..c58cb0fec20a1bc9c0e27b7e5a392b3289431b41 100644
--- a/server/src/api/helpers.rs
+++ b/server/src/api/helpers.rs
@@ -5,7 +5,11 @@ use slug_types::ItemId;
 use slug_types::*;
 use std::collections::HashMap;
 
-use crate::{canonical_path::canonicalize_item, ranking::connected_components_from_voted_pairs};
+use crate::{
+    canonical_path::canonicalize_item,
+    ranking::connected_components_from_voted_pairs,
+    reducer::ContentState,
+};
 
 pub fn api_error(
     status: StatusCode,
@@ -81,10 +85,12 @@ pub fn validate_garden_parent_scope_paths(
         return Ok(());
     }
     let none_exist = specs.iter().all(|spec| {
-        let Some(canon) = ItemId::parse(spec) else {
+        let Some(canon) = ItemId::parse(spec).map(|id| id.ontology_leaf()) else {
             return true;
         };
-        !content.items.contains(&canon) && !content.item_children.contains_key(&canon)
+        !content.items.contains(&canon)
+            && content.members_of(&canon).is_empty()
+            && !content.item_children.contains_key(&canon)
     });
     if none_exist {
         return Err((
@@ -226,7 +232,23 @@ pub fn compute_connectivity_stats(
     }
 }
 
-pub fn vote_touches_path(a: &str, b: &str, parent_canon: &str) -> bool {
-    let under = |item: &str| item == parent_canon || item.starts_with(&format!("{parent_canon}/"));
-    under(a) || under(b)
+/// Whether a pairwise vote involves `parent` as a scope: either side *is* the
+/// parent, or is an active member of it (containment for tilde items; path
+/// children for URL / external items). Prefix matching is wrong under leaf identity
+/// (`~/rust` is not under `https://slug.social/~/languages/`).
+pub fn vote_touches_path(content: &ContentState, a: &str, b: &str, parent_canon: &str) -> bool {
+    let Some(parent) = ItemId::parse(parent_canon).map(|id| id.ontology_leaf()) else {
+        return false;
+    };
+    let Some(a) = ItemId::parse(a).map(|id| id.ontology_leaf()) else {
+        return false;
+    };
+    let Some(b) = ItemId::parse(b).map(|id| id.ontology_leaf()) else {
+        return false;
+    };
+    if a == parent || b == parent {
+        return true;
+    }
+    let members = content.members_of(&parent);
+    members.iter().any(|m| *m == a || *m == b)
 }
diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs
index 142866c2eba729ba326b4fd52d927ca9bfede134..6f98fedc8e5f3f3946b869db3281239b2acd2903 100644
--- a/server/src/api/mod.rs
+++ b/server/src/api/mod.rs
@@ -101,4 +101,25 @@ mod tests {
         assert_eq!(err.0, StatusCode::BAD_REQUEST);
         assert!(err.1.contains("missing body"));
     }
+
+    #[test]
+    fn recent_votes_parent_filter_uses_containment_not_path_prefix() {
+        let mut reduced = ReducerState::default();
+        apply_ingest(
+            &mut reduced,
+            1,
+            "~/languages/rust {r}\n~/languages/python {p}\n{why}\n~/languages/rust 2:1 ~/languages/python\n",
+        );
+        let content = reduced.public();
+        let rust = "https://slug.social/~/rust";
+        let python = "https://slug.social/~/python";
+        assert!(
+            vote_touches_path(content, rust, python, "https://slug.social/~/languages"),
+            "leaf members must count as touching their scope"
+        );
+        assert!(
+            !vote_touches_path(content, rust, python, "https://slug.social/~/unrelated"),
+            "a vote must not touch a scope neither side belongs to"
+        );
+    }
 }
diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs
index f180d6ed45d6caa2bdd38658f20bf7b0da9df7b3..19be1c3b5c448b69e00ebfdc54b91376bbcabd54 100644
--- a/server/src/api/rpc.rs
+++ b/server/src/api/rpc.rs
@@ -248,7 +248,9 @@ fn build_rank_response_for_content(
         let parent_id = if is_global || specs.is_empty() {
             ItemId::ontology_root()
         } else {
-            ItemId::parse(&specs[0]).unwrap_or_else(|| ItemId::opaque(specs[0].clone()))
+            ItemId::parse(&specs[0])
+                .map(|id| id.ontology_leaf())
+                .unwrap_or_else(|| ItemId::opaque(specs[0].clone()))
         };
         let empty = crate::reducer::GroupState::new();
         let group = content
@@ -443,13 +445,15 @@ async fn rpc_check(
         required.insert(ThreadCapability::View);
         for stmt in &v.doc.statements {
             match stmt {
-                dsl::Stmt::Vote { .. } => {
+                dsl::Stmt::Vote { .. } | dsl::Stmt::Containment { sugar: false, .. } => {
                     required.insert(ThreadCapability::Vote);
                 }
                 dsl::Stmt::Item { .. } => {
                     required.insert(ThreadCapability::AddItem);
                 }
-                dsl::Stmt::Prose { .. } | dsl::Stmt::Aspect { .. } => {
+                dsl::Stmt::Prose { .. }
+                | dsl::Stmt::Aspect { .. }
+                | dsl::Stmt::Containment { sugar: true, .. } => {
                     required.insert(ThreadCapability::Post);
                 }
             }
@@ -1060,8 +1064,10 @@ pub async fn dispatch_rpc(state: &AppState, headers: &HeaderMap, cmd: RpcCommand
             } else {
                 let content = content_for_room(&reduced, &room);
                 let item_str = canonicalize_item(&item_path);
-                let item =
-                    ItemId::parse(&item_str).unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item = ItemId::parse(&item_str)
+                    .map(|id| id.ontology_leaf())
+                    .unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item_str = item.as_str().to_string();
                 if !content.items.contains(&item) {
                     line_err(
                         "item not found",
@@ -1472,8 +1478,10 @@ pub async fn dispatch_rpc(state: &AppState, headers: &HeaderMap, cmd: RpcCommand
             } else {
                 let content = content_for_room(&reduced, &room);
                 let item_str = canonicalize_item(&item_path);
-                let item =
-                    ItemId::parse(&item_str).unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item = ItemId::parse(&item_str)
+                    .map(|id| id.ontology_leaf())
+                    .unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item_str = item.as_str().to_string();
                 let limit = limit.unwrap_or(50).clamp(1, 200);
                 if !content.items.contains(&item) {
                     line_err(
@@ -1521,8 +1529,10 @@ pub async fn dispatch_rpc(state: &AppState, headers: &HeaderMap, cmd: RpcCommand
                 let content = content_for_room(&reduced, &room);
                 let scope = scope_from_room_wire(&room);
                 let item_str = canonicalize_item(&item_path);
-                let item =
-                    ItemId::parse(&item_str).unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item = ItemId::parse(&item_str)
+                    .map(|id| id.ontology_leaf())
+                    .unwrap_or_else(|| ItemId::opaque(item_str.clone()));
+                let item_str = item.as_str().to_string();
                 let entries = content.rank_history.get(&item).cloned().unwrap_or_default();
                 let history: Vec<RankHistoryRow> = entries
                     .iter()
@@ -1668,7 +1678,7 @@ pub async fn dispatch_rpc(state: &AppState, headers: &HeaderMap, cmd: RpcCommand
                 let iter: Box<dyn Iterator<Item = _>> = if let Some(p) = &parent {
                     let parent_can = canonicalize_item(p);
                     Box::new(iter.filter(move |v| {
-                        vote_touches_path(v.a.as_str(), v.b.as_str(), &parent_can)
+                        vote_touches_path(content, v.a.as_str(), v.b.as_str(), &parent_can)
                     }))
                 } else {
                     Box::new(iter)
diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs
index 749791094f79203653dea9f858ef4d80ada6d9cb..c941ade0e1cc9cb169ce29ea3aba6bc3970ae045 100644
--- a/server/src/api/ui_html.rs
+++ b/server/src/api/ui_html.rs
@@ -396,7 +396,7 @@ async fn dispatch_ui_action(
             let Some(item) = ItemId::parse(&raw) else {
                 return (StatusCode::BAD_REQUEST, "bad item").into_response();
             };
-            let item = item.normalized_storage();
+            let item = item.ontology_leaf().normalized_storage();
             let val = encode_pin_cookie_value(&room, item.as_str());
             let cookie =
                 format!("{GARDEN_PIN_COOKIE}={val}; Path=/; SameSite=Lax; Max-Age=7776000");
diff --git a/server/src/api/validate.rs b/server/src/api/validate.rs
index e4a338b6c283232d209824f09f29967ff158b788..301112c78465c88f925981a63ba191a6b3a870ee 100644
--- a/server/src/api/validate.rs
+++ b/server/src/api/validate.rs
@@ -58,7 +58,7 @@ pub fn validate_ingest_document(
         match s {
             dsl::Stmt::Item { title, body } => {
                 let item = match resolve_item(title) {
-                    Ok(v) => v,
+                    Ok(v) => v.ontology_leaf(),
                     Err(msg) => {
                         return Err((StatusCode::BAD_REQUEST, "invalid item path".to_string(), Some(msg)));
                     }
@@ -79,9 +79,48 @@ pub fn validate_ingest_document(
                 }
                 defined_in_doc.insert(item);
             }
+            dsl::Stmt::Containment {
+                child,
+                parent,
+                sugar: false,
+                ..
+            } => {
+                for raw in [child, parent] {
+                    let it = match resolve_item(raw) {
+                        Ok(v) => v.ontology_leaf(),
+                        Err(msg) => {
+                            return Err((
+                                StatusCode::BAD_REQUEST,
+                                "invalid containment item path".to_string(),
+                                Some(msg),
+                            ));
+                        }
+                    };
+                    if !defined_in_doc.contains(&it) && !item_exists(&it) {
+                        return Err((
+                            StatusCode::BAD_REQUEST,
+                            "containment references undefined item(s)".to_string(),
+                            Some(format!(
+                                "define items with bodies before claiming membership. missing: {}",
+                                GardenItemUrl::from_stored(&it, room_wire)
+                            )),
+                        ));
+                    }
+                    if !defined_in_doc.contains(&it) && !body_exists(&it) {
+                        return Err((
+                            StatusCode::BAD_REQUEST,
+                            "containment references item(s) without bodies".to_string(),
+                            Some(format!(
+                                "missing bodies: {}",
+                                GardenItemUrl::from_stored(&it, room_wire)
+                            )),
+                        ));
+                    }
+                }
+            }
             dsl::Stmt::Vote { item1, item2, .. } => {
                 let a = match resolve_item(item1) {
-                    Ok(v) => v,
+                    Ok(v) => v.ontology_leaf(),
                     Err(msg) => {
                         return Err((
                             StatusCode::BAD_REQUEST,
@@ -91,7 +130,7 @@ pub fn validate_ingest_document(
                     }
                 };
                 let b = match resolve_item(item2) {
-                    Ok(v) => v,
+                    Ok(v) => v.ontology_leaf(),
                     Err(msg) => {
                         return Err((
                             StatusCode::BAD_REQUEST,
diff --git a/server/src/api/write_actor.rs b/server/src/api/write_actor.rs
index 8ad39ba903a2eed1066d137b41fd49caf3d288bf..b2468416bfac1027390a5e6d75662992ce4cddfb 100644
--- a/server/src/api/write_actor.rs
+++ b/server/src/api/write_actor.rs
@@ -321,13 +321,15 @@ pub async fn writer_actor(mut rx: mpsc::Receiver<WriteCmd>, state: AppState) {
                         required.insert(ThreadCapability::View);
                         for stmt in &v.doc.statements {
                             match stmt {
-                                dsl::Stmt::Vote { .. } => {
+                                dsl::Stmt::Vote { .. } | dsl::Stmt::Containment { sugar: false, .. } => {
                                     required.insert(ThreadCapability::Vote);
                                 }
                                 dsl::Stmt::Item { .. } => {
                                     required.insert(ThreadCapability::AddItem);
                                 }
-                                dsl::Stmt::Prose { .. } | dsl::Stmt::Aspect { .. } => {
+                                dsl::Stmt::Prose { .. }
+                                | dsl::Stmt::Aspect { .. }
+                                | dsl::Stmt::Containment { sugar: true, .. } => {
                                     required.insert(ThreadCapability::Post);
                                 }
                             }
@@ -369,15 +371,28 @@ pub async fn writer_actor(mut rx: mpsc::Receiver<WriteCmd>, state: AppState) {
                             } = s
                             {
                                 if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
-                                    if let Some(p) = a.parent() {
-                                        parents.insert(p);
-                                    }
-                                    if let Some(p) = b.parent() {
+                                    let a = a.ontology_leaf();
+                                    let b = b.ontology_leaf();
+                                    let content = content_for_room(&reduced, &room_key);
+                                    for p in content.shared_scopes(&a, &b) {
                                         parents.insert(p);
                                     }
                                 }
                             }
                         }
+                        for s in &v.doc.statements {
+                            if let dsl::Stmt::Containment {
+                                parent,
+                                sugar: true,
+                                border: false,
+                                ..
+                            } = s
+                            {
+                                if let Ok(p) = resolve_item(parent) {
+                                    parents.insert(p.ontology_leaf());
+                                }
+                            }
+                        }
                         let mut out: Vec<ItemId> = parents.into_iter().collect();
                         out.sort();
                         out
diff --git a/server/src/dsl.rs b/server/src/dsl.rs
index 9292c3645392891cd020b458dc1e04e473d94dbc..f50821fc653bd28ad90bf1025aaecf47ad772a5b 100644
--- a/server/src/dsl.rs
+++ b/server/src/dsl.rs
@@ -26,6 +26,18 @@ pub enum Stmt {
         slug: Option<String>,
         prompt: Option<String>,
     },
+    /// Weighted containment (`<:`) or border (`!<:`) claim.
+    ///
+    /// Explicit claims carry a required explanation (like rank votes). Path-desugared
+    /// sugar edges set `sugar: true` and `explanation: None`.
+    Containment {
+        child: String,
+        parent: String,
+        /// `true` for `!<:` (non-membership border).
+        border: bool,
+        explanation: Option<String>,
+        sugar: bool,
+    },
     Prose {
         text: String,
     },
@@ -262,6 +274,25 @@ fn is_external_item_path_rest(name: &str) -> bool {
     })
 }
 
+fn is_path_segment(seg: &str) -> bool {
+    if seg.is_empty() {
+        return false;
+    }
+    let mut parts = seg.split('-');
+    let Some(first) = parts.next() else {
+        return false;
+    };
+    if first.is_empty() || !first.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
+        return false;
+    }
+    for p in parts {
+        if p.is_empty() || !p.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
+            return false;
+        }
+    }
+    true
+}
+
 fn is_item_name(s: &str) -> bool {
     let mut name = s.trim();
     if let Some(rest) = name.strip_prefix("-/") {
@@ -269,30 +300,63 @@ fn is_item_name(s: &str) -> bool {
     }
     if let Some(rest) = name.strip_prefix("~/") {
         name = rest;
+    } else if let Some(rest) = name.strip_prefix('~') {
+        return !rest.is_empty() && !rest.contains('/') && is_path_segment(rest);
     } else if let Some(rest) = name.strip_prefix('/') {
         name = rest;
     }
     if name.is_empty() {
         return false;
     }
-    for seg in name.split('/') {
-        if seg.is_empty() {
-            return false;
-        }
-        let mut parts = seg.split('-');
-        let Some(first) = parts.next() else {
-            return false;
-        };
-        if first.is_empty() || !first.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-            return false;
+    name.split('/').all(is_path_segment)
+}
+
+/// Compile-time path sugar: `~/a/b/c` → leaf `~c` plus idempotent edges
+/// `c <: b`, `b <: a`, `a <: ~` (root). URL / `-/` refs stay atomic.
+/// Bare `~name` is already a leaf and yields no edges.
+pub fn desugar_item_ref(raw: &str) -> (String, Vec<(String, String)>) {
+    let raw = raw.trim();
+    if raw.starts_with("http://") || raw.starts_with("https://") || raw.starts_with("-/") {
+        return (raw.to_string(), vec![]);
+    }
+    if raw == "~/" || raw == "~" {
+        return ("~/".to_string(), vec![]);
+    }
+    if let Some(rest) = raw.strip_prefix("~/") {
+        let segs: Vec<&str> = rest.split('/').filter(|s| !s.is_empty()).collect();
+        if segs.is_empty() {
+            return ("~/".to_string(), vec![]);
         }
-        for p in parts {
-            if p.is_empty() || !p.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-                return false;
-            }
+        let leaf = format!("~{}", segs[segs.len() - 1]);
+        let mut edges = Vec::new();
+        let mut child = leaf.clone();
+        for i in (0..segs.len() - 1).rev() {
+            let parent = format!("~{}", segs[i]);
+            edges.push((child, parent.clone()));
+            child = parent;
         }
+        edges.push((child, "~/".to_string()));
+        return (leaf, edges);
     }
-    true
+    if raw.starts_with('~') && !raw[1..].contains('/') {
+        return (raw.to_string(), vec![]);
+    }
+    (raw.to_string(), vec![])
+}
+
+fn sugar_containments(raw: &str) -> (String, Vec<Stmt>) {
+    let (leaf, edges) = desugar_item_ref(raw);
+    let stmts = edges
+        .into_iter()
+        .map(|(child, parent)| Stmt::Containment {
+            child,
+            parent,
+            border: false,
+            explanation: None,
+            sugar: true,
+        })
+        .collect();
+    (leaf, stmts)
 }
 
 pub fn is_valid_aspect_slug(s: &str) -> bool {
@@ -478,24 +542,44 @@ fn parse_item_name_at_with_mode(
         return Some((raw.to_string(), j));
     }
 
-    // ITEM_REF: "~/" ITEM_NAME  OR  https?:// URL
-    // Leading `/path` alone is not valid — use `~/path` for ontology items.
+    // ITEM_REF: "~/" ITEM_NAME, bare "~" TOKEN, or https?:// URL
+    // Leading `/path` alone is not valid — use `~/path` or `~name` for ontology items.
     let mut j = i;
     if bytes[j] != b'~' {
         return None;
     }
     j += 1;
-    if j >= bytes.len() || bytes[j] != b'/' {
-        return None;
+    if j < bytes.len() && bytes[j] == b'/' {
+        j += 1;
+        let start = j;
+        while j < bytes.len() {
+            if bytes[j..].starts_with(b"__BLOCK_") {
+                break;
+            }
+            let c = bytes[j] as char;
+            if c.is_ascii_alphanumeric() || c == '_' || c == '-' || c == '/' {
+                j += 1;
+                continue;
+            }
+            break;
+        }
+        if j <= start {
+            return None;
+        }
+        let name = &s[start..j];
+        if !is_item_name(name) {
+            return None;
+        }
+        return Some((format!("~/{name}"), j));
     }
-    j += 1;
+    // Bare tilde token: `~name` (one path segment, no slash).
     let start = j;
     while j < bytes.len() {
         if bytes[j..].starts_with(b"__BLOCK_") {
             break;
         }
         let c = bytes[j] as char;
-        if c.is_ascii_alphanumeric() || c == '_' || c == '-' || c == '/' {
+        if c.is_ascii_alphanumeric() || c == '_' || c == '-' {
             j += 1;
             continue;
         }
@@ -505,10 +589,10 @@ fn parse_item_name_at_with_mode(
         return None;
     }
     let name = &s[start..j];
-    if !is_item_name(name) {
+    if !is_path_segment(name) {
         return None;
     }
-    Some((format!("~/{name}"), j))
+    Some((format!("~{name}"), j))
 }
 
 fn parse_item_name_at(s: &str, i: usize) -> Option<(String, usize)> {
@@ -572,6 +656,18 @@ fn parse_block_token_at(s: &str, i: usize) -> Option<(String, usize)> {
     }
 }
 
+/// `<:` (membership) or `!<:` (border). Must be checked before rank-vote `<`.
+fn parse_containment_op_at(s: &str, i: usize) -> Option<(bool, usize)> {
+    let rest = s.get(i..)?;
+    if rest.starts_with("!<:") {
+        return Some((true, i + 3));
+    }
+    if rest.starts_with("<:") {
+        return Some((false, i + 2));
+    }
+    None
+}
+
 fn parse_comparison_at(s: &str, i: usize) -> Option<((i32, i32), usize)> {
     let bytes = s.as_bytes();
     if i >= bytes.len() {
@@ -580,7 +676,8 @@ fn parse_comparison_at(s: &str, i: usize) -> Option<((i32, i32), usize)> {
     if bytes[i] == b'>' {
         return Some(((2, 1), i + 1));
     }
-    if bytes[i] == b'<' {
+    // Digraph `<:` is containment, not the rank-vote shorthand `<`.
+    if bytes[i] == b'<' && bytes.get(i + 1) != Some(&b':') {
         return Some(((1, 2), i + 1));
     }
     if bytes[i] == b'=' {
@@ -615,14 +712,14 @@ fn parse_block_prefixed_statement(
     block_token: &str,
     tail: &str,
     masker: &BlockMasker,
-) -> Result<Stmt, DslError> {
+) -> Result<Vec<Stmt>, DslError> {
     if masker.block_kind(block_token) == Some(BlockKind::CodeFence) {
         return Err(DslError::Parse(
             "vote explanations must use `{ ... }`; code fences belong inside body blocks"
                 .to_string(),
         ));
     }
-    // vote: block item_ref comparison item_ref
+    // vote / containment: block item_ref (comparison | <: | !<:) item_ref
     let s = tail.trim_start();
     if s.is_empty() {
         return Err(DslError::Parse(
@@ -630,7 +727,7 @@ fn parse_block_prefixed_statement(
         ));
     }
 
-    let (item1, j) =
+    let (item1_raw, j) =
         parse_item_name_at(s, 0).ok_or_else(|| DslError::Parse("invalid item name".to_string()))?;
     let explanation = masker.extract_body(block_token);
     let mut i = skip_ws(s, j);
@@ -642,6 +739,32 @@ fn parse_block_prefixed_statement(
         ));
     }
 
+    if explanation.trim().is_empty() {
+        return Err(DslError::Parse("empty vote explanation".to_string()));
+    }
+
+    if let Some((border, k)) = parse_containment_op_at(s, i) {
+        i = skip_ws(s, k);
+        let Some((item2_raw, m)) = parse_item_name_at(s, i) else {
+            return Err(DslError::Parse("not a DSL line".to_string()));
+        };
+        i = skip_ws(s, m);
+        if !s[i..].trim().is_empty() {
+            return Err(DslError::Parse("not a DSL line".to_string()));
+        }
+        let (child, mut stmts) = sugar_containments(&item1_raw);
+        let (parent, parent_sugar) = sugar_containments(&item2_raw);
+        stmts.extend(parent_sugar);
+        stmts.push(Stmt::Containment {
+            child,
+            parent,
+            border,
+            explanation: Some(explanation),
+            sugar: false,
+        });
+        return Ok(stmts);
+    }
+
     let ((ratio_left, ratio_right), k) = parse_comparison_at(s, i)
         .ok_or_else(|| DslError::Parse(format!("invalid comparison near: {}", &s[i..])))?;
     if ratio_left == 0 || ratio_right == 0 {
@@ -656,37 +779,58 @@ fn parse_block_prefixed_statement(
     }
     let (ratio_left, ratio_right) = reduce_ratio(ratio_left, ratio_right);
     i = skip_ws(s, k);
-    let (item2, m) = parse_item_name_at(s, i)
+    let (item2_raw, m) = parse_item_name_at(s, i)
         .ok_or_else(|| DslError::Parse("invalid rhs item name".to_string()))?;
     i = skip_ws(s, m);
-    if explanation.trim().is_empty() {
-        return Err(DslError::Parse("empty vote explanation".to_string()));
-    }
-    let tail = s[i..].trim();
-    if !tail.is_empty() {
+    let extra = s[i..].trim();
+    if !extra.is_empty() {
         return Err(DslError::Parse("extra tokens after vote".to_string()));
     }
 
-    Ok(Stmt::Vote {
+    let (item1, mut stmts) = sugar_containments(&item1_raw);
+    let (item2, rhs_sugar) = sugar_containments(&item2_raw);
+    stmts.extend(rhs_sugar);
+    stmts.push(Stmt::Vote {
         item1,
         item2,
         ratio_left,
         ratio_right,
         explanation,
         aspect: None,
-    })
+    });
+    Ok(stmts)
 }
 
-fn parse_item_definition_statement(stripped: &str, masker: &BlockMasker) -> Result<Stmt, DslError> {
-    let (item1, j) = parse_item_name_at(stripped, 0)
+fn parse_item_definition_statement(stripped: &str, masker: &BlockMasker) -> Result<Vec<Stmt>, DslError> {
+    let (item1_raw, j) = parse_item_name_at(stripped, 0)
         .ok_or_else(|| DslError::Parse("invalid item name".to_string()))?;
     let i = skip_ws(stripped, j);
 
     if i >= stripped.len() {
-        return Ok(Stmt::Item {
-            title: item1,
+        let (title, mut stmts) = sugar_containments(&item1_raw);
+        stmts.push(Stmt::Item {
+            title,
             body: None,
         });
+        return Ok(stmts);
+    }
+
+    if parse_containment_op_at(stripped, i).is_some() {
+        // Complete `~a <: ~b` without explanation is an error (like a rank vote).
+        // Incomplete / extra-token forms fall back to prose.
+        let (_, k) = parse_containment_op_at(stripped, i).unwrap();
+        let after = skip_ws(stripped, k);
+        match parse_item_name_at(stripped, after) {
+            None => return Err(DslError::Parse("not a DSL line".to_string())),
+            Some((_, m)) if !stripped[skip_ws(stripped, m)..].trim().is_empty() => {
+                return Err(DslError::Parse("not a DSL line".to_string()));
+            }
+            Some(_) => {
+                return Err(DslError::Parse(
+                    "containment claims require a leading `{ ... }` explanation block".to_string(),
+                ));
+            }
+        }
     }
 
     if let Some((tok, end)) = parse_block_token_at(stripped, i) {
@@ -700,10 +844,12 @@ fn parse_item_definition_statement(stripped: &str, masker: &BlockMasker) -> Resu
         if !tail.is_empty() {
             return Err(DslError::Parse("extra tokens after item".to_string()));
         }
-        return Ok(Stmt::Item {
-            title: item1,
+        let (title, mut stmts) = sugar_containments(&item1_raw);
+        stmts.push(Stmt::Item {
+            title,
             body: Some(body),
         });
+        return Ok(stmts);
     }
 
     Err(DslError::Parse(
@@ -727,22 +873,22 @@ fn parse_line(masked_line: &str, masker: &BlockMasker) -> Result<Vec<Stmt>, DslE
             let Some((tok, end)) = parse_block_token_at(stripped, 0) else {
                 return Err(DslError::Parse("not a DSL line".to_string()));
             };
-            parse_block_prefixed_statement(&tok, &stripped[end..], masker).map(|stmt| vec![stmt])
+            parse_block_prefixed_statement(&tok, &stripped[end..], masker)
         }
         '/' => Err(DslError::Parse(
             "item paths must use `~/` (e.g. `~/languages/python`), not a leading `/`".to_string(),
         )),
-        '~' => Ok(vec![parse_item_definition_statement(stripped, masker)?]),
+        '~' => parse_item_definition_statement(stripped, masker),
         'h' => {
             if stripped.starts_with("https://") || stripped.starts_with("http://") {
-                Ok(vec![parse_item_definition_statement(stripped, masker)?])
+                parse_item_definition_statement(stripped, masker)
             } else {
                 Err(DslError::Parse("not a DSL line".to_string()))
             }
         }
         '-' => {
             if stripped.starts_with("-/") {
-                Ok(vec![parse_item_definition_statement(stripped, masker)?])
+                parse_item_definition_statement(stripped, masker)
             } else {
                 Err(DslError::Parse("not a DSL line".to_string()))
             }
@@ -781,17 +927,29 @@ pub fn parse_full(text: &str) -> Result<Document, DslError> {
                 continue;
             }
             if stripped.starts_with("-/")
-                || stripped.starts_with("~/")
+                || stripped.starts_with('~')
                 || stripped.starts_with("https://")
                 || stripped.starts_with("http://")
             {
-                let mut stmt = parse_block_prefixed_statement(tok, stripped, &masker)?;
-                if let Stmt::Vote { aspect, .. } = &mut stmt {
-                    *aspect = current_aspect.clone();
+                let start = statements.len();
+                match parse_block_prefixed_statement(tok, stripped, &masker) {
+                    Ok(stmts) => {
+                        statements.extend(stmts);
+                        for stmt in &mut statements[start..] {
+                            if let Stmt::Vote { aspect, .. } = stmt {
+                                *aspect = current_aspect.clone();
+                            }
+                        }
+                        pending_block = None;
+                        continue;
+                    }
+                    Err(DslError::Parse(msg)) if msg == "not a DSL line" => {
+                        return Err(DslError::Parse(
+                            "expected vote statement after leading explanation block".to_string(),
+                        ));
+                    }
+                    Err(e) => return Err(e),
                 }
-                statements.push(stmt);
-                pending_block = None;
-                continue;
             }
             return Err(DslError::Parse(
                 "expected vote statement after leading explanation block".to_string(),
@@ -830,13 +988,23 @@ pub fn parse_full(text: &str) -> Result<Document, DslError> {
                 }
             }
 
-            // Parse DSL line; DSL statements are not prose, so errors should propagate.
+            // Parse DSL line; DSL statements are not prose, so errors should propagate
+            // except malformed containment forms (`~a <:`, `~a <: ~b extra`) which fall
+            // back to prose — they were never a successful historical parse.
             let start = statements.len();
-            statements.extend(parse_line(line, &masker)?);
-            for stmt in &mut statements[start..] {
-                if let Stmt::Vote { aspect, .. } = stmt {
-                    *aspect = current_aspect.clone();
+            match parse_line(line, &masker) {
+                Ok(stmts) => {
+                    statements.extend(stmts);
+                    for stmt in &mut statements[start..] {
+                        if let Stmt::Vote { aspect, .. } = stmt {
+                            *aspect = current_aspect.clone();
+                        }
+                    }
+                }
+                Err(DslError::Parse(msg)) if msg == "not a DSL line" => {
+                    prose_buffer.push(line);
                 }
+                Err(e) => return Err(e),
             }
         } else {
             prose_buffer.push(line);
@@ -859,6 +1027,27 @@ pub fn parse_full(text: &str) -> Result<Document, DslError> {
 mod tests {
     use super::*;
 
+    fn items(doc: &Document) -> Vec<&Stmt> {
+        doc.statements
+            .iter()
+            .filter(|s| matches!(s, Stmt::Item { .. }))
+            .collect()
+    }
+
+    fn votes(doc: &Document) -> Vec<&Stmt> {
+        doc.statements
+            .iter()
+            .filter(|s| matches!(s, Stmt::Vote { .. }))
+            .collect()
+    }
+
+    fn containments(doc: &Document) -> Vec<&Stmt> {
+        doc.statements
+            .iter()
+            .filter(|s| matches!(s, Stmt::Containment { .. }))
+            .collect()
+    }
+
     #[test]
     fn blockmasker_masks_and_unmasks_nested_braces() {
         let input = "hello {a {b} c} world";
@@ -947,12 +1136,22 @@ mod tests {
         let input = "~/rust { Systems language }";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Item {
-                title: "~/rust".to_string(),
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~rust".to_string(),
                 body: Some("Systems language".to_string()),
             }]
         );
+        assert!(containments(&doc).iter().any(|s| matches!(
+            s,
+            Stmt::Containment {
+                child,
+                parent,
+                sugar: true,
+                border: false,
+                ..
+            } if child == "~rust" && parent == "~/"
+        )));
     }
 
     #[test]
@@ -960,9 +1159,9 @@ mod tests {
         let input = "~/item/in/url {\n```json\n{\"test\": true}\n```\n}";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Item {
-                title: "~/item/in/url".to_string(),
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~url".to_string(),
                 body: Some("```json\n{\"test\": true}\n```".to_string()),
             }]
         );
@@ -1017,10 +1216,10 @@ mod tests {
     fn parse_vote_ratio_and_symbols() {
         let d1 = parse_full("{because}\n~/a 3:1 ~/b").unwrap();
         assert_eq!(
-            d1.statements,
-            vec![Stmt::Vote {
-                item1: "~/a".to_string(),
-                item2: "~/b".to_string(),
+            votes(&d1),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
                 ratio_left: 3,
                 ratio_right: 1,
                 explanation: "because".to_string(),
@@ -1030,10 +1229,10 @@ mod tests {
 
         let d2 = parse_full("{because}\n~/a > ~/b").unwrap();
         assert_eq!(
-            d2.statements,
-            vec![Stmt::Vote {
-                item1: "~/a".to_string(),
-                item2: "~/b".to_string(),
+            votes(&d2),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
                 ratio_left: 2,
                 ratio_right: 1,
                 explanation: "because".to_string(),
@@ -1043,10 +1242,10 @@ mod tests {
 
         let d3 = parse_full("{because}\n~/a = ~/b").unwrap();
         assert_eq!(
-            d3.statements,
-            vec![Stmt::Vote {
-                item1: "~/a".to_string(),
-                item2: "~/b".to_string(),
+            votes(&d3),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
                 ratio_left: 1,
                 ratio_right: 1,
                 explanation: "because".to_string(),
@@ -1153,9 +1352,9 @@ mod tests {
         let input = "~/arrived{I had arrived.}";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Item {
-                title: "~/arrived".to_string(),
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~arrived".to_string(),
                 body: Some("I had arrived.".to_string()),
             }]
         );
@@ -1166,10 +1365,10 @@ mod tests {
         let input = "{because}~/a 2:1 ~/b";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Vote {
-                item1: "~/a".to_string(),
-                item2: "~/b".to_string(),
+            votes(&doc),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
                 ratio_left: 2,
                 ratio_right: 1,
                 explanation: "because".to_string(),
@@ -1183,12 +1382,26 @@ mod tests {
         let input = "~/whitepaper/architectural-choices { Body }";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Item {
-                title: "~/whitepaper/architectural-choices".to_string(),
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~architectural-choices".to_string(),
                 body: Some("Body".to_string()),
             }]
         );
+        let sugars: Vec<(&str, &str)> = containments(&doc)
+            .iter()
+            .filter_map(|s| match s {
+                Stmt::Containment {
+                    child,
+                    parent,
+                    sugar: true,
+                    ..
+                } => Some((child.as_str(), parent.as_str())),
+                _ => None,
+            })
+            .collect();
+        assert!(sugars.contains(&("~architectural-choices", "~whitepaper")));
+        assert!(sugars.contains(&("~whitepaper", "~/")));
     }
 
     #[test]
@@ -1196,10 +1409,10 @@ mod tests {
         let input = "{ because }\n~/whitepaper/a 3:1 ~/whitepaper/b";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Vote {
-                item1: "~/whitepaper/a".to_string(),
-                item2: "~/whitepaper/b".to_string(),
+            votes(&doc),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
                 ratio_left: 3,
                 ratio_right: 1,
                 explanation: "because".to_string(),
@@ -1382,18 +1595,19 @@ mod tests {
     fn parse_aspect_does_not_affect_item_definitions() {
         let input = ":beauty\n~/t/x {defined after aspect}";
         let doc = parse_full(input).unwrap();
+        assert!(matches!(
+            doc.statements.first(),
+            Some(Stmt::Aspect {
+                slug: Some(s),
+                prompt: None,
+            }) if s == "beauty"
+        ));
         assert_eq!(
-            doc.statements,
-            vec![
-                Stmt::Aspect {
-                    slug: Some("beauty".to_string()),
-                    prompt: None,
-                },
-                Stmt::Item {
-                    title: "~/t/x".to_string(),
-                    body: Some("defined after aspect".to_string()),
-                },
-            ]
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~x".to_string(),
+                body: Some("defined after aspect".to_string()),
+            }]
         );
     }
 
@@ -1475,8 +1689,8 @@ mod tests {
         let input = "{ because }\nhttps://slug.social/~/music/a 3:1 https://slug.social/~/music/b";
         let doc = parse_full(input).unwrap();
         assert_eq!(
-            doc.statements,
-            vec![Stmt::Vote {
+            votes(&doc),
+            vec![&Stmt::Vote {
                 item1: "https://slug.social/~/music/a".to_string(),
                 item2: "https://slug.social/~/music/b".to_string(),
                 ratio_left: 3,
@@ -1485,5 +1699,230 @@ mod tests {
                 aspect: None,
             }]
         );
+        assert!(containments(&doc).is_empty(), "URL items are never desugared");
+    }
+
+    #[test]
+    fn parse_bare_tilde_token_item() {
+        let doc = parse_full("~luke { a jedi }").unwrap();
+        assert_eq!(
+            items(&doc),
+            vec![&Stmt::Item {
+                title: "~luke".to_string(),
+                body: Some("a jedi".to_string()),
+            }]
+        );
+        assert!(
+            containments(&doc).is_empty(),
+            "bare ~name is already a leaf; no path sugar"
+        );
+    }
+
+    #[test]
+    fn parse_bare_tilde_token_in_vote() {
+        let doc = parse_full("{ because }\n~luke 2:1 ~vader").unwrap();
+        assert_eq!(
+            votes(&doc),
+            vec![&Stmt::Vote {
+                item1: "~luke".to_string(),
+                item2: "~vader".to_string(),
+                ratio_left: 2,
+                ratio_right: 1,
+                explanation: "because".to_string(),
+                aspect: None,
+            }]
+        );
+    }
+
+    #[test]
+    fn parse_explicit_containment_requires_explanation() {
+        let err = parse_full("~a <: ~b").unwrap_err().to_string();
+        assert!(
+            err.contains("containment claims require"),
+            "unexpected error: {err}"
+        );
+        let doc = parse_full("{ luke is a jedi }\n~luke <: ~jedi").unwrap();
+        assert_eq!(
+            containments(&doc)
+                .iter()
+                .filter(|s| matches!(s, Stmt::Containment { sugar: false, .. }))
+                .count(),
+            1
+        );
+        assert!(matches!(
+            containments(&doc).iter().find(|s| matches!(s, Stmt::Containment { sugar: false, .. })),
+            Some(Stmt::Containment {
+                child,
+                parent,
+                border: false,
+                explanation: Some(e),
+                sugar: false,
+            }) if child == "~luke" && parent == "~jedi" && e == "luke is a jedi"
+        ));
+    }
+
+    #[test]
+    fn parse_explicit_border_claim() {
+        let doc = parse_full("{ not a jedi }\n~ahsoka !<: ~jedi").unwrap();
+        assert!(matches!(
+            containments(&doc).iter().find(|s| matches!(s, Stmt::Containment { sugar: false, .. })),
+            Some(Stmt::Containment {
+                child,
+                parent,
+                border: true,
+                explanation: Some(e),
+                sugar: false,
+            }) if child == "~ahsoka" && parent == "~jedi" && e == "not a jedi"
+        ));
+    }
+
+    #[test]
+    fn parse_containment_desugars_path_sides() {
+        let doc = parse_full("{ in }\n~/x/luke <: ~/y/jedi").unwrap();
+        let claims = containments(&doc);
+        let explicit = claims
+            .iter()
+            .find(|s| matches!(s, Stmt::Containment { sugar: false, .. }))
+            .unwrap();
+        assert!(matches!(
+            explicit,
+            Stmt::Containment {
+                child,
+                parent,
+                border: false,
+                sugar: false,
+                ..
+            } if child == "~luke" && parent == "~jedi"
+        ));
+        let sugars: Vec<(&str, &str)> = claims
+            .iter()
+            .filter_map(|s| match s {
+                Stmt::Containment {
+                    child,
+                    parent,
+                    sugar: true,
+                    ..
+                } => Some((child.as_str(), parent.as_str())),
+                _ => None,
+            })
+            .collect();
+        assert!(sugars.contains(&("~luke", "~x")));
+        assert!(sugars.contains(&("~jedi", "~y")));
+    }
+
+    #[test]
+    fn parse_containment_url_side_stays_atomic() {
+        let doc = parse_full("{ src }\nhttps://example.com/a/b <: ~sources").unwrap();
+        assert!(matches!(
+            containments(&doc).iter().find(|s| matches!(s, Stmt::Containment { sugar: false, .. })),
+            Some(Stmt::Containment {
+                child,
+                parent,
+                ..
+            }) if child == "https://example.com/a/b" && parent == "~sources"
+        ));
+    }
+
+    #[test]
+    fn parse_bare_less_than_is_still_rank_vote() {
+        let doc = parse_full("{ prefer b }\n~a < ~b").unwrap();
+        assert_eq!(
+            votes(&doc),
+            vec![&Stmt::Vote {
+                item1: "~a".to_string(),
+                item2: "~b".to_string(),
+                ratio_left: 1,
+                ratio_right: 2,
+                explanation: "prefer b".to_string(),
+                aspect: None,
+            }]
+        );
+    }
+
+    #[test]
+    fn parse_equality_operator_is_not_implemented() {
+        // `=` remains the rank-tie shorthand. `==` is extra tokens after that shorthand.
+        let err = parse_full("{ same }\n~a == ~b").unwrap_err().to_string();
+        assert!(
+            err.contains("extra tokens after vote") || err.contains("invalid rhs item name"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn parse_containment_mid_prose_stays_prose() {
+        let input = "the relation a <: b is discussed here";
+        let doc = parse_full(input).unwrap();
+        assert_eq!(
+            doc.statements,
+            vec![Stmt::Prose {
+                text: input.to_string()
+            }]
+        );
+    }
+
+    #[test]
+    fn parse_malformed_containment_falls_back_to_prose() {
+        let incomplete = parse_full("~a <:").unwrap();
+        assert_eq!(
+            incomplete.statements,
+            vec![Stmt::Prose {
+                text: "~a <:".to_string()
+            }]
+        );
+        let extra = parse_full("~a <: ~b extra").unwrap();
+        assert_eq!(
+            extra.statements,
+            vec![Stmt::Prose {
+                text: "~a <: ~b extra".to_string()
+            }]
+        );
+    }
+
+    #[test]
+    fn parse_containment_inside_code_fence_stays_prose() {
+        let input = "```\n~a <: ~b\n```";
+        let doc = parse_full(input).unwrap();
+        assert_eq!(
+            doc.statements,
+            vec![Stmt::Prose {
+                text: input.to_string()
+            }]
+        );
+    }
+
+    #[test]
+    fn prose_tokenizer_finds_bare_tilde_tokens() {
+        let tokens = tokenize_prose_item_refs("see ~luke and ~/x/y.");
+        assert_eq!(
+            tokens,
+            vec![
+                ProseToken::Text("see ".to_string()),
+                ProseToken::ItemRef("~luke".to_string()),
+                ProseToken::Text(" and ".to_string()),
+                ProseToken::ItemRef("~/x/y".to_string()),
+                ProseToken::Text(".".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn desugar_path_emits_idempotent_chain_including_root() {
+        let (leaf, edges) = desugar_item_ref("~/a/b/c");
+        assert_eq!(leaf, "~c");
+        assert_eq!(
+            edges,
+            vec![
+                ("~c".to_string(), "~b".to_string()),
+                ("~b".to_string(), "~a".to_string()),
+                ("~a".to_string(), "~/".to_string()),
+            ]
+        );
+        let (leaf, edges) = desugar_item_ref("~luke");
+        assert_eq!(leaf, "~luke");
+        assert!(edges.is_empty());
+        let (leaf, edges) = desugar_item_ref("https://example.com/a/b");
+        assert_eq!(leaf, "https://example.com/a/b");
+        assert!(edges.is_empty());
     }
 }
diff --git a/server/src/html/breadcrumb_path.rs b/server/src/html/breadcrumb_path.rs
index 1a674ae19f633e42ba3717d51a97d0efe5132cfe..6a970d4fef62113baca356f2a9beea46ddf0a3d3 100644
--- a/server/src/html/breadcrumb_path.rs
+++ b/server/src/html/breadcrumb_path.rs
@@ -28,6 +28,20 @@ impl OntologyPath {
         Self { item, segments }
     }
 
+    /// Nested `x/luke` → canonical leaf path `/~/luke`. `luke` (already a leaf) → `None`.
+    ///
+    /// Mirrors [`ExternalOntologyPath::legacy_redirect_target`]: callers issue a permanent
+    /// redirect and preserve the query string.
+    pub(super) fn nested_redirect_target(request_path: &str) -> Option<String> {
+        let item = tilde_http_path_to_item_id(request_path);
+        let leaf = item.ontology_leaf();
+        if leaf.as_str() == item.as_str() {
+            return None;
+        }
+        let disp = leaf.display_path();
+        Some(format!("/{}", disp.trim_start_matches('/')))
+    }
+
     pub(super) fn root() -> Self {
         Self::from_item(ItemId::ontology_root())
     }
@@ -208,4 +222,18 @@ mod tests {
         let repaired = ExternalOntologyPath::from_input("https:/github.com/org/repo");
         assert_eq!(repaired.as_str(), "https://github.com/org/repo");
     }
+
+    #[test]
+    fn nested_tilde_path_redirects_to_leaf() {
+        assert_eq!(
+            OntologyPath::nested_redirect_target("x/luke").as_deref(),
+            Some("/~/luke")
+        );
+        assert_eq!(
+            OntologyPath::nested_redirect_target("a/b/c").as_deref(),
+            Some("/~/c")
+        );
+        assert_eq!(OntologyPath::nested_redirect_target("luke"), None);
+        assert_eq!(OntologyPath::nested_redirect_target(""), None);
+    }
 }
diff --git a/server/src/html/forum/nav.rs b/server/src/html/forum/nav.rs
index 93c4a28280700973e3dd4aa16b6062f6e4be5617..b9afec5f621a52ffc1a6bd3e072778bbb36ccce9 100644
--- a/server/src/html/forum/nav.rs
+++ b/server/src/html/forum/nav.rs
@@ -67,7 +67,9 @@ impl ThreadNav {
     }
 
     /// Relative href for a structured [`crate::path_types::ItemId`] in this scope’s garden.
+    /// Tilde items use the leaf (`~/x/luke` → `/~/luke`).
     pub(crate) fn garden_item_href(&self, c: &crate::path_types::ItemId) -> String {
+        let c = c.ontology_leaf();
         if let Some(tail) = c.tilde_tail().map(str::to_owned) {
             format!("{}/{}", self.garden_path_prefix, tail)
         } else if c.as_str().starts_with("http://") || c.as_str().starts_with("https://") {
diff --git a/server/src/html/garden/browse.rs b/server/src/html/garden/browse.rs
index 9155ef8bae427e595f3184ee9e8451d3076b058e..bd9aea9183e7f0b8edbff6a804fff16759f08a05 100644
--- a/server/src/html/garden/browse.rs
+++ b/server/src/html/garden/browse.rs
@@ -4,8 +4,9 @@ use crate::{
     html::{
         breadcrumb_path::{ExternalOntologyPath, OntologyPath},
         forum::ThreadNav,
-        bc_path, bc_path_external, bc_segment,
+        bc_path_external, bc_segment,
     },
+    path_types::ItemId,
     reducer::ScopeId,
 };
 
@@ -53,27 +54,49 @@ impl GardenBrowsePath {
     }
 }
 
-pub(super) fn scoped_bc_path_for(path: &GardenBrowsePath, nav: &ThreadNav) -> maud::Markup {
+pub(super) fn scoped_bc_path_for(
+    path: &GardenBrowsePath,
+    nav: &ThreadNav,
+    crumbs: &[ItemId],
+) -> maud::Markup {
     match path {
-        GardenBrowsePath::Tilde(p) => scoped_bc_path(p, nav),
+        GardenBrowsePath::Tilde(p) => scoped_bc_containment(p, crumbs, nav),
         GardenBrowsePath::External(p) => scoped_bc_path_external(p, nav),
     }
 }
 
-pub(super) fn scoped_bc_path(path: &OntologyPath, nav: &ThreadNav) -> maud::Markup {
+/// Primary crumb trail from containment (strongest-parent walk), leaf hrefs.
+pub(super) fn scoped_bc_containment(
+    path: &OntologyPath,
+    crumbs: &[ItemId],
+    nav: &ThreadNav,
+) -> maud::Markup {
+    let garden = nav.garden_root_url();
+    let segments = html! {
+        @for (i, id) in crumbs.iter().enumerate() {
+            @let leaf = id.ontology_leaf();
+            @let href = match leaf.tilde_tail() {
+                Some("") => garden.to_string(),
+                Some(tail) => format!("{garden}/{tail}"),
+                None => format!("{garden}/{}", leaf.last_segment()),
+            };
+            @let is_last = i + 1 == crumbs.len();
+            (bc_segment(leaf.last_segment(), &href, is_last))
+        }
+    };
     match nav.scope() {
-        ScopeId::Public => bc_path(path),
+        ScopeId::Public => html! {
+            a href=(path.slug_root_href()) { "slug.social" }
+            (bc_segment("~", "/~", path.is_root()))
+            (segments)
+        },
         ScopeId::Room(rid) => {
             let slug = rid.split_once('/').map(|(_, s)| s).unwrap_or(rid.as_str());
             html! {
                 a href="/" { "slug.social" }
                 (bc_segment(&format!("room:{slug}"), nav.room_url(), false))
                 (bc_segment("~", nav.garden_root_url(), path.is_root()))
-                @for (i, seg) in path.segments().iter().enumerate() {
-                    @let href = format!("{}/{}", nav.garden_root_url(), path.segments()[..=i].join("/"));
-                    @let is_last = i == path.segments().len() - 1;
-                    (bc_segment(seg, &href, is_last))
-                }
+                (segments)
             }
         }
     }
diff --git a/server/src/html/garden/copy.rs b/server/src/html/garden/copy.rs
index f6337cbcfc886cf0ec023d2910ccd678ee5d90d6..40816681f3ec3501e110b16d428ecae5d22e7ad4 100644
--- a/server/src/html/garden/copy.rs
+++ b/server/src/html/garden/copy.rs
@@ -68,7 +68,7 @@ fn rankings_for_copy(
         let hosts = external_root_host_items(state_content);
         return build_rankings_for_item_set(state_content, &hosts);
     }
-    let parent = ItemId::parse(parent_path.trim())
+    let parent = ItemId::parse(parent_path.trim()).map(|id| id.ontology_leaf())
         .unwrap_or_else(|| ItemId::ontology_root())
         .normalized_storage();
     let depth = depth.max(1);
diff --git a/server/src/html/garden/item.rs b/server/src/html/garden/item.rs
index a38124c91eca70cf63157a6046e5e2f3da53b39e..b5a842a59956b1490b7109b9f058001389b747e9 100644
--- a/server/src/html/garden/item.rs
+++ b/server/src/html/garden/item.rs
@@ -12,7 +12,7 @@ pub(super) const GARDEN_DEPTH_ALL: usize = usize::MAX;
 
 pub(super) fn item_display_path(item: &str) -> String {
     ItemId::parse(item)
-        .map(|c| c.display_path())
+        .map(|c| c.ontology_leaf().display_path())
         .unwrap_or_else(|| canonicalize_item(item))
 }
 
@@ -170,6 +170,13 @@ mod tests {
         assert_eq!(child_depth_from_uri(&dall), GARDEN_DEPTH_ALL);
     }
 
+    #[test]
+    fn item_display_path_emits_leaf_form() {
+        assert_eq!(item_display_path("~/x/luke"), "~/luke");
+        assert_eq!(item_display_path("~/luke"), "~/luke");
+        assert_eq!(item_display_path("https://slug.social/~/x/luke"), "~/luke");
+    }
+
     #[test]
     fn garden_depth_select_marks_current() {
         let html = garden_depth_select_markup(2).into_string();
diff --git a/server/src/html/garden/item_page.rs b/server/src/html/garden/item_page.rs
index 9be4460ff50746c5d54e62fcc37b88f746167cbf..bfb75e5aad477461064e90bdc0dcb6de73672ced 100644
--- a/server/src/html/garden/item_page.rs
+++ b/server/src/html/garden/item_page.rs
@@ -1,13 +1,18 @@
+use std::collections::HashSet;
+
 use maud::html;
 
 use crate::{
     html::forum::ThreadNav,
     path_types::ItemId,
-    reducer::{ContentState, ScopeId},
+    reducer::{
+        BorderPairState, ContentState, FallenBorderEntry, MembershipStatus, ScopeId,
+    },
     scope_rank::{
         build_children_rankings, build_children_rankings_in_group, build_rankings_for_item_set,
         resolve_scope_recursive, ChildrenRankings,
     },
+    timeago,
 };
 
 use super::{
@@ -85,6 +90,18 @@ pub(super) struct ItemPageViewModel {
     pub(super) sibling_nav: Option<SiblingNavBar>,
     /// False at the tilde ontology root (`~/`): sibling-rank footnote does not apply.
     pub(super) item_has_parent: bool,
+    /// True when this item has active members (it is used as a scope / role).
+    pub(super) is_scope: bool,
+    /// Strongest-parent walk, root-adjacent first, including the current item. Empty at root.
+    pub(super) crumb_chain: Vec<ItemId>,
+    /// Active scopes other than the primary (strongest) parent.
+    pub(super) alternate_scopes: Vec<ItemId>,
+    /// Active memberships (this item as child) with weights.
+    pub(super) memberships: Vec<BorderPairState>,
+    /// Suspended borders (`containment_weight <= border_weight`) where this item is the child.
+    pub(super) suspended_borders: Vec<BorderPairState>,
+    /// Fallen-border journal entries that name this item as child or parent.
+    pub(super) fallen_journal: Vec<FallenBorderEntry>,
     pub(super) child_rankings: ChildrenRankings,
     pub(super) aspect_rankings: Vec<AspectRankingView>,
     pub(super) child_depth: usize,
@@ -93,6 +110,77 @@ pub(super) struct ItemPageViewModel {
     pub(super) threads: Vec<String>,
 }
 
+/// Strongest active parent: highest containment weight, then lex-smaller parent id.
+pub(super) fn strongest_parent(content: &ContentState, item: &ItemId) -> Option<ItemId> {
+    let item = item.ontology_leaf();
+    let mut best: Option<(u32, ItemId)> = None;
+    for parent in content.scopes_of(&item) {
+        let w = content
+            .border_state(&item, &parent)
+            .map(|s| s.containment_weight)
+            .unwrap_or(0);
+        let take = match &best {
+            None => true,
+            Some((bw, bp)) => w > *bw || (w == *bw && parent.as_str() < bp.as_str()),
+        };
+        if take {
+            best = Some((w, parent));
+        }
+    }
+    best.map(|(_, p)| p)
+}
+
+/// Ancestors (strongest parent walk) then the item itself. Empty at the ontology root.
+pub(super) fn containment_crumb_chain(content: &ContentState, item: &ItemId) -> Vec<ItemId> {
+    let item = item.clone().ontology_leaf().normalized_storage();
+    if item.tilde_tail() == Some("") || item == ItemId::ontology_root() {
+        return vec![];
+    }
+    let mut ancestors = Vec::new();
+    let mut seen = HashSet::new();
+    seen.insert(item.clone());
+    let mut cur = item.clone();
+    while let Some(parent) = strongest_parent(content, &cur) {
+        let parent = parent.ontology_leaf().normalized_storage();
+        if parent.tilde_tail() == Some("") || parent == ItemId::ontology_root() {
+            break;
+        }
+        if !seen.insert(parent.clone()) {
+            break;
+        }
+        ancestors.push(parent.clone());
+        cur = parent;
+    }
+    ancestors.reverse();
+    ancestors.push(item);
+    ancestors
+}
+
+fn child_border_pairs(content: &ContentState, item: &ItemId) -> Vec<BorderPairState> {
+    let item = item.ontology_leaf();
+    let mut parents = HashSet::new();
+    for (c, p) in content.containment.keys() {
+        if c == &item {
+            parents.insert(p.clone());
+        }
+    }
+    for (c, p) in content.borders.keys() {
+        if c == &item {
+            parents.insert(p.clone());
+        }
+    }
+    let mut out: Vec<BorderPairState> = parents
+        .into_iter()
+        .filter_map(|p| content.border_state(&item, &p))
+        .collect();
+    out.sort_by(|a, b| {
+        b.containment_weight
+            .cmp(&a.containment_weight)
+            .then_with(|| a.parent.as_str().cmp(b.parent.as_str()))
+    });
+    out
+}
+
 pub(super) fn aspect_rankings_for_parent(
     content: &ContentState,
     parent: &ItemId,
@@ -131,9 +219,9 @@ fn build_sibling_nav(
     scope: &ScopeId,
     current: &ItemId,
 ) -> Option<SiblingNavBar> {
-    let current = current.clone().normalized_storage();
-    let parent = current.parent()?.normalized_storage();
+    let current = current.clone().normalized_storage().ontology_leaf();
     let content = content_for_garden_view(reduced, scope);
+    let parent = strongest_parent(content, &current)?.normalized_storage();
     let rankings = build_children_rankings(content, &parent);
     let mut groups: Vec<SiblingNavGroup> = Vec::new();
     for comp in &rankings.component_rankings {
@@ -233,13 +321,106 @@ pub(super) fn sibling_nav_markup(nav: &ThreadNav, bar: &SiblingNavBar, current_i
     }
 }
 
+fn pair_weight_label(pair: &BorderPairState) -> String {
+    format!(
+        "containment {} · border {}",
+        pair.containment_weight, pair.border_weight
+    )
+}
+
+pub(super) fn item_relations_markup(
+    model: &ItemPageViewModel,
+    nav: &ThreadNav,
+    now: i64,
+) -> maud::Markup {
+    html! {
+        @if !model.alternate_scopes.is_empty() {
+            p class="muted ont-alt-scopes" {
+                "also in "
+                @for (i, scope) in model.alternate_scopes.iter().enumerate() {
+                    @if i > 0 { span class="muted" { " · " } }
+                    a href=(item_href(scope.as_str(), nav)) { (item_display_path(scope.as_str())) }
+                }
+            }
+        }
+        @if !model.memberships.is_empty() {
+            section class="ont-tab-panel ont-tab-panel-memberships" {
+                h3 { "memberships" }
+                ul class="ont-group-list" {
+                    @for pair in &model.memberships {
+                        li {
+                            a href=(item_href(pair.parent.as_str(), nav)) {
+                                (item_display_path(pair.parent.as_str()))
+                            }
+                            " "
+                            span class="muted" { (pair_weight_label(pair)) }
+                        }
+                    }
+                }
+            }
+        }
+        @if !model.suspended_borders.is_empty() {
+            section class="ont-tab-panel ont-tab-panel-borders" {
+                h3 { "suspended borders" }
+                ul class="ont-group-list" {
+                    @for pair in &model.suspended_borders {
+                        li class="muted ont-border-suspended" {
+                            (item_display_path(pair.child.as_str()))
+                            " <: "
+                            a href=(item_href(pair.parent.as_str(), nav)) {
+                                (item_display_path(pair.parent.as_str()))
+                            }
+                            " "
+                            span { (pair_weight_label(pair)) }
+                        }
+                    }
+                }
+            }
+        }
+        @if !model.fallen_journal.is_empty() {
+            details class="ont-rank-history ont-fallen-borders" {
+                summary {
+                    "fallen borders "
+                    span class="muted" { (format!("({} events)", model.fallen_journal.len())) }
+                }
+                @for e in &model.fallen_journal {
+                    @let hover = timeago::rfc3339_utc(e.ts);
+                    @let ago = timeago::timeago(now, e.ts);
+                    div class="rank-history-entry" {
+                        div class="rank-history-meta" title=(hover) {
+                            span class="ts-recency" { (ago) }
+                            " · "
+                            a href=(item_href(e.child.as_str(), nav)) {
+                                (item_display_path(e.child.as_str()))
+                            }
+                            " <: "
+                            a href=(item_href(e.parent.as_str(), nav)) {
+                                (item_display_path(e.parent.as_str()))
+                            }
+                            " · "
+                            span class="muted" {
+                                (format!(
+                                    "containment {} · border {}",
+                                    e.containment_weight, e.border_weight
+                                ))
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn build_rank_history(
     reduced: &crate::reducer::ReducerState,
     scope: &ScopeId,
     item: &str,
 ) -> Vec<RankHistoryEntryView> {
     let content = content_for_garden_view(reduced, scope);
-    let item_key = ItemId::parse(item).unwrap_or_else(|| ItemId::opaque(item.to_string()));
+    let item_key = ItemId::parse(item)
+        .map(|id| id.ontology_leaf())
+        .unwrap_or_else(|| ItemId::opaque(item.to_string()));
     let entries = match content.rank_history.get(&item_key) {
         None => return vec![],
         Some(e) => e,
@@ -350,9 +531,35 @@ pub(super) fn build_item_page_view_model(
 ) -> ItemPageViewModel {
     let content = content_for_garden_view(reduced, scope);
     let item_key = ItemId::parse(item)
+        .map(|id| id.ontology_leaf())
         .unwrap_or_else(|| ItemId::parse("~/").unwrap())
         .normalized_storage();
-    let item_has_parent = item_key.parent().is_some();
+    let item_has_parent = !content.scopes_of(&item_key).is_empty();
+    let is_scope = !content.members_of(&item_key).is_empty();
+    let crumb_chain = containment_crumb_chain(content, &item_key);
+    let primary_parent = strongest_parent(content, &item_key);
+    let alternate_scopes: Vec<ItemId> = content
+        .scopes_of(&item_key)
+        .into_iter()
+        .filter(|s| Some(s) != primary_parent.as_ref())
+        .collect();
+    let pairs = child_border_pairs(content, &item_key);
+    let memberships: Vec<BorderPairState> = pairs
+        .iter()
+        .filter(|p| p.status == MembershipStatus::Active)
+        .cloned()
+        .collect();
+    let suspended_borders: Vec<BorderPairState> = pairs
+        .iter()
+        .filter(|p| p.status == MembershipStatus::Suspended)
+        .cloned()
+        .collect();
+    let fallen_journal: Vec<FallenBorderEntry> = content
+        .fallen_borders()
+        .iter()
+        .filter(|e| e.child == item_key || e.parent == item_key)
+        .cloned()
+        .collect();
     let child_depth = child_depth.max(1);
     let child_rankings = if child_depth > 1 {
         let items = resolve_scope_recursive(content, &[item_key.as_str().to_string()], child_depth);
@@ -380,6 +587,12 @@ pub(super) fn build_item_page_view_model(
             .or_else(|| reduced.public().item_bodies.get(&item_key).cloned()),
         sibling_nav,
         item_has_parent,
+        is_scope,
+        crumb_chain,
+        alternate_scopes,
+        memberships,
+        suspended_borders,
+        fallen_journal,
         child_rankings,
         aspect_rankings: aspect_rankings_for_parent(content, &item_key),
         child_depth,
diff --git a/server/src/html/garden/pin.rs b/server/src/html/garden/pin.rs
index e10b5c88bb912e325192d617416f4820b30cff57..3069c8a8431fcf8900c3e008340fcc52c250d1f2 100644
--- a/server/src/html/garden/pin.rs
+++ b/server/src/html/garden/pin.rs
@@ -25,8 +25,8 @@ pub(super) fn pinned_item_from_jar(jar: &CookieJar) -> Option<(String, ItemId)>
         v.to_string()
     };
     let (room, rest) = raw.split_once(PIN_COOKIE_SEP)?;
-    let item = ItemId::parse(rest.trim())?;
-    Some((room.trim().to_string(), item.normalized_storage()))
+    let item = ItemId::parse(rest.trim())?.ontology_leaf().normalized_storage();
+    Some((room.trim().to_string(), item))
 }
 
 pub(crate) fn encode_pin_cookie_value(room: &str, item_storage: &str) -> String {
diff --git a/server/src/html/garden/render.rs b/server/src/html/garden/render.rs
index d6ce27348f13714544191e4b4b048ad9027e9ab5..7608eb68bd744036be2dc6531cb0c35542a83656 100644
--- a/server/src/html/garden/render.rs
+++ b/server/src/html/garden/render.rs
@@ -33,7 +33,10 @@ use super::{
         child_depth_from_uri, garden_depth_select_markup, item_code_label, item_display_path,
         item_href,
     },
-    item_page::{build_item_page_view_model, sibling_nav_markup, AspectRankingView},
+    item_page::{
+        build_item_page_view_model, item_relations_markup, sibling_nav_markup, strongest_parent,
+        AspectRankingView,
+    },
     pin::{child_row_pin_or_vote, ont_pin_vote_controls, pinned_item_from_jar},
     vote::vote_pool_href,
 };
@@ -142,7 +145,7 @@ pub(super) async fn render_scope_view(
         &item_display_path(&model.item),
         "view-ontology view-ontology-light",
         html! {
-            nav class="breadcrumb" { (scoped_bc_path_for(&browse, &nav)) }
+            nav class="breadcrumb" { (scoped_bc_path_for(&browse, &nav, &model.crumb_chain)) }
             @if let Some(ref bar) = model.sibling_nav {
                 (sibling_nav_markup(&nav, bar, &model.item))
             }
@@ -153,9 +156,10 @@ pub(super) async fn render_scope_view(
                         span class="muted ont-item-unranked-note" { "unranked among siblings" }
                     }
                     @let vote_item_href = model.sibling_nav.as_ref().and_then(|_| {
-                        ItemId::parse(&model.item)
-                            .and_then(|i| i.parent())
-                            .map(|p| vote_pool_href(&nav, p.as_str()))
+                        ItemId::parse(&model.item).and_then(|i| {
+                            strongest_parent(scope_content, &i)
+                                .map(|p| vote_pool_href(&nav, p.as_str()))
+                        })
                     });
                     (ont_pin_vote_controls(
                         &nav,
@@ -167,6 +171,9 @@ pub(super) async fn render_scope_view(
                 }
                 @if let Some(body) = &model.body {
                     div class="ont-item-content" {
+                        @if model.is_scope {
+                            p class="muted ont-aspect-prompt" { "prompt" }
+                        }
                         (render_item_body_in_scope(
                             body,
                             nav.garden_root_url(),
@@ -294,6 +301,8 @@ pub(super) async fn render_scope_view(
                 }
             }
 
+            (item_relations_markup(&model, &nav, now_ms()))
+
             section class="ont-tab-panel ont-tab-panel-children" {
                 @let total_children = model.child_rankings.component_rankings
                     .iter().map(|c| c.ranked.len()).sum::<usize>()
diff --git a/server/src/html/garden/routes.rs b/server/src/html/garden/routes.rs
index 4bd0bba63a8a199368edfa8fc245d81bb23165cb..918a4c7547a54f9898ba450bab7e932f56302b56 100644
--- a/server/src/html/garden/routes.rs
+++ b/server/src/html/garden/routes.rs
@@ -148,6 +148,13 @@ pub async fn ontology_path(
     jar: CookieJar,
     uri: Uri,
 ) -> impl IntoResponse {
+    if let Some(canonical) = OntologyPath::nested_redirect_target(&path) {
+        let loc = match uri.query() {
+            Some(q) if !q.is_empty() => format!("{canonical}?{q}"),
+            _ => canonical,
+        };
+        return axum::response::Redirect::permanent(&loc).into_response();
+    }
     let path = OntologyPath::from_input(&path);
     render_scope_view(
         state,
@@ -157,6 +164,7 @@ pub async fn ontology_path(
         uri,
     )
     .await
+    .into_response()
 }
 
 /// External ontology index (`/-/`).
@@ -446,7 +454,21 @@ pub async fn room_ontology_path(
         return room_not_found_page(&jar, &uri).into_response();
     }
     drop(reduced);
+    if let Some(canonical) = OntologyPath::nested_redirect_target(&path) {
+        let loc = if let Some(rest) = canonical.strip_prefix("/~") {
+            format!("{}{rest}", nav.garden_root_url())
+        } else {
+            canonical
+        };
+        let loc = match uri.query() {
+            Some(q) if !q.is_empty() => format!("{loc}?{q}"),
+            _ => loc,
+        };
+        return axum::response::Redirect::permanent(&loc).into_response();
+    }
     let path = OntologyPath::from_input(&path);
-    render_scope_view(state, GardenBrowsePath::Tilde(path), nav, jar, uri).await
+    render_scope_view(state, GardenBrowsePath::Tilde(path), nav, jar, uri)
+        .await
+        .into_response()
 }
 
diff --git a/server/src/html/garden/tests.rs b/server/src/html/garden/tests.rs
index 6fd72f0319c76b5acb6bfbadde3792d279c63fc1..2c94e26930f7d22f09aa12dbd9d32f3abbcf058d 100644
--- a/server/src/html/garden/tests.rs
+++ b/server/src/html/garden/tests.rs
@@ -1,7 +1,11 @@
 use super::{
     access::content_for_garden_view,
     external::{external_frame_allowed, external_resolver_status_markup, external_source_href},
-    item_page::{build_item_page_view_model, sibling_nav_markup},
+    browse::scoped_bc_containment,
+    item_page::{
+        build_item_page_view_model, containment_crumb_chain, item_relations_markup,
+        sibling_nav_markup,
+    },
     render::aspect_ranking_sections_markup,
     pin::ont_pin_vote_controls,
     vote::{
@@ -14,7 +18,7 @@ use crate::{
     events::{Event, Ingest},
     html::forum::ThreadNav,
     path_types::ItemId,
-    reducer::{ReducerState, ScopeId},
+    reducer::{MembershipStatus, ReducerState, ScopeId},
 };
 
 fn apply_ingest(state: &mut ReducerState, ts: i64, raw: &str) {
@@ -55,8 +59,8 @@ fn vote_edge_compare_sorts_rows_by_strength_for_page_left() {
          {strong for a}\n             ~/topic/a 8:2 ~/topic/b\n",
     );
     let content = content_for_garden_view(&reduced, &ScopeId::Public);
-    let page_left = ItemId::parse("~/topic/a").unwrap().normalized_storage();
-    let page_right = ItemId::parse("~/topic/b").unwrap().normalized_storage();
+    let page_left = ItemId::parse("~/topic/a").unwrap().ontology_leaf();
+    let page_right = ItemId::parse("~/topic/b").unwrap().ontology_leaf();
     let raw = edge_vote_entries_for_pair(content, &page_left, &page_right);
     assert_eq!(raw.len(), 2);
     let sorted = sort_votes_for_compare_display(raw, &page_left, &page_right);
@@ -83,8 +87,8 @@ fn edge_vote_count_for_pair_matches_votes_for_edge_len() {
          ~/topic/b 2:3 ~/topic/a\n",
     );
     let content = content_for_garden_view(&reduced, &ScopeId::Public);
-    let a = ItemId::parse("~/topic/a").unwrap().normalized_storage();
-    let b = ItemId::parse("~/topic/b").unwrap().normalized_storage();
+    let a = ItemId::parse("~/topic/a").unwrap().ontology_leaf();
+    let b = ItemId::parse("~/topic/b").unwrap().ontology_leaf();
     assert_eq!(
         edge_vote_count_for_pair(content, &a, &b),
         edge_vote_entries_for_pair(content, &a, &b).len()
@@ -106,8 +110,8 @@ fn suggest_next_vote_pair_prefers_unvoted_sibling_pair() {
          {a beats b}\n             ~/topic/a 2:1 ~/topic/b\n",
     );
     let content = content_for_garden_view(&reduced, &ScopeId::Public);
-    let a = ItemId::parse("~/topic/a").unwrap().normalized_storage();
-    let b = ItemId::parse("~/topic/b").unwrap().normalized_storage();
+    let a = ItemId::parse("~/topic/a").unwrap().ontology_leaf();
+    let b = ItemId::parse("~/topic/b").unwrap().ontology_leaf();
     let next = suggest_next_vote_pair(content, &a, &b, None).expect("next sibling pair");
     assert_ne!(
         canonical_edge_items(&next.0, &next.1),
@@ -242,7 +246,7 @@ fn sibling_nav_markup_includes_rank_and_winner_percentile() {
     let winner = build_item_page_view_model(&reduced, &ScopeId::Public, "~/topic/a", 1);
     let winner_nav = winner.sibling_nav.expect("sibling nav");
     let nav = ThreadNav::public();
-    let html = sibling_nav_markup(&nav, &winner_nav, "~/topic/a").into_string();
+    let html = sibling_nav_markup(&nav, &winner_nav, &winner.item).into_string();
     assert!(html.contains("rank: 1/3"), "missing rank in {html}");
     assert!(
         html.contains("top 66th percentile"),
@@ -251,7 +255,7 @@ fn sibling_nav_markup_includes_rank_and_winner_percentile() {
 
     let mid = build_item_page_view_model(&reduced, &ScopeId::Public, "~/topic/b", 1);
     let mid_nav = mid.sibling_nav.expect("sibling nav");
-    let mid_html = sibling_nav_markup(&nav, &mid_nav, "~/topic/b").into_string();
+    let mid_html = sibling_nav_markup(&nav, &mid_nav, &mid.item).into_string();
     assert!(mid_html.contains("rank: 2/3"), "missing mid rank in {mid_html}");
     assert!(
         !mid_html.contains("percentile"),
@@ -313,8 +317,8 @@ fn item_page_renders_aspect_section_below_canonical() {
     let aspect_top = model.aspect_rankings[0].rankings.component_rankings[0].ranked[0]
         .item
         .as_str();
-    assert!(canon_top.contains("topic/a"));
-    assert!(aspect_top.contains("topic/b"));
+    assert!(canon_top.ends_with("/a"), "canonical winner {canon_top}");
+    assert!(aspect_top.ends_with("/b"), "aspect winner {aspect_top}");
 
     let content = content_for_garden_view(&reduced, &ScopeId::Public);
     let html = aspect_ranking_sections_markup(
@@ -379,8 +383,8 @@ fn item_page_model_builds_ranked_child_components() {
     assert_eq!(
         names,
         vec![
-            "https://slug.social/~/topic/a",
-            "https://slug.social/~/topic/b"
+            "https://slug.social/~/a",
+            "https://slug.social/~/b"
         ]
     );
     use crate::path_types::ItemId;
@@ -388,11 +392,11 @@ fn item_page_model_builds_ranked_child_components() {
         model
             .child_rankings
             .unranked_items
-            .contains(&ItemId::parse("https://slug.social/~/topic/kid1").unwrap())
+            .contains(&ItemId::parse("https://slug.social/~/kid1").unwrap())
             || model
                 .child_rankings
                 .unranked_items
-                .contains(&ItemId::parse("https://slug.social/~/topic/kid2").unwrap())
+                .contains(&ItemId::parse("https://slug.social/~/kid2").unwrap())
     );
 }
 
@@ -496,9 +500,9 @@ fn item_page_model_depth_includes_descendants() {
         .iter()
         .map(|u| u.as_str())
         .collect();
-    assert!(items.contains("https://slug.social/~/topic/a"));
-    assert!(items.contains("https://slug.social/~/topic/a/leaf"));
-    assert!(items.contains("https://slug.social/~/topic/b"));
+    assert!(items.contains("https://slug.social/~/a"));
+    assert!(items.contains("https://slug.social/~/leaf"));
+    assert!(items.contains("https://slug.social/~/b"));
 }
 
 #[test]
@@ -528,8 +532,8 @@ fn item_page_model_depth_all_includes_deep_descendants() {
         .iter()
         .map(|u| u.as_str())
         .collect();
-    assert!(items.contains("https://slug.social/~/topic/a/mid/leaf"));
-    assert!(items.contains("https://slug.social/~/topic/b"));
+    assert!(items.contains("https://slug.social/~/leaf"));
+    assert!(items.contains("https://slug.social/~/b"));
 }
 
 #[test]
@@ -627,3 +631,109 @@ fn external_frame_allowed_skips_known_blocked_hosts() {
     ));
     assert!(external_frame_allowed("https://example.com/path"));
 }
+
+#[test]
+fn item_page_scope_labels_prompt_and_lists_memberships() {
+    let mut reduced = ReducerState::default();
+    apply_ingest(
+        &mut reduced,
+        1,
+        "~jedi { who is a jedi }\n~luke { farm boy }\n{ in }\n~luke <: ~jedi\n",
+    );
+    let jedi = build_item_page_view_model(&reduced, &ScopeId::Public, "~/jedi", 1);
+    assert!(jedi.is_scope, "jedi has an active member");
+    assert_eq!(jedi.body.as_deref(), Some("who is a jedi"));
+    assert!(jedi.memberships.is_empty());
+
+    let luke = build_item_page_view_model(&reduced, &ScopeId::Public, "~/x/luke", 1);
+    assert!(!luke.is_scope);
+    assert_eq!(luke.body.as_deref(), Some("farm boy"));
+    assert_eq!(luke.memberships.len(), 1);
+    assert_eq!(luke.memberships[0].status, MembershipStatus::Active);
+    assert!(luke.memberships[0].parent.as_str().ends_with("/jedi"));
+    assert_eq!(luke.memberships[0].containment_weight, 1);
+    let crumbs: Vec<String> = luke
+        .crumb_chain
+        .iter()
+        .map(|id| id.last_segment().to_string())
+        .collect();
+    assert_eq!(crumbs, vec!["jedi", "luke"]);
+}
+
+#[test]
+fn item_page_crumb_picks_strongest_parent_lists_alternates() {
+    let mut reduced = ReducerState::default();
+    apply_ingest(
+        &mut reduced,
+        1,
+        "~jedi { j }\n~sith { s }\n~luke { l }\n{ j1 }\n~luke <: ~jedi\n{ s1 }\n~luke <: ~sith\n{ j2 }\n~luke <: ~jedi\n",
+    );
+    let content = content_for_garden_view(&reduced, &ScopeId::Public);
+    let luke = ItemId::parse("~luke").unwrap().ontology_leaf();
+    let chain = containment_crumb_chain(content, &luke);
+    assert_eq!(
+        chain.last().map(|id| id.last_segment()),
+        Some("luke")
+    );
+    assert_eq!(chain[0].last_segment(), "jedi", "stronger jedi parent first");
+
+    let model = build_item_page_view_model(&reduced, &ScopeId::Public, "~luke", 1);
+    assert_eq!(model.alternate_scopes.len(), 1);
+    assert_eq!(model.alternate_scopes[0].last_segment(), "sith");
+}
+
+#[test]
+fn item_page_renders_memberships_suspended_borders_and_journal() {
+    let mut reduced = ReducerState::default();
+    apply_ingest(&mut reduced, 1, "~jedi { j }\n~luke { l }\n{ in }\n~luke <: ~jedi\n");
+    apply_ingest(&mut reduced, 2, "{ out }\n~luke !<: ~jedi\n");
+    let suspended = build_item_page_view_model(&reduced, &ScopeId::Public, "~luke", 1);
+    assert!(suspended.memberships.is_empty());
+    assert_eq!(suspended.suspended_borders.len(), 1);
+    assert_eq!(
+        suspended.suspended_borders[0].status,
+        MembershipStatus::Suspended
+    );
+    let html_sus = item_relations_markup(&suspended, &ThreadNav::public(), 10_000).into_string();
+    assert!(
+        html_sus.contains("ont-tab-panel-borders"),
+        "missing suspended section: {html_sus}"
+    );
+    assert!(html_sus.contains("suspended borders"));
+    assert!(html_sus.contains("ont-border-suspended"));
+
+    apply_ingest(&mut reduced, 3, "{ still in }\n~luke <: ~jedi\n");
+    let breached = build_item_page_view_model(&reduced, &ScopeId::Public, "~luke", 1);
+    assert_eq!(breached.memberships.len(), 1);
+    assert_eq!(breached.fallen_journal.len(), 1);
+    let html = item_relations_markup(&breached, &ThreadNav::public(), 10_000).into_string();
+    assert!(html.contains("ont-tab-panel-memberships"), "missing memberships: {html}");
+    assert!(html.contains("memberships"));
+    assert!(html.contains("containment 2"));
+    assert!(html.contains("ont-fallen-borders"), "missing journal: {html}");
+    assert!(html.contains("fallen borders"));
+}
+
+#[test]
+fn item_page_scope_body_is_labeled_prompt_in_relations_model() {
+    let mut reduced = ReducerState::default();
+    apply_ingest(
+        &mut reduced,
+        1,
+        "~/topic {the prompt}\n~/topic/a {alpha}\n~/topic/b {beta}\n",
+    );
+    let model = build_item_page_view_model(&reduced, &ScopeId::Public, "~/topic", 1);
+    assert!(model.is_scope);
+    assert_eq!(model.body.as_deref(), Some("the prompt"));
+}
+
+#[test]
+fn containment_breadcrumb_emits_leaf_hrefs() {
+    let jedi = ItemId::parse("~jedi").unwrap().ontology_leaf();
+    let luke = ItemId::parse("~luke").unwrap().ontology_leaf();
+    let path = crate::html::breadcrumb_path::OntologyPath::from_item(luke.clone());
+    let html = scoped_bc_containment(&path, &[jedi, luke], &ThreadNav::public()).into_string();
+    assert!(html.contains("href=\"/~/jedi\""), "missing jedi crumb: {html}");
+    assert!(html.contains("href=\"/~/luke\""), "missing luke crumb: {html}");
+    assert!(!html.contains("/~/x/"));
+}
diff --git a/server/src/html/garden/vote.rs b/server/src/html/garden/vote.rs
index 9ae2073cdfc89a6a3ced891cb5f3fb5eb41c9aa0..d7f501298c69954cbca9f63b0b4d8ad8681681a6 100644
--- a/server/src/html/garden/vote.rs
+++ b/server/src/html/garden/vote.rs
@@ -291,26 +291,17 @@ pub(super) fn suggest_next_vote_pair(
     pool_parent: Option<&ItemId>,
 ) -> Option<(ItemId, ItemId)> {
     let pool: Vec<ItemId> = if let Some(parent) = pool_parent {
+        content.members_of(&parent.ontology_leaf())
+    } else {
         content
-            .item_children
-            .get(parent)
-            .map(|s| s.iter().cloned().collect())
-            .unwrap_or_default()
-    } else if current_left.parent().as_ref().map(|p| p.as_str())
-        == current_right.parent().as_ref().map(|p| p.as_str())
-    {
-        current_left
-            .parent()
-            .and_then(|parent| {
-                content
-                    .item_children
-                    .get(&parent.normalized_storage())
-                    .cloned()
-            })
-            .map(|children| children.into_iter().collect())
+            .shared_scopes(
+                &current_left.ontology_leaf(),
+                &current_right.ontology_leaf(),
+            )
+            .into_iter()
+            .next()
+            .map(|scope| content.members_of(&scope))
             .unwrap_or_default()
-    } else {
-        Vec::new()
     };
     let pool = comparable_items(content, pool);
     if pool.len() < 2 {
@@ -411,7 +402,7 @@ async fn vote_compare_inner(
 ) -> axum::response::Response {
     let pool_id: Option<ItemId> = match q.pool.as_deref() {
         Some(p) => match ItemId::parse(p.trim()) {
-            Some(i) => Some(i.normalized_storage()),
+            Some(i) => Some(i.normalized_storage().ontology_leaf()),
             None => return (StatusCode::BAD_REQUEST, "bad pool item").into_response(),
         },
         None => None,
@@ -420,11 +411,11 @@ async fn vote_compare_inner(
     let (left, right) = match (q.left.as_deref(), q.right.as_deref()) {
         (Some(l), Some(r)) => {
             let left = match ItemId::parse(l.trim()) {
-                Some(i) => i.normalized_storage(),
+                Some(i) => i.normalized_storage().ontology_leaf(),
                 None => return (StatusCode::NOT_FOUND, "bad left item").into_response(),
             };
             let right = match ItemId::parse(r.trim()) {
-                Some(i) => i.normalized_storage(),
+                Some(i) => i.normalized_storage().ontology_leaf(),
                 None => return (StatusCode::NOT_FOUND, "bad right item").into_response(),
             };
             if left == right {
@@ -438,11 +429,7 @@ async fn vote_compare_inner(
             };
             let reduced = state.reduced.read().await;
             let content = content_for_garden_view(&reduced, &nav.scope());
-            let children: Vec<ItemId> = content
-                .item_children
-                .get(pool)
-                .map(|s| s.iter().cloned().collect())
-                .unwrap_or_default();
+            let children: Vec<ItemId> = content.members_of(&pool.ontology_leaf());
             let children = comparable_items(content, children);
             if children.len() < 2 {
                 drop(reduced);
diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs
index ed524a869357a1f5808395dc44f789fdd5623f5f..26b3bdd914e93909a3f3146d532702d5d19ac2c3 100644
--- a/server/src/html/mod.rs
+++ b/server/src/html/mod.rs
@@ -767,7 +767,7 @@ fn garden_href_for_item_ref(
     garden_prefix: &str,
 ) -> Option<(crate::path_types::ItemId, String)> {
     let key = slug_types::canonicalize_item(raw_ref);
-    let id = crate::path_types::ItemId::parse(&key)?;
+    let id = crate::path_types::ItemId::parse(&key)?.ontology_leaf();
     let href = if let Some(tail) = id.tilde_tail() {
         if tail.is_empty() {
             garden_prefix.trim_end_matches('/').to_string()
@@ -808,7 +808,12 @@ fn push_item_ref_anchor(
         }
     }
     out.push('>');
-    out.push_str(&escape_html(raw_ref));
+    let label = if id.tilde_tail().is_some() {
+        id.display_path()
+    } else {
+        raw_ref.to_string()
+    };
+    out.push_str(&escape_html(&label));
     out.push_str("</a>");
     true
 }
@@ -1146,11 +1151,14 @@ mod linkify_title_tests {
     #[test]
     fn tilde_link_gets_title_from_item_bodies() {
         let mut bodies = HashMap::new();
-        let key = ItemId::parse(&slug_types::canonicalize_item("~/foo/bar")).unwrap();
+        let key = ItemId::parse(&slug_types::canonicalize_item("~/foo/bar"))
+            .unwrap()
+            .ontology_leaf();
         bodies.insert(key, "Hello  world\nline".to_string());
         let html = linkify_slugs_with_prefix("see ~/foo/bar ok", "/r/x/~", Some(&bodies));
         assert!(html.contains("title=\"Hello world line\""));
-        assert!(html.contains("href=\"/r/x/~/foo/bar\""));
+        assert!(html.contains("href=\"/r/x/~/bar\""));
+        assert!(html.contains(">~/bar<"), "leaf display text, got {html}");
     }
 
     #[test]
diff --git a/server/src/mcp/mod.rs b/server/src/mcp/mod.rs
index 8d67814a82eda9568a228a61c3f17187b600f7d2..93f9e57e9058ff352a24256ccfee1ee3a56535c4 100644
--- a/server/src/mcp/mod.rs
+++ b/server/src/mcp/mod.rs
@@ -26,8 +26,13 @@ use self::oauth::{cors_headers, www_authenticate_challenge};
 const SERVER_NAME: &str = "slug-social";
 const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
 const INSTRUCTIONS: &str = "\
-Slug is a garden (path-addressed ontology + pairwise rank centrality) and a forum \
-(bump-ordered threads), including private rooms. After the human links their \
+Slug is a garden (leaf-identity ontology + weighted containment + pairwise rank \
+centrality) and a forum (bump-ordered threads), including private rooms. Garden \
+items are flat tilde tokens (`~luke`); `~/x/luke` is the same item as `~luke`. \
+A scope is any item with active members — its body is the prompt for that role. \
+`{ explanation }` then `~a <: ~b` claims membership; `~a !<: ~b` raises a border \
+(suspended when containment <= border). `==` does not exist. Nested paths in \
+.sorter files are sugar for those claims. After the human links their \
 account: call whoami, then list_rooms, then read_room(room_id) to catch up on \
 private-room threads and recent posts (each post has actor and delegate). \
 get_thread(room_id, thread_tag) reads one private thread. get_feed is the \
@@ -384,11 +389,11 @@ fn tools_list() -> Value {
             tool(
                 "get_rank",
                 "Garden ranking",
-                "Ranked children under a garden parent path (e.g. ~ or ~/languages).",
+                "Ranked active members of a garden item used as a scope (leaf identity: ~/x/luke and ~luke are the same; default parent is ~, the root electorate).",
                 json!({
                     "type": "object",
                     "properties": {
-                        "parent_path": {"type": "string", "description": "Garden parent, default ~"},
+                        "parent_path": {"type": "string", "description": "Garden scope (leaf or legacy nested path; resolved to leaf). Default ~"},
                         "room_id": room_id_schema(),
                         "depth": {"type": "integer"},
                         "offset": {"type": "integer"},
@@ -404,7 +409,7 @@ fn tools_list() -> Value {
             tool(
                 "get_item",
                 "Garden item",
-                "Item body plus related thread tags for a garden path.",
+                "Item body plus related thread tags. Identity is the leaf (`~luke` / `~/luke`); nested `~/x/luke` resolves to the same item. When the item has active members, the body is that scope's prompt.",
                 json!({
                     "type": "object",
                     "properties": {
@@ -436,11 +441,11 @@ fn tools_list() -> Value {
             tool(
                 "get_matchup",
                 "Item vote history",
-                "Evidence trail for one garden item: each vote (win/loss ratio, opponent, actor) and the forum thread that recorded it. Same as CLI `garden matchup`.",
+                "Evidence trail for one garden item (leaf identity): each vote (win/loss ratio, opponent, actor) and the forum thread that recorded it. Same as CLI `garden matchup`. `item_path` accepts `luke`, `~luke`, or legacy `~/x/luke`.",
                 json!({
                     "type": "object",
                     "properties": {
-                        "item_path": {"type": "string", "description": "Garden item, e.g. ~/sorts/insertion"},
+                        "item_path": {"type": "string", "description": "Garden item leaf, e.g. insertion or ~/insertion"},
                         "room_id": room_id_schema(),
                         "limit": {"type": "integer"}
                     },
@@ -453,7 +458,7 @@ fn tools_list() -> Value {
             tool(
                 "check_sorter",
                 "Dry-run a .sorter document",
-                "Parse and preview ranking effects of a .sorter document without writing.",
+                "Parse and preview ranking and containment effects of a .sorter document without writing. Items are `~name` (or `~/path` sugar). Claims require a leading { explanation } then `~a <: ~b` / `~a !<: ~b`. `==` is not a statement.",
                 json!({
                     "type": "object",
                     "properties": {
@@ -526,7 +531,7 @@ fn tools_list() -> Value {
             tool(
                 "post_sorter",
                 "Publish a .sorter document",
-                "Publish a comparison or item definition to a forum thread. delegate is required (uuid:rig:provider/model) and is bound to the linked human. Ask the human for the exact delegate; do not invent one. room_id defaults to public. thread_tag is the forum channel inside that room.",
+                "Publish a comparison, item, or containment claim to a forum thread. Items are leaf tokens (`~luke`); nested `~/x/luke` is sugar for the same leaf plus membership edges. `{ explanation }` then `~a <: ~b` / `~a !<: ~b` (no `==`). A scope is any item with active members — its body is the prompt. delegate is required (uuid:rig:provider/model) and is bound to the linked human. Ask the human for the exact delegate; do not invent one. room_id defaults to public. thread_tag is the forum channel inside that room.",
                 json!({
                     "type": "object",
                     "properties": {
diff --git a/server/src/offline.rs b/server/src/offline.rs
index efce128e6fd37e016a7dbef346dafbe4c99a0df9..ac299eb83dcb0edc2875b7f638c44d8d68167e7e 100644
--- a/server/src/offline.rs
+++ b/server/src/offline.rs
@@ -106,7 +106,7 @@ fn document_stats(doc: &dsl::Document) -> CompileStats {
             dsl::Stmt::Item { .. } => items += 1,
             dsl::Stmt::Vote { .. } => votes += 1,
             dsl::Stmt::Prose { .. } => prose_blocks += 1,
-            dsl::Stmt::Aspect { .. } => {}
+            dsl::Stmt::Aspect { .. } | dsl::Stmt::Containment { .. } => {}
         }
     }
     CompileStats {
@@ -139,7 +139,10 @@ fn threads_in_document(text: &str) -> Vec<String> {
     tags
 }
 
-fn voted_ranking_keys(doc: &dsl::Document) -> Vec<(ItemId, Option<String>)> {
+fn voted_ranking_keys(
+    content: &crate::reducer::ContentState,
+    doc: &dsl::Document,
+) -> Vec<(ItemId, Option<String>)> {
     let mut keys = HashSet::new();
     for stmt in &doc.statements {
         if let dsl::Stmt::Vote {
@@ -150,10 +153,9 @@ fn voted_ranking_keys(doc: &dsl::Document) -> Vec<(ItemId, Option<String>)> {
         } = stmt
         {
             if let (Ok(a), Ok(b)) = (resolve_item(item1), resolve_item(item2)) {
-                if let Some(p) = a.parent() {
-                    keys.insert((p, aspect.clone()));
-                }
-                if let Some(p) = b.parent() {
+                let a = a.ontology_leaf();
+                let b = b.ontology_leaf();
+                for p in content.shared_scopes(&a, &b) {
                     keys.insert((p, aspect.clone()));
                 }
             }
@@ -172,25 +174,18 @@ pub fn rankings_for_document(
 ) -> Vec<CheckScopeRanking> {
     use crate::scope_rank::build_rankings_for_group_and_items;
 
-    voted_ranking_keys(doc)
+    let scoped_content = simulated
+        .content_for_scope(scope)
+        .unwrap_or_else(|| simulated.public());
+    voted_ranking_keys(scoped_content, doc)
         .into_iter()
         .map(|(parent, aspect)| {
-            let scoped_content = simulated
-                .content_for_scope(scope)
-                .unwrap_or_else(|| simulated.public());
             let empty = crate::reducer::GroupState::new();
             let scoped = if let Some(ref slug) = aspect {
                 let group = scoped_content
                     .aspect_group(&parent, slug)
                     .unwrap_or(&empty);
-                build_rankings_for_group_and_items(
-                    group,
-                    &scoped_content
-                        .item_children
-                        .get(&parent)
-                        .map(|s| s.iter().cloned().collect::<Vec<_>>())
-                        .unwrap_or_default(),
-                )
+                build_rankings_for_group_and_items(group, &scoped_content.members_of(&parent))
             } else {
                 build_children_rankings(scoped_content, &parent)
             };
@@ -444,15 +439,15 @@ mod tests {
         assert!(result.rankings[0].components[0].ranking[0]
             .item
             .as_str()
-            .contains("songs/a"));
+            .ends_with("/a"));
         assert!(result.rankings[1].components[0].ranking[0]
             .item
             .as_str()
-            .contains("songs/a"));
+            .ends_with("/a"));
         assert!(result.rankings[2].components[0].ranking[0]
             .item
             .as_str()
-            .contains("songs/a"));
+            .ends_with("/a"));
     }
 
     #[test]
diff --git a/server/src/reducer.rs b/server/src/reducer.rs
index bba0980224a837130becd553b0d661985a83d49c..434871e2bbe29cb832ce5cf8ab1b147c016d63fe 100644
--- a/server/src/reducer.rs
+++ b/server/src/reducer.rs
@@ -140,6 +140,47 @@ impl GroupState {
     }
 }
 
+/// Weights on one directed containment pair `(child, parent)`.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct ContainmentWeights {
+    /// Accumulating explicit `<:` claims.
+    pub explicit: u32,
+    /// At most one from path desugaring (idempotent across ingests).
+    pub sugar: bool,
+}
+
+impl ContainmentWeights {
+    pub fn containment_weight(&self) -> u32 {
+        self.explicit.saturating_add(u32::from(self.sugar))
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MembershipStatus {
+    Active,
+    Suspended,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BorderPairState {
+    pub child: ItemId,
+    pub parent: ItemId,
+    pub containment_weight: u32,
+    pub border_weight: u32,
+    pub status: MembershipStatus,
+}
+
+/// Derived fallen-border journal entry (rebuilt on replay; never persisted).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FallenBorderEntry {
+    pub ts: i64,
+    pub child: ItemId,
+    pub parent: ItemId,
+    pub containment_weight: u32,
+    pub border_weight: u32,
+    pub ingest_id: String,
+}
+
 /// Compact rank-history entry stored per item in the ledger.
 /// `caused_by` is resolved lazily at query time from `ingests_by_id`.
 #[derive(Debug, Clone)]
@@ -217,6 +258,7 @@ pub(crate) struct RankPositionCache {
     generation: u64,
     /// 1-indexed global rank and component-local Rank Centrality score.
     global: HashMap<ItemId, (usize, f64)>,
+    /// Scope item → 1-indexed rank among that scope's active members.
     by_parent: HashMap<ItemId, HashMap<ItemId, usize>>,
     #[cfg(test)]
     recomputations: usize,
@@ -228,7 +270,21 @@ pub struct ContentState {
     pub items: HashSet<ItemId>,
     pub item_bodies: HashMap<ItemId, String>,
     /// Parent [`ItemId`] -> direct children.
+    ///
+    /// Tilde-ontology keys are active containment members (synced from
+    /// [`Self::members_by_scope`]). URL / external keys keep path-hierarchy
+    /// children from [`ReducerState::add_child_edge`], plus any containment members.
     pub item_children: HashMap<ItemId, HashSet<ItemId>>,
+    /// `(child, parent)` → containment weights (explicit accumulates; sugar is idempotent).
+    pub containment: HashMap<(ItemId, ItemId), ContainmentWeights>,
+    /// `(child, parent)` → `!<:` border weight (accumulates).
+    pub borders: HashMap<(ItemId, ItemId), u32>,
+    /// Parent → currently **active** members (`containment_weight > border_weight`).
+    pub members_by_scope: HashMap<ItemId, HashSet<ItemId>>,
+    /// Child → scopes in which membership is active.
+    pub scopes_by_member: HashMap<ItemId, HashSet<ItemId>>,
+    /// Fallen-border journal, chronological. Derived; rebuilt on replay.
+    pub fallen_border_journal: Vec<FallenBorderEntry>,
     /// Per-item vote history (most recent first).
     pub item_votes: HashMap<ItemId, VecDeque<VoteData>>,
     /// Per-item ingest references (most recent first).
@@ -237,8 +293,9 @@ pub struct ContentState {
     pub item_threads: HashMap<ItemId, HashSet<String>>,
     /// Per-item rank history, oldest first.
     pub rank_history: HashMap<ItemId, Vec<RankHistoryEntry>>,
-    /// Aspect ranking groups keyed by (parent item, aspect slug).
-    /// Canonical votes stay in `ranking_group`.
+    /// Aspect ranking groups keyed by (scope item, aspect slug).
+    /// Canonical votes stay in `ranking_group`. Membership follows the
+    /// scope item's active-member electorate.
     pub aspect_groups: HashMap<(ItemId, String), GroupState>,
     /// Prompt text per aspect slug in this room; last non-empty write wins.
     pub aspect_prompts: HashMap<String, String>,
@@ -255,12 +312,178 @@ pub struct ContentState {
 
 impl ContentState {
     pub fn aspect_group(&self, parent: &ItemId, aspect: &str) -> Option<&GroupState> {
-        self.aspect_groups.get(&(parent.clone(), aspect.to_string()))
+        self.aspect_groups.get(&(parent.ontology_leaf(), aspect.to_string()))
     }
 
     pub fn aspect_prompt(&self, aspect: &str) -> Option<&str> {
         self.aspect_prompts.get(aspect).map(String::as_str)
     }
+
+    /// Active members of `item` (the electorate when `item` is used as a scope).
+    pub fn members_of(&self, item: &ItemId) -> Vec<ItemId> {
+        let key = item.ontology_leaf();
+        let mut out: Vec<ItemId> = self
+            .members_by_scope
+            .get(&key)
+            .map(|s| s.iter().cloned().collect())
+            .unwrap_or_default();
+        if key.tilde_tail().is_none() {
+            if let Some(ch) = self.item_children.get(&key) {
+                out.extend(ch.iter().cloned());
+            }
+            if let Some(ch) = self.item_children.get(item) {
+                out.extend(ch.iter().cloned());
+            }
+        }
+        out.sort();
+        out.dedup();
+        out
+    }
+
+    /// Scopes in which `item` is an active member.
+    pub fn scopes_of(&self, item: &ItemId) -> Vec<ItemId> {
+        let key = item.ontology_leaf();
+        let mut out: Vec<ItemId> = self
+            .scopes_by_member
+            .get(&key)
+            .map(|s| s.iter().cloned().collect())
+            .unwrap_or_default();
+        out.sort();
+        out
+    }
+
+    /// Shared scopes: items in which both `a` and `b` are active members.
+    pub fn shared_scopes(&self, a: &ItemId, b: &ItemId) -> Vec<ItemId> {
+        let sa: HashSet<ItemId> = self.scopes_of(a).into_iter().collect();
+        let mut out: Vec<ItemId> = self
+            .scopes_of(b)
+            .into_iter()
+            .filter(|s| sa.contains(s))
+            .collect();
+        out.sort();
+        out
+    }
+
+    pub fn border_state(&self, child: &ItemId, parent: &ItemId) -> Option<BorderPairState> {
+        let child = child.ontology_leaf();
+        let parent = parent.ontology_leaf();
+        let pair = (child.clone(), parent.clone());
+        let c_w = self
+            .containment
+            .get(&pair)
+            .map(ContainmentWeights::containment_weight)
+            .unwrap_or(0);
+        let b_w = self.borders.get(&pair).copied().unwrap_or(0);
+        if c_w == 0 && b_w == 0 {
+            return None;
+        }
+        let status = if c_w > b_w {
+            MembershipStatus::Active
+        } else {
+            MembershipStatus::Suspended
+        };
+        Some(BorderPairState {
+            child,
+            parent,
+            containment_weight: c_w,
+            border_weight: b_w,
+            status,
+        })
+    }
+
+    pub fn fallen_borders(&self) -> &[FallenBorderEntry] {
+        &self.fallen_border_journal
+    }
+
+    fn apply_containment_claim(
+        &mut self,
+        child: ItemId,
+        parent: ItemId,
+        border: bool,
+        sugar: bool,
+        ts: i64,
+        ingest_id: &str,
+    ) {
+        let child = child.ontology_leaf();
+        let parent = parent.ontology_leaf();
+        if child == parent {
+            return;
+        }
+        let pair = (child.clone(), parent.clone());
+        let old_c = self
+            .containment
+            .get(&pair)
+            .map(ContainmentWeights::containment_weight)
+            .unwrap_or(0);
+        let old_b = self.borders.get(&pair).copied().unwrap_or(0);
+        let prev_holding = old_b > 0 && old_c <= old_b;
+
+        if border {
+            *self.borders.entry(pair.clone()).or_insert(0) += 1;
+        } else if sugar {
+            let w = self.containment.entry(pair.clone()).or_default();
+            w.sugar = true;
+        } else {
+            self.containment.entry(pair.clone()).or_default().explicit += 1;
+        }
+
+        let new_c = self
+            .containment
+            .get(&pair)
+            .map(ContainmentWeights::containment_weight)
+            .unwrap_or(0);
+        let new_b = self.borders.get(&pair).copied().unwrap_or(0);
+        let now_active = new_c > new_b;
+
+        if prev_holding && now_active {
+            self.fallen_border_journal.push(FallenBorderEntry {
+                ts,
+                child: child.clone(),
+                parent: parent.clone(),
+                containment_weight: new_c,
+                border_weight: new_b,
+                ingest_id: ingest_id.to_string(),
+            });
+        }
+
+        if now_active {
+            self.members_by_scope
+                .entry(parent.clone())
+                .or_default()
+                .insert(child.clone());
+            self.scopes_by_member
+                .entry(child.clone())
+                .or_default()
+                .insert(parent.clone());
+            self.item_children
+                .entry(parent)
+                .or_default()
+                .insert(child);
+        } else {
+            if let Some(set) = self.members_by_scope.get_mut(&parent) {
+                set.remove(&child);
+                if set.is_empty() {
+                    self.members_by_scope.remove(&parent);
+                }
+            }
+            if let Some(set) = self.scopes_by_member.get_mut(&child) {
+                set.remove(&parent);
+                if set.is_empty() {
+                    self.scopes_by_member.remove(&child);
+                }
+            }
+            // Tilde scopes are membership-only; drop the child when suspended.
+            // URL scopes keep path-hierarchy children from add_child_edge.
+            if parent.tilde_tail().is_some() || parent == ItemId::ontology_root() {
+                if let Some(set) = self.item_children.get_mut(&parent) {
+                    set.remove(&child);
+                    if set.is_empty() {
+                        self.item_children.remove(&parent);
+                    }
+                }
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -438,11 +661,13 @@ impl ReducerState {
         self.content.get(&ScopeId::Public).expect("public scope missing")
     }
 
-    /// Register parent→child edges for the full ancestor chain.
-    /// For `a/b/c/d` this creates: `a/b/c→d`, `a/b→a/b/c`, `a→a/b`, `""→a`.
-    /// Stops early when an intermediate is already registered (its ancestors must be too).
+    /// Register parent→child edges for the full ancestor chain of **URL / external**
+    /// items. Tilde-ontology hierarchy is containment (path sugar), not path identity.
     /// @e2bdefa9-a6fa-4725-b0a2-c0b09d95bb20:claudecode:anthropic/claude-opus-4
     fn add_child_edge(content: &mut ContentState, item: &ItemId) {
+        if item.tilde_tail().is_some() {
+            return;
+        }
         let mut child = item.clone();
         loop {
             let Some(parent) = child.parent() else { break };
@@ -456,21 +681,21 @@ impl ReducerState {
         }
     }
 
-    /// Resolve an item path as a first-class [`ItemId`].
+    /// Resolve a DSL item ref. Tilde paths collapse to the leaf token.
     fn normalize_item(item: &str) -> Option<ItemId> {
-        ItemId::parse(item)
+        ItemId::parse(item).map(|id| id.ontology_leaf())
     }
 
-    /// 1-indexed rank within its own connected component, for every child of
+    /// 1-indexed rank within its own connected component, for every active member of
     /// `scope`. Items with no votes connecting them to a sibling are absent.
     fn scope_positions(
         group: &GroupState,
-        scope: &ItemId,
-        item_children: &HashMap<ItemId, HashSet<ItemId>>,
+        members: &HashSet<ItemId>,
     ) -> HashMap<ItemId, usize> {
-        let Some(children) = item_children.get(scope) else {
+        if members.is_empty() {
             return HashMap::new();
-        };
+        }
+        let children = members;
         let sibling_idxs: Vec<usize> = children
             .iter()
             .filter_map(|c| group.item_to_idx.get(c).copied())
@@ -563,44 +788,48 @@ impl ReducerState {
             });
         }
 
-        let parents: HashSet<ItemId> = items.iter().filter_map(ItemId::parent).collect();
-        let missing_parents: Vec<ItemId> = parents
+        let scopes: HashSet<ItemId> = items
+            .iter()
+            .flat_map(|item| content.scopes_of(item))
+            .collect();
+        let missing_scopes: Vec<ItemId> = scopes
             .into_iter()
-            .filter(|parent| {
+            .filter(|scope| {
                 !content
                     .rank_position_cache
                     .as_ref()
                     .expect("cache initialized")
                     .by_parent
-                    .contains_key(parent)
+                    .contains_key(scope)
             })
             .collect();
-        for parent in missing_parents {
-            let positions = Self::scope_positions(
-                &content.ranking_group,
-                &parent,
-                &content.item_children,
-            );
+        for scope in missing_scopes {
+            let members: HashSet<ItemId> = content.members_of(&scope).into_iter().collect();
+            let positions = Self::scope_positions(&content.ranking_group, &members);
             content
                 .rank_position_cache
                 .as_mut()
                 .expect("cache initialized")
                 .by_parent
-                .insert(parent, positions);
+                .insert(scope, positions);
         }
 
+        let item_scopes: Vec<(ItemId, Vec<ItemId>)> = items
+            .iter()
+            .map(|item| (item.clone(), content.scopes_of(item)))
+            .collect();
         let cache = content
             .rank_position_cache
             .as_ref()
             .expect("cache initialized");
         let mut content_positions = HashMap::with_capacity(items.len());
-        for item in items {
-            let scope = item
-                .parent()
-                .and_then(|parent| {
+        for (item, scopes) in &item_scopes {
+            let scope = scopes
+                .iter()
+                .find_map(|scope| {
                     cache
                         .by_parent
-                        .get(&parent)
+                        .get(scope)
                         .and_then(|positions| positions.get(item).copied())
                 })
                 .unwrap_or(0);
@@ -664,6 +893,30 @@ impl ReducerState {
                         }
                     }
                 }
+                dsl::Stmt::Containment {
+                    child,
+                    parent,
+                    border,
+                    sugar,
+                    ..
+                } => {
+                    let Some(child_id) = Self::normalize_item(&child) else {
+                        continue;
+                    };
+                    let Some(parent_id) = Self::normalize_item(&parent) else {
+                        continue;
+                    };
+                    ingest_items.insert(child_id.clone());
+                    ingest_items.insert(parent_id.clone());
+                    content.apply_containment_claim(
+                        child_id,
+                        parent_id,
+                        border,
+                        sugar,
+                        ing.ts,
+                        &ing.id,
+                    );
+                }
                 dsl::Stmt::Aspect { slug, prompt } => {
                     if let (Some(s), Some(p)) = (slug, prompt) {
                         if !p.trim().is_empty() {
@@ -707,14 +960,13 @@ impl ReducerState {
                     Self::add_child_edge(content, &item_b);
 
                     if let Some(asp) = aspect {
-                        if let (Some(pa), Some(pb)) = (item_a.parent(), item_b.parent()) {
-                            if pa == pb {
-                                content
-                                    .aspect_groups
-                                    .entry((pa, asp))
-                                    .or_default()
-                                    .apply_vote(vote);
-                            }
+                        let shared = content.shared_scopes(&item_a, &item_b);
+                        for scope in shared {
+                            content
+                                .aspect_groups
+                                .entry((scope, asp.clone()))
+                                .or_default()
+                                .apply_vote(vote.clone());
                         }
                     } else {
                         content.ranking_group.apply_vote(vote.clone());
@@ -759,10 +1011,10 @@ impl ReducerState {
                 } else {
                     after_global as i32 - before_global as i32
                 };
-                let scope_total = item
-                    .parent()
-                    .and_then(|p| content.item_children.get(&p))
-                    .map(|s| s.len())
+                let scope_total = content
+                    .scopes_of(item)
+                    .first()
+                    .map(|s| content.members_of(s).len())
                     .unwrap_or(0);
                 let global_total = content.ranking_group.idx_to_item.len();
                 content.rank_history.entry(item.clone()).or_default().push(RankHistoryEntry {
@@ -1103,7 +1355,7 @@ mod rank_position_cache_tests {
             cache.recomputations, 3,
             "the second ingest must reuse its before positions and recompute only after voting"
         );
-        assert_eq!(content.rank_history[&ItemId::parse("~/memo/b").unwrap()].len(), 2);
+        assert_eq!(content.rank_history[&ItemId::parse("~b").unwrap()].len(), 2);
     }
 }
 
@@ -1283,3 +1535,225 @@ mod aspect_tests {
         );
     }
 }
+
+#[cfg(test)]
+mod containment_tests {
+    use super::*;
+    use crate::events::PostRedacted;
+
+    fn ingest_at(id: &str, ts: i64, raw: &str) -> Ingest {
+        Ingest {
+            ts,
+            id: id.to_string(),
+            raw: raw.to_string(),
+            principal: "tester".to_string(),
+            delegate: None,
+            room_id: "public".to_string(),
+            thread_tag: "contain".to_string(),
+        }
+    }
+
+    fn item(s: &str) -> ItemId {
+        ItemId::parse(s).unwrap().ontology_leaf()
+    }
+
+    #[test]
+    fn activation_when_containment_beats_border() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "in",
+            1,
+            "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+        )));
+        let c = state.public();
+        assert_eq!(c.members_of(&item("~jedi")), vec![item("~luke")]);
+        assert_eq!(c.scopes_of(&item("~luke")), vec![item("~jedi")]);
+        let st = c.border_state(&item("~luke"), &item("~jedi")).unwrap();
+        assert_eq!(st.status, MembershipStatus::Active);
+        assert_eq!(st.containment_weight, 1);
+        assert_eq!(st.border_weight, 0);
+    }
+
+    #[test]
+    fn suspension_at_equality() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "in",
+            1,
+            "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "out",
+            2,
+            "{ out }\n~luke !<: ~jedi",
+        )));
+        let c = state.public();
+        assert!(c.members_of(&item("~jedi")).is_empty());
+        let st = c.border_state(&item("~luke"), &item("~jedi")).unwrap();
+        assert_eq!(st.status, MembershipStatus::Suspended);
+        assert_eq!(st.containment_weight, 1);
+        assert_eq!(st.border_weight, 1);
+        assert!(c.fallen_borders().is_empty());
+    }
+
+    #[test]
+    fn breach_journals_when_containment_overtakes_holding_border() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "in",
+            1,
+            "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "out",
+            2,
+            "{ out }\n~luke !<: ~jedi",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "in2",
+            3,
+            "{ still in }\n~luke <: ~jedi",
+        )));
+        let c = state.public();
+        let st = c.border_state(&item("~luke"), &item("~jedi")).unwrap();
+        assert_eq!(st.status, MembershipStatus::Active);
+        assert_eq!(st.containment_weight, 2);
+        assert_eq!(st.border_weight, 1);
+        assert_eq!(c.members_of(&item("~jedi")), vec![item("~luke")]);
+        assert_eq!(c.fallen_borders().len(), 1);
+        let j = &c.fallen_borders()[0];
+        assert_eq!(j.ts, 3);
+        assert_eq!(j.ingest_id, "in2");
+        assert_eq!(j.containment_weight, 2);
+        assert_eq!(j.border_weight, 1);
+        assert_eq!(j.child, item("~luke"));
+        assert_eq!(j.parent, item("~jedi"));
+    }
+
+    #[test]
+    fn sugar_weights_are_idempotent() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "one",
+            1,
+            "~/jedi/luke { l }",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "two",
+            2,
+            "~/jedi/luke { l again }",
+        )));
+        let c = state.public();
+        let st = c.border_state(&item("~luke"), &item("~jedi")).unwrap();
+        assert_eq!(st.containment_weight, 1);
+        assert_eq!(st.status, MembershipStatus::Active);
+        assert_eq!(c.item_bodies.get(&item("~luke")).map(String::as_str), Some("l again"));
+    }
+
+    #[test]
+    fn explicit_weights_accumulate() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "a",
+            1,
+            "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "b",
+            2,
+            "{ still }\n~luke <: ~jedi",
+        )));
+        let st = state
+            .public()
+            .border_state(&item("~luke"), &item("~jedi"))
+            .unwrap();
+        assert_eq!(st.containment_weight, 2);
+    }
+
+    #[test]
+    fn leaf_collision_merges_two_old_paths() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "x",
+            1,
+            "~/x/luke { from x }",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "y",
+            2,
+            "~/y/luke { from y }",
+        )));
+        let c = state.public();
+        assert!(c.items.contains(&item("~luke")));
+        assert!(!c.items.contains(&ItemId::parse("~/x/luke").unwrap()));
+        assert_eq!(c.item_bodies.get(&item("~luke")).map(String::as_str), Some("from y"));
+        assert_eq!(c.members_of(&item("~x")), vec![item("~luke")]);
+        assert_eq!(c.members_of(&item("~y")), vec![item("~luke")]);
+        let mut scopes = c.scopes_of(&item("~luke"));
+        scopes.sort();
+        assert_eq!(scopes, vec![item("~x"), item("~y")]);
+    }
+
+    #[test]
+    fn replay_determinism_containment_and_journal() {
+        let events = [
+            Event::Ingest(ingest_at(
+                "in",
+                1,
+                "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+            )),
+            Event::Ingest(ingest_at("out", 2, "{ out }\n~luke !<: ~jedi")),
+            Event::Ingest(ingest_at("in2", 3, "{ still }\n~luke <: ~jedi")),
+            Event::Ingest(ingest_at("path", 4, "~/jedi/obiwan { o }")),
+        ];
+        let mut a = ReducerState::default();
+        let mut b = ReducerState::default();
+        for ev in &events {
+            a.apply_event(ev.clone());
+            b.apply_event(ev.clone());
+        }
+        let ca = a.public();
+        let cb = b.public();
+        assert_eq!(ca.containment, cb.containment);
+        assert_eq!(ca.borders, cb.borders);
+        assert_eq!(ca.members_by_scope, cb.members_by_scope);
+        assert_eq!(ca.fallen_border_journal, cb.fallen_border_journal);
+        assert_eq!(ca.members_of(&item("~jedi")), cb.members_of(&item("~jedi")));
+    }
+
+    #[test]
+    fn redaction_rebuilds_containment() {
+        let mut state = ReducerState::default();
+        state.apply_event(Event::Ingest(ingest_at(
+            "keep",
+            1,
+            "~luke { l }\n~jedi { j }\n{ in }\n~luke <: ~jedi",
+        )));
+        state.apply_event(Event::Ingest(ingest_at(
+            "drop",
+            2,
+            "{ out }\n~luke !<: ~jedi",
+        )));
+        assert_eq!(
+            state
+                .public()
+                .border_state(&item("~luke"), &item("~jedi"))
+                .unwrap()
+                .status,
+            MembershipStatus::Suspended
+        );
+        state.apply_event(Event::PostRedacted(PostRedacted {
+            ts: 3,
+            post_id: "drop".to_string(),
+            principal: "tester".to_string(),
+        }));
+        let c = state.public();
+        assert_eq!(
+            c.border_state(&item("~luke"), &item("~jedi"))
+                .unwrap()
+                .status,
+            MembershipStatus::Active
+        );
+        assert!(c.fallen_borders().is_empty());
+    }
+}
diff --git a/server/src/scope_rank.rs b/server/src/scope_rank.rs
index b5d7fd08a6aafb39b0c4b3f9b75e3b3402b7c38e..4338b10c61af41e91d0857de6f3bfd5a6cf1e01e 100644
--- a/server/src/scope_rank.rs
+++ b/server/src/scope_rank.rs
@@ -20,18 +20,13 @@ pub struct ChildrenRankings {
     pub unranked_items: Vec<ItemId>,
 }
 
-/// Resolve one scope spec (literal path) to direct children of that parent. No wildcards.
+/// Resolve one scope spec (literal path) to active members of that scope item.
+/// Tilde parent paths collapse to the leaf token (`~/x/luke` → `~luke`).
 fn resolve_one_scope(content: &ContentState, spec: &str) -> HashSet<ItemId> {
-    let Some(parent) = ItemId::parse(spec.trim()) else {
+    let Some(parent) = ItemId::parse(spec.trim()).map(|id| id.ontology_leaf()) else {
         return HashSet::new();
     };
-    content
-        .item_children
-        .get(&parent)
-        .cloned()
-        .unwrap_or_default()
-        .into_iter()
-        .collect()
+    content.members_of(&parent).into_iter().collect()
 }
 
 /// Resolve multiple scope specs (literal paths) to a single merged, deduplicated list of item paths.
@@ -77,16 +72,17 @@ pub fn resolve_scope_recursive(
         return vec![];
     }
     let mut visited: HashSet<ItemId> = HashSet::new();
-    let mut frontier: Vec<ItemId> = specs.iter().filter_map(|s| ItemId::parse(s)).collect();
+    let mut frontier: Vec<ItemId> = specs
+        .iter()
+        .filter_map(|s| ItemId::parse(s).map(|id| id.ontology_leaf()))
+        .collect();
 
     for _level in 0..depth {
         let mut next_frontier: Vec<ItemId> = Vec::new();
         for parent in &frontier {
-            if let Some(children) = content.item_children.get(parent) {
-                for child in children {
-                    if visited.insert(child.clone()) {
-                        next_frontier.push(child.clone());
-                    }
+            for child in content.members_of(parent) {
+                if visited.insert(child.clone()) {
+                    next_frontier.push(child);
                 }
             }
         }
@@ -198,12 +194,8 @@ pub fn build_rankings_for_group_and_items(
 /// Build connected-component rankings for direct children of parent_scope.
 /// Matches the HTML garden view: multiple components, isolates, no-vote items.
 pub fn build_children_rankings(content: &ContentState, parent: &ItemId) -> ChildrenRankings {
-    let parent = parent.clone().normalized_storage();
-    let items: Vec<ItemId> = content
-        .item_children
-        .get(&parent)
-        .map(|s| s.iter().cloned().collect())
-        .unwrap_or_default();
+    let parent = parent.clone().normalized_storage().ontology_leaf();
+    let items = content.members_of(&parent);
     build_rankings_for_item_set(content, &items)
 }
 
@@ -212,12 +204,8 @@ pub fn build_children_rankings_in_group(
     parent: &ItemId,
     group: &GroupState,
 ) -> ChildrenRankings {
-    let parent = parent.clone().normalized_storage();
-    let items: Vec<ItemId> = content
-        .item_children
-        .get(&parent)
-        .map(|s| s.iter().cloned().collect())
-        .unwrap_or_default();
+    let parent = parent.clone().normalized_storage().ontology_leaf();
+    let items = content.members_of(&parent);
     build_rankings_for_group_and_items(group, &items)
 }
 
diff --git a/server/tests/basic.rs b/server/tests/basic.rs
index 06fed5a78e2fe1a7e83db062cff7af643be4f136..1556e0e1cd325e011d0a9492a69510c80b001664 100644
--- a/server/tests/basic.rs
+++ b/server/tests/basic.rs
@@ -84,9 +84,9 @@ fn reducer_and_ranking_linear_chain() {
     let mut group = state.public().ranking_group.clone();
     let ranked = ranked_items(&mut group, 20000, 1e-9);
     assert_eq!(ranked.len(), 3);
-    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/t/a");
-    assert_eq!(ranked[1].item.as_str(), "https://slug.social/~/t/b");
-    assert_eq!(ranked[2].item.as_str(), "https://slug.social/~/t/c");
+    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/a");
+    assert_eq!(ranked[1].item.as_str(), "https://slug.social/~/b");
+    assert_eq!(ranked[2].item.as_str(), "https://slug.social/~/c");
 }
 
 #[test]
@@ -119,16 +119,14 @@ fn reducer_handles_item_and_body_from_ingest() {
     ));
 
     let content = state.public();
-    assert!(content.items.contains(&item_id("https://slug.social/~/t/test-item")));
+    assert!(content.items.contains(&item_id("https://slug.social/~/test-item")));
     assert_eq!(
-        content.item_bodies.get(&item_id("https://slug.social/~/t/test-item")),
+        content.item_bodies.get(&item_id("https://slug.social/~/test-item")),
         Some(&"Description here".to_string())
     );
     assert!(content
-        .item_children
-        .get(&item_id("https://slug.social/~/t"))
-        .map(|c| c.contains(&item_id("https://slug.social/~/t/test-item")))
-        .unwrap_or(false));
+        .members_of(&item_id("https://slug.social/~/t"))
+        .contains(&item_id("https://slug.social/~/test-item")));
 }
 
 #[test]
@@ -143,12 +141,12 @@ fn reducer_indexes_item_threads_and_vote_thread() {
     state.apply_event(Event::Ingest(ev));
 
     let content = state.public();
-    let threads_for_insertion = content.item_threads.get(&item_id("https://slug.social/~/sorts/insertion")).unwrap();
+    let threads_for_insertion = content.item_threads.get(&item_id("https://slug.social/~/insertion")).unwrap();
     assert!(threads_for_insertion.contains("sorting-hat"));
-    let threads_for_mergesort = content.item_threads.get(&item_id("https://slug.social/~/sorts/mergesort")).unwrap();
+    let threads_for_mergesort = content.item_threads.get(&item_id("https://slug.social/~/mergesort")).unwrap();
     assert!(threads_for_mergesort.contains("sorting-hat"));
 
-    let vote = content.item_votes.get(&item_id("https://slug.social/~/sorts/insertion")).unwrap().front().unwrap();
+    let vote = content.item_votes.get(&item_id("https://slug.social/~/insertion")).unwrap().front().unwrap();
     assert_eq!(vote.thread_tag, "sorting-hat");
 }
 
@@ -162,8 +160,8 @@ fn reducer_aggregates_multiple_votes() {
     }
 
     let group = &state.public().ranking_group;
-    let a_idx = group.item_to_idx[&item_id("https://slug.social/~/t/a")];
-    let b_idx = group.item_to_idx[&item_id("https://slug.social/~/t/b")];
+    let a_idx = group.item_to_idx[&item_id("https://slug.social/~/a")];
+    let b_idx = group.item_to_idx[&item_id("https://slug.social/~/b")];
 
     // Should have accumulated edge weights in both directions.
     assert!(group.edges.contains_key(&(a_idx, b_idx)));
@@ -239,7 +237,7 @@ fn ranking_dominant_item_wins() {
     let mut group = state.public().ranking_group.clone();
     let ranked = ranked_items(&mut group, 20000, 1e-9);
 
-    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/t/champion");
+    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/champion");
     assert!(ranked[0].score > ranked[1].score);
 }
 
@@ -386,7 +384,7 @@ async fn full_workflow_reducer_and_ranking() {
     let ranked = ranked_items(&mut group, 20000, 1e-9);
 
     assert_eq!(ranked.len(), 2);
-    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/langs/rust"); // Should win
+    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/rust"); // Should win
     assert!(ranked[0].score > ranked[1].score);
 }
 
@@ -400,29 +398,24 @@ fn reducer_materializes_ancestor_path_segments() {
         "~/ai-models/anthropic/claude-opus {opus}\n~/ai-models/anthropic/claude-sonnet {sonnet}\n",
     ));
 
-    // The intermediate path "https://slug.social/~/ai-models/anthropic" should appear as a child of "https://slug.social/~/ai-models".
+    // Leaf identity: path segments become flat tokens with containment edges.
     let content = state.public();
-    let ai_models_children = content.item_children.get(&item_id("https://slug.social/~/ai-models")).expect("ai-models should have children");
-    assert!(
-        ai_models_children.contains(&item_id("https://slug.social/~/ai-models/anthropic")),
-        "ai-models/anthropic should be a child of ai-models"
-    );
-
-    // The leaf items should still be children of "https://slug.social/~/ai-models/anthropic".
-    let anthropic_children = content.item_children.get(&item_id("https://slug.social/~/ai-models/anthropic")).expect("ai-models/anthropic should have children");
-    assert!(anthropic_children.contains(&item_id("https://slug.social/~/ai-models/anthropic/claude-opus")));
-    assert!(anthropic_children.contains(&item_id("https://slug.social/~/ai-models/anthropic/claude-sonnet")));
-
-    // Root should contain "https://slug.social/~/ai-models".
-    let root_children = content.item_children.get(&item_id("https://slug.social/~")).expect("root should have children");
-    assert!(root_children.contains(&item_id("https://slug.social/~/ai-models")));
-
-    // The phantom intermediates should NOT be in the items set (they weren't explicitly created).
-    assert!(!content.items.contains(&item_id("https://slug.social/~/ai-models")));
-    assert!(!content.items.contains(&item_id("https://slug.social/~/ai-models/anthropic")));
-    // But the leaf items should be.
-    assert!(content.items.contains(&item_id("https://slug.social/~/ai-models/anthropic/claude-opus")));
-    assert!(content.items.contains(&item_id("https://slug.social/~/ai-models/anthropic/claude-sonnet")));
+    let ai_models = item_id("https://slug.social/~/ai-models");
+    let anthropic = item_id("https://slug.social/~/anthropic");
+    let opus = item_id("https://slug.social/~/claude-opus");
+    let sonnet = item_id("https://slug.social/~/claude-sonnet");
+    assert!(content.members_of(&ai_models).contains(&anthropic));
+    assert!(content.members_of(&anthropic).contains(&opus));
+    assert!(content.members_of(&anthropic).contains(&sonnet));
+    assert!(content
+        .members_of(&item_id("https://slug.social/~"))
+        .contains(&ai_models));
+
+    // Intermediate tokens are scopes (have members) but were not declared as items.
+    assert!(!content.items.contains(&ai_models));
+    assert!(!content.items.contains(&anthropic));
+    assert!(content.items.contains(&opus));
+    assert!(content.items.contains(&sonnet));
 }
 
 #[test]
@@ -476,9 +469,9 @@ fn ranking_repeated_votes_normalized() {
 
     // Same winner regardless of how many times voted.
     assert_eq!(ranked_once[0].item, ranked_many[0].item);
-    assert_eq!(ranked_once[0].item.as_str(), "https://slug.social/~/norm/a");
+    assert_eq!(ranked_once[0].item.as_str(), "https://slug.social/~/a");
     assert_eq!(ranked_once[1].item, ranked_many[1].item);
-    assert_eq!(ranked_once[1].item.as_str(), "https://slug.social/~/norm/b");
+    assert_eq!(ranked_once[1].item.as_str(), "https://slug.social/~/b");
 
     // Scores should be identical (normalization makes repeated votes idempotent).
     let eps = 1e-6;
@@ -604,26 +597,21 @@ fn reducer_deep_path_ancestor_materialization_four_levels() {
     // Ancestor chain: parent() now walks purely within the ontology namespace.
     // The spurious "" → "https://slug.social" levels are gone; root is "https://slug.social/~".
     let content = state.public();
-    let tilde_scope = content
-        .item_children
-        .get(&item_id("https://slug.social/~"))
-        .expect("~/ scope should have children");
-    assert!(tilde_scope.contains(&item_id("https://slug.social/~/a")));
-
-    let a_children = content.item_children.get(&item_id("https://slug.social/~/a")).expect("a should have children");
-    assert!(a_children.contains(&item_id("https://slug.social/~/a/b")));
-
-    let ab_children = content.item_children.get(&item_id("https://slug.social/~/a/b")).expect("a/b should have children");
-    assert!(ab_children.contains(&item_id("https://slug.social/~/a/b/c")));
-
-    let abc_children = content.item_children.get(&item_id("https://slug.social/~/a/b/c")).expect("a/b/c should have children");
-    assert!(abc_children.contains(&item_id("https://slug.social/~/a/b/c/d")));
+    let root = item_id("https://slug.social/~");
+    let a = item_id("https://slug.social/~/a");
+    let b = item_id("https://slug.social/~/b");
+    let c = item_id("https://slug.social/~/c");
+    let d = item_id("https://slug.social/~/d");
+    assert!(content.members_of(&root).contains(&a));
+    assert!(content.members_of(&a).contains(&b));
+    assert!(content.members_of(&b).contains(&c));
+    assert!(content.members_of(&c).contains(&d));
 
     // Only the leaf should be in items set
-    assert!(content.items.contains(&item_id("https://slug.social/~/a/b/c/d")));
-    assert!(!content.items.contains(&item_id("https://slug.social/~/a")));
-    assert!(!content.items.contains(&item_id("https://slug.social/~/a/b")));
-    assert!(!content.items.contains(&item_id("https://slug.social/~/a/b/c")));
+    assert!(content.items.contains(&d));
+    assert!(!content.items.contains(&a));
+    assert!(!content.items.contains(&b));
+    assert!(!content.items.contains(&c));
 }
 
 // ============================================================================
@@ -663,7 +651,7 @@ fn ranking_convergence_tolerance_triggers_early_exit() {
     // Very tight tolerance but huge max_iters — should still converge fast
     let ranked = ranked_items(&mut group, 1_000_000, 1e-15);
     assert_eq!(ranked.len(), 2);
-    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/t/a");
+    assert_eq!(ranked[0].item.as_str(), "https://slug.social/~/a");
 }
 
 // ============================================================================
@@ -677,14 +665,14 @@ fn test_item_body_overwrite() {
         1,
         "~/t/x {first}\n",
     ));
-    assert_eq!(state.public().item_bodies.get(&item_id("https://slug.social/~/t/x")), Some(&"first".to_string()));
+    assert_eq!(state.public().item_bodies.get(&item_id("https://slug.social/~/x")), Some(&"first".to_string()));
 
     state.apply_event(ingest_event(
         2,
         "~/t/x {second}\n",
     ));
     assert_eq!(
-        state.public().item_bodies.get(&item_id("https://slug.social/~/t/x")),
+        state.public().item_bodies.get(&item_id("https://slug.social/~/x")),
         Some(&"second".to_string()),
         "last writer should win for item bodies"
     );
@@ -698,9 +686,9 @@ fn test_empty_body_not_stored() {
         "~/t/blank {   }\n",
     ));
     let content = state.public();
-    assert!(content.items.contains(&item_id("https://slug.social/~/t/blank")), "item should exist");
+    assert!(content.items.contains(&item_id("https://slug.social/~/blank")), "item should exist");
     assert!(
-        !content.item_bodies.contains_key(&item_id("https://slug.social/~/t/blank")),
+        !content.item_bodies.contains_key(&item_id("https://slug.social/~/blank")),
         "whitespace-only body should not be stored"
     );
 }
@@ -717,7 +705,7 @@ fn test_duplicate_items_across_ingests() {
         "~/t/dup {second}\n",
     ));
     let content = state.public();
-    let count = content.items.iter().filter(|i| i.as_str() == "https://slug.social/~/t/dup").count();
+    let count = content.items.iter().filter(|i| i.as_str() == "https://slug.social/~/dup").count();
     assert_eq!(count, 1, "items set should deduplicate across ingests");
 }
 
@@ -799,7 +787,7 @@ fn test_thread_id_is_used_for_votes_and_indexes() {
     let content = state.public();
     let vote = content
         .item_votes
-        .get(&item_id("https://slug.social/~/t/a"))
+        .get(&item_id("https://slug.social/~/a"))
         .unwrap()
         .front()
         .unwrap();
@@ -808,7 +796,7 @@ fn test_thread_id_is_used_for_votes_and_indexes() {
     assert!(state
         .public()
         .item_threads
-        .get(&item_id("https://slug.social/~/t/a"))
+        .get(&item_id("https://slug.social/~/a"))
         .is_some_and(|threads| threads.contains("first")));
 }
 
@@ -820,11 +808,11 @@ fn test_rank_history_created_for_voted_items() {
         "~/t/a {a}\n~/t/b {b}\n{reason}\n~/t/a 3:1 ~/t/b\n",
     ));
     assert!(
-        state.public().rank_history.contains_key(&item_id("https://slug.social/~/t/a")),
+        state.public().rank_history.contains_key(&item_id("https://slug.social/~/a")),
         "rank_history should have entry for voted item a"
     );
     assert!(
-        state.public().rank_history.contains_key(&item_id("https://slug.social/~/t/b")),
+        state.public().rank_history.contains_key(&item_id("https://slug.social/~/b")),
         "rank_history should have entry for voted item b"
     );
 }
@@ -837,7 +825,7 @@ fn test_rank_history_not_created_for_unvoted_items() {
         "~/t/c {just a definition}\n",
     ));
     assert!(
-        !state.public().rank_history.contains_key(&item_id("https://slug.social/~/t/c")),
+        !state.public().rank_history.contains_key(&item_id("https://slug.social/~/c")),
         "rank_history should NOT have entry for item with no votes"
     );
 }
@@ -849,7 +837,7 @@ fn test_rank_history_first_entry_delta_zero() {
         1,
         "~/t/a {a}\n~/t/b {b}\n{reason}\n~/t/a 3:1 ~/t/b\n",
     ));
-    let history_a = state.public().rank_history.get(&item_id("https://slug.social/~/t/a")).unwrap();
+    let history_a = state.public().rank_history.get(&item_id("https://slug.social/~/a")).unwrap();
     assert_eq!(history_a.len(), 1);
     assert_eq!(
         history_a[0].scope_rank_delta, 0,
diff --git a/server/tests/dsl_fixtures.rs b/server/tests/dsl_fixtures.rs
index 48c0b3e8d53e4fd12a1fe2a57d83c4884d587842..3db406596571872eb3b02bc69e8f14b9021ae12a 100644
--- a/server/tests/dsl_fixtures.rs
+++ b/server/tests/dsl_fixtures.rs
@@ -18,7 +18,7 @@ fn parses_tutorial_fixture_with_prose() {
             dsl::Stmt::Item { .. } => items += 1,
             dsl::Stmt::Vote { .. } => votes += 1,
             dsl::Stmt::Prose { .. } => prose += 1,
-            dsl::Stmt::Aspect { .. } => {}
+            dsl::Stmt::Aspect { .. } | dsl::Stmt::Containment { .. } => {}
         }
     }
 
diff --git a/server/tests/integration_html.rs b/server/tests/integration_html.rs
index b72130a0d9dea6c8ba1409a0354649a43f398c69..7617a89ad38dcc9b35727568eaabe84b2305d611 100644
--- a/server/tests/integration_html.rs
+++ b/server/tests/integration_html.rs
@@ -13,6 +13,34 @@ async fn test_ontology_item_page_shows_body_children_and_collapsible_votes() {
     // HTML routes are offline during the auth-v3 refactor.
 }
 
+#[tokio::test]
+async fn test_nested_tilde_url_permanently_redirects_to_leaf() {
+    let (addr, _tmp, _log, _state, _handle) = create_test_server_with_state().await;
+    let client = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+    let nested = client
+        .get(format!("http://{addr}/~/x/luke?depth=2"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(nested.status(), reqwest::StatusCode::PERMANENT_REDIRECT);
+    let loc = nested
+        .headers()
+        .get(reqwest::header::LOCATION)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+    assert_eq!(loc, "/~/luke?depth=2");
+
+    let leaf = client
+        .get(format!("http://{addr}/~/luke"))
+        .send()
+        .await
+        .unwrap();
+    assert!(leaf.status().is_success(), "leaf page should render: {}", leaf.status());
+}
+
 /// Thread connective tissue: item_threads and VoteData.thread_tag are exposed by item, pair, and matchup RPC.
 #[tokio::test]
 async fn test_search_page_and_results() {
diff --git a/server/tests/integration_rooms.rs b/server/tests/integration_rooms.rs
index e623523ba352ce456674a399542c689505760b78..69343d3c644c620c9e0e876f4c932db3f0ca5060 100644
--- a/server/tests/integration_rooms.rs
+++ b/server/tests/integration_rooms.rs
@@ -821,11 +821,12 @@ async fn test_private_room_post_links_use_private_garden_routes() {
         .unwrap();
     assert!(thread_page.status().is_success());
     let body = thread_page.text().await.unwrap();
-    assert!(body.contains(&format!("/r/{room_seg}/~/secret/item")));
+    assert!(body.contains(&format!("/r/{room_seg}/~/item")));
+    assert!(!body.contains("href=\"/~/item\""));
     assert!(!body.contains("href=\"/~/secret/item\""));
 
     let garden_page = client
-        .get(format!("http://{addr}/r/{room_seg}/~/secret/item"))
+        .get(format!("http://{addr}/r/{room_seg}/~/item"))
         .header("Authorization", format!("Bearer {bearer}"))
         .send()
         .await
@@ -834,6 +835,24 @@ async fn test_private_room_post_links_use_private_garden_routes() {
     let garden_body = garden_page.text().await.unwrap();
     assert!(garden_body.contains("classified"));
     assert!(garden_body.contains(&format!("/r/{room_seg}/t/garden-thread")));
+
+    let no_follow = reqwest::Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+    let nested = no_follow
+        .get(format!("http://{addr}/r/{room_seg}/~/secret/item"))
+        .header("Authorization", format!("Bearer {bearer}"))
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(nested.status(), reqwest::StatusCode::PERMANENT_REDIRECT);
+    let loc = nested
+        .headers()
+        .get(reqwest::header::LOCATION)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("");
+    assert_eq!(loc, format!("/r/{room_seg}/~/item"));
 }
 
 #[tokio::test]
diff --git a/server/tests/integration_rpc.rs b/server/tests/integration_rpc.rs
index 1a6f74344f55d1e230a0c5a379dc13affff17cd6..11429a56b9620ba1d56a4c2dff439000d2e67961 100644
--- a/server/tests/integration_rpc.rs
+++ b/server/tests/integration_rpc.rs
@@ -319,7 +319,7 @@ async fn test_garden_item_pair_matchup_include_threads() {
     )
     .await;
     let item = &item_body["results"][0]["result"]["GardenItem"];
-    assert_eq!(item["item"], "https://slug.social/~/sorts/insertion");
+    assert_eq!(item["item"], "https://slug.social/~/insertion");
     assert!(item["body"].as_str().unwrap().contains("O(n^2)"));
     let threads: Vec<&str> = item["threads"]
         .as_array()
@@ -371,7 +371,7 @@ async fn test_garden_item_pair_matchup_include_threads() {
     )
     .await;
     let matchup = &matchup_body["results"][0]["result"]["Matchup"];
-    assert_eq!(matchup["item"], "https://slug.social/~/sorts/insertion");
+    assert_eq!(matchup["item"], "https://slug.social/~/insertion");
     let votes = matchup["votes"].as_array().unwrap();
     assert!(!votes.is_empty(), "matchup should have at least one vote");
     let first_thread = votes[0]["thread"].as_str().unwrap();
@@ -505,7 +505,7 @@ async fn test_rank_history() {
     )
     .await;
     let resp = &hist_rust["results"][0]["result"]["RankHistory"];
-    assert_eq!(resp["item"], "https://slug.social/~/hist/rust");
+    assert_eq!(resp["item"], "https://slug.social/~/rust");
     let history = resp["history"].as_array().unwrap();
     assert_eq!(history.len(), 1, "one ingest → one history entry");
     let entry = &history[0];
diff --git a/test/browser_garden_depth.clj b/test/browser_garden_depth.clj
index ba045d340646a168083d55c4e2f05fd2eefa4ccb..9d94c41d9480666f435fd8cfd5739ea678144768 100644
--- a/test/browser_garden_depth.clj
+++ b/test/browser_garden_depth.clj
@@ -109,30 +109,31 @@
                (page/navigate pg (str base-url "/~/depth-demo"))
                (is (wait-for-text pg "#garden-depth-select" "1" 10000)
                    "depth select present at default depth 1")
-               (is (wait-for-text pg "body" "~/depth-demo/child-a" 10000)
+               ;; Leaf identity: children display as ~/child-a and ~/leaf.
+               (is (wait-for-text pg "body" "~/child-a" 10000)
                    "depth 1 shows direct child")
                (is (not (str/includes? (or (locator/text-content (page/locator pg "body")) "")
-                                       "~/depth-demo/child-a/leaf"))
+                                       "~/leaf"))
                    "depth 1 does not list nested leaf")
 
                (is (select-depth-navigates! pg "2")
                    "selecting depth 2 navigates to ?depth=2")
                (is (wait-for-text pg "#garden-depth-select option[selected]" "2" 10000)
                    "depth 2 remains selected after navigation")
-               (is (wait-for-text pg "body" "~/depth-demo/child-a/leaf" 10000)
+               (is (wait-for-text pg "body" "~/leaf" 10000)
                    "depth 2 lists nested leaf")
 
                (is (select-depth-navigates! pg "all")
                    "selecting ∞ navigates to ?depth=all")
-               (is (wait-for-text pg "body" "~/depth-demo/child-a/leaf" 10000)
+               (is (wait-for-text pg "body" "~/leaf" 10000)
                    "depth=all still shows nested leaf")
 
                (is (select-depth-navigates! pg "1")
                    "selecting depth 1 navigates to ?depth=1")
-               (is (wait-for-text pg "body" "~/depth-demo/child-a" 10000)
+               (is (wait-for-text pg "body" "~/child-a" 10000)
                    "depth 1 again shows direct child")
                (is (not (str/includes? (or (locator/text-content (page/locator pg "body")) "")
-                                       "~/depth-demo/child-a/leaf"))
+                                       "~/leaf"))
                    "depth 1 again hides nested leaf"))))))
 
      (finally
diff --git a/test/browser_garden_pin.clj b/test/browser_garden_pin.clj
index 579976f4c2493a149f9eba081862ca07919f4fe9..4b4b0481db0940e4f2cef1121bc6ca8ce35a6a99 100644
--- a/test/browser_garden_pin.clj
+++ b/test/browser_garden_pin.clj
@@ -78,44 +78,61 @@
              (core/with-page [pg (core/new-page-from-context ctx)]
                (page/navigate pg (str base-url "/login"))
                (is (wait-for-text pg "body" "@alice" 15000) "alice session after login")
+               ;; Nested URL must 308 to the leaf; do not stay on /~/gp-parent/pin-a.
                (page/navigate pg (str base-url "/~/gp-parent/pin-a"))
-               (is (wait-for-text pg ".ont-item-shell" "~/gp-parent/pin-a" 15000) "on item a page")
+               (let [url-a (or (page/url pg) "")]
+                 (is (str/includes? url-a "/~/pin-a")
+                     (str "nested /~/gp-parent/pin-a 308s to /~/pin-a (got " url-a ")"))
+                 (is (not (str/includes? url-a "/~/gp-parent/pin-a"))
+                     (str "must not remain on nested pin-a URL (got " url-a ")")))
+               (is (wait-for-text pg ".ont-item-shell" "~/pin-a" 15000) "on leaf item a page")
                ;; Native form POST /ui (data-navigate=full) — not fetch/eval
                (locator/click (page/locator pg ".ont-item-pin-zone form.ont-pin-form button[type=submit]"))
-               (is (wait-for-text pg "#slug-pin-hud" "gp-parent/pin-a" 15000)
-                   "HUD shows pinned item label after redirect")
+               (is (wait-for-text pg "#slug-pin-hud" "~/pin-a" 15000)
+                   "HUD shows leaf pin label after redirect")
                (page/navigate pg (str base-url "/~/gp-parent/pin-b"))
-               (is (wait-for-text pg ".ont-item-shell" "~/gp-parent/pin-b" 15000) "on item b page")
+               (let [url-b (or (page/url pg) "")]
+                 (is (str/includes? url-b "/~/pin-b")
+                     (str "nested /~/gp-parent/pin-b 308s to /~/pin-b (got " url-b ")"))
+                 (is (not (str/includes? url-b "/~/gp-parent/pin-b"))
+                     (str "must not remain on nested pin-b URL (got " url-b ")")))
+               (is (wait-for-text pg ".ont-item-shell" "~/pin-b" 15000) "on leaf item b page")
                (is (wait-for-text pg "a.ont-vote-compare-btn" "vote" 10000)
                    "vote link visible vs pinned item")
-               ;; Unpin from ranked child groups on parent page
+               ;; Unpin from ranked child groups on parent page (parent is already a leaf)
                (page/navigate pg (str base-url "/~/gp-parent"))
                (is (wait-for-text pg ".ont-tab-panel-children" "ranked child groups" 15000)
                    "parent page shows ranked child groups")
                (is (wait-for-text pg ".ont-ranking-list button.ont-garden-pin-ico-active" "📌" 10000)
                    "pinned row shows active pin in ranked list")
                (locator/click (page/locator pg ".ont-ranking-list button.ont-garden-pin-ico-active"))
-               (is (wait-for-absence-substr pg "#slug-pin-hud" "gp-parent/pin-a" 15000)
+               (is (wait-for-absence-substr pg "#slug-pin-hud" "~/pin-a" 15000)
                    "HUD clears after unpin from ranked child list")
                (is (wait-for-absence-substr pg ".ont-ranking-list" "ont-garden-vote-ico" 10000)
                    "vote icons removed from ranked list after unpin")
                (page/navigate pg (str base-url "/~/gp-parent/pin-b"))
-               (is (wait-for-text pg ".ont-item-shell" "~/gp-parent/pin-b" 15000) "on item b page again")
+               (is (str/includes? (or (page/url pg) "") "/~/pin-b")
+                   "pin-b nested URL still 308s after unpin")
+               (is (wait-for-text pg ".ont-item-shell" "~/pin-b" 15000) "on leaf item b page again")
                (is (wait-for-absence-substr pg "body" "ont-vote-compare-btn" 15000)
                    "compare vote CTA removed after ranked-list unpin")
                ;; HUD unpin still works from item page context
                (page/navigate pg (str base-url "/~/gp-parent/pin-a"))
+               (is (str/includes? (or (page/url pg) "") "/~/pin-a")
+                   "re-pin navigation lands on leaf /~/pin-a")
                (locator/click (page/locator pg ".ont-item-pin-zone form.ont-pin-form button[type=submit]"))
-               (is (wait-for-text pg "#slug-pin-hud" "gp-parent/pin-a" 15000)
-                   "re-pin from item page for HUD unpin test")
+               (is (wait-for-text pg "#slug-pin-hud" "~/pin-a" 15000)
+                   "re-pin from leaf item page for HUD unpin test")
                (page/navigate pg (str base-url "/~/gp-parent/pin-b"))
                (locator/click (page/locator pg "#slug-pin-hud button.slug-pin-hud-unpin-btn"))
-               (is (wait-for-absence-substr pg "#slug-pin-hud" "gp-parent/pin-a" 15000)
+               (is (wait-for-absence-substr pg "#slug-pin-hud" "~/pin-a" 15000)
                    "HUD clears after unpin from HUD button")
                (is (wait-for-absence-substr pg "body" "ont-vote-compare-btn" 15000)
                    "compare vote CTA removed after HUD unpin on same reload")
-               (is (str/includes? (or (page/url pg) "") "/~/gp-parent/pin-b")
-                   "still on item b after HUD unpin"))))))
+               (is (str/includes? (or (page/url pg) "") "/~/pin-b")
+                   "still on leaf item b after HUD unpin")
+               (is (not (str/includes? (or (page/url pg) "") "/~/gp-parent/pin-b"))
+                   "HUD unpin must not revive the nested pin-b URL"))))))
 
      (finally
        (when-some [s @!server] (common/kill-server s))
diff --git a/test/browser_vote_pool.clj b/test/browser_vote_pool.clj
index 738608801027d1e662660b5d6c830b4ccd07c434..a12818443f29063cbd5a6bd86e4410215db8febf 100644
--- a/test/browser_vote_pool.clj
+++ b/test/browser_vote_pool.clj
@@ -99,10 +99,11 @@
                  (when (< votes-cast total-pairs)
                    (let [left-text  (element-text pg ".vote-compare-left code")
                          right-text (element-text pg ".vote-compare-right code")]
-                     (is (str/includes? left-text "~/pool/")
-                         (str "vote " votes-cast ": left is in pool: " left-text))
-                     (is (str/includes? right-text "~/pool/")
-                         (str "vote " votes-cast ": right is in pool: " right-text))
+                     ;; Leaf identity: pool items display as ~/a … ~/j, not ~/pool/a.
+                     (is (contains? (set letters) (leaf left-text))
+                         (str "vote " votes-cast ": left is a pool leaf: " left-text))
+                     (is (contains? (set letters) (leaf right-text))
+                         (str "vote " votes-cast ": right is a pool leaf: " right-text))
                      (set-ratio! pg left-text right-text)
                      (let [winner (if (neg? (compare (leaf left-text) (leaf right-text)))
                                     (leaf left-text) (leaf right-text))]
diff --git a/test/integration.clj b/test/integration.clj
index 933fa3e129a416dca780734af55db59d1bc4dcd9..8482a0e93b454ecaaed36aef00964db10e36033d 100644
--- a/test/integration.clj
+++ b/test/integration.clj
@@ -225,10 +225,12 @@
       (bind ranked          (mapv :item (mapcat :ranking (:components children-resp))))
       (is (= 3 (count ranked))
                (str "3 items ranked (got " (count ranked) ")"))
-      (is (str/ends-with? (first ranked) "languages/rust")
-               (str "rust is #1 (got " (first ranked) ")"))
-      (is (str/ends-with? (last ranked) "languages/go")
-               (str "go is #3 (got " (last ranked) ")"))
+      (is (str/ends-with? (first ranked) "/rust")
+               (str "rust is #1 as leaf ~/rust (got " (first ranked) ")"))
+      (is (not (str/includes? (first ranked) "languages/rust"))
+               "ranked item identity is the leaf, not the old nested path")
+      (is (str/ends-with? (last ranked) "/go")
+          (str "go is #3 as leaf ~/go (got " (last ranked) ")"))
 
       (println "\nchecking agent-facing missing path error…")
       (bind missing-path-result
@@ -273,8 +275,10 @@
       (is (zero? (:exit tree-result))
           (str "cli garden tree exits 0 (err: " (:err tree-result) ")"))
       (bind tree-paths (->> (:out tree-result) str/split-lines (remove str/blank?) set))
-      (is (contains? tree-paths "~/languages/rust")
-          "tree renders slug.social leaves as clean ~/ paths")
+      (is (contains? tree-paths "~/rust")
+          "tree renders slug.social leaves as clean ~/leaf paths")
+      (is (not (contains? tree-paths "~/languages/rust"))
+          "tree does not keep the pre-containment nested path")
       (is (contains? tree-paths "-/https://github.com/iss/1")
           "tree renders external leaves with the -/ URL form")
       (is (not-any? #(str/starts-with? % "~/http") tree-paths)
@@ -307,8 +311,8 @@
       (is (pos? (:ranked_total grank-resp)) "global rank has ranked items")
       (bind grank-items (vec (mapcat :ranking (:components grank-resp))))
       (is (not-empty grank-items) "global rank returns ranked components")
-      (is (str/ends-with? (:item (first grank-items)) "languages/rust")
-               (str "rust is first in its component (got " (:item (first grank-items)) ")"))
+      (is (str/ends-with? (:item (first grank-items)) "/rust")
+               (str "rust is first in its component as leaf (got " (:item (first grank-items)) ")"))
 
       (bind grank-pct-result (common/run-cli cli-bin base-url ["public" "garden" "rank" "--percent" "--limit" "2" "--json"]))
       (is (zero? (:exit grank-pct-result)) "cli garden rank --percent --limit 2 exits 0")
@@ -345,7 +349,8 @@
       (is (zero? (:exit hist-result))
                (str "cli garden history exits 0 (err: " (:err hist-result) ")"))
       (bind hist-resp        (json/parse-string (:out hist-result) true))
-      (is (= "https://slug.social/~/languages/rust" (:item hist-resp)) "history item path is canonical ~/languages/rust URL")
+      (is (= "https://slug.social/~/rust" (:item hist-resp))
+          "history item path is the leaf URL (nested languages/rust query still resolves)")
       (is (>= (count (:history hist-resp)) 2)
                (str "rust has at least 2 history entries (got " (count (:history hist-resp)) ")"))
       (bind hist-last        (last (:history hist-resp)))
@@ -371,8 +376,8 @@
       (bind replay-resp   (json/parse-string (:out replay-result) true))
       (bind replay-ranked (mapv :item (mapcat :ranking (:components replay-resp))))
       (is (= 3 (count replay-ranked)) "3 items ranked after replay")
-      (is (str/ends-with? (first replay-ranked) "languages/rust")
-               (str "rust still #1 after replay (got " (first replay-ranked) ")")))
+      (is (str/ends-with? (first replay-ranked) "/rust")
+               (str "rust still #1 leaf after replay (got " (first replay-ranked) ")")))
 
      (finally
        (when-some [s @!server]
diff --git a/test/walkthrough_fixture.clj b/test/walkthrough_fixture.clj
index fb7f4ee8c996e7b4ffb55e225f73f3266feda220..82229e843f9661ceefeec4bd8e642ee3fd50228e 100644
--- a/test/walkthrough_fixture.clj
+++ b/test/walkthrough_fixture.clj
@@ -90,7 +90,9 @@
             :slug room-slug
             :url (str base-url "/r/" room-short room-slug)
             :thread_url (str base-url "/r/" room-short room-slug "/t/walkthrough-thread")
-            :garden_url (str base-url "/r/" room-short room-slug "/~/secret/item")}}))
+            ;; Leaf page is canonical; nested /~/secret/item 308s here.
+            :garden_url (str base-url "/r/" room-short room-slug "/~/item")
+            :garden_url_nested (str base-url "/r/" room-short room-slug "/~/secret/item")}}))
 
 (defn- rebase-fixture-summary [saved current-base-url current-google-url current-data-dir]
   (let [inner (:summary saved)
@@ -105,7 +107,8 @@
                            :room (assoc room
                                          :url (str current-base-url "/r/" rs lg)
                                          :thread_url (str current-base-url "/r/" rs lg "/t/walkthrough-thread")
-                                         :garden_url (str current-base-url "/r/" rs lg "/~/secret/item"))))))
+                                         :garden_url (str current-base-url "/r/" rs lg "/~/item")
+                                         :garden_url_nested (str current-base-url "/r/" rs lg "/~/secret/item"))))))
 
 (defn- fixture-log-present? [data-dir]
   (let [p (fs/path data-dir "events.jsonl")]
@@ -161,6 +164,8 @@
         (println (str "  room page:     " (get-in summary [:summary :room :url])))
         (println (str "  thread page:   " (get-in summary [:summary :room :thread_url])))
         (println (str "  garden page:   " (get-in summary [:summary :room :garden_url])))
+        (println (str "  garden nested: " (get-in summary [:summary :room :garden_url_nested])
+                      "  (308 → leaf /~/item)"))
         (println (str "  data dir:      " data-dir))
         (println (str "  summary json:  " summary-path))
         (println "")
diff --git a/types/src/item_id.rs b/types/src/item_id.rs
index fc5226f362d6e677f8b0c1248bf443b4b923aefc..8c0e0c0a278a31e293814bd8bf58ee2e4bbf2de4 100644
--- a/types/src/item_id.rs
+++ b/types/src/item_id.rs
@@ -87,6 +87,19 @@ impl ItemId {
         s.rsplit('/').find(|x| !x.is_empty()).unwrap_or(s)
     }
 
+    /// Leaf identity for tilde-ontology items: `~/x/luke` and `~luke` are `~/luke`.
+    /// URL / external items are unchanged (never desugared).
+    pub fn ontology_leaf(&self) -> Self {
+        match self.tilde_tail() {
+            Some("") => Self::Root,
+            Some(tail) => {
+                let leaf = tail.rsplit('/').find(|s| !s.is_empty()).unwrap_or(tail);
+                Self::parse(&format!("~{leaf}")).unwrap_or_else(|| self.clone())
+            }
+            None => self.clone(),
+        }
+    }
+
     pub fn parent(&self) -> Option<Self> {
         match self {
             ItemId::Root => None,
diff --git a/types/src/item_wire.rs b/types/src/item_wire.rs
index 5c823f403320998642725d3c583940c88902091d..1edb559bb1720d20081a87fc28b43d84199c817b 100644
--- a/types/src/item_wire.rs
+++ b/types/src/item_wire.rs
@@ -119,6 +119,20 @@ pub fn canonicalize_item(input: &str) -> String {
         });
     }
 
+    // Bare tilde token `~name` (no slash): same ontology item as `~/name`.
+    // Bare `~` is the ontology root (same as `~/`).
+    if s.starts_with('~') && !s.starts_with("~/") {
+        let token = s[1..].trim();
+        if token.is_empty() {
+            return SLUG_TILDE_ONTOLOGY_ROOT.to_string();
+        }
+        if token.contains('/') {
+            return String::new();
+        }
+        let tail = token.to_lowercase();
+        return format!("https://slug.social/~/{tail}");
+    }
+
     let is_tilde = s.starts_with("~/");
     let rest = s.strip_prefix("~/").or_else(|| s.strip_prefix("/")).unwrap_or(&s);
 
diff --git a/types/src/paths.rs b/types/src/paths.rs
index 27057d2448b9620840b8b727795969200d8a012d..01bb3bb68ca3ff048d5fba19e39315770777e311 100644
--- a/types/src/paths.rs
+++ b/types/src/paths.rs
@@ -349,6 +349,33 @@ impl Deref for TildeOntologyPath {
 mod tests {
     use super::*;
 
+    #[test]
+    fn canonicalize_bare_tilde_token() {
+        assert_eq!(canonicalize_item("~luke"), "https://slug.social/~/luke");
+        assert_eq!(canonicalize_item("~Luke"), "https://slug.social/~/luke");
+        assert_eq!(canonicalize_item("~"), SLUG_TILDE_ONTOLOGY_ROOT);
+        assert_eq!(canonicalize_item("~luke"), canonicalize_item("~/luke"));
+        assert!(canonicalize_item("~a/b").is_empty());
+    }
+
+    #[test]
+    fn ontology_leaf_collapses_tilde_path() {
+        assert_eq!(
+            ItemId::parse("~/x/luke").unwrap().ontology_leaf().as_str(),
+            "https://slug.social/~/luke"
+        );
+        assert_eq!(
+            ItemId::parse("~luke").unwrap().ontology_leaf(),
+            ItemId::parse("~/y/luke").unwrap().ontology_leaf()
+        );
+        assert_eq!(
+            ItemId::parse("~/").unwrap().ontology_leaf(),
+            ItemId::ontology_root()
+        );
+        let url = ItemId::parse("https://example.com/a/b").unwrap();
+        assert_eq!(url.ontology_leaf(), url);
+    }
+
     #[test]
     fn item_parent_deep() {
         let c = ItemId::parse("~/a/b/c").unwrap();