diff --git a/plugin-designs/plugin-studio/plugin-studio.vue b/plugin-designs/plugin-studio/plugin-studio.vue
index 3cfa985c0..ca3dacd08 100644
--- a/plugin-designs/plugin-studio/plugin-studio.vue
+++ b/plugin-designs/plugin-studio/plugin-studio.vue
@@ -8,9 +8,9 @@
 
   ONE element, <plugin-studio>, renders a VERTICAL-TAB layout whose sidebar is the composability
   ladder grouped by CAPABILITY (5 → 1). Under each capability heading it lists every element that
-  tier holds; clicking a row nests that element in the main slot. Below the tiers, one collapsible
-  "Inside <composite>" section per composite draws its full composition tree, so a defect can be
-  pinned on the exact nested element responsible. This is the DX viewing surface:
+  tier holds; clicking a row nests that element in the main slot. Directly under each composite's
+  row, its full composition tree is drawn indented, so a defect can be pinned on the exact nested
+  element responsible. This is the DX viewing surface:
   the spot to SEE every plugin element work, in one place, ordered by capability, with the embed
   snippet for each — so a developer (or the Driver) can review each element and give feedback.
 
@@ -97,7 +97,7 @@
     <!-- Toolbar strip: the active element's identity and copy-embed. Kept to ONE line on purpose —
          the plugin is what the studio is for, so it gets the rest of the main area. (A "Composed of"
          panel used to sit here; the Driver removed it 2026-09-24 because it took the plugin's space.
-         Composition lives in the rail's "Inside <composite>" trees instead.) -->
+         Composition lives in the rail, indented under each composite.) -->
     <template #toolbar>
       <div class="ps-toolbar" v-if="active">
         <div class="ps-bar">
@@ -399,67 +399,49 @@ export default defineComponent({
         .filter(c => byCap[c] && byCap[c].length)
         .map(c => ({ cap: c, label: CAP_LABEL[c] || ('capability ' + c), rows: byCap[c] }))
     },
-    // The GROUPED rail model the shared VerticalTabsLayout paints, in two parts (Driver, 2026-09-24:
-    // "clear capability sections 5→1, every plugin reachable, composition tree legible"):
+    // The GROUPED rail model the shared VerticalTabsLayout paints: ONE list, highest capability to
+    // lowest (Driver, 2026-09-24: "everything in studio organized by highest capability to lowest";
+    // "the composability in the capability sidebar vertical tabs … to understand the interoperability
+    // and the various elements that go into each plugin").
     //
-    //   1. CAPABILITY SECTIONS, CAP 5 → CAP 1 — where each plugin LIVES. Exactly one node per plugin,
-    //      so every plugin has one name to report it by. Collapsible folders, open by default.
-    //   2. COMPOSITION TREES — what each composite is MADE OF. One collapsible section per composite
-    //      (closed by default so the rail stays short), headed by the composite itself, with every
-    //      element nested into it drawn as an indented tree, ordered by capability at each level.
-    //      A child repeats in every section that nests it — the Driver's spec: "duplication across
-    //      sections is intended", because the question here is "what composes THIS plugin".
+    //   CAP 5 → CAP 1 sections, collapsible, open by default. Every plugin has exactly ONE canonical
+    //   row, in its own tier. Directly under a COMPOSITE's row sits its composition tree: every element
+    //   nested into it, indented by depth, ordered by capability at each level. So reading down the
+    //   rail never jumps back up the ladder — the tree lives with the plugin it explains.
     //
     // ★ HOW THE REPEATS STAY ONE IDENTITY. Every tree row is an ALIAS (VerticalTabsLayout `selects`):
-    //   clicking people-groups-grid under big-picture selects the SAME canonical row as clicking it in
-    //   CAP 2 and highlights both. afe6abe removed the earlier rail
-    //   folders because six independent nodes for one plugin meant there was no single name to report
-    //   it by; an alias has no separate identity, so the tree and the one-name rule now coexist.
+    //   people-groups-grid under dashboard-plus-grid selects the SAME canonical row as its own CAP 2
+    //   entry and highlights both, and arrow keys skip aliases. afe6abe removed the first rail folders
+    //   because six independent nodes for one plugin left no single name to report it by; an alias has
+    //   no separate identity, so nesting and the one-name rule coexist. The section count counts
+    //   canonical plugins only.
     navGroups() {
       const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-      const rowModel = (r) => ({
-        key: r.key,
-        label: r.label,
-        icon: r.icon,
-        sub: '<code>&lt;' + esc(r.tag) + '&gt;</code>'
-      })
-      const tiers = this.groups.map(g => ({
+      const treeOf = new Map(this.compositionTrees.map(t => [t.nodes[0].selects, t]))
+      const rowsFor = (r) => {
+        const out = [{ key: r.key, label: r.label, icon: r.icon, sub: '<code>&lt;' + esc(r.tag) + '&gt;</code>' }]
+        const t = treeOf.get(r.key)
+        if (t) {
+          t.nodes.slice(1).forEach((n, i) => out.push({
+            key: 'tree-' + r.key + '-' + i,
+            selects: n.selects || ('none:' + r.key),
+            depth: n.depth,
+            label: n.label,
+            badge: n.part ? 'part' : '',
+            sub: n.part ? 'no standalone page' : 'CAP ' + n.cap + ' · <code>&lt;' + esc(n.tag) + '&gt;</code>'
+          }))
+        }
+        return out
+      }
+      return this.groups.map(g => ({
         key: 'cap-' + g.cap,
         badge: 'CAP ' + g.cap,
         label: g.label,
         count: g.rows.length,
         folder: true,
         open: true,
-        rows: g.rows.map(rowModel)
+        rows: g.rows.flatMap(rowsFor)
       }))
-      // A composite is named by its BUNDLE here, not its profile: "Inside my-upg-100-list" says which
-      // plugin you are looking into; "Inside upg-100-mfe" made you already know the answer.
-      const trees = this.compositionTrees.map(t => ({
-        key: 'tree-' + t.bundle,
-        label: 'Inside ' + t.bundle,
-        count: t.nodes.length - 1,
-        folder: true,
-        open: false,
-        rows: t.nodes.map((n, i) => ({
-          key: 'tree-' + t.bundle + '-' + i,
-          // An empty selects (the studio's own head, or a part inside it) still gets a key no row
-          // has, so it stays an alias: click is a no-op and arrow keys skip it.
-          selects: n.selects || ('none:' + t.bundle),
-          depth: n.depth || null,
-          label: n.label,
-          badge: n.part ? 'part' : '',
-          sub: n.part
-            ? 'no standalone page'
-            : 'CAP ' + n.cap + ' · <code>&lt;' + esc(n.tag) + '&gt;</code>'
-        }))
-      }))
-      // Two row-less plain groups act as part titles, so the eye can tell "where each plugin lives"
-      // from "what each composite is made of" — the two halves otherwise share one heading style.
-      const title = (key, label) => ({ key, label, rows: [] })
-      return [
-        title('part-caps', 'Every plugin, by capability'), ...tiers,
-        ...(trees.length ? [title('part-trees', 'What each composite is made of'), ...trees] : [])
-      ]
     },
     // ★ ONE TREE PER COMPOSITE, built ENTIRELY from the manifest's `composes` edges — no bundle names
     // or child lists live in this file, so a new composite appears here with zero edits.
@@ -492,31 +474,25 @@ export default defineComponent({
           kids.push(child)
         }
         kids.sort((a, b2) => b2.cap - a.cap || a.label.localeCompare(b2.label))
-        for (const ref of parts) {
-          nodes.push({ label: ref, part: true, selects: row.real ? row.key : '', depth: depth + 1 })
-        }
         for (const k of kids) {
           nodes.push({ label: k.label, tag: k.tag, cap: k.cap, selects: k.key, depth: depth + 1 })
-          if (!path.has(k.key)) walk({ ...k, real: true }, depth + 1, new Set([...path, k.key]), nodes)
+          if (!path.has(k.key)) walk(k, depth + 1, new Set([...path, k.key]), nodes)
         }
+        // Unpublished parts have no tier, so they sort LAST — below every capability — and open the
+        // composite they live in.
+        for (const ref of parts) nodes.push({ label: ref, part: true, selects: row.key, depth: depth + 1 })
       }
       for (const b of this.manifestBundles) {
         if (!b.composes || !b.composes.length || STUDIO_HIDDEN.has(b.bundle)) continue
         // The composite's own row: its highest-capability profile (rows are sorted cap desc).
-        // ★ plugin-studio HAS NO ROW — it never lists itself as its own tab (mounting <plugin-studio>
-        // inside itself is infinite regress). Its tree is still the one a developer most wants, so it
-        // gets a head built from the manifest entry with an empty `selects`: select()'s dead-key guard
-        // turns a click on it into a no-op rather than a blank pane.
+        // plugin-studio has no row (it never lists itself), so it has no tree either: every row of
+        // this rail already IS its composition.
         const own = this.rows.find(r => r.bundle === b.bundle)
-        const p0 = (b.profiles && b.profiles[0]) || {}
-        const head = own
-          ? { ...own, real: true }
-          : { key: '', bundle: b.bundle, label: p0.profile || b.bundle, tag: p0.element || b.bundle, cap: capFor(p0.type || 'single'), real: false }
-        const nodes = [{ label: head.label, tag: head.tag, cap: head.cap, selects: head.key, depth: 0 }]
-        walk(head, 0, new Set([head.key]), nodes)
-        if (nodes.length > 1) out.push({ bundle: b.bundle, label: head.label, cap: head.cap, nodes })
+        if (!own) continue
+        const nodes = [{ label: own.label, tag: own.tag, cap: own.cap, selects: own.key, depth: 0 }]
+        walk(own, 0, new Set([own.key]), nodes)
+        if (nodes.length > 1) out.push({ bundle: b.bundle, nodes })
       }
-      out.sort((a, b) => b.cap - a.cap || a.bundle.localeCompare(b.bundle))
       return out
     },
     active() { return this.rows.find(r => r.key === this.activeKey) || null },