diff --git a/docs/process-hardening.md b/docs/process-hardening.md
index 58fdb831b6..01b8aa4672 100644
--- a/docs/process-hardening.md
+++ b/docs/process-hardening.md
@@ -89,6 +89,7 @@ For each: trace which module-scope helpers/icons/types it uses; move solely-cons
 - **Known follow-up debts (documented, not actioned):**
   - Live migration history has duplicate-version churn (two each of `api_rate_limits`, `audit_logs`, `rag_queries_retention`, `audit_logs_service_role_policy`, `indexing_reliability_recovery`) from the same raw-apply habit. Do not rewrite history; treat as a caution for future applies.
   - Auth server is capped at 10 absolute DB connections (Supabase advisor); switch to percentage-based allocation in the dashboard before scaling instance size (not settable via SQL/MCP).
+  - `storage_cleanup_jobs` live indexes drifted from `supabase/schema.sql`: live carries legacy auto-names (`storage_cleanup_jobs_document_id_idx`, `storage_cleanup_jobs_owner_id_idx`, a non-partial `storage_cleanup_jobs_status_created_idx`) that the hardening defs superseded. Migration `20260703030000_reconcile_storage_cleanup_jobs_indexes` is **prepared but NOT applied** — it drops the legacy names and (re)creates the intended named/partial indexes to match schema.sql. Functional-not-broken (the document_id FK is covered), so apply to live only with explicit approval. `20260703000000`/`010000` are also absent from live `schema_migrations` and will self-heal on the next `supabase db push`.
 
 ## PR merge gate: tiered CI + required checks (2026-07-02)
 
diff --git a/scripts/seed-registry-records.ts b/scripts/seed-registry-records.ts
index c4468b6f16..c0e5c3acc4 100644
--- a/scripts/seed-registry-records.ts
+++ b/scripts/seed-registry-records.ts
@@ -1,9 +1,8 @@
 import { loadEnvConfig } from "@next/env";
 
 import { confirm } from "./cli-utils";
-import { recordToRow, type RegistryRecordKind } from "@/lib/registry-records";
-import { serviceRecords } from "@/lib/services";
-import { formRecords } from "@/lib/forms";
+import { type RegistryRecordKind } from "@/lib/registry-records";
+import { buildDefaultRegistryRows, defaultRegistryRecords } from "@/lib/registry-seed";
 import type { ServiceRecord } from "@/lib/services";
 
 loadEnvConfig(process.cwd());
@@ -59,10 +58,8 @@ function parseArgs(argv: string[]): SeedArgs {
 }
 
 function seedSets(kind: SeedArgs["kind"]): Array<{ kind: RegistryRecordKind; records: ServiceRecord[] }> {
-  const sets: Array<{ kind: RegistryRecordKind; records: ServiceRecord[] }> = [];
-  if (kind === "service" || kind === "all") sets.push({ kind: "service", records: serviceRecords });
-  if (kind === "form" || kind === "all") sets.push({ kind: "form", records: formRecords });
-  return sets;
+  const kinds: RegistryRecordKind[] = kind === "all" ? ["service", "form"] : [kind];
+  return kinds.map((seedKind) => ({ kind: seedKind, records: defaultRegistryRecords(seedKind) }));
 }
 
 async function main() {
@@ -72,7 +69,7 @@ async function main() {
   }
 
   const sets = seedSets(args.kind);
-  const rows = sets.flatMap((set) => set.records.map((record) => recordToRow(record, args.ownerId!, set.kind)));
+  const rows = sets.flatMap((set) => buildDefaultRegistryRows(args.ownerId!, set.kind));
 
   console.log(`[registry:seed] owner ${args.ownerId}`);
   for (const row of rows) {
diff --git a/src/app/api/registry/records/[slug]/route.ts b/src/app/api/registry/records/[slug]/route.ts
index c9d8aad733..b095ae26f2 100644
--- a/src/app/api/registry/records/[slug]/route.ts
+++ b/src/app/api/registry/records/[slug]/route.ts
@@ -12,6 +12,7 @@ import {
   rowToServiceRecord,
   type RegistryRecordRow,
 } from "@/lib/registry-records";
+import { ensureRegistrySeeded } from "@/lib/registry-seed";
 import { getServiceRecord } from "@/lib/services";
 import { createAdminClient } from "@/lib/supabase/admin";
 import { AuthenticationError, requireAuthenticatedUser, unauthorizedResponse } from "@/lib/supabase/auth";
@@ -65,17 +66,42 @@ export async function GET(request: Request, context: { params: Promise<{ slug: s
       return rateLimitJsonResponse("Registry requests are rate limited. Try again shortly.", rateLimit);
     }
 
-    const { data, error } = await supabase
-      .from("clinical_registry_records")
-      .select("*")
-      .eq("owner_id", user.id)
-      .eq("kind", kind)
-      .eq("slug", normalizedSlug)
-      .maybeSingle();
-    if (error) throw new Error(error.message);
-    if (!data) return notFoundResponse(normalizedSlug);
+    const fetchRecord = async () => {
+      const { data, error } = await supabase
+        .from("clinical_registry_records")
+        .select("*")
+        .eq("owner_id", user.id)
+        .eq("kind", kind)
+        .eq("slug", normalizedSlug)
+        .maybeSingle();
+      if (error) throw new Error(error.message);
+      return (data as RegistryRecordRow | null) ?? null;
+    };
 
-    const row = data as RegistryRecordRow;
+    let row = await fetchRecord();
+    if (!row) {
+      // A new owner may deep-link a default record (e.g. a saved favourite)
+      // before ever loading the Services/Forms home list that seeds them. If
+      // this owner has no records of this kind at all, lazily seed the curated
+      // defaults and retry once. Non-fatal — fall through to 404 on failure.
+      const { count, error: countError } = await supabase
+        .from("clinical_registry_records")
+        .select("id", { count: "exact", head: true })
+        .eq("owner_id", user.id)
+        .eq("kind", kind);
+      if (countError) throw new Error(countError.message);
+      if ((count ?? 0) === 0) {
+        // Only the seed write is best-effort; the re-read stays outside the try
+        // so a genuine read failure surfaces rather than a misleading 404.
+        try {
+          await ensureRegistrySeeded(supabase, user.id, kind);
+        } catch (seedError) {
+          console.error(`[registry] auto-seed failed for owner ${user.id} (${kind})`, seedError);
+        }
+        row = await fetchRecord();
+      }
+    }
+    if (!row) return notFoundResponse(normalizedSlug);
 
     const { data: links, error: linksError } = await supabase
       .from("clinical_registry_record_sources")
diff --git a/src/app/api/registry/records/route.ts b/src/app/api/registry/records/route.ts
index 83fd73cf13..b2e1d666da 100644
--- a/src/app/api/registry/records/route.ts
+++ b/src/app/api/registry/records/route.ts
@@ -12,6 +12,7 @@ import {
   type RegistryRecordKind,
   type RegistryRecordRow,
 } from "@/lib/registry-records";
+import { ensureRegistrySeeded } from "@/lib/registry-seed";
 import { rankServiceRecords, serviceRecords, type ServiceRecord, type ServiceSearchMatch } from "@/lib/services";
 import { createAdminClient } from "@/lib/supabase/admin";
 import { AuthenticationError, requireAuthenticatedUser, unauthorizedResponse } from "@/lib/supabase/auth";
@@ -83,16 +84,33 @@ export async function GET(request: Request) {
       return rateLimitJsonResponse("Registry requests are rate limited. Try again shortly.", rateLimit);
     }
 
-    const { data, error } = await supabase
-      .from("clinical_registry_records")
-      .select("*")
-      .eq("owner_id", user.id)
-      .eq("kind", kind)
-      .order("title")
-      .limit(REGISTRY_MAX_RECORDS);
-    if (error) throw new Error(error.message);
+    const fetchRecords = async () => {
+      const { data, error } = await supabase
+        .from("clinical_registry_records")
+        .select("*")
+        .eq("owner_id", user.id)
+        .eq("kind", kind)
+        .order("title")
+        .limit(REGISTRY_MAX_RECORDS);
+      if (error) throw new Error(error.message);
+      return (data ?? []) as RegistryRecordRow[];
+    };
+
+    let rows = await fetchRecords();
+    if (rows.length === 0) {
+      // First visit for this owner: lazily seed the curated defaults so new
+      // accounts get populated Services/Forms instead of the empty state. Only
+      // the seed write is best-effort (a failure falls back to the empty set);
+      // the re-read stays outside the try so a genuine read failure still
+      // surfaces as an error rather than a misleading empty registry.
+      try {
+        await ensureRegistrySeeded(supabase, user.id, kind);
+      } catch (seedError) {
+        console.error(`[registry] auto-seed failed for owner ${user.id} (${kind})`, seedError);
+      }
+      rows = await fetchRecords();
+    }
 
-    const rows = (data ?? []) as RegistryRecordRow[];
     const records = rows.map(rowToServiceRecord);
     const governanceBySlug = Object.fromEntries(rows.map((row) => [row.slug, rowGovernance(row)]));
 
diff --git a/src/components/clinical-dashboard/favourites-hub.tsx b/src/components/clinical-dashboard/favourites-hub.tsx
index d1ee15172e..9a3080d784 100644
--- a/src/components/clinical-dashboard/favourites-hub.tsx
+++ b/src/components/clinical-dashboard/favourites-hub.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import { ArrowUpDown, ChevronDown, Filter, Folder, FolderInput, Heart, Plus, Search, X } from "lucide-react";
-import { useRef, useState, type KeyboardEvent as ReactKeyboardEvent } from "react";
+import { useMemo, useRef, useState, type KeyboardEvent as ReactKeyboardEvent } from "react";
 import { useDismissableLayer } from "@/components/use-dismissable-layer";
 import { ModeHomeHero } from "@/components/mode-home-template";
 import { cn, floatingControl, iconTilePremium, panelSubtle, primaryControl } from "@/components/ui-primitives";
@@ -9,11 +9,11 @@ import {
   favouriteItems,
   favouriteSets,
   favouriteTabs,
-  favouriteTypeCount,
   type FavouriteItem,
   type FavouriteSet,
   type FavouriteTabId,
 } from "@/components/clinical-dashboard/favourites-prototype-data";
+import { useSavedRegistryFavourites } from "@/components/clinical-dashboard/use-saved-registry-favourites";
 
 function favouriteMatchesQuery(value: { title: string; meta?: string; set?: string; keywords: string }, query: string) {
   const normalized = query.trim().toLowerCase();
@@ -45,11 +45,18 @@ export function FavouritesHub({
   const tabButtonRef = useRef<HTMLButtonElement | null>(null);
   const tabOptionRefs = useRef<Array<HTMLButtonElement | null>>([]);
   const normalizedQuery = query.trim();
+  // Real saved services/forms (localStorage slugs hydrated via the registry
+  // API) merged in alongside the prototype items for the not-yet-backed types.
+  const savedRegistryItems = useSavedRegistryFavourites();
+  const allItems = useMemo(() => [...favouriteItems, ...savedRegistryItems], [savedRegistryItems]);
+  const countType = (type: FavouriteTabId) => {
+    if (type === "all") return allItems.length + favouriteSets.length;
+    if (type === "sets") return favouriteSets.length;
+    return allItems.filter((item) => item.type === type).length;
+  };
   const selectedSet = selectedSetId ? favouriteSets.find((set) => set.id === selectedSetId) : null;
   const tabItems =
-    selectedTab === "all" || selectedTab === "sets"
-      ? favouriteItems
-      : favouriteItems.filter((item) => item.type === selectedTab);
+    selectedTab === "all" || selectedTab === "sets" ? allItems : allItems.filter((item) => item.type === selectedTab);
   const visibleItems = tabItems
     .filter((item) => favouriteMatchesQuery(item, normalizedQuery))
     .filter((item) => !selectedSet || item.set === selectedSet.title);
@@ -59,9 +66,9 @@ export function FavouritesHub({
   const empty = (!showItems || visibleItems.length === 0) && (!showSets || visibleSets.length === 0);
   const selectedTabMeta = favouriteTabs.find((tab) => tab.id === selectedTab) ?? favouriteTabs[0];
   const selectedTabLabel = selectedTabMeta.label;
-  const selectedTabCount = favouriteTypeCount(selectedTab);
+  const selectedTabCount = countType(selectedTab);
   const SelectedTabIcon = selectedTabMeta.icon;
-  const itemCount = favouriteItems.length;
+  const itemCount = allItems.length;
   const setCount = favouriteSets.length;
   const activeFilterCount = (normalizedQuery ? 1 : 0) + (selectedSet ? 1 : 0);
   const selectedTabIndex = Math.max(
@@ -199,7 +206,7 @@ export function FavouritesHub({
                 {favouriteTabs.map((tab, index) => {
                   const Icon = tab.icon;
                   const selected = selectedTab === tab.id;
-                  const count = favouriteTypeCount(tab.id);
+                  const count = countType(tab.id);
                   return (
                     <button
                       key={tab.id}
diff --git a/src/components/clinical-dashboard/favourites-prototype-data.ts b/src/components/clinical-dashboard/favourites-prototype-data.ts
index b2269fc3e1..b6484c8bca 100644
--- a/src/components/clinical-dashboard/favourites-prototype-data.ts
+++ b/src/components/clinical-dashboard/favourites-prototype-data.ts
@@ -1,6 +1,6 @@
-import { FileText, Folder, LayoutList, Pill, Quote, Search } from "lucide-react";
+import { ClipboardList, FileText, Folder, LayoutList, Pill, Quote, Search, Stethoscope } from "lucide-react";
 
-export type FavouriteType = "medications" | "documents" | "sources" | "sets";
+export type FavouriteType = "medications" | "documents" | "sources" | "services" | "forms" | "sets";
 export type FavouriteTabId = "all" | FavouriteType;
 
 export type FavouriteItem = {
@@ -33,6 +33,8 @@ export const favouriteTabs: Array<{
   { id: "medications", label: "Medications", shortLabel: "Meds", icon: Pill },
   { id: "documents", label: "Documents", shortLabel: "Docs", icon: FileText },
   { id: "sources", label: "Sources", shortLabel: "Sources", icon: Quote },
+  { id: "services", label: "Services", shortLabel: "Services", icon: Stethoscope },
+  { id: "forms", label: "Forms", shortLabel: "Forms", icon: ClipboardList },
   { id: "sets", label: "Sets", shortLabel: "Sets", icon: Folder },
 ];
 
diff --git a/src/components/clinical-dashboard/use-saved-registry-favourites.ts b/src/components/clinical-dashboard/use-saved-registry-favourites.ts
new file mode 100644
index 0000000000..b4944429c8
--- /dev/null
+++ b/src/components/clinical-dashboard/use-saved-registry-favourites.ts
@@ -0,0 +1,74 @@
+"use client";
+
+import { ClipboardList, Stethoscope } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+
+import type { FavouriteItem } from "@/components/clinical-dashboard/favourites-prototype-data";
+import type { ServiceRecord } from "@/lib/services";
+import { useRegistryRecords } from "@/lib/use-registry-records";
+
+// localStorage keys written by the service/form detail pages when a record is
+// saved (see service-detail-page.tsx / form-detail-page.tsx).
+const savedServicesKey = "clinical-kb-saved-services";
+const savedFormsKey = "clinical-kb-saved-forms";
+
+function readSavedSlugs(key: string): string[] {
+  try {
+    const raw = window.localStorage.getItem(key);
+    const parsed = raw ? JSON.parse(raw) : [];
+    return Array.isArray(parsed) ? parsed.filter((item): item is string => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
+function recordToFavourite(record: ServiceRecord, type: "services" | "forms"): FavouriteItem {
+  return {
+    id: `${type}:${record.slug}`,
+    title: record.title,
+    type,
+    set: "",
+    meta: record.subtitle ?? (type === "services" ? "Saved service" : "Saved form"),
+    sourceMeta: type === "services" ? "Service" : "Form",
+    primaryAction: "Open",
+    icon: type === "services" ? Stethoscope : ClipboardList,
+    keywords: [record.title, record.subtitle, ...(record.tags ?? [])].filter(Boolean).join(" ").toLowerCase(),
+  };
+}
+
+/**
+ * Hydrate the user's saved services/forms into the FavouriteItem shape the hub
+ * renders. Slugs live in localStorage; titles/metadata come from the owner's
+ * registry via useRegistryRecords (demo mode serves fixtures, so this also
+ * works env-less). Fetching is gated on there being saved slugs, so the common
+ * "nothing saved" case makes no request.
+ */
+export function useSavedRegistryFavourites(): FavouriteItem[] {
+  const [savedServices, setSavedServices] = useState<string[]>([]);
+  const [savedForms, setSavedForms] = useState<string[]>([]);
+
+  useEffect(() => {
+    const refresh = () => {
+      setSavedServices(readSavedSlugs(savedServicesKey));
+      setSavedForms(readSavedSlugs(savedFormsKey));
+    };
+    refresh();
+    window.addEventListener("storage", refresh);
+    return () => window.removeEventListener("storage", refresh);
+  }, []);
+
+  const services = useRegistryRecords("service", { enabled: savedServices.length > 0 });
+  const forms = useRegistryRecords("form", { enabled: savedForms.length > 0 });
+
+  return useMemo(() => {
+    const savedServiceSet = new Set(savedServices);
+    const savedFormSet = new Set(savedForms);
+    const serviceItems = services.records
+      .filter((record) => savedServiceSet.has(record.slug))
+      .map((record) => recordToFavourite(record, "services"));
+    const formItems = forms.records
+      .filter((record) => savedFormSet.has(record.slug))
+      .map((record) => recordToFavourite(record, "forms"));
+    return [...serviceItems, ...formItems];
+  }, [services.records, forms.records, savedServices, savedForms]);
+}
diff --git a/src/lib/registry-seed.ts b/src/lib/registry-seed.ts
new file mode 100644
index 0000000000..62c45407b6
--- /dev/null
+++ b/src/lib/registry-seed.ts
@@ -0,0 +1,51 @@
+import { formRecords } from "@/lib/forms";
+import {
+  recordToRow,
+  type RegistryRecordInsert,
+  type RegistryRecordKind,
+  type RegistryRecordRow,
+} from "@/lib/registry-records";
+import { serviceRecords } from "@/lib/services";
+
+// Type-only reference to the admin client so this module carries no runtime
+// dependency on the Supabase admin singleton — the CLI can import the row
+// builders without pulling in service-role env, and callers pass their own
+// client into `ensureRegistrySeeded`.
+type AdminClient = ReturnType<typeof import("@/lib/supabase/admin").createAdminClient>;
+
+/** The curated default registry fixtures for a kind — the same set the CLI
+ *  seeds and the API falls back to when an owner has no records yet. */
+export function defaultRegistryRecords(kind: RegistryRecordKind) {
+  return kind === "form" ? formRecords : serviceRecords;
+}
+
+/** Build insertable rows for an owner from the default fixtures. Shared by the
+ *  CLI (`scripts/seed-registry-records.ts`) and the lazy API auto-seed so both
+ *  map fixtures → rows identically. */
+export function buildDefaultRegistryRows(ownerId: string, kind: RegistryRecordKind): RegistryRecordInsert[] {
+  return defaultRegistryRecords(kind).map((record) => recordToRow(record, ownerId, kind));
+}
+
+/**
+ * Idempotently seed the curated default registry records for an owner + kind
+ * and return the stored rows. Called lazily by the registry API when an
+ * authenticated owner has no records yet, so new accounts get populated
+ * Services/Forms instead of the empty state. Safe under concurrent first
+ * requests — the (owner_id, kind, slug) conflict target dedupes the upsert.
+ *
+ * First-seed helper only: it does NOT preserve post-seed governance edits, so
+ * the reseed path (the CLI) layers its own preservation on top.
+ */
+export async function ensureRegistrySeeded(
+  supabase: AdminClient,
+  ownerId: string,
+  kind: RegistryRecordKind,
+): Promise<RegistryRecordRow[]> {
+  const rows = buildDefaultRegistryRows(ownerId, kind);
+  const { data, error } = await supabase
+    .from("clinical_registry_records")
+    .upsert(rows, { onConflict: "owner_id,kind,slug" })
+    .select("*");
+  if (error) throw new Error(`Registry seed failed: ${error.message}`);
+  return (data ?? []) as RegistryRecordRow[];
+}
diff --git a/supabase/migrations/20260703030000_reconcile_storage_cleanup_jobs_indexes.sql b/supabase/migrations/20260703030000_reconcile_storage_cleanup_jobs_indexes.sql
new file mode 100644
index 0000000000..3a2726796c
--- /dev/null
+++ b/supabase/migrations/20260703030000_reconcile_storage_cleanup_jobs_indexes.sql
@@ -0,0 +1,48 @@
+-- Reconcile storage_cleanup_jobs indexes on the LIVE database with the names /
+-- definitions already declared in supabase/schema.sql (and migration
+-- 20260528007000_database_hardening_before_import.sql).
+--
+-- Why: the live project (sjrfecxgysukkwxsowpy) carries legacy auto-generated
+-- index names that predate the hardening migration, even though that migration
+-- is recorded as applied in supabase_migrations.schema_migrations:
+--
+--   live (legacy)                              intended (schema.sql)
+--   storage_cleanup_jobs_document_id_idx    -> storage_cleanup_jobs_document_idx
+--   storage_cleanup_jobs_owner_id_idx       -> storage_cleanup_jobs_owner_status_idx
+--                                              (owner_id, status, created_at desc)
+--   storage_cleanup_jobs_status_created_idx -> storage_cleanup_jobs_status_created_idx
+--     (full)                                   (partial: status in pending/failed)
+--
+-- All three still cover their columns on live, so this is a cosmetic +
+-- optimisation reconciliation, NOT a functional fix (the document_id FK is
+-- already covered). It is prepared for review only.
+--
+-- >>> DO NOT APPLY TO LIVE without explicit approval. <<<
+--
+-- Idempotent and safe on a fresh `supabase db reset` too: the legacy names
+-- never exist there so the drops are no-ops, and the intended indexes already
+-- match schema.sql so the creates are no-ops. The status index shares its name
+-- across both shapes, so it is dropped and recreated to guarantee the partial
+-- form (a negligible rebuild of a small index).
+--
+-- NOTE for the applier: these are plain (transactional) statements. If you want
+-- a lock-free rebuild on a busy table, run the DROP/CREATE steps manually with
+-- CONCURRENTLY *outside* a transaction instead -- CONCURRENTLY cannot run inside
+-- the migration transaction. storage_cleanup_jobs is small, so the brief lock
+-- from the plain form is normally fine.
+
+-- document_id FK covering index: legacy auto-name -> intended name
+drop index if exists storage_cleanup_jobs_document_id_idx;
+create index if not exists storage_cleanup_jobs_document_idx
+  on public.storage_cleanup_jobs(document_id);
+
+-- owner index: legacy single-column -> intended composite
+drop index if exists storage_cleanup_jobs_owner_id_idx;
+create index if not exists storage_cleanup_jobs_owner_status_idx
+  on public.storage_cleanup_jobs(owner_id, status, created_at desc);
+
+-- status index: same name, ensure the partial (pending/failed) form
+drop index if exists storage_cleanup_jobs_status_created_idx;
+create index if not exists storage_cleanup_jobs_status_created_idx
+  on public.storage_cleanup_jobs(status, created_at)
+  where status in ('pending', 'failed');
diff --git a/tests/registry-records-route.test.ts b/tests/registry-records-route.test.ts
index fa636c591d..638e60c7cb 100644
--- a/tests/registry-records-route.test.ts
+++ b/tests/registry-records-route.test.ts
@@ -12,6 +12,8 @@ type QueryCall = {
   filters: QueryFilter[];
   inFilters: Array<{ column: string; values: unknown[] }>;
   maybeSingle: boolean;
+  upsert?: boolean;
+  upsertRows?: unknown[];
 };
 type QueryResolver = (call: QueryCall) => QueryResult;
 
@@ -83,6 +85,12 @@ class QueryBuilder implements PromiseLike<QueryResult> {
     return this;
   }
 
+  upsert(rows: unknown) {
+    this.call.upsert = true;
+    this.call.upsertRows = Array.isArray(rows) ? rows : [rows];
+    return this;
+  }
+
   maybeSingle() {
     this.call.maybeSingle = true;
     return Promise.resolve(this.resolver(this.call));
@@ -299,4 +307,49 @@ describe("registry records API", () => {
     expect(payload.record.slug).toBe("transport-crisis-form");
     expect(client.from).not.toHaveBeenCalled();
   });
+
+  it("seeds the curated default set for an owner with an empty registry", async () => {
+    let stored: Array<Record<string, unknown>> = [];
+    const client = createSupabaseMock((call) => {
+      if (call.table !== "clinical_registry_records") return ok([]);
+      if (call.upsert) {
+        stored = (call.upsertRows ?? []) as Array<Record<string, unknown>>;
+        return ok(stored);
+      }
+      return ok(stored);
+    });
+    mockRuntime(client);
+    const { GET } = await import("../src/app/api/registry/records/route");
+    const { serviceRecords } = await import("../src/lib/services");
+
+    const response = await GET(authedRequest("/api/registry/records?kind=service"));
+    const payload = (await response.json()) as { records: Array<{ slug: string }>; total: number };
+
+    expect(response.status).toBe(200);
+    // The empty owner is seeded once, owner-scoped, with the full default set.
+    const upsertCall = client.calls.find((call) => call.table === "clinical_registry_records" && call.upsert);
+    expect(upsertCall).toBeDefined();
+    expect(upsertCall?.upsertRows).toHaveLength(serviceRecords.length);
+    expect(
+      (upsertCall?.upsertRows ?? []).every((row) => {
+        const typed = row as { owner_id: string; kind: string };
+        return typed.owner_id === userId && typed.kind === "service";
+      }),
+    ).toBe(true);
+    expect(payload.records).toHaveLength(serviceRecords.length);
+    expect(payload.total).toBe(serviceRecords.length);
+  });
+
+  it("does not seed when the owner already has registry records", async () => {
+    const client = createSupabaseMock((call) =>
+      call.table === "clinical_registry_records" ? ok([registryRow()]) : ok([]),
+    );
+    mockRuntime(client);
+    const { GET } = await import("../src/app/api/registry/records/route");
+
+    const response = await GET(authedRequest("/api/registry/records?kind=service"));
+
+    expect(response.status).toBe(200);
+    expect(client.calls.some((call) => call.upsert)).toBe(false);
+  });
 });
diff --git a/tests/ui-smoke.spec.ts b/tests/ui-smoke.spec.ts
index 43751c33e2..76fa949147 100644
--- a/tests/ui-smoke.spec.ts
+++ b/tests/ui-smoke.spec.ts
@@ -1263,6 +1263,30 @@ test.describe("Clinical KB UI smoke coverage", () => {
     await expect(page.getByTestId("global-search-input")).toBeFocused();
   });
 
+  test("favourites hub hydrates saved services from the registry", async ({ page }) => {
+    await page.setViewportSize({ width: 1280, height: 900 });
+    await mockDemoApi(page);
+    // mockDemoApi does not cover the registry list used for favourite hydration.
+    await page.route(/\/api\/registry\/records(?:\?.*)?$/, async (route) => {
+      await route.fulfill({
+        json: {
+          records: [{ slug: "13yarn", title: "13YARN", subtitle: "Crisis support line" }],
+          total: 1,
+          demoMode: true,
+          governance: {},
+        },
+      });
+    });
+    await page.addInitScript(() => {
+      window.localStorage.setItem("clinical-kb-saved-services", JSON.stringify(["13yarn"]));
+    });
+    await gotoApp(page, "/favourites");
+
+    await expect(page.getByTestId("favourites-hub")).toBeVisible();
+    // The saved service slug is hydrated to its registry title in the hub.
+    await expect(page.getByTestId("favourites-hub").getByText("13YARN").first()).toBeVisible();
+  });
+
   test("app mode menu supports keyboard navigation without removed prototype modes", async ({ page }) => {
     await page.setViewportSize({ width: 1280, height: 900 });
     await mockDemoApi(page);