diff --git a/layers/registry/app/components/SkillDetail.vue b/layers/registry/app/components/SkillDetail.vue
index 6e0be472..b55e2ed3 100644
--- a/layers/registry/app/components/SkillDetail.vue
+++ b/layers/registry/app/components/SkillDetail.vue
@@ -8,9 +8,11 @@ import { partitionMetadataEntries } from '../utils/skill-metadata'
 import { resolveSkillPageState } from '../utils/skill-page-state'
 import { resolveSkillRawUrl } from '../utils/skill-raw-url'
 import { resolveSkillTitle } from '../utils/skill-title'
+import { isUniqueValueTreatment } from '../utils/skill-unique-value-experiment'
 import SkillCommandPanel from './_SkillCommandPanel.vue'
 import SkillReceiptsPanel from './_SkillReceiptsPanel.vue'
 import SkillThirdPartyChecks from './_SkillThirdPartyChecks.vue'
+import SkillUniqueValue from './_SkillUniqueValue.vue'
 
 const props = defineProps<{
   owner: string
@@ -22,6 +24,8 @@ const owner = computed(() => props.owner)
 const repo = computed(() => props.repo)
 const name = computed(() => props.name)
 const slug = computed(() => `${owner.value}/${repo.value}/${name.value}`)
+// SEO experiment C (skill-unique-value-experiment.ts). Same page for every visitor.
+const uniqueValueTreatment = computed(() => isUniqueValueTreatment(slug.value))
 
 interface RelatedSkill {
   name: string
@@ -1345,8 +1349,26 @@ useHead(computed(() => ({
 
       <div class="mx-auto max-w-5xl px-4 sm:px-6 py-8 md:py-10 lg:grid lg:grid-cols-12 lg:gap-8 lg:items-start">
         <div class="lg:col-span-8 space-y-10 md:space-y-12">
+          <SkillUniqueValue
+            v-if="uniqueValueTreatment"
+            :owner="data.owner"
+            :repo="data.repo"
+            :name="data.name"
+            :description="data.description"
+            :stars="data.stars"
+            :pushed-at="data.pushedAt"
+            :maturity="data.maturity"
+            :assets="data.assets"
+            :asset-count="data.assetCount"
+            :content-html="data.contentHtml"
+            :compatibility="typeof data.frontmatter?.compatibility === 'string' ? data.frontmatter.compatibility : null"
+            :curators="data.curators"
+            :skill-file-url="skillFileUrl"
+            :github-url="githubUrl"
+            :registry-path="data.registryPath"
+          />
           <section
-            v-if="data.contentHtml"
+            v-else-if="data.contentHtml"
             class="skill-content-section"
             aria-labelledby="content-heading"
           >
@@ -1781,6 +1803,7 @@ useHead(computed(() => ({
           </section>
 
           <section
+            v-if="!uniqueValueTreatment"
             class="2xl:hidden"
             aria-labelledby="files-heading"
           >
@@ -2098,7 +2121,7 @@ useHead(computed(() => ({
     </template>
   </div>
 
-  <template v-if="data && !error">
+  <template v-if="data && !error && !uniqueValueTreatment">
     <USeparator />
     <section
       ref="relatedSlot"
diff --git a/layers/registry/app/components/_SkillUniqueValue.vue b/layers/registry/app/components/_SkillUniqueValue.vue
new file mode 100644
index 00000000..764862eb
--- /dev/null
+++ b/layers/registry/app/components/_SkillUniqueValue.vue
@@ -0,0 +1,244 @@
+<script setup lang="ts">
+// SEO experiment C, treatment pages only. See skill-unique-value-experiment.ts.
+// Every block is built from data skilld already holds. Delete with the gate.
+import type { RepoHistoryResponse } from '../../server/api/repos/[owner]/[repo]/history.get'
+import type { SkillFileEntry } from '../utils/skill-unique-value'
+import { useTimeAgo } from '@vueuse/core'
+import RepoSparkline from '../pages/gh/[owner]/[repo]/_RepoSparkline.vue'
+import { excerptSkillHtml, resolveSkillCommands, resolveSkillFileFacts } from '../utils/skill-unique-value'
+
+interface RelatedItem {
+  name: string
+  owner: string
+  repo: string
+  displayName: string
+  description: string | null
+  registryPath: string
+}
+
+interface RelatedResponse {
+  relatedRepoSkills: RelatedItem[]
+  relatedOwnerSkills: RelatedItem[]
+  coOccurrenceSkills: RelatedItem[]
+  semanticSiblings: RelatedItem[]
+}
+
+const props = defineProps<{
+  owner: string
+  repo: string
+  name: string
+  description: string | null
+  stars: number
+  pushedAt: string | null
+  maturity: { sinceUpdateDays: number, cadence: 'active' | 'steady' | 'dormant' } | null
+  assets: SkillFileEntry[]
+  assetCount: number
+  contentHtml: string | null
+  compatibility: string | null
+  curators: { handle: string, collectionName: string, collectionSlug: string, reason?: string }[]
+  skillFileUrl: string
+  githubUrl: string
+  registryPath: string
+}>()
+
+// Both requests run on the server, so the blocks sit in the HTML a crawler
+// reads. Only the ten treatment pages pay for them. Related Skills come from
+// the edge-cached endpoint that the browser already uses.
+const { data: related } = await useFetch<RelatedResponse>(
+  () => `/api/skill-related/${props.owner}/${props.repo}/${props.name}`,
+  { key: () => `uv-related:${props.owner}/${props.repo}/${props.name}` },
+)
+const { data: history } = await useFetch<RepoHistoryResponse>(
+  () => `/api/repos/${props.owner}/${props.repo}/history`,
+  { key: () => `uv-history:${props.owner}/${props.repo}` },
+)
+
+const files = computed(() => resolveSkillFileFacts({ assets: props.assets, total: props.assetCount }))
+const commands = computed(() => resolveSkillCommands(props))
+const excerpt = computed(() => excerptSkillHtml(props.contentHtml, { description: props.description }))
+const markdownUrl = computed(() => `${props.registryPath}.md`)
+
+const pushedAtAgo = useTimeAgo(() => new Date(props.pushedAt ?? 0))
+
+const MONTH_FORMAT = new Intl.DateTimeFormat('en-GB', { month: 'short', year: 'numeric', timeZone: 'UTC' })
+const starTrend = computed(() => {
+  const h = history.value?.starHistory
+  if (h?._tag === 'ready')
+    return { _tag: 'ready' as const, points: h.points }
+  if (h?._tag === 'collecting')
+    return { _tag: 'tracking' as const, label: `Tracking since ${MONTH_FORMAT.format(h.trackedSince * 1000)}` }
+  return null
+})
+
+const relatedGroups = computed(() => {
+  const r = related.value
+  if (!r)
+    return []
+  return [
+    { label: 'Similar', items: r.semanticSiblings },
+    { label: 'Paired with', items: r.coOccurrenceSkills },
+    { label: `From ${props.owner}/${props.repo}`, items: r.relatedRepoSkills },
+    { label: `Other by ${props.owner}`, items: r.relatedOwnerSkills },
+  ]
+    .map(g => ({ ...g, items: g.items.slice(0, 6) }))
+    .filter(g => g.items.length > 0)
+})
+
+const CADENCE_LABEL = { active: 'active', steady: 'steady', dormant: 'dormant' } as const
+</script>
+
+<template>
+  <div class="space-y-10 md:space-y-12" data-testid="skill-unique-value">
+    <section aria-labelledby="uv-facts-heading">
+      <h2 id="uv-facts-heading" class="section-label mb-3">
+        Facts from the repository
+      </h2>
+      <dl class="grid gap-3 sm:grid-cols-2">
+        <div class="rounded-lg border border-default bg-muted/30 p-3 sm:col-span-2">
+          <dt class="data-label">
+            Run command
+          </dt>
+          <dd class="mt-2">
+            <code class="install-command install-command--wrap block">{{ commands.run }}</code>
+            <p class="mt-2 text-sm text-muted">
+              Your Agent reads the Skill now. Nothing lands in your repository.
+            </p>
+            <p class="data-label mt-4">
+              Install command
+            </p>
+            <code class="install-command install-command--wrap mt-2 block">{{ commands.install }}</code>
+            <p class="mt-2 text-sm text-muted">
+              Install it to keep the Skill in every session.
+            </p>
+          </dd>
+        </div>
+
+        <div class="rounded-lg border border-default bg-muted/30 p-3">
+          <dt class="data-label">
+            Files beside SKILL.md
+          </dt>
+          <dd class="mt-2 text-sm">
+            <template v-if="files._tag === 'only-skill-md'">
+              None. This Skill is one file.
+            </template>
+            <template v-else>
+              <p class="font-mono tabular-nums">
+                {{ files.total.toLocaleString() }} files
+              </p>
+              <p class="mt-1 text-muted">
+                {{ files.markdown.toLocaleString() }} markdown, {{ files.code.toLocaleString() }} code
+              </p>
+              <p v-if="files.codePaths.length" class="mt-1 break-words font-mono text-xs text-muted">
+                {{ files.codePaths.slice(0, 3).join(', ') }}<template v-if="files.codePaths.length > 3">
+                  and {{ (files.codePaths.length - 3).toLocaleString() }} more
+                </template>
+              </p>
+            </template>
+          </dd>
+        </div>
+
+        <div class="rounded-lg border border-default bg-muted/30 p-3">
+          <dt class="data-label">
+            GitHub stars
+          </dt>
+          <dd class="mt-2 flex min-h-8 items-end justify-between gap-3">
+            <span class="font-mono text-xl font-medium tabular-nums">{{ stars.toLocaleString() }}</span>
+            <span class="h-7 w-20 shrink-0 sm:w-24">
+              <RepoSparkline
+                v-if="starTrend?._tag === 'ready'"
+                :points="starTrend.points"
+                label="GitHub stars"
+                approximate
+              />
+              <span v-else-if="starTrend" class="block text-right text-[10px] leading-tight text-muted">
+                {{ starTrend.label }}
+              </span>
+            </span>
+          </dd>
+        </div>
+
+        <div v-if="pushedAt" class="rounded-lg border border-default bg-muted/30 p-3">
+          <dt class="data-label">
+            Repository updated
+          </dt>
+          <dd class="mt-2 text-sm">
+            <p class="font-mono">
+              {{ pushedAtAgo }}
+            </p>
+            <p v-if="maturity" class="mt-1 text-muted">
+              Update pace: {{ CADENCE_LABEL[maturity.cadence] }}
+            </p>
+          </dd>
+        </div>
+
+        <div v-if="compatibility" class="rounded-lg border border-default bg-muted/30 p-3">
+          <dt class="data-label">
+            Agent compatibility
+          </dt>
+          <dd class="mt-2 text-sm">
+            {{ compatibility }}
+          </dd>
+        </div>
+
+        <div
+          v-if="curators.length"
+          class="rounded-lg border border-default bg-muted/30 p-3 sm:col-span-2"
+        >
+          <dt class="data-label">
+            In collections
+          </dt>
+          <dd class="mt-2 space-y-2 text-sm">
+            <p v-for="curator in curators" :key="`${curator.handle}/${curator.collectionSlug}`">
+              <NuxtLink
+                :to="`/@${curator.handle}/${curator.collectionSlug}`"
+                class="font-mono hover:text-highlighted"
+              >
+                {{ curator.collectionName }}
+              </NuxtLink>
+              by @{{ curator.handle }}<template v-if="curator.reason">
+                : {{ curator.reason }}
+              </template>
+            </p>
+          </dd>
+        </div>
+      </dl>
+    </section>
+
+    <section aria-labelledby="uv-excerpt-heading">
+      <h2 id="uv-excerpt-heading" class="section-label mb-3">
+        Excerpt from SKILL.md
+      </h2>
+      <div class="rounded-lg border border-default p-4 sm:p-6">
+        <!-- eslint-disable-next-line vue/no-v-html -- HTML from the same sanitising renderer as the full body -->
+        <div v-if="excerpt" class="skill-prose" v-html="excerpt" />
+      </div>
+      <p class="mt-3 flex flex-wrap gap-x-4 gap-y-1 text-xs text-muted">
+        <a
+          :href="skillFileUrl || githubUrl"
+          target="_blank"
+          rel="noopener"
+          class="font-mono hover:text-default transition-colors"
+        >
+          Read the full SKILL.md on GitHub
+        </a>
+        <a :href="markdownUrl" class="font-mono hover:text-default transition-colors">
+          Full SKILL.md as markdown
+        </a>
+      </p>
+    </section>
+
+    <section v-if="relatedGroups.length" aria-labelledby="uv-related-heading">
+      <h2 id="uv-related-heading" class="section-label mb-3">
+        Related skills
+      </h2>
+      <div class="space-y-6">
+        <div v-for="group in relatedGroups" :key="group.label">
+          <h3 class="mb-2 font-mono text-xs text-muted">
+            {{ group.label }}
+          </h3>
+          <SkillSourceList :items="group.items" variant="grid" :aria-label="`${group.label} skills`" />
+        </div>
+      </div>
+    </section>
+  </div>
+</template>
diff --git a/layers/registry/app/utils/skill-unique-value-experiment.ts b/layers/registry/app/utils/skill-unique-value-experiment.ts
new file mode 100644
index 00000000..931a5f14
--- /dev/null
+++ b/layers/registry/app/utils/skill-unique-value-experiment.ts
@@ -0,0 +1,74 @@
+/**
+ * SEO experiment C, "unique value": the gate and the two groups. Delete this
+ * file after the decision. Nothing else decides which Skill page is treated.
+ *
+ * Started 2026-09-30. Read the result at the Search Console gate on 2026-11-11.
+ * Google holds the curated Skill URLs as "Discovered, currently not indexed",
+ * and about 72% of a Skill page's text is the GitHub SKILL.md word for word.
+ * The question: do pages that carry data GitHub lacks get crawled and indexed
+ * sooner than pages that stay as they are?
+ *
+ * Treatment pages show the run command with install beneath it, the file inventory, the
+ * repository star trend, related Skills, and a SKILL.md excerpt in place of the
+ * full body. Every visitor sees the same page, crawler or not. Control pages
+ * stay unchanged.
+ *
+ * Every Skill below sits on a trending list (week, month, or all-time), in the
+ * production skills sitemap, and was indexable on 2026-09-30. A parallel
+ * experiment keeps only trending Skills indexable, so a control outside those
+ * lists would leave the index. Membership came from `/api/feed/trending`,
+ * `/api/skills/leaderboard`, and the sitemap, checked against `/api/skills`,
+ * not against an HTTP status. Only Skills whose canonical page is the
+ * three-segment `SkillDetail` route qualify; single-Skill repositories render
+ * on the repository hub. Twenty-two Skills qualified. Two were dropped and the
+ * rest were paired by repository stars. Within each pair, the treatment Skill
+ * alternates between the higher and the lower star count.
+ *
+ * Cull path: after the decision, delete this file, `skill-unique-value.ts`,
+ * `_SkillUniqueValue.vue`, and the `isUniqueValueTreatment` branches in
+ * `SkillDetail.vue`. If the treatment wins, roll the template out by
+ * removing the gate; if not, remove the template.
+ */
+/*
+ * 2026-09-30: swapped `onmax/nuxt-skills/arkenv` (treatment) for `ferdinandobons/startup-skill/startup-pitch`,
+ * and `pbakaus/agent-reviews/resolve-agent-reviews` (control) for `browser-use/plugins/browser-use`.
+ * The trending-only rule (#322) left both originals off every board, so they went
+ * `noindex,follow` and no longer matched their indexable partners.
+ */
+export const UNIQUE_VALUE_EXPERIMENT = {
+  startedOn: '2026-09-30',
+  endsOn: '2026-11-11',
+  /** Treatment: `owner/repo/name`. */
+  treatment: [
+    'obra/superpowers/writing-plans',
+    'imbad0202/academic-research-skills/academic-pipeline',
+    'emilkowalski/skills/emil-design-eng',
+    'vercel-labs/agent-skills/react-best-practices',
+    'ibelick/ui-skills/create-design-md',
+    'remotion-dev/skills/remotion-best-practices',
+    'dimillian/skills/bug-hunt-swarm',
+    'ferdinandobons/startup-skill/startup-pitch',
+    'neondatabase/agent-skills/neon-postgres',
+    'clerk/skills/clerk-orgs',
+  ],
+  /** Control: the star-matched partner of the treatment Skill at the same index. */
+  control: [
+    'mattpocock/skills/ask-matt',
+    'coreyhaines31/marketingskills/ai-seo',
+    'kepano/obsidian-skills/knap',
+    'othmanadi/planning-with-files/planning-with-files',
+    'microsoft/playwright-cli/playwright-cli',
+    'antfu/skills/nitro',
+    'addyosmani/web-quality-skills/accessibility',
+    'getsentry/skills/prompt-optimizer',
+    'browser-use/plugins/browser-use',
+    'prisma/skills/prisma-database-setup',
+  ],
+} as const
+
+const TREATMENT = new Set<string>(UNIQUE_VALUE_EXPERIMENT.treatment.map(slug => slug.toLowerCase()))
+
+/** True when the Skill page `owner/repo/name` gets the experiment template. */
+export function isUniqueValueTreatment(slug: string): boolean {
+  return TREATMENT.has(slug.toLowerCase())
+}
diff --git a/layers/registry/app/utils/skill-unique-value.ts b/layers/registry/app/utils/skill-unique-value.ts
new file mode 100644
index 00000000..5294dc43
--- /dev/null
+++ b/layers/registry/app/utils/skill-unique-value.ts
@@ -0,0 +1,247 @@
+import { skillInstallCmd, skillRunCmd } from '#shared/skill-commands'
+
+/**
+ * Data shaping for the experiment C template. Pure functions of data the Skill
+ * API already returns. Delete with `skill-unique-value-experiment.ts`.
+ */
+
+export interface SkillFileEntry {
+  path: string
+  size: number
+  type: 'markdown' | 'code' | 'image' | 'data' | 'other'
+}
+
+export type SkillFileFacts
+  = | { _tag: 'only-skill-md' }
+    | {
+      _tag: 'has-files'
+      /** Every file beside SKILL.md, as the sync counted them. */
+      total: number
+      markdown: number
+      code: number
+      other: number
+      codePaths: string[]
+      /** False when the API listed fewer files than the Skill holds. */
+      complete: boolean
+    }
+
+export function resolveSkillFileFacts(input: { assets: readonly SkillFileEntry[], total: number }): SkillFileFacts {
+  if (input.total === 0 && input.assets.length === 0)
+    return { _tag: 'only-skill-md' }
+  const codePaths = input.assets.filter(a => a.type === 'code').map(a => a.path)
+  return {
+    _tag: 'has-files',
+    total: Math.max(input.total, input.assets.length),
+    markdown: input.assets.filter(a => a.type === 'markdown').length,
+    code: codePaths.length,
+    other: input.assets.filter(a => a.type === 'other').length,
+    codePaths,
+    complete: input.assets.length >= input.total,
+  }
+}
+
+export interface SkillCommands {
+  run: string
+  install: string
+}
+
+/**
+ * Every Skill surface leads with the run command. The install command sits
+ * beneath it as the opt-in for keeping the Skill (`VISION.md`).
+ */
+export function resolveSkillCommands(skill: { owner: string, repo: string, name: string }): SkillCommands {
+  return {
+    run: skillRunCmd(skill.owner, skill.repo, skill.name),
+    install: skillInstallCmd(skill.owner, skill.repo, skill.name),
+  }
+}
+
+const VOID_TAGS = new Set(['br', 'hr', 'img', 'input', 'col', 'wbr'])
+const TAG = /<(\/?)([a-z][a-z0-9]*)\b[^>]*?(\/?)>/gi
+
+function isBalanced(html: string): boolean {
+  const stack: string[] = []
+  for (const match of html.matchAll(TAG)) {
+    const tag = match[2]!.toLowerCase()
+    if (VOID_TAGS.has(tag) || match[3] === '/')
+      continue
+    if (match[1] === '/') {
+      if (stack.pop() !== tag)
+        return false
+    }
+    else {
+      stack.push(tag)
+    }
+  }
+  return stack.length === 0
+}
+
+/** Top-level blocks of rendered HTML. Malformed markup yields no blocks. */
+function splitBlocks(html: string): string[] {
+  const blocks: string[] = []
+  let depth = 0
+  let start = 0
+  const push = (end: number): void => {
+    const block = html.slice(start, end).trim()
+    if (block)
+      blocks.push(block)
+    start = end
+  }
+  for (const match of html.matchAll(TAG)) {
+    const tag = match[2]!.toLowerCase()
+    const end = match.index + match[0].length
+    if (VOID_TAGS.has(tag) || match[3] === '/') {
+      if (depth === 0)
+        push(end)
+    }
+    else if (match[1] === '/') {
+      depth--
+      if (depth < 0)
+        return []
+      if (depth === 0)
+        push(end)
+    }
+    else {
+      depth++
+    }
+  }
+  if (depth !== 0)
+    return []
+  push(html.length)
+  return blocks
+}
+
+function textOf(html: string): string {
+  return html
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, '\'')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** Words a reader sees in rendered HTML. */
+export function countHtmlWords(html: string): number {
+  const text = textOf(html)
+  return text ? text.split(' ').length : 0
+}
+
+const isHeading = (block: string): boolean => /^<h[1-6][\s>]/i.test(block)
+
+/** A code fence stays only when it is short enough to read as part of the excerpt. */
+const MAX_CODE_LINES = 12
+const MAX_CODE_WORDS = 60
+
+/** Cut one block down to whole sentences or list items within `budget` words, or null. */
+function trimBlock(block: string, budget: number): string | null {
+  const open = /^<(p|ul|ol)(?:\s[^>]*)?>/i.exec(block)
+  if (!open)
+    return null
+  const tag = open[1]!.toLowerCase()
+  const inner = block.slice(open[0].length, block.length - `</${tag}>`.length)
+  if (tag === 'p') {
+    const ends = [...inner.matchAll(/[.!?](?=\s|$)/g)].map(m => m.index + 1)
+    for (const end of ends.reverse()) {
+      const cut = inner.slice(0, end)
+      if (countHtmlWords(cut) <= budget && isBalanced(cut))
+        return `${open[0]}${cut}</p>`
+    }
+    return null
+  }
+  const items = splitBlocks(inner)
+  const kept: string[] = []
+  let used = 0
+  for (const item of items) {
+    const w = countHtmlWords(item)
+    if (used + w > budget)
+      break
+    kept.push(item)
+    used += w
+  }
+  return kept.length ? `${open[0]}\n${kept.join('\n')}\n</${tag}>` : null
+}
+
+export interface ExcerptOptions {
+  /** The frontmatter description. A block that repeats it is dropped. */
+  description?: string | null
+  /** Upper bound on words. */
+  maxWords?: number
+  /** A first section with fewer body words pulls in the second one. */
+  shortSectionWords?: number
+}
+
+/**
+ * The opening of the rendered SKILL.md: the first section's blocks, plus the
+ * second section when the first is short, capped near `maxWords`. The API
+ * already renders the body to HTML, so this cuts that HTML and never reads
+ * markdown. It cuts only at block boundaries, or at a sentence or list item
+ * when one block alone exceeds the cap, so it never ends mid-sentence. It
+ * returns balanced HTML, or null when no body text is left.
+ */
+export function excerptSkillHtml(html: string | null | undefined, options: ExcerptOptions = {}): string | null {
+  const { description = null, maxWords = 250, shortSectionWords = 120 } = options
+  const source = html?.trim()
+  if (!source)
+    return null
+
+  const described = description ? textOf(description) : null
+  const usable = splitBlocks(source).filter((block) => {
+    if (described && !isHeading(block) && textOf(block) === described)
+      return false
+    if (/^<pre[\s>]/i.test(block))
+      return block.split('\n').length <= MAX_CODE_LINES && countHtmlWords(block) <= MAX_CODE_WORDS
+    return true
+  })
+
+  // Sections start at a heading. Text ahead of the first heading is its own section.
+  const sections: string[][] = []
+  for (const block of usable) {
+    if (isHeading(block) || sections.length === 0)
+      sections.push([block])
+    else
+      sections.at(-1)!.push(block)
+  }
+  const bodyWords = (section: string[]): number =>
+    section.filter(b => !isHeading(b)).reduce((sum, b) => sum + countHtmlWords(b), 0)
+
+  const chosen = [sections[0] ?? []]
+  let next = 1
+  while (bodyWords(chosen.flat()) < shortSectionWords && sections[next] && chosen.length < 2) {
+    chosen.push(sections[next]!)
+    next++
+  }
+  // A first section with no body pulls in following sections until one has text.
+  while (bodyWords(chosen.flat()) === 0 && sections[next]) {
+    chosen.push(sections[next]!)
+    next++
+  }
+
+  const out: string[] = []
+  let words = 0
+  let bodyBlocks = 0
+  for (const block of chosen.flat()) {
+    const w = countHtmlWords(block)
+    if (words + w <= maxWords) {
+      out.push(block)
+      words += w
+      if (!isHeading(block))
+        bodyBlocks++
+      continue
+    }
+    if (isHeading(block))
+      break
+    const trimmed = trimBlock(block, maxWords - words)
+    if (trimmed) {
+      out.push(trimmed)
+      bodyBlocks++
+    }
+    break
+  }
+  while (out.length && isHeading(out.at(-1)!))
+    out.pop()
+  return bodyBlocks > 0 ? out.join('\n') : null
+}
diff --git a/test/unit/skill-unique-value-experiment.test.ts b/test/unit/skill-unique-value-experiment.test.ts
new file mode 100644
index 00000000..7d95f934
--- /dev/null
+++ b/test/unit/skill-unique-value-experiment.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import {
+  isUniqueValueTreatment,
+  UNIQUE_VALUE_EXPERIMENT,
+} from '../../layers/registry/app/utils/skill-unique-value-experiment'
+
+describe('unique value experiment gate', () => {
+  it('treats every listed treatment Skill', () => {
+    for (const slug of UNIQUE_VALUE_EXPERIMENT.treatment)
+      expect(isUniqueValueTreatment(slug)).toBe(true)
+  })
+
+  it('leaves every listed control Skill unchanged', () => {
+    for (const slug of UNIQUE_VALUE_EXPERIMENT.control)
+      expect(isUniqueValueTreatment(slug)).toBe(false)
+  })
+
+  it('leaves a Skill outside both lists unchanged', () => {
+    expect(isUniqueValueTreatment('someone/else/not-listed')).toBe(false)
+  })
+
+  it('ignores letter case, because GitHub logins ignore it', () => {
+    const [first] = UNIQUE_VALUE_EXPERIMENT.treatment
+    expect(isUniqueValueTreatment(first!.toUpperCase())).toBe(true)
+  })
+
+  it('keeps the two groups the same size and apart', () => {
+    const { treatment, control } = UNIQUE_VALUE_EXPERIMENT
+    expect(treatment).toHaveLength(10)
+    expect(control).toHaveLength(10)
+    expect(new Set([...treatment, ...control].map(s => s.toLowerCase())).size).toBe(20)
+  })
+})
diff --git a/test/unit/skill-unique-value.test.ts b/test/unit/skill-unique-value.test.ts
new file mode 100644
index 00000000..5f14eb8a
--- /dev/null
+++ b/test/unit/skill-unique-value.test.ts
@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest'
+import {
+  countHtmlWords,
+  excerptSkillHtml,
+  resolveSkillCommands,
+  resolveSkillFileFacts,
+} from '../../layers/registry/app/utils/skill-unique-value'
+
+const ref = { owner: 'acme', repo: 'skills', name: 'lint' }
+
+function asset(path: string, type: 'markdown' | 'code' | 'image' | 'data' | 'other') {
+  return { path, size: 10, type }
+}
+
+describe('resolveSkillFileFacts', () => {
+  it('reports a Skill that is only SKILL.md', () => {
+    expect(resolveSkillFileFacts({ assets: [], total: 0 })).toEqual({
+      _tag: 'only-skill-md',
+    })
+  })
+
+  it('counts files by type and lists code files', () => {
+    const facts = resolveSkillFileFacts({
+      assets: [
+        asset('references/a.md', 'markdown'),
+        asset('references/b.md', 'markdown'),
+        asset('scripts/run.py', 'code'),
+        asset('data.json', 'data'),
+      ],
+      total: 4,
+    })
+    expect(facts).toEqual({
+      _tag: 'has-files',
+      total: 4,
+      markdown: 2,
+      code: 1,
+      other: 0,
+      codePaths: ['scripts/run.py'],
+      complete: true,
+    })
+  })
+
+  it('marks a truncated list as incomplete', () => {
+    const facts = resolveSkillFileFacts({ assets: [asset('a.md', 'markdown')], total: 300 })
+    expect(facts._tag === 'has-files' && facts.complete).toBe(false)
+  })
+})
+
+describe('resolveSkillCommands', () => {
+  it('leads with run and offers install as the opt-in', () => {
+    expect(resolveSkillCommands(ref)).toEqual({
+      run: 'npx skilld run acme/skills/lint',
+      install: 'npx skilld install acme/skills/lint',
+    })
+  })
+})
+
+const words = (n: number, w = 'word') => Array.from({ length: n }).fill(w).join(' ')
+const sentences = (n: number) => Array.from({ length: n }, (_, i) => `Sentence number ${i} says something.`).join(' ')
+
+describe('excerptSkillHtml', () => {
+  it('keeps the first heading with its body text', () => {
+    const html = `<h2>Title</h2>\n<p>Intro text.</p>\n<ul>\n<li>one</li>\n</ul>\n<h3>Next</h3>\n<p>${words(200)}</p>`
+    const out = excerptSkillHtml(html)!
+    expect(out).toContain('<p>Intro text.</p>')
+    expect(out).toContain('<li>one</li>')
+  })
+
+  it('adds the second section when the first is short', () => {
+    const html = `<h2>One</h2>\n<p>${words(20)}</p>\n<h2>Two</h2>\n<p>Second body.</p>\n<h2>Three</h2>\n<p>Never shown.</p>`
+    const out = excerptSkillHtml(html)!
+    expect(out).toContain('Second body.')
+    expect(out).not.toContain('Never shown.')
+  })
+
+  it('skips ahead when the first section is only a heading', () => {
+    const html = '<h2>Writing Plans</h2>\n<h3>Overview</h3>\n<p>The real body starts here.</p>\n<h3>Later</h3>\n<p>Not shown.</p>'
+    const out = excerptSkillHtml(html)!
+    expect(out).toContain('The real body starts here.')
+    expect(out).not.toContain('Not shown.')
+  })
+
+  it('returns null when the page holds only headings', () => {
+    expect(excerptSkillHtml('<h2>A</h2>\n<h3>B</h3>')).toBeNull()
+  })
+
+  it('does not add the second section when the first is long enough', () => {
+    const html = `<h2>One</h2>\n<p>${words(130)}</p>\n<h2>Two</h2>\n<p>Second body.</p>`
+    expect(excerptSkillHtml(html)!).not.toContain('Second body.')
+  })
+
+  it('caps a long section at a block boundary', () => {
+    const para = `<p>${words(100)}</p>`
+    const html = `<h2>Title</h2>\n${para}\n${para}\n${para}\n${para}`
+    const out = excerptSkillHtml(html, { maxWords: 250 })!
+    expect(countHtmlWords(out)).toBeLessThanOrEqual(250)
+    expect(out.endsWith('</p>')).toBe(true)
+    expect((out.match(/<p>/g) ?? []).length).toBe(2)
+  })
+
+  it('cuts a single oversized paragraph at a sentence end', () => {
+    const html = `<h2>Title</h2>\n<p>${sentences(80)}</p>`
+    const out = excerptSkillHtml(html, { maxWords: 100 })!
+    expect(countHtmlWords(out)).toBeLessThanOrEqual(100)
+    expect(out).toMatch(/says something\.<\/p>$/)
+  })
+
+  it('cuts an oversized list at an item boundary', () => {
+    const items = Array.from({ length: 60 }, (_, i) => `<li>item ${i} ${words(4)}</li>`).join('\n')
+    const out = excerptSkillHtml(`<h2>Title</h2>\n<ul>\n${items}\n</ul>`, { maxWords: 50 })!
+    expect(countHtmlWords(out)).toBeLessThanOrEqual(50)
+    expect(out.endsWith('</li>\n</ul>')).toBe(true)
+  })
+
+  it('drops a block that repeats the description', () => {
+    const description = 'Use when you have a spec, before touching code'
+    const html = `<h2>Title</h2>\n<p>${description}</p>\n<p>Actual guidance.</p>`
+    const out = excerptSkillHtml(html, { description })!
+    expect(out).not.toContain('before touching code')
+    expect(out).toContain('Actual guidance.')
+  })
+
+  it('keeps a short code fence and drops a long one', () => {
+    const short = '<pre><code>npm run build</code></pre>'
+    const long = `<pre><code>${Array.from({ length: 30 }, (_, i) => `line ${i}`).join('\n')}</code></pre>`
+    const out = excerptSkillHtml(`<h2>T</h2>\n<p>Intro.</p>\n${short}\n${long}`)!
+    expect(out).toContain('npm run build')
+    expect(out).not.toContain('line 29')
+  })
+
+  it('never returns unbalanced tags', () => {
+    const html = '<blockquote>\n<h3>Inside</h3>\n<p>Quote.</p>\n</blockquote>\n<p>After.</p>'
+    const out = excerptSkillHtml(html)!
+    expect((out.match(/<blockquote>/g) ?? []).length).toBe((out.match(/<\/blockquote>/g) ?? []).length)
+  })
+
+  it('returns null for an empty body', () => {
+    expect(excerptSkillHtml('  ')).toBeNull()
+    expect(excerptSkillHtml(null)).toBeNull()
+  })
+})