From 1af0be5b01ea2a52c24dbf1e2ec8b1d164ecfb1b Mon Sep 17 00:00:00 2001
From: Harlan Wilton <harlan@harlanzw.com>
Date: Tue, 6 Oct 2026 02:47:50 +1100
Subject: [PATCH 1/4] feat(trending): give Skills a lasting trending award

A Skill that trends has no record of it once it leaves the board.
Record the best rank each evidenced row reaches per week and month,
show it beside the Skill heading, and let the README badge carry it.
---
 GLOSSARY.md                                   |   9 +
 VISION.md                                     |   2 +-
 app/components/BadgeEmbedControl.vue          |  55 ++++-
 docs/adr/0010-trending-awards.md              |  41 ++++
 docs/arch/cron.md                             |   3 +-
 .../registry/app/components/SkillDetail.vue   |  34 ++-
 .../server/api/skills/[...slug].get.ts        |   7 +-
 .../server/tasks/record-trending-awards.ts    |  51 ++++
 .../registry/server/utils/trending-awards.ts  | 126 ++++++++++
 migrations/0139_skill_trending_awards.sql     |  21 ++
 server/routes/b/[...slug].get.ts              |  14 +-
 server/utils/skill-badge.ts                   |  63 ++++-
 shared/schedule-policy.ts                     |   1 +
 shared/skill-badge.ts                         |  28 +++
 shared/trending-award.ts                      |  98 ++++++++
 test/unit/badge-embed-control.test.ts         |  21 +-
 test/unit/trending-awards.test.ts             | 223 ++++++++++++++++++
 17 files changed, 775 insertions(+), 22 deletions(-)
 create mode 100644 docs/adr/0010-trending-awards.md
 create mode 100644 layers/registry/server/tasks/record-trending-awards.ts
 create mode 100644 layers/registry/server/utils/trending-awards.ts
 create mode 100644 migrations/0139_skill_trending_awards.sql
 create mode 100644 shared/trending-award.ts
 create mode 100644 test/unit/trending-awards.test.ts

diff --git a/GLOSSARY.md b/GLOSSARY.md
index 4220c5df..c01cbd5c 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -24,6 +24,7 @@ Shared terms match the skilld CLI glossary (`skilld-dev/skilld/GLOSSARY.md`). Th
 | track | `/skills/<slug>`, `layers/registry` | track 1—N Skill | "track" |
 | comparison | `/compare/<slug>`, `layers/marketing` | comparison N—N Skill | "comparison" |
 | trending | `/skills/trending`, ADR-0004 | Repository 1—N social mention | "trending" |
+| trending award | `skill_trending_awards`, ADR-0010 | Skill 1—N trending award | "#3 trending" |
 | registry | skilld.dev | one | "skilld" |
 | skilld token | `cli_tokens`, `layers/identity` | Author 1—N token | "skilld token" |
 | provenance | Skill detail, cards | Skill 1—1 author and source link | "written by", "source" |
@@ -153,6 +154,14 @@ Collisions
 
 **Never:** popular, hot, top, leaderboard.
 
+### trending award
+
+**Is:** the best rank a Skill reached on the `week` or `month` trending board in one calendar period (ADR-0010). It stays after the Skill leaves the board. Only a row with a post or a star surge earns one.
+
+**Format:** `#3 trending · Sep 2026` on a chip or a README badge. `#3 trending, week of 29 Sep 2026` in full.
+
+**Never:** trophy, medal, achievement, honor, top pick.
+
 ### registry
 
 **Is:** skilld.dev, the curated index of Skills and the discovery MCP server.
diff --git a/VISION.md b/VISION.md
index 7ad1c741..059b57c6 100644
--- a/VISION.md
+++ b/VISION.md
@@ -156,7 +156,7 @@ The interface recedes; the content speaks. Warm stone, rare rose, mono chrome, b
 1. **skilld-maintained Skills stay separate from registry provenance.** The skilld project may publish visible skilld-maintained Skills for generation, review, search, and install guidance. They name the project as author and remain readable source assets. Generated output never enters the registry as platform-authored maintainer content. Registry Skills retain their Repository owner and exact GitHub provenance. Machine-generated search metadata stays labeled and stays metadata.
 2. **We are not AI-powered.** The product category is a curated registry. "AI" never modifies skilld itself in copy, positioning, or feature naming.
 3. **No pay-to-play, ever.** No sponsored listings, promoted skills, paid placement, or ads. This is the money posture made permanent: curation that can be bought is not curation.
-4. **Popularity is never the quality signal.** Unverifiable third-party counts (installs scraped from skills.sh) never order a surface, never feed trust tiers, and never appear as our numbers; we cannot vouch for a figure we cannot source. GitHub stars are the one sanctioned popularity signal: verifiable at the canonical source, synced for free, honest to display. Stars may order browse surfaces (catalog sort, the human-reviewed leaderboard) and may feed trust as a supporting input (a well-starred repository has earned community evidence), but stars alone never grant the top trust tier: admission and the highest trust signals stay human judgments, the homepage's organizing principle stays curation and freshness, and no star count ever substitutes for review. **Likes carve-out (ADR-0003, 2026-08-10):** Skill likes are first-party (a row we wrote, keyed to a GitHub-authenticated user, so we can state exactly what the number counts) and Skill-grained (stars measure a repository and lend the same count to all twenty Skills inside it). Like counts may be displayed and may back an opt-in `?sort=likes`. They never feed trust, never affect admission, never become a default order, and never order a trending surface: a board ranked by our own users' taste is a mirror. The carve-out covers display and that one sort key; every other clause above holds unchanged. **Trending carve-out (ADR-0004, 2026-08-19):** `/skills/trending` and the weekly email are ordered by social mentions we record ourselves from the public X and Bluesky APIs, and by star surges on repositories holding exactly one Skill. Both pass the test that admitted stars and rejected installs: we can state what the number counts, and a reader can check it, because every socially attributed row ships the post that named the Skill with its author and link. Each row states which route named it; a heading may never claim people named something when a star count did. Neither signal feeds trust or admission, and installs stay barred.
+4. **Popularity is never the quality signal.** Unverifiable third-party counts (installs scraped from skills.sh) never order a surface, never feed trust tiers, and never appear as our numbers; we cannot vouch for a figure we cannot source. GitHub stars are the one sanctioned popularity signal: verifiable at the canonical source, synced for free, honest to display. Stars may order browse surfaces (catalog sort, the human-reviewed leaderboard) and may feed trust as a supporting input (a well-starred repository has earned community evidence), but stars alone never grant the top trust tier: admission and the highest trust signals stay human judgments, the homepage's organizing principle stays curation and freshness, and no star count ever substitutes for review. **Likes carve-out (ADR-0003, 2026-08-10):** Skill likes are first-party (a row we wrote, keyed to a GitHub-authenticated user, so we can state exactly what the number counts) and Skill-grained (stars measure a repository and lend the same count to all twenty Skills inside it). Like counts may be displayed and may back an opt-in `?sort=likes`. They never feed trust, never affect admission, never become a default order, and never order a trending surface: a board ranked by our own users' taste is a mirror. The carve-out covers display and that one sort key; every other clause above holds unchanged. **Trending carve-out (ADR-0004, 2026-08-19):** `/skills/trending` and the weekly email are ordered by social mentions we record ourselves from the public X and Bluesky APIs, and by star surges on repositories holding exactly one Skill. Both pass the test that admitted stars and rejected installs: we can state what the number counts, and a reader can check it, because every socially attributed row ships the post that named the Skill with its author and link. Each row states which route named it; a heading may never claim people named something when a star count did. Neither signal feeds trust or admission, and installs stay barred. **Awards carve-out (ADR-0010, 2026-10-06):** a trending award keeps the best rank an evidenced row reached on the week or month board, dated to its period, on the Skill page and on an opt-in README badge. It repeats a claim the board already made with its evidence, so no one can buy or farm it. Star filler and the all-time range earn none, and awards never feed trust, admission, indexability, or order.
 5. **We are not the npm of skills.** No publish flow and no namespace ownership. GitHub is the registry of record. Artifact delivery may cache immutable signed bytes for installation. It never becomes the source of truth. Protocol work serves the skilld CLI and requires a dated ADR.
 6. **We do not optimize engagement.** Sessions per week is not a goal. Time-to-install and digest usefulness are. No streaks, no notification escalation, no re-engagement campaigns beyond the digest the user asked for.
 7. **We are not an enterprise product.** No private registries, SSO, seats, or compliance surface. Private GitHub Artifact delivery is transient and account scoped. The free posture cannot carry enterprise support obligations.
diff --git a/app/components/BadgeEmbedControl.vue b/app/components/BadgeEmbedControl.vue
index b063cd04..4ea1a830 100644
--- a/app/components/BadgeEmbedControl.vue
+++ b/app/components/BadgeEmbedControl.vue
@@ -1,13 +1,20 @@
 <script setup lang="ts">
 import type { SkillBadgeEmbedInput, SkillBadgeTheme } from '~~/shared/skill-badge'
-import { skillBadgeEmbed, skillBadgeImagePath } from '~~/shared/skill-badge'
+import type { TrendingAward } from '~~/shared/trending-award'
+import { skillBadgeAwardWidth, skillBadgeEmbed, skillBadgeImagePath } from '~~/shared/skill-badge'
 import { repoHubPath } from '~~/shared/skill-routes'
+import { trendingAwardBadgeLabel, trendingAwardLabel } from '~~/shared/trending-award'
 
-const props = defineProps<Pick<SkillBadgeEmbedInput, 'owner' | 'repo' | 'name' | 'registryPath'>>()
+const props = defineProps<Pick<SkillBadgeEmbedInput, 'owner' | 'repo' | 'name' | 'registryPath'> & {
+  /** The award the badge would show. The award option appears only with one. */
+  trendingAward?: TrendingAward | null
+}>()
 
 const open = ref(false)
 const showLabel = ref(true)
 const showLikes = ref(false)
+// On by default: an earned award is the usual reason to add the badge.
+const showTrendingAward = ref(Boolean(props.trendingAward))
 const previewTheme = ref<SkillBadgeTheme>('light')
 const { copy, copied } = useClipboard()
 
@@ -21,12 +28,15 @@ const configuredInput = computed(() => ({
   ...badgeInput.value,
   showLabel: showLabel.value,
   showLikes: showLikes.value,
+  showTrendingAward: Boolean(props.trendingAward) && showTrendingAward.value,
 }))
 const minimalInput = computed(() => ({ ...badgeInput.value, showLabel: false }))
 const minimalLightImage = computed(() => skillBadgeImagePath(minimalInput.value, 'light'))
 const minimalDarkImage = computed(() => skillBadgeImagePath(minimalInput.value, 'dark'))
 const previewImage = computed(() => skillBadgeImagePath(configuredInput.value, previewTheme.value))
-const previewWidth = computed(() => (showLabel.value ? 153 : 81) + (showLikes.value ? 46 : 0))
+const previewWidth = computed(() => (showLabel.value ? 153 : 81)
+  + (showLikes.value ? 46 : 0)
+  + (props.trendingAward && showTrendingAward.value ? skillBadgeAwardWidth(trendingAwardBadgeLabel(props.trendingAward)) : 0))
 const targetLabel = computed(() => props.registryPath === repoHubPath(props.owner, props.repo)
   ? `${props.owner}/${props.repo}`
   : `${props.owner}/${props.repo}/${props.name}`)
@@ -220,6 +230,45 @@ function copyEmbed(): void {
               />
             </div>
           </fieldset>
+
+          <fieldset
+            v-if="trendingAward"
+            class="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-4 py-3"
+          >
+            <legend class="sr-only">
+              Trending award
+            </legend>
+            <div>
+              <p class="font-mono text-sm text-highlighted" aria-hidden="true">
+                Trending award
+              </p>
+              <p class="mt-0.5 text-xs text-muted">
+                Add {{ trendingAwardLabel(trendingAward) }}.
+              </p>
+            </div>
+            <div class="flex gap-1" role="group" aria-label="Badge trending award">
+              <UButton
+                type="button"
+                label="Plain"
+                size="sm"
+                color="neutral"
+                :variant="showTrendingAward ? 'ghost' : 'soft'"
+                class="min-h-11"
+                :aria-pressed="!showTrendingAward"
+                @click="showTrendingAward = false"
+              />
+              <UButton
+                type="button"
+                label="With award"
+                size="sm"
+                color="neutral"
+                :variant="showTrendingAward ? 'soft' : 'ghost'"
+                class="min-h-11"
+                :aria-pressed="showTrendingAward"
+                @click="showTrendingAward = true"
+              />
+            </div>
+          </fieldset>
         </div>
       </template>
 
diff --git a/docs/adr/0010-trending-awards.md b/docs/adr/0010-trending-awards.md
new file mode 100644
index 00000000..17091aa2
--- /dev/null
+++ b/docs/adr/0010-trending-awards.md
@@ -0,0 +1,41 @@
+# ADR-0010: Trending awards
+
+**Status:** Accepted
+**Date:** 2026-10-06
+
+## Context
+
+The trending boards change every hour. A Skill that ranked third last week has no record of it
+once it leaves the board. Maintainers ask for proof they can keep, and a README badge that links
+back to the Skill page is the channel VISION already names: the install command spreading
+through maintainers' own READMEs.
+
+VISION names badges as something the growth-hacking Skill author wants. The concern there is a
+badge a maintainer can farm or buy. A trending award repeats a claim the board already made in
+public, with the post or the star surge that put the row there.
+
+## Decision
+
+Record a trending award for every evidenced row on the `week` and `month` boards.
+
+- An evidenced row has a post that named the Skill or a star surge on a repository holding
+  exactly one Skill. Star filler earns nothing. The `all` range earns nothing, because it ranks
+  by lifetime stars.
+- An award is keyed by Skill, board, and calendar period in UTC: the ISO week starting Monday,
+  or the month. It keeps the best rank the board showed during that period.
+- `record-trending-awards` samples the boards hourly. It never removes a row and never worsens
+  a rank.
+- The Skill page shows the best award beside the heading. The README badge adds it on request
+  with `?trending=1`. Both always show the period, because an undated rank reads as current.
+- Awards are display only. They never feed trust, admission, indexability, or ordering.
+
+## Consequences
+
+The award inherits the board's evidence. If the board ranking changes, past awards keep the rank
+the old board showed, which is what readers saw at the time.
+
+Awards are separate from the SEO admission experiment in `trending-admission.ts`. Ending that
+experiment does not end awards.
+
+Cull path: drop the `record-trending-awards` task, remove the chip and the badge option, then
+drop `skill_trending_awards`.
diff --git a/docs/arch/cron.md b/docs/arch/cron.md
index 732dff18..848f2eab 100644
--- a/docs/arch/cron.md
+++ b/docs/arch/cron.md
@@ -2,7 +2,7 @@
 
 Generated from literal `defineScheduledTask` declarations. Run `pnpm cron:docs` after schedule changes.
 
-Tasks: 21. Unique Cloudflare triggers: 14.
+Tasks: 22. Unique Cloudflare triggers: 14.
 
 | Task | Cron | Source |
 | --- | --- | --- |
@@ -18,6 +18,7 @@ Tasks: 21. Unique Cloudflare triggers: 14.
 | `purge-personal-data` | `30 4 * * *` | `layers/identity/server/tasks/purge-personal-data.ts` |
 | `recompute-skill-scores` | `0 3 * * *` | `layers/registry/server/tasks/recompute-skill-scores.ts` |
 | `reconcile-rendered` | `20 */6 * * *` | `layers/registry/server/tasks/reconcile-rendered.ts` |
+| `record-trending-awards` | `0 * * * *` | `layers/registry/server/tasks/record-trending-awards.ts` |
 | `refresh-x-engagement` | `10 * * * *` | `layers/registry/server/tasks/refresh-x-engagement.ts` |
 | `scheduled-cadence-watchdog` | `*/5 * * * *` | `server/tasks/scheduled-cadence-watchdog.ts` |
 | `send-digests` | `0 9 1 * *` | `layers/identity/server/tasks/send-digests.ts` |
diff --git a/layers/registry/app/components/SkillDetail.vue b/layers/registry/app/components/SkillDetail.vue
index b48947d1..f38693bb 100644
--- a/layers/registry/app/components/SkillDetail.vue
+++ b/layers/registry/app/components/SkillDetail.vue
@@ -1,11 +1,13 @@
 <script setup lang="ts">
 import type { SkillAudit } from '~~/app/utils/skill-audit-overview'
+import type { TrendingAward } from '#shared/trending-award'
 import type { ZipState } from '../utils/skill-zip'
 import { formatTimeAgo } from '@vueuse/core'
 import { resolveSkillAuditOverview } from '~~/app/utils/skill-audit-overview'
 import { comparisonLinkForSkill } from '#shared/comparison-navigation'
 import { avatarProxyUrl, githubAvatarProxyUrl } from '#shared/image-proxy'
 import { skillPageUrl as exactSkillPageUrl, skillInstallCmd, skillRunCmd, skillRunPrompt } from '#shared/skill-commands'
+import { headlineTrendingAward, trendingAwardBadgeLabel, trendingAwardLabel, trendingAwardPath } from '#shared/trending-award'
 import { formatByteSize, formatTokenCount, resolveSkillContextCost, resolveSkillFileContext } from '../utils/skill-context-cost'
 import { fileIcon, highlightLangFromPath } from '../utils/skill-file-tree'
 import { partitionMetadataEntries } from '../utils/skill-metadata'
@@ -197,6 +199,8 @@ const skillFetch = useFetch(
   tags: SkillTag[]
   keywords: string[]
   likeCount: number
+  /** Best rank first. Optional while an edge-cached payload predates it. */
+  trendingAwards?: TrendingAward[]
   faqs: FaqItem[]
   summary: SkillSummary | null
   dependencies: string[]
@@ -671,6 +675,7 @@ useResizeObserver(descriptionEl, () => {
     descriptionClamped.value = el.scrollHeight > el.clientHeight + 1
 })
 const shortSha = computed(() => data.value?.provenance?.sourceCommitSha?.slice(0, 7) ?? null)
+const trendingAward = computed(() => headlineTrendingAward(data.value?.trendingAwards ?? []))
 
 // Frontmatter licences are free text ("Proprietary. LICENSE.txt has complete
 // terms"). The chip keeps the first clause; the title carries the rest.
@@ -1401,6 +1406,20 @@ useHead(computed(() => ({
                   />
                   official
                 </span>
+                <NuxtLink
+                  v-if="trendingAward"
+                  :to="trendingAwardPath(trendingAward)"
+                  class="skill-award"
+                  :aria-label="trendingAwardLabel(trendingAward)"
+                  :title="trendingAwardLabel(trendingAward)"
+                >
+                  <UIcon
+                    name="i-lucide-award"
+                    class="size-3.5"
+                    aria-hidden="true"
+                  />
+                  {{ trendingAwardBadgeLabel(trendingAward) }}
+                </NuxtLink>
               </div>
               <div class="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-sm text-muted">
                 <span>
@@ -2486,7 +2505,10 @@ useHead(computed(() => ({
               <h2 id="readme-badge-heading" class="sr-only">
                 README badge
               </h2>
-              <BadgeEmbedControl v-bind="badgeInput" />
+              <BadgeEmbedControl
+                v-bind="badgeInput"
+                :trending-award="trendingAward"
+              />
             </section>
           </div>
 
@@ -2686,7 +2708,8 @@ useHead(computed(() => ({
   }
   /* The solid xs badge set 10px text on rose. This keeps the accent and reads
      at chip size. */
-  .skill-official {
+  .skill-official,
+  .skill-award {
     display: inline-flex;
     align-items: center;
     gap: 0.25rem;
@@ -2698,6 +2721,13 @@ useHead(computed(() => ({
     line-height: 1.25rem;
     color: var(--syntax-arg);
   }
+  .skill-award {
+    font-variant-numeric: tabular-nums;
+    transition: border-color 150ms ease;
+  }
+  .skill-award:hover {
+    border-color: var(--syntax-arg);
+  }
   .skill-sha {
     color: var(--syntax-arg);
   }
diff --git a/layers/registry/server/api/skills/[...slug].get.ts b/layers/registry/server/api/skills/[...slug].get.ts
index 0f973f74..797968d3 100644
--- a/layers/registry/server/api/skills/[...slug].get.ts
+++ b/layers/registry/server/api/skills/[...slug].get.ts
@@ -19,6 +19,7 @@ import { parseSkillMd } from '../../utils/skill-md-render'
 import { findDuplicateGroupForSkill, findSkillWithRow } from '../../utils/skills-registry'
 import { tagLinkPath } from '../../utils/tag-quality'
 import { isSkillIndexable, noteAdmissionFallback, SKILL_INDEX_INPUT_COLUMNS_SQL } from '../../utils/trending-admission'
+import { parseSkillTrendingAwards, SKILL_TRENDING_AWARDS_SQL } from '../../utils/trending-awards'
 import { fetchUpstreamText } from '../../utils/upstream-text'
 
 interface FaqPayload { faqs: { question: string, answer: string }[] }
@@ -145,7 +146,8 @@ const DETAIL_COLUMNS_SQL = `r.forks, r.repo_created_at,
   s.rendered_status, s.rendered_raw, s.rendered_frontmatter, s.rendered_html,
   (SELECT sr.sha FROM skill_revisions sr
     WHERE sr.owner = s.owner AND sr.repo = s.repo AND sr.name = s.name
-    ORDER BY sr.modified_at DESC LIMIT 1) AS latest_revision_sha`
+    ORDER BY sr.modified_at DESC LIMIT 1) AS latest_revision_sha,
+  ${SKILL_TRENDING_AWARDS_SQL}`
 
 interface SkillDetailRow {
   // repo meta
@@ -176,6 +178,7 @@ interface SkillDetailRow {
   probe_exception: number | null
   admissions_populated: number | null
   repo_kind: string | null
+  trending_awards: string | null
   seo_index_reasons: string | null
   seo_index_synced_at: number | null
   curator_count: number | null
@@ -421,6 +424,8 @@ async function loadSkillDetail(event: H3Event, platform: Platform, slug: string)
     // Deliberately top-level, not under `seo`: likes are displayed and back
     // ?sort=likes, but never feed indexability or trust (ADR-0003).
     likeCount: row.like_count ?? 0,
+    // Best rank first. Display only, like likes: never trust or indexability (ADR-0010).
+    trendingAwards: parseSkillTrendingAwards(row.trending_awards),
     faqs: faqRow?.payload.faqs ?? [],
     summary: summaryRow?.payload?.text
       ? { text: summaryRow.payload.text }
diff --git a/layers/registry/server/tasks/record-trending-awards.ts b/layers/registry/server/tasks/record-trending-awards.ts
new file mode 100644
index 00000000..b7476227
--- /dev/null
+++ b/layers/registry/server/tasks/record-trending-awards.ts
@@ -0,0 +1,51 @@
+/// <reference types="@cloudflare/workers-types" />
+
+import { resolveCloudflareBindings } from '@harlan-zw/nuxt-cloudflare/bindings'
+import { runObservedScheduledTask } from '~~/server/utils/scheduled-run'
+import { reportJobRun } from '~~/server/utils/sync-job-reporter'
+import { observedSchedulePolicy } from '#shared/schedule-policy'
+import { recordTrendingAwards } from '../utils/trending-awards'
+
+const CRON = '0 * * * *'
+
+/**
+ * Scheduled task: record each evidenced trending row as a trending award
+ * (ADR-0010). The rule lives in `#shared/trending-award`.
+ *
+ * Hourly, so a rank held for one hour still counts. It never removes a row and
+ * never worsens a rank: an award is a record of what the board said.
+ */
+export default defineScheduledTask({
+  name: 'record-trending-awards',
+  cron: '0 * * * *',
+  description: 'Record the best rank each Skill reaches on the trending boards',
+  async run({ context }) {
+    const env = resolveCloudflareBindings<Cloudflare.Env>(context)
+    const db = env?.DB as D1Database | undefined
+    if (!env || !db) {
+      emitOperationalEvent(createWideEvent({ operation: 'record-trending-awards', outcome: 'binding-missing' }))
+      return { result: { error: 'no-db' } }
+    }
+
+    return await runObservedScheduledTask({
+      db,
+      env,
+      context,
+      policy: observedSchedulePolicy('record-trending-awards'),
+    }, async () => {
+      const startedAt = Date.now()
+      const written = await recordTrendingAwards(db, Math.floor(startedAt / 1000))
+      emitOperationalEvent(createWideEvent({
+        'operation': 'record-trending-awards',
+        'outcome': 'completed',
+        'success.count': written.length,
+      }))
+      await reportJobRun(db, 'record-trending-awards', {
+        cron: CRON,
+        status: 'ok',
+        durationMs: Date.now() - startedAt,
+      })
+      return { result: { written: written.length } }
+    })
+  },
+})
diff --git a/layers/registry/server/utils/trending-awards.ts b/layers/registry/server/utils/trending-awards.ts
new file mode 100644
index 00000000..24a636e1
--- /dev/null
+++ b/layers/registry/server/utils/trending-awards.ts
@@ -0,0 +1,126 @@
+/**
+ * Trending awards (ADR-0010). The rule and the labels live in
+ * `#shared/trending-award`. This file reads the boards and writes the table.
+ *
+ * Separate from `trending-admission.ts` on purpose. Admission is an SEO
+ * experiment with its own gate and cull path, and ending it must not end the
+ * awards. Both read the same board loader, so they agree on what trended.
+ */
+
+import type { TrendingAward, TrendingAwardBoard } from '#shared/trending-award'
+import type { SkillRef } from './trending-admission'
+import { loadTrendingBoard } from '#shared/server/trending-board'
+import { compareTrendingAwards, TRENDING_AWARD_BOARDS, trendingAwardPeriod } from '#shared/trending-award'
+import { TRENDING_BOARD_LIMIT, trendingRangeMeta } from '#shared/trending-range'
+import { admissionKey } from './trending-admission'
+
+export interface AwardSighting {
+  board: TrendingAwardBoard
+  rank: number
+  skill: SkillRef
+}
+
+export interface AwardWrite extends TrendingAward {
+  skill: SkillRef
+}
+
+function awardKey(skill: SkillRef, board: TrendingAwardBoard, period: string): string {
+  return `${admissionKey(skill)}/${board}/${period}`
+}
+
+/**
+ * Every evidenced row on the `week` and `month` boards, with its rank.
+ *
+ * Rank is the row's position on the board a reader sees. Named Skills come
+ * first there, so their index is their rank. Star filler sits below them and
+ * earns nothing; neither does a named row with no post and no surge.
+ */
+export async function loadAwardSightings(db: D1Database, now: number): Promise<AwardSighting[]> {
+  const sightings: AwardSighting[] = []
+  for (const board of TRENDING_AWARD_BOARDS) {
+    const windowHours = trendingRangeMeta(board).windowHours
+    if (windowHours === null)
+      continue
+    const { namedSkills } = await loadTrendingBoard({ db, now, limit: TRENDING_BOARD_LIMIT, windowHours })
+    namedSkills.forEach((entry, index) => {
+      const evidenced = entry.evidence !== null || (entry.github?.latestGain ?? null) !== null
+      if (evidenced)
+        sightings.push({ board, rank: index + 1, skill: { owner: entry.owner, repo: entry.repo, name: entry.slug } })
+    })
+  }
+  return sightings
+}
+
+/**
+ * The awards a run must write, given what it saw and what is already held.
+ *
+ * Pure. A write happens only for a new award or a better rank in the same
+ * period, so a replay or a quiet hour writes nothing, and a rank never worsens.
+ */
+export function planAwardWrites(
+  held: ReadonlyMap<string, number>,
+  sightings: readonly AwardSighting[],
+  now: number,
+): AwardWrite[] {
+  const planned = new Map<string, AwardWrite>()
+  for (const { board, rank, skill } of sightings) {
+    const period = trendingAwardPeriod(board, now)
+    const key = awardKey(skill, board, period)
+    const best = Math.min(held.get(key) ?? Infinity, planned.get(key)?.rank ?? Infinity)
+    if (rank < best)
+      planned.set(key, { skill, board, period, rank })
+  }
+  return [...planned.values()]
+}
+
+async function loadHeldRanks(db: D1Database, now: number): Promise<Map<string, number>> {
+  const periods = TRENDING_AWARD_BOARDS.map(board => trendingAwardPeriod(board, now))
+  const rows = (await db
+    .prepare(`SELECT owner, repo, name, board, period, best_rank FROM skill_trending_awards WHERE period IN (?1, ?2)`)
+    .bind(periods[0], periods[1])
+    .all<SkillRef & { board: TrendingAwardBoard, period: string, best_rank: number }>()).results ?? []
+  return new Map(rows.map(row => [awardKey(row, row.board, row.period), row.best_rank]))
+}
+
+/** Record this hour's board placements. Returns the awards it wrote. */
+export async function recordTrendingAwards(db: D1Database, now: number): Promise<AwardWrite[]> {
+  const [held, sightings] = await Promise.all([loadHeldRanks(db, now), loadAwardSightings(db, now)])
+  const writes = planAwardWrites(held, sightings, now)
+  if (writes.length === 0)
+    return []
+  await db.batch(writes.map(({ skill, board, period, rank }) => db
+    .prepare(`INSERT INTO skill_trending_awards (owner, repo, name, board, period, best_rank, ranked_at)
+              VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+              ON CONFLICT (owner, repo, name, board, period) DO UPDATE
+                SET best_rank = excluded.best_rank, ranked_at = excluded.ranked_at
+                WHERE excluded.best_rank < skill_trending_awards.best_rank`)
+    .bind(skill.owner, skill.repo, skill.name, board, period, rank, now)))
+  return writes
+}
+
+/**
+ * A `skills s` row's awards as one JSON column, `trending_awards`.
+ *
+ * A column on the Skill read rather than its own query: an uncached Skill
+ * page has a fixed D1 read budget (`skill-detail-d1-cost.test.ts`).
+ */
+export const SKILL_TRENDING_AWARDS_SQL = `(SELECT json_group_array(json_object('board', a.board, 'period', a.period, 'rank', a.best_rank))
+    FROM skill_trending_awards a
+    WHERE a.owner = s.owner AND a.repo = s.repo AND a.name = s.name) AS trending_awards`
+
+function isTrendingAward(value: unknown): value is TrendingAward {
+  if (!value || typeof value !== 'object')
+    return false
+  const { board, period, rank } = value as Record<string, unknown>
+  return (board === 'week' || board === 'month')
+    && typeof period === 'string'
+    && typeof rank === 'number' && Number.isInteger(rank) && rank >= 1
+}
+
+/** Parse the `trending_awards` column. Best award first. */
+export function parseSkillTrendingAwards(json: string | null): TrendingAward[] {
+  if (!json)
+    return []
+  const rows = JSON.parse(json) as unknown
+  return Array.isArray(rows) ? rows.filter(isTrendingAward).sort(compareTrendingAwards) : []
+}
diff --git a/migrations/0139_skill_trending_awards.sql b/migrations/0139_skill_trending_awards.sql
new file mode 100644
index 00000000..88d1406c
--- /dev/null
+++ b/migrations/0139_skill_trending_awards.sql
@@ -0,0 +1,21 @@
+-- Trending awards (ADR-0010). One row is the best rank a Skill reached on one
+-- trending board in one period. A row stays after the Skill leaves the board.
+--
+-- Only an evidenced board row earns one: a post that named the Skill, or a
+-- star surge on a repository holding exactly one Skill. Star filler never does.
+-- The hourly `record-trending-awards` task writes this table and nothing else.
+-- Cull path: drop the task, then `DROP TABLE skill_trending_awards`.
+CREATE TABLE IF NOT EXISTS skill_trending_awards (
+  owner TEXT NOT NULL,
+  repo TEXT NOT NULL,
+  name TEXT NOT NULL,
+  -- 'week' or 'month'. The 'all' range ranks by stars, so it awards nothing.
+  board TEXT NOT NULL CHECK (board IN ('week', 'month')),
+  -- 'YYYY-MM-DD' for the Monday (UTC) that starts a week, 'YYYY-MM' for a month.
+  period TEXT NOT NULL,
+  -- 1 is the first row on the board.
+  best_rank INTEGER NOT NULL CHECK (best_rank >= 1),
+  -- Unix seconds of the run that first saw `best_rank`.
+  ranked_at INTEGER NOT NULL,
+  PRIMARY KEY (owner, repo, name, board, period)
+) WITHOUT ROWID;
diff --git a/server/routes/b/[...slug].get.ts b/server/routes/b/[...slug].get.ts
index 39f3358f..5cec81c8 100644
--- a/server/routes/b/[...slug].get.ts
+++ b/server/routes/b/[...slug].get.ts
@@ -1,6 +1,6 @@
 import { createError, getQuery, getRouterParam } from 'h3'
 import { getDB } from '#server/utils/db'
-import { createSkillBadgeResponse, loadSkillBadgeLikeCount, parseSkillBadgeAppearance, parseSkillBadgeTarget } from '../../utils/skill-badge'
+import { createSkillBadgeResponse, loadSkillBadgeAward, loadSkillBadgeLikeCount, parseSkillBadgeAppearance, parseSkillBadgeTarget } from '../../utils/skill-badge'
 
 export default defineEventHandler(async (event) => {
   const target = parseSkillBadgeTarget(getRouterParam(event, 'slug') ?? '')
@@ -13,10 +13,16 @@ export default defineEventHandler(async (event) => {
 
   const query = getQuery(event)
   const appearance = parseSkillBadgeAppearance(query)
+  const wantsLikes = query.likes === '1'
+  const wantsAward = query.trending === '1'
 
-  if (query.likes !== '1')
+  if (!wantsLikes && !wantsAward)
     return createSkillBadgeResponse({ target, ...appearance })
 
-  const likeCount = await loadSkillBadgeLikeCount(getDB(event), target)
-  return createSkillBadgeResponse({ target, ...appearance, likeCount })
+  const db = getDB(event)
+  const [likeCount, award] = await Promise.all([
+    wantsLikes ? loadSkillBadgeLikeCount(db, target) : undefined,
+    wantsAward ? loadSkillBadgeAward(db, target) : undefined,
+  ])
+  return createSkillBadgeResponse({ target, ...appearance, likeCount, award })
 })
diff --git a/server/utils/skill-badge.ts b/server/utils/skill-badge.ts
index f119a069..11efe549 100644
--- a/server/utils/skill-badge.ts
+++ b/server/utils/skill-badge.ts
@@ -1,9 +1,15 @@
 /// <reference types="@cloudflare/workers-types" />
 
 import type { SkillBadgeTheme } from '../../shared/skill-badge'
+import type { TrendingAward } from '../../shared/trending-award'
+import { skillBadgeAwardTextWidth, skillBadgeAwardWidth } from '../../shared/skill-badge'
+import { headlineTrendingAward, trendingAwardBadgeLabel, trendingAwardLabel } from '../../shared/trending-award'
 
 const PLAIN_CACHE_POLICY = 'public, max-age=86400, stale-while-revalidate=604800'
 const LIKES_CACHE_POLICY = 'public, max-age=300, stale-while-revalidate=3600'
+// Awards change at most once an hour, when `record-trending-awards` runs.
+const AWARD_CACHE_POLICY = 'public, max-age=3600, stale-while-revalidate=86400'
+const AWARD_FILL = '#d7003f'
 
 export type SkillBadgeTarget
   = | { _tag: 'repository', owner: string, repo: string }
@@ -21,6 +27,8 @@ export interface SkillBadgeResponseInput {
   theme?: SkillBadgeTheme
   showLabel?: boolean
   likeCount?: number
+  /** Undefined when not asked for. Null when asked for and none was earned. */
+  award?: TrendingAward | null
 }
 
 export function parseSkillBadgeAppearance(query: { theme?: unknown, label?: unknown }): SkillBadgeAppearance {
@@ -58,6 +66,25 @@ export async function loadSkillBadgeLikeCount(db: D1Database, target: SkillBadge
   return row?.count ?? 0
 }
 
+/**
+ * The best trending award for a badge target. A repository badge takes the
+ * best award any of its Skills holds, as its like count sums their likes.
+ */
+export async function loadSkillBadgeAward(db: D1Database, target: SkillBadgeTarget): Promise<TrendingAward | null> {
+  const statement = target._tag === 'skill'
+    ? db.prepare(`SELECT board, period, best_rank AS rank
+        FROM skill_trending_awards
+        WHERE owner = ?1 COLLATE NOCASE
+          AND repo = ?2 COLLATE NOCASE
+          AND name = ?3 COLLATE NOCASE`).bind(target.owner, target.repo, target.name)
+    : db.prepare(`SELECT board, period, best_rank AS rank
+        FROM skill_trending_awards
+        WHERE owner = ?1 COLLATE NOCASE
+          AND repo = ?2 COLLATE NOCASE`).bind(target.owner, target.repo)
+  const rows = (await statement.all<TrendingAward>()).results ?? []
+  return headlineTrendingAward(rows)
+}
+
 function badgeLikeLabel(likeCount: number): string {
   return new Intl.NumberFormat('en-US', {
     notation: 'compact',
@@ -66,7 +93,7 @@ function badgeLikeLabel(likeCount: number): string {
 }
 
 function skillBadgeSvg(input: SkillBadgeResponseInput): string {
-  const { target, theme = 'light', likeCount } = input
+  const { target, theme = 'light', likeCount, award } = input
   const showLabel = input.showLabel !== false
   const safeLikeCount = likeCount === undefined ? null : Math.max(0, Math.floor(likeCount))
   const showLikes = safeLikeCount !== null
@@ -74,13 +101,18 @@ function skillBadgeSvg(input: SkillBadgeResponseInput): string {
   const likeWord = safeLikeCount === 1 ? 'like' : 'likes'
   const countWidth = showLikes ? Math.max(46, 25 + likeLabel.length * 7) : 0
   const badgeWidth = showLabel ? 153 : 81
-  const width = badgeWidth + countWidth
+  const awardLabel = award ? trendingAwardBadgeLabel(award) : ''
+  const awardWidth = award ? skillBadgeAwardWidth(awardLabel) : 0
+  const awardX = badgeWidth + countWidth
+  const width = awardX + awardWidth
   const brandX = showLabel ? 72 : 0
   const categoryLabel = target._tag === 'repository' ? 'Skill repo' : 'Agent skill'
   const targetLabel = target._tag === 'repository' ? 'Skill repository' : 'Agent skill'
-  const accessibleLabel = showLikes
-    ? `${targetLabel} on skilld.dev, ${safeLikeCount} ${likeWord}`
-    : `${targetLabel} on skilld.dev`
+  const accessibleLabel = [
+    `${targetLabel} on skilld.dev`,
+    showLikes ? `${safeLikeCount} ${likeWord}` : null,
+    award ? trendingAwardLabel(award) : null,
+  ].filter(Boolean).join(', ')
   const darkTheme = theme === 'dark'
   const categoryFill = darkTheme ? '#3f3833' : '#f5f5f4'
   const categoryText = darkTheme ? '#ffffff' : '#292524'
@@ -100,6 +132,19 @@ function skillBadgeSvg(input: SkillBadgeResponseInput): string {
     ? `
     <rect x="${badgeWidth}" width="${countWidth}" height="22" fill="${likesFill}"/>`
     : ''
+  const awardSegment = award
+    ? `
+    <rect x="${awardX}" width="${awardWidth}" height="22" fill="${AWARD_FILL}"/>`
+    : ''
+  // Lucide "award", stroked white so it reads on the rose fill in both themes.
+  const awardContent = award
+    ? `
+  <g fill="none" stroke="#ffffff" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" transform="translate(${awardX + 5} 4.4) scale(.55)">
+    <path d="m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526"/>
+    <circle cx="12" cy="8" r="6"/>
+  </g>
+  <text x="${awardX + 21}" y="15" fill="#ffffff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="${skillBadgeAwardTextWidth(awardLabel)}" lengthAdjust="spacingAndGlyphs">${awardLabel}</text>`
+    : ''
   const likesContent = showLikes
     ? `
   <path d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78a5.5 5.5 0 0 0 0-7.78Z" fill="none" stroke="#fb7185" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" transform="translate(${badgeWidth + 4} 3.5) scale(.55)"/>
@@ -111,17 +156,19 @@ function skillBadgeSvg(input: SkillBadgeResponseInput): string {
   <clipPath id="r"><rect width="${width}" height="22" rx="4"/></clipPath>
   <g clip-path="url(#r)">
     ${categorySegment}
-    <rect x="${brandX}" width="81" height="22" fill="${brandFill}"/>${likesSegment}
+    <rect x="${brandX}" width="81" height="22" fill="${brandFill}"/>${likesSegment}${awardSegment}
   </g>${categoryContent}
   <svg x="${brandX + 8.4}" y="6" width="12" height="12" viewBox="0 0 160 160" aria-hidden="true">
     <path d="M80 34 L135 104 L121 104 L80 52 L39 104 L25 104 Z" fill="#fb7185"/>
   </svg>
-  <text x="${brandX + 23.3}" y="15" fill="${brandText}" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="47.4" lengthAdjust="spacingAndGlyphs">skilld.dev</text>${likesContent}
+  <text x="${brandX + 23.3}" y="15" fill="${brandText}" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="47.4" lengthAdjust="spacingAndGlyphs">skilld.dev</text>${likesContent}${awardContent}
 </svg>`
 }
 
 export function createSkillBadgeResponse(input: SkillBadgeResponseInput): Response {
-  const cachePolicy = input.likeCount === undefined ? PLAIN_CACHE_POLICY : LIKES_CACHE_POLICY
+  const cachePolicy = input.likeCount !== undefined
+    ? LIKES_CACHE_POLICY
+    : input.award !== undefined ? AWARD_CACHE_POLICY : PLAIN_CACHE_POLICY
   return new Response(skillBadgeSvg(input), {
     status: 200,
     headers: {
diff --git a/shared/schedule-policy.ts b/shared/schedule-policy.ts
index 66d0d709..ca8fc79d 100644
--- a/shared/schedule-policy.ts
+++ b/shared/schedule-policy.ts
@@ -70,6 +70,7 @@ export const SCHEDULE_POLICY = [
   { _tag: 'observed', taskName: 'recompute-skill-scores', cron: '0 3 * * *', maxSilenceSeconds: 36 * 60 * 60, maxRuntimeSeconds: 60 * 60 },
   { _tag: 'observed', taskName: 'refresh-x-engagement', cron: '10 * * * *', maxSilenceSeconds: 3 * 60 * 60, maxRuntimeSeconds: 30 * 60 },
   { _tag: 'observed', taskName: 'reconcile-rendered', cron: '20 */6 * * *', maxSilenceSeconds: 15 * 60 * 60, maxRuntimeSeconds: 30 * 60 },
+  { _tag: 'observed', taskName: 'record-trending-awards', cron: '0 * * * *', maxSilenceSeconds: 3 * 60 * 60, maxRuntimeSeconds: 10 * 60 },
   // The watchdog rides whatever it re-invokes, so its runtime cap sits under
   // the cron invocation wall clock rather than under its siblings' ceilings.
   { _tag: 'observed', taskName: 'scheduled-cadence-watchdog', cron: '*/5 * * * *', maxSilenceSeconds: 20 * 60, maxRuntimeSeconds: 14 * 60 },
diff --git a/shared/skill-badge.ts b/shared/skill-badge.ts
index bf5dfda9..f0b28a0b 100644
--- a/shared/skill-badge.ts
+++ b/shared/skill-badge.ts
@@ -8,12 +8,38 @@ export interface SkillBadgeEmbedInput {
   siteUrl?: string
   showLikes?: boolean
   showLabel?: boolean
+  /** Add the best trending award. The badge stays plain while the Skill has none. */
+  showTrendingAward?: boolean
 }
 
 export type SkillBadgeTheme = 'light' | 'dark'
 
 const DEFAULT_SITE_URL = 'https://skilld.dev'
 
+/**
+ * Award text width, from Verdana advance widths at 10px. The SVG pins its text
+ * to this width, so the preview and the served badge always agree.
+ */
+export function skillBadgeAwardTextWidth(label: string): number {
+  let width = 0
+  for (const char of label) {
+    if (char === ' ' || char === '·')
+      width += 3.5
+    else if (char === '#')
+      width += 8.4
+    else if (/[A-Z]/.test(char))
+      width += 7
+    else
+      width += 6.1
+  }
+  return Math.round(width * 10) / 10
+}
+
+/** Width of the award segment: icon, gap, text, end padding. */
+export function skillBadgeAwardWidth(label: string): number {
+  return Math.ceil(21 + skillBadgeAwardTextWidth(label) + 7)
+}
+
 export function skillBadgeImagePath(input: SkillBadgeEmbedInput, theme?: SkillBadgeTheme): string {
   const repoPath = repoHubPath(input.owner, input.repo)
   const badgeSegments = input.registryPath === repoPath
@@ -23,6 +49,8 @@ export function skillBadgeImagePath(input: SkillBadgeEmbedInput, theme?: SkillBa
   const query = new URLSearchParams()
   if (input.showLikes)
     query.set('likes', '1')
+  if (input.showTrendingAward)
+    query.set('trending', '1')
   if (theme)
     query.set('theme', theme)
   if (input.showLabel === false)
diff --git a/shared/trending-award.ts b/shared/trending-award.ts
new file mode 100644
index 00000000..567297d5
--- /dev/null
+++ b/shared/trending-award.ts
@@ -0,0 +1,98 @@
+/**
+ * Trending awards (ADR-0010): the best rank a Skill reached on one trending
+ * board in one period, kept after the Skill leaves the board.
+ *
+ * The award repeats a claim the board already made in public, so it inherits
+ * the board's evidence rule. Only a row with a post or a star surge behind it
+ * earns one. Star filler never does, and the `all` range awards nothing,
+ * because it ranks by lifetime stars rather than by anyone talking.
+ *
+ * Pure, so the Skill page, the README badge, and the recording task share one
+ * reading of a period and one label.
+ */
+
+import { formatBoardDay } from './trending-range'
+
+export type TrendingAwardBoard = 'week' | 'month'
+
+export const TRENDING_AWARD_BOARDS: readonly TrendingAwardBoard[] = ['week', 'month']
+
+export interface TrendingAward {
+  board: TrendingAwardBoard
+  /** `YYYY-MM-DD` for the Monday (UTC) that starts a week, `YYYY-MM` for a month. */
+  period: string
+  /** Best rank in the period. 1 is the first row on the board. */
+  rank: number
+}
+
+const DAY_SECONDS = 86_400
+
+/**
+ * The period a board sighting at `nowSeconds` counts toward.
+ *
+ * Calendar periods in UTC, not the board's rolling window. A rolling window
+ * has no name a reader can check, and an award needs one.
+ */
+export function trendingAwardPeriod(board: TrendingAwardBoard, nowSeconds: number): string {
+  const date = new Date(nowSeconds * 1000)
+  if (board === 'month')
+    return date.toISOString().slice(0, 7)
+  // getUTCDay: Sunday is 0. ISO weeks start on Monday.
+  const sinceMonday = (date.getUTCDay() + 6) % 7
+  const midnight = Math.floor(nowSeconds / DAY_SECONDS) * DAY_SECONDS
+  return new Date((midnight - sinceMonday * DAY_SECONDS) * 1000).toISOString().slice(0, 10)
+}
+
+/** `week of 29 Sep 2026` or `September 2026`. */
+export function trendingAwardPeriodLabel(award: Pick<TrendingAward, 'board' | 'period'>): string {
+  if (award.board === 'week') {
+    const day = formatBoardDay(Date.parse(`${award.period}T00:00:00Z`) / 1000)
+    return `week of ${day}`
+  }
+  return new Intl.DateTimeFormat('en', { month: 'long', year: 'numeric', timeZone: 'UTC' })
+    .format(Date.parse(`${award.period}-01T00:00:00Z`))
+}
+
+/**
+ * The chip and README badge text: `#3 trending · Sep 2026`.
+ *
+ * Always dated. A badge outlives the board, and an undated rank reads as
+ * current months later. The month of a week award is the month it started in.
+ */
+export function trendingAwardBadgeLabel(award: TrendingAward): string {
+  const month = new Intl.DateTimeFormat('en', { month: 'short', year: 'numeric', timeZone: 'UTC' })
+    .format(Date.parse(`${award.period.slice(0, 7)}-01T00:00:00Z`))
+  return `#${award.rank} trending · ${month}`
+}
+
+/** The full claim: `#3 trending, week of 29 Sep 2026`. */
+export function trendingAwardLabel(award: TrendingAward): string {
+  return `#${award.rank} trending, ${trendingAwardPeriodLabel(award)}`
+}
+
+/** The board range that awarded it. */
+export function trendingAwardPath(award: Pick<TrendingAward, 'board'>): string {
+  return award.board === 'week' ? '/skills/trending?range=week' : '/skills/trending'
+}
+
+/**
+ * The one award a Skill leads with: best rank first, then the month board,
+ * which takes thirty days of attention to top, then the newest period.
+ */
+export function headlineTrendingAward(awards: readonly TrendingAward[]): TrendingAward | null {
+  let best: TrendingAward | null = null
+  for (const award of awards) {
+    if (!best || compareTrendingAwards(award, best) < 0)
+      best = award
+  }
+  return best
+}
+
+/** Sort order for a list of awards. The headline award sorts first. */
+export function compareTrendingAwards(left: TrendingAward, right: TrendingAward): number {
+  if (left.rank !== right.rank)
+    return left.rank - right.rank
+  if (left.board !== right.board)
+    return left.board === 'month' ? -1 : 1
+  return right.period.localeCompare(left.period)
+}
diff --git a/test/unit/badge-embed-control.test.ts b/test/unit/badge-embed-control.test.ts
index 025b7257..dbd04759 100644
--- a/test/unit/badge-embed-control.test.ts
+++ b/test/unit/badge-embed-control.test.ts
@@ -23,9 +23,9 @@ const input = {
   registryPath: '/gh/antfu/skills/vite',
 }
 
-async function mountControl() {
+async function mountControl(extra: { trendingAward?: { board: 'week' | 'month', period: string, rank: number } } = {}) {
   return await mountSuspended(BadgeEmbedControl, {
-    props: input,
+    props: { ...input, ...extra },
     global: {
       stubs: {
         UModal: ModalStub,
@@ -77,4 +77,21 @@ describe('readme badge editor', () => {
     }))
     wrapper.unmount()
   })
+
+  it('offers the award only when the Skill holds one, and starts with it on', async () => {
+    const plain = await mountControl()
+    await plain.get('button[aria-label="Configure README badge"]').trigger('click')
+    expect(plain.findAll('button').some(button => button.text().includes('With award'))).toBe(false)
+    plain.unmount()
+
+    const wrapper = await mountControl({ trendingAward: { board: 'month', period: '2026-09', rank: 2 } })
+    await wrapper.get('button[aria-label="Configure README badge"]').trigger('click')
+    expect(wrapper.text()).toContain('Add #2 trending, September 2026.')
+    expect(wrapper.get('[data-testid="badge-preview"]').attributes('src')).toBe('/b/antfu/skills/vite?trending=1&theme=light')
+
+    const awardGroup = wrapper.get('[aria-label="Badge trending award"]')
+    await awardGroup.findAll('button').find(button => button.text() === 'Plain')!.trigger('click')
+    expect(wrapper.get('[data-testid="badge-preview"]').attributes('src')).toBe('/b/antfu/skills/vite?theme=light')
+    wrapper.unmount()
+  })
 })
diff --git a/test/unit/trending-awards.test.ts b/test/unit/trending-awards.test.ts
new file mode 100644
index 00000000..e6e82518
--- /dev/null
+++ b/test/unit/trending-awards.test.ts
@@ -0,0 +1,223 @@
+// @vitest-environment node
+import type { SqliteD1 } from './helpers/d1-sqlite'
+import { afterEach, describe, expect, it } from 'vitest'
+import { parseSkillTrendingAwards, planAwardWrites, recordTrendingAwards, SKILL_TRENDING_AWARDS_SQL } from '../../layers/registry/server/utils/trending-awards'
+import { createSkillBadgeResponse, loadSkillBadgeAward } from '../../server/utils/skill-badge'
+import { skillBadgeImagePath } from '../../shared/skill-badge'
+import {
+  headlineTrendingAward,
+  trendingAwardBadgeLabel,
+  trendingAwardLabel,
+  trendingAwardPeriod,
+} from '../../shared/trending-award'
+import { allMigrations, createSqliteD1 } from './helpers/d1-sqlite'
+
+// Wednesday 1 Oct 2026, 12:00 UTC.
+const NOW = Date.UTC(2026, 9, 1, 12) / 1000
+const DAY = 86_400
+
+let harness: SqliteD1 | null = null
+function db() {
+  harness ??= createSqliteD1(allMigrations())
+  return harness
+}
+afterEach(() => {
+  harness?.close()
+  harness = null
+})
+
+function addSkill(input: { owner: string, repo: string, name: string, stars?: number }) {
+  db().raw.prepare(`INSERT OR IGNORE INTO repos (owner, repo, stars, repo_kind) VALUES (?, ?, ?, 'creator')`).run(input.owner, input.repo, input.stars ?? 10)
+  db().raw.prepare(
+    `INSERT INTO skills (owner, repo, name, slug, display_name, source_resolved, seo_indexable, description, rendered_skill_path)
+     VALUES (?, ?, ?, ?, ?, 1, 1, 'd', ?)`,
+  ).run(input.owner, input.repo, input.name, `${input.owner}/${input.name}`, input.name, `${input.name}/SKILL.md`)
+}
+
+function mention(input: { owner: string, repo: string, name: string, handle: string, at: number }) {
+  const id = `p-${input.handle}-${input.name}-${input.at}`
+  db().raw.prepare(
+    `INSERT INTO x_posts (
+       post_id, author_id, author_handle, author_name, author_followers,
+       text_extract, lang, posted_at, first_seen_at,
+       favourite_count, repost_count, reply_count, quote_count,
+       bookmark_count, impression_count, metrics_updated_at,
+       refresh_tier, next_refresh_at, author_avatar
+     ) VALUES (?, ?, ?, NULL, 0, 'post', 'en', ?, ?, 5, 0, 0, 0, 0, 0, ?, 'hot', ?, NULL)`,
+  ).run(id, `a-${input.handle}`, input.handle, input.at, input.at, input.at, input.at + 3600)
+  db().raw.prepare(
+    `INSERT INTO x_post_skills (post_id, owner, repo, slug, canonical_name, skill_path, detection, matched_on, verified_at)
+     VALUES (?, ?, ?, ?, ?, 'SKILL.md', 'slash', 'directory', ?)`,
+  ).run(id, input.owner, input.repo, input.name, input.name, NOW)
+}
+
+/** A Skill's awards, read the way the Skill page reads them. */
+function skillAwards(skill: { owner: string, repo: string, name: string }) {
+  const row = db().raw.prepare(`SELECT ${SKILL_TRENDING_AWARDS_SQL} FROM skills s WHERE s.owner = ? AND s.repo = ? AND s.name = ?`).get(skill.owner, skill.repo, skill.name) as { trending_awards: string | null }
+  return parseSkillTrendingAwards(row.trending_awards)
+}
+
+function awardRows() {
+  return db().raw.prepare('SELECT owner, repo, name, board, period, best_rank FROM skill_trending_awards ORDER BY board, best_rank').all()
+}
+
+describe('trendingAwardPeriod', () => {
+  it('keys a week by the Monday that starts it, in UTC', () => {
+    expect(trendingAwardPeriod('week', NOW)).toBe('2026-09-28')
+    expect(trendingAwardPeriod('week', Date.UTC(2026, 8, 28) / 1000)).toBe('2026-09-28')
+    // Sunday 23:59 still belongs to the week that started six days earlier.
+    expect(trendingAwardPeriod('week', Date.UTC(2026, 9, 4, 23, 59) / 1000)).toBe('2026-09-28')
+    expect(trendingAwardPeriod('week', Date.UTC(2026, 9, 5) / 1000)).toBe('2026-10-05')
+  })
+
+  it('keys a month by its calendar month', () => {
+    expect(trendingAwardPeriod('month', NOW)).toBe('2026-10')
+    expect(trendingAwardPeriod('month', Date.UTC(2026, 8, 30, 23, 59) / 1000)).toBe('2026-09')
+  })
+})
+
+describe('award labels', () => {
+  it('dates every label, so an old award never reads as current', () => {
+    expect(trendingAwardBadgeLabel({ board: 'week', period: '2026-09-28', rank: 3 })).toBe('#3 trending · Sep 2026')
+    expect(trendingAwardBadgeLabel({ board: 'month', period: '2026-10', rank: 1 })).toBe('#1 trending · Oct 2026')
+    expect(trendingAwardLabel({ board: 'week', period: '2026-09-28', rank: 3 })).toMatch(/^#3 trending, week of 28 Sept? 2026$/)
+    expect(trendingAwardLabel({ board: 'month', period: '2026-10', rank: 1 })).toBe('#1 trending, October 2026')
+  })
+})
+
+describe('headlineTrendingAward', () => {
+  it('leads with the best rank, then the month board, then the newest period', () => {
+    const weekTwo = { board: 'week' as const, period: '2026-09-28', rank: 2 }
+    const monthTwo = { board: 'month' as const, period: '2026-09', rank: 2 }
+    const newerMonthTwo = { board: 'month' as const, period: '2026-10', rank: 2 }
+    const weekFive = { board: 'week' as const, period: '2026-10-05', rank: 5 }
+
+    expect(headlineTrendingAward([])).toBeNull()
+    expect(headlineTrendingAward([weekFive, weekTwo])).toEqual(weekTwo)
+    expect(headlineTrendingAward([weekTwo, monthTwo])).toEqual(monthTwo)
+    expect(headlineTrendingAward([monthTwo, newerMonthTwo, weekFive])).toEqual(newerMonthTwo)
+  })
+})
+
+describe('planAwardWrites', () => {
+  const skill = { owner: 'o', repo: 'r', name: 'a' }
+
+  it('writes a new award and keeps the best rank seen in one run', () => {
+    expect(planAwardWrites(new Map(), [
+      { board: 'week', rank: 4, skill },
+      { board: 'week', rank: 2, skill },
+      { board: 'month', rank: 7, skill },
+    ], NOW)).toEqual([
+      { skill, board: 'week', period: '2026-09-28', rank: 2 },
+      { skill, board: 'month', period: '2026-10', rank: 7 },
+    ])
+  })
+
+  it('writes only a better rank than the one held for the period', () => {
+    const held = new Map([['o/r/a/week/2026-09-28', 3]])
+    expect(planAwardWrites(held, [{ board: 'week', rank: 5, skill }], NOW)).toEqual([])
+    expect(planAwardWrites(held, [{ board: 'week', rank: 3, skill }], NOW)).toEqual([])
+    expect(planAwardWrites(held, [{ board: 'week', rank: 1, skill }], NOW)).toEqual([
+      { skill, board: 'week', period: '2026-09-28', rank: 1 },
+    ])
+  })
+})
+
+describe('recordTrendingAwards', () => {
+  it('awards evidenced rows by board position and keeps the award after they leave', async () => {
+    addSkill({ owner: 'anthropics', repo: 'skills', name: 'frontend-design' })
+    addSkill({ owner: 'emil', repo: 'skills', name: 'animate' })
+    mention({ owner: 'anthropics', repo: 'skills', name: 'frontend-design', handle: 'h1', at: NOW - 3600 })
+    mention({ owner: 'anthropics', repo: 'skills', name: 'frontend-design', handle: 'h2', at: NOW - 3600 })
+    mention({ owner: 'emil', repo: 'skills', name: 'animate', handle: 'h3', at: NOW - 3600 })
+
+    const written = await recordTrendingAwards(db().db, NOW)
+    expect(written).toHaveLength(4)
+    expect(awardRows()).toEqual([
+      { owner: 'anthropics', repo: 'skills', name: 'frontend-design', board: 'month', period: '2026-10', best_rank: 1 },
+      { owner: 'emil', repo: 'skills', name: 'animate', board: 'month', period: '2026-10', best_rank: 2 },
+      { owner: 'anthropics', repo: 'skills', name: 'frontend-design', board: 'week', period: '2026-09-28', best_rank: 1 },
+      { owner: 'emil', repo: 'skills', name: 'animate', board: 'week', period: '2026-09-28', best_rank: 2 },
+    ])
+
+    // A replay in the same hour writes nothing.
+    expect(await recordTrendingAwards(db().db, NOW + 60)).toEqual([])
+
+    // Sixty days later every mention is outside both windows.
+    expect(await recordTrendingAwards(db().db, NOW + 60 * DAY)).toEqual([])
+    expect(skillAwards({ owner: 'emil', repo: 'skills', name: 'animate' })).toEqual([
+      { board: 'month', period: '2026-10', rank: 2 },
+      { board: 'week', period: '2026-09-28', rank: 2 },
+    ])
+  })
+
+  it('never worsens a rank the period already holds', async () => {
+    addSkill({ owner: 'a', repo: 'one', name: 'first' })
+    addSkill({ owner: 'b', repo: 'two', name: 'second' })
+    mention({ owner: 'a', repo: 'one', name: 'first', handle: 'h1', at: NOW - 3600 })
+    await recordTrendingAwards(db().db, NOW)
+
+    // Two later posts push `second` above `first` within the same week.
+    mention({ owner: 'b', repo: 'two', name: 'second', handle: 'h2', at: NOW + 3600 })
+    mention({ owner: 'b', repo: 'two', name: 'second', handle: 'h3', at: NOW + 3600 })
+    await recordTrendingAwards(db().db, NOW + 2 * 3600)
+
+    const weekRank = (owner: string, repo: string, name: string) =>
+      skillAwards({ owner, repo, name }).find(award => award.board === 'week')?.rank
+    expect(weekRank('b', 'two', 'second')).toBe(1)
+    expect(weekRank('a', 'one', 'first')).toBe(1)
+  })
+
+  it('gives star filler no award', async () => {
+    addSkill({ owner: 'quiet', repo: 'repo', name: 'starred', stars: 50_000 })
+    await recordTrendingAwards(db().db, NOW)
+    expect(awardRows()).toEqual([])
+  })
+})
+
+describe('rEADME badge award', () => {
+  it('asks for the award only when requested', () => {
+    const input = { owner: 'emil', repo: 'skills', name: 'animate', registryPath: '/gh/emil/skills/animate' }
+    expect(skillBadgeImagePath(input, 'light')).toBe('/b/emil/skills/animate?theme=light')
+    expect(skillBadgeImagePath({ ...input, showTrendingAward: true }, 'light')).toBe('/b/emil/skills/animate?trending=1&theme=light')
+  })
+
+  it('shows the best award a Skill or its repository holds', async () => {
+    addSkill({ owner: 'emil', repo: 'skills', name: 'animate' })
+    addSkill({ owner: 'emil', repo: 'skills', name: 'review' })
+    const insert = db().raw.prepare(`INSERT INTO skill_trending_awards (owner, repo, name, board, period, best_rank, ranked_at) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+    insert.run('emil', 'skills', 'animate', 'week', '2026-09-28', 4, NOW)
+    insert.run('emil', 'skills', 'review', 'month', '2026-09', 2, NOW)
+
+    const skillAward = await loadSkillBadgeAward(db().db, { _tag: 'skill', owner: 'Emil', repo: 'skills', name: 'animate' })
+    expect(skillAward).toEqual({ board: 'week', period: '2026-09-28', rank: 4 })
+    const repoAward = await loadSkillBadgeAward(db().db, { _tag: 'repository', owner: 'emil', repo: 'skills' })
+    expect(repoAward).toEqual({ board: 'month', period: '2026-09', rank: 2 })
+    expect(await loadSkillBadgeAward(db().db, { _tag: 'skill', owner: 'emil', repo: 'skills', name: 'none' })).toBeNull()
+  })
+
+  it('renders the dated award segment and refreshes hourly', async () => {
+    const response = createSkillBadgeResponse({
+      target: { _tag: 'skill', owner: 'emil', repo: 'skills', name: 'animate' },
+      theme: 'light',
+      award: { board: 'week', period: '2026-09-28', rank: 3 },
+    })
+
+    expect(response.headers.get('cache-control')).toBe('public, max-age=3600, stale-while-revalidate=86400')
+    const svg = await response.text()
+    expect(svg).toMatch(/<title>Agent skill on skilld\.dev, #3 trending, week of 28 Sept? 2026<\/title>/)
+    expect(svg).toContain('>#3 trending · Sep 2026<')
+  })
+
+  it('stays plain, and still refreshes hourly, while the Skill has no award', async () => {
+    const response = createSkillBadgeResponse({
+      target: { _tag: 'skill', owner: 'emil', repo: 'skills', name: 'animate' },
+      award: null,
+    })
+
+    expect(response.headers.get('cache-control')).toBe('public, max-age=3600, stale-while-revalidate=86400')
+    const svg = await response.text()
+    expect(svg).toContain('<title>Agent skill on skilld.dev</title>')
+    expect(svg).toContain('width="153" height="22"')
+  })
+})

From a824cce87fc35f09785e01b13931a06c4a23dc5d Mon Sep 17 00:00:00 2001
From: Harlan Wilton <harlan@harlanzw.com>
Date: Tue, 6 Oct 2026 03:42:49 +1100
Subject: [PATCH 2/4] fix(trending): mark awards with the trending spark and
 index lookups

DESIGN.md now marks trending with the braille spark, so the chip and
the README badge use it instead of a lucide icon. The badge matches
owner and repo case-insensitively, which the binary primary key cannot
serve, so the migration adds a NOCASE index.
---
 .../registry/app/components/SkillDetail.vue   |  6 +----
 migrations/0139_skill_trending_awards.sql     |  5 ++++
 server/utils/skill-badge.ts                   | 24 ++++++++++++++-----
 shared/skill-badge.ts                         |  4 ++--
 4 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/layers/registry/app/components/SkillDetail.vue b/layers/registry/app/components/SkillDetail.vue
index 48b62955..081d0c6d 100644
--- a/layers/registry/app/components/SkillDetail.vue
+++ b/layers/registry/app/components/SkillDetail.vue
@@ -1419,11 +1419,7 @@ useHead(computed(() => ({
                   :aria-label="trendingAwardLabel(trendingAward)"
                   :title="trendingAwardLabel(trendingAward)"
                 >
-                  <UIcon
-                    name="i-lucide-award"
-                    class="size-3.5"
-                    aria-hidden="true"
-                  />
+                  <TrendingMark />
                   {{ trendingAwardBadgeLabel(trendingAward) }}
                 </NuxtLink>
               </div>
diff --git a/migrations/0139_skill_trending_awards.sql b/migrations/0139_skill_trending_awards.sql
index 88d1406c..83f6a6c1 100644
--- a/migrations/0139_skill_trending_awards.sql
+++ b/migrations/0139_skill_trending_awards.sql
@@ -19,3 +19,8 @@ CREATE TABLE IF NOT EXISTS skill_trending_awards (
   ranked_at INTEGER NOT NULL,
   PRIMARY KEY (owner, repo, name, board, period)
 ) WITHOUT ROWID;
+
+-- The README badge matches owner and repo case-insensitively, as GitHub does.
+-- The primary key is binary, so that lookup needs its own index.
+CREATE INDEX IF NOT EXISTS idx_skill_trending_awards_repo_nocase
+  ON skill_trending_awards (owner COLLATE NOCASE, repo COLLATE NOCASE);
diff --git a/server/utils/skill-badge.ts b/server/utils/skill-badge.ts
index 11efe549..00fe10a5 100644
--- a/server/utils/skill-badge.ts
+++ b/server/utils/skill-badge.ts
@@ -85,6 +85,21 @@ export async function loadSkillBadgeAward(db: D1Database, target: SkillBadgeTarg
   return headlineTrendingAward(rows)
 }
 
+/**
+ * The trending mark (`⣤⣶⣿`, see `TrendingMark.vue`) drawn as dots. A badge
+ * renders in GitHub's image proxy, where no font is sure to carry braille.
+ */
+function trendingMarkDots(x: number): string {
+  const dots: string[] = []
+  for (const [cell, level] of [2, 3, 4].entries()) {
+    for (let row = 0; row < level; row++) {
+      for (const column of [0, 2.2])
+        dots.push(`<circle cx="${Math.round((x + cell * 5.6 + column) * 10) / 10}" cy="${Math.round((15.4 - row * 2.2) * 10) / 10}" r="0.85"/>`)
+    }
+  }
+  return dots.join('')
+}
+
 function badgeLikeLabel(likeCount: number): string {
   return new Intl.NumberFormat('en-US', {
     notation: 'compact',
@@ -136,14 +151,11 @@ function skillBadgeSvg(input: SkillBadgeResponseInput): string {
     ? `
     <rect x="${awardX}" width="${awardWidth}" height="22" fill="${AWARD_FILL}"/>`
     : ''
-  // Lucide "award", stroked white so it reads on the rose fill in both themes.
+  // White on the rose fill, so the newest bar spends no second rose.
   const awardContent = award
     ? `
-  <g fill="none" stroke="#ffffff" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" transform="translate(${awardX + 5} 4.4) scale(.55)">
-    <path d="m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526"/>
-    <circle cx="12" cy="8" r="6"/>
-  </g>
-  <text x="${awardX + 21}" y="15" fill="#ffffff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="${skillBadgeAwardTextWidth(awardLabel)}" lengthAdjust="spacingAndGlyphs">${awardLabel}</text>`
+  <g fill="#ffffff" aria-hidden="true">${trendingMarkDots(awardX + 7)}</g>
+  <text x="${awardX + 24}" y="15" fill="#ffffff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="${skillBadgeAwardTextWidth(awardLabel)}" lengthAdjust="spacingAndGlyphs">${awardLabel}</text>`
     : ''
   const likesContent = showLikes
     ? `
diff --git a/shared/skill-badge.ts b/shared/skill-badge.ts
index f0b28a0b..346af0f0 100644
--- a/shared/skill-badge.ts
+++ b/shared/skill-badge.ts
@@ -35,9 +35,9 @@ export function skillBadgeAwardTextWidth(label: string): number {
   return Math.round(width * 10) / 10
 }
 
-/** Width of the award segment: icon, gap, text, end padding. */
+/** Width of the award segment: spark, gap, text, end padding. */
 export function skillBadgeAwardWidth(label: string): number {
-  return Math.ceil(21 + skillBadgeAwardTextWidth(label) + 7)
+  return Math.ceil(24 + skillBadgeAwardTextWidth(label) + 7)
 }
 
 export function skillBadgeImagePath(input: SkillBadgeEmbedInput, theme?: SkillBadgeTheme): string {

From c4a5a6b7bfb4c7c0b8dd80e46633ae86f94ce291 Mon Sep 17 00:00:00 2001
From: Harlan Wilton <harlan@harlanzw.com>
Date: Tue, 6 Oct 2026 03:44:43 +1100
Subject: [PATCH 3/4] fix(trending): draw all four spark cells on the README
 badge

---
 server/utils/skill-badge.ts | 6 +++---
 shared/skill-badge.ts       | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/server/utils/skill-badge.ts b/server/utils/skill-badge.ts
index 00fe10a5..dcfb5402 100644
--- a/server/utils/skill-badge.ts
+++ b/server/utils/skill-badge.ts
@@ -86,12 +86,12 @@ export async function loadSkillBadgeAward(db: D1Database, target: SkillBadgeTarg
 }
 
 /**
- * The trending mark (`⣤⣶⣿`, see `TrendingMark.vue`) drawn as dots. A badge
+ * The trending mark (`⣀⣤⣶⣿`, see `TrendingMark.vue`) drawn as dots. A badge
  * renders in GitHub's image proxy, where no font is sure to carry braille.
  */
 function trendingMarkDots(x: number): string {
   const dots: string[] = []
-  for (const [cell, level] of [2, 3, 4].entries()) {
+  for (const [cell, level] of [1, 2, 3, 4].entries()) {
     for (let row = 0; row < level; row++) {
       for (const column of [0, 2.2])
         dots.push(`<circle cx="${Math.round((x + cell * 5.6 + column) * 10) / 10}" cy="${Math.round((15.4 - row * 2.2) * 10) / 10}" r="0.85"/>`)
@@ -155,7 +155,7 @@ function skillBadgeSvg(input: SkillBadgeResponseInput): string {
   const awardContent = award
     ? `
   <g fill="#ffffff" aria-hidden="true">${trendingMarkDots(awardX + 7)}</g>
-  <text x="${awardX + 24}" y="15" fill="#ffffff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="${skillBadgeAwardTextWidth(awardLabel)}" lengthAdjust="spacingAndGlyphs">${awardLabel}</text>`
+  <text x="${awardX + 30}" y="15" fill="#ffffff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="10" textLength="${skillBadgeAwardTextWidth(awardLabel)}" lengthAdjust="spacingAndGlyphs">${awardLabel}</text>`
     : ''
   const likesContent = showLikes
     ? `
diff --git a/shared/skill-badge.ts b/shared/skill-badge.ts
index 346af0f0..7b803dd8 100644
--- a/shared/skill-badge.ts
+++ b/shared/skill-badge.ts
@@ -37,7 +37,7 @@ export function skillBadgeAwardTextWidth(label: string): number {
 
 /** Width of the award segment: spark, gap, text, end padding. */
 export function skillBadgeAwardWidth(label: string): number {
-  return Math.ceil(24 + skillBadgeAwardTextWidth(label) + 7)
+  return Math.ceil(30 + skillBadgeAwardTextWidth(label) + 7)
 }
 
 export function skillBadgeImagePath(input: SkillBadgeEmbedInput, theme?: SkillBadgeTheme): string {

From bcd87e331b074dc2abe5378260f27842f0881ed5 Mon Sep 17 00:00:00 2001
From: Harlan Wilton <harlan@harlanzw.com>
Date: Tue, 6 Oct 2026 15:09:53 +1100
Subject: [PATCH 4/4] fix(trending): move awards migration past main migrations

---
 ...9_skill_trending_awards.sql => 0141_skill_trending_awards.sql} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename migrations/{0139_skill_trending_awards.sql => 0141_skill_trending_awards.sql} (100%)

diff --git a/migrations/0139_skill_trending_awards.sql b/migrations/0141_skill_trending_awards.sql
similarity index 100%
rename from migrations/0139_skill_trending_awards.sql
rename to migrations/0141_skill_trending_awards.sql