Restore an account that grouped its own mood factors

An account that ever created its own mood category could not be restored
at all. Not partially, not with a gap: the restore violated
mood_tags_category_id_fkey and rolled the whole file back, so the
operator got a 500 naming a constraint and an empty account.

The coverage register described this as custom tags landing in a
grouping that no longer exists, which reads like a cosmetic loss.
Measured, it is the same shape the retired-catalogue-key work already
removed once: one row nobody thought about taking down everything else
with it.

MoodTag.categoryId is a real foreign key. Seeded categories belong to
the instance and are deliberately still not carried, but a category the
person made is theirs, cascades away with them, and has to travel. It
now does, and it is written before the tags that point at it.

The hidden set travels by key rather than id, because what people hide
is almost always a seeded tag whose id differs on every instance. A key
this instance no longer knows costs one hidden row and is reported: a
silent drop would un-hide a factor somebody had deliberately taken out
of their mood editor, and they would have no way to know why it came
back.

Found by experiment rather than by reading: seeding a user-owned
category into the round trip turned it red with the constraint name, and
the same test is green now.

src/app/api/admin/backups/[id]/restore/__tests__/round-trip.test.ts

@@ -297,6 +297,8 @@ function sourceClient() {
     measurementReminder: { findMany: vi.fn().mockResolvedValue([]) },
     measurementReminderEvent: { findMany: vi.fn().mockResolvedValue([]) },
     coachConversation: { findMany: vi.fn().mockResolvedValue([]) },
+    moodTagCategory: { findMany: vi.fn().mockResolvedValue([]) },
+    moodTagHidden: { findMany: vi.fn().mockResolvedValue([]) },
     coachFact: { findMany: vi.fn().mockResolvedValue([]) },
     coachPlan: { findMany: vi.fn().mockResolvedValue([]) },
     coachReminder: { findMany: vi.fn().mockResolvedValue([]) },

src/app/api/admin/backups/[id]/restore/route.ts

@@ -794,6 +794,33 @@ const handler = apiHandler(
               (entry) => entry.structuredTags,
             );
             const tagKeys = [...new Set(referencedTagKeys)];
+            // The account's own CATEGORIES go in before its tags. A custom
+            // tag's `categoryId` is a real foreign key, so writing the tag
+            // first threw `mood_tags_category_id_fkey` and rolled the entire
+            // restore back — an account that had grouped its own mood factors
+            // could not be restored at all, and the failure named a constraint
+            // rather than the thing that was missing.
+            //
+            // Upserted by key for the same reason the tags below are: `key` is
+            // globally unique, so a seeded category that later claims the key
+            // must be left alone rather than overwritten by a restore.
+            for (const category of payload.customMoodTagCategories) {
+              await tx.moodTagCategory.upsert({
+                where: { key: category.key },
+                create: {
+                  id: category.id,
+                  userId: ownerId,
+                  key: category.key,
+                  labelKey: category.labelKey,
+                  icon: category.icon ?? null,
+                  sortOrder: category.sortOrder ?? 0,
+                  isActive: category.isActive ?? true,
+                  labelEncrypted: category.labelEncrypted ?? null,
+                },
+                update: {},
+              });
+            }
+
             // Re-create the account's own tag definitions first. The lookup
             // below used to ask only for the seeded catalogue (`userId: null`),
             // so a single custom rated tag made the whole restore throw
@@ -822,6 +849,53 @@ const handler = apiHandler(
               });
             }
 
+            // Which tags the account hid. Delete-then-recreate like every
+            // other section, and resolved by KEY: what people hide is almost
+            // always a seeded tag, whose id differs on every instance.
+            //
+            // A key this instance no longer knows costs one hidden row and is
+            // REPORTED. Dropping it silently would un-hide a factor the person
+            // had deliberately taken out of their mood editor, and they would
+            // have no way to know why it came back.
+            await tx.moodTagHidden.deleteMany({ where: { userId: ownerId } });
+            if (payload.hiddenMoodTags.length > 0) {
+              const hiddenKeys = payload.hiddenMoodTags.map((h) => h.key);
+              const hiddenRows = await tx.moodTag.findMany({
+                where: {
+                  key: { in: [...new Set(hiddenKeys)] },
+                  OR: [{ userId: null }, { userId: ownerId }],
+                },
+                select: { id: true, key: true },
+              });
+              const hiddenByKey = new Map(
+                hiddenRows.map((row) => [row.key, row.id]),
+              );
+              const unresolvedHidden: string[] = [];
+              const writableHidden = payload.hiddenMoodTags.filter((entry) => {
+                if (hiddenByKey.has(entry.key)) return true;
+                unresolvedHidden.push(entry.key);
+                return false;
+              });
+              if (writableHidden.length > 0) {
+                await tx.moodTagHidden.createMany({
+                  data: writableHidden.map((entry) => ({
+                    userId: ownerId,
+                    moodTagId: hiddenByKey.get(entry.key)!,
+                    ...(entry.createdAt
+                      ? { createdAt: new Date(entry.createdAt) }
+                      : {}),
+                  })),
+                  skipDuplicates: true,
+                });
+              }
+              recordUnknownKeys(
+                skips,
+                "moodTag",
+                [...new Set(unresolvedHidden)],
+                unresolvedHidden,
+              );
+            }
+
             const factorRows =
               factorKeys.length === 0
                 ? []