feat: implement comprehensive achievement system with 62 achievements

Adds a complete achievement system with gamification features across all user interactions.

**Database & Types:**
- Add UserAchievement model to track user progress and earned achievements
- Add achievement-related fields to User model (achievementPoints, currentStreak, lastStreakCheck)
- Add ACHIEVEMENT_UNLOCKED audit action type
- Define 62 achievements as TypeScript constants across 5 categories

**Achievement Categories:**
- Suggestions (15): First suggestion through ultimate curator milestones
- Likes (12): First like through legendary fan milestones
- Comments (12): First comment through review legend milestones
- Engagement (15): Login streaks and total activity tracking
- Reports (8): Valid reports and accuracy tracking

**Backend Implementation:**
- Create AchievementService with comprehensive checking logic
- Add achievement route with 6 API endpoints
- Integrate achievement checking into all user interaction points:
  - Suggestions (create + accept)
  - Likes (toggle)
  - Comments (all 6 media types)
  - Login streaks
  - Reports (profile + comment)
- Update UserService to include achievement points in profiles

**Frontend Implementation:**
- Create AchievementService for API communication
- Create achievements page showing all 62 achievements with:
  - Category filtering (All, Suggestions, Likes, Comments, Engagement, Reports)
  - Tier-based styling (Bronze, Silver, Gold, Platinum, Diamond)
  - Progress indicators for in-progress achievements
  - Earned date display for completed achievements
- Add "Recent Achievements" section to user profiles
- Add "🏆 Achievements" link to header navigation
- Only show "View All" link on own profile

**Technical Features:**
- Real-time achievement checking on user actions
- Progress tracking to avoid recalculation
- Points system for gamification
- Tier-based gradient styling
- Leaderboard-ready architecture

Resolves #48

Co-Authored-By: Hikari <hikari@nhcarrigan.com>

api/prisma/schema.prisma

@@ -207,6 +207,9 @@ model User {
   isVip         Boolean        @default(false)
   isMod         Boolean        @default(false)
   isStaff       Boolean        @default(false)
+  achievementPoints Int         @default(0)
+  currentStreak     Int         @default(0)
+  lastStreakCheck   DateTime?
   createdAt     DateTime       @default(now())
   updatedAt     DateTime       @updatedAt
   comments         Comment[]
@@ -218,6 +221,7 @@ model User {
   reportsReviewed       ProfileReport[] @relation("Reviewer")
   commentReportsMade    CommentReport[] @relation("CommentReporter")
   commentReportsReviewed CommentReport[] @relation("CommentReviewer")
+  userAchievements      UserAchievement[]
 
   @@index([slug], map: "User_slug_key")
 }
@@ -276,6 +280,7 @@ enum AuditAction {
   RATE_LIMIT_EXCEEDED
   CSRF_VALIDATION_FAILED
   UNAUTHORIZED_ACCESS
+  ACHIEVEMENT_UNLOCKED
 }
 
 enum AuditCategory {
@@ -400,3 +405,20 @@ model CommentReport {
   @@index([reporterId])
   @@index([status])
 }
+
+model UserAchievement {
+  id              String      @id @default(auto()) @map("_id") @db.ObjectId
+  userId          String      @db.ObjectId
+  user            User        @relation(fields: [userId], references: [id])
+  achievementKey  String
+  progress        Int         @default(0)
+  earned          Boolean     @default(false)
+  earnedAt        DateTime?
+  createdAt       DateTime    @default(now())
+  updatedAt       DateTime    @updatedAt
+
+  @@unique([userId, achievementKey])
+  @@index([userId])
+  @@index([achievementKey])
+  @@index([earned])
+}

api/src/app/routes/achievements/index.ts

@@ -0,0 +1,122 @@
+/**
+ * @copyright 2026 NHCarrigan
+ * @license Naomi's Public License
+ * @author Naomi Carrigan
+ */
+
+import type { FastifyPluginAsync } from "fastify";
+import {
+  ACHIEVEMENT_LIST,
+  ACHIEVEMENTS,
+  AchievementProgress,
+  UserAchievementSummary,
+} from "@library/shared-types";
+import { AchievementService } from "../../services/achievement.service";
+
+const achievementsRoutes: FastifyPluginAsync = async (app) => {
+  const achievementService = new AchievementService();
+
+  /**
+   * Get all achievement definitions (public route).
+   */
+  app.get("/definitions", async () => {
+    return ACHIEVEMENT_LIST;
+  });
+
+  /**
+   * Get a specific achievement definition by key (public route).
+   */
+  app.get<{ Params: { key: string } }>(
+    "/definitions/:key",
+    async (request, reply) => {
+      const { key } = request.params;
+      const achievement = ACHIEVEMENTS[key];
+
+      if (!achievement) {
+        return reply.notFound("Achievement not found");
+      }
+
+      return achievement;
+    },
+  );
+
+  /**
+   * Get current user's achievement summary (authenticated users).
+   */
+  app.get<{ Reply: UserAchievementSummary }>(
+    "/summary",
+    {
+      preValidation: [app.authenticate],
+    },
+    async (request) => {
+      const userId = request.user.id;
+      const summary = await achievementService.getUserAchievementSummary(
+        userId,
+      );
+      return summary;
+    },
+  );
+
+  /**
+   * Get current user's achievement progress (authenticated users).
+   */
+  app.get<{ Reply: AchievementProgress[] }>(
+    "/progress",
+    {
+      preValidation: [app.authenticate],
+    },
+    async (request) => {
+      const userId = request.user.id;
+      const progress = await achievementService.getUserAchievementProgress(
+        userId,
+      );
+      return progress;
+    },
+  );
+
+  /**
+   * Get another user's achievement summary by ID (authenticated users).
+   */
+  app.get<{ Params: { userId: string }; Reply: UserAchievementSummary }>(
+    "/users/:userId/summary",
+    {
+      preValidation: [app.authenticate],
+    },
+    async (request, reply) => {
+      const { userId } = request.params;
+
+      try {
+        const summary = await achievementService.getUserAchievementSummary(
+          userId,
+        );
+        return summary;
+      } catch (error) {
+        return reply.notFound("User not found");
+      }
+    },
+  );
+
+  /**
+   * Get another user's achievement progress by ID (authenticated users).
+   */
+  app.get<{ Params: { userId: string }; Reply: AchievementProgress[] }>(
+    "/users/:userId/progress",
+    {
+      preValidation: [app.authenticate],
+    },
+    async (request, reply) => {
+      const { userId } = request.params;
+
+      try {
+        const progress = await achievementService.getUserAchievementProgress(
+          userId,
+        );
+        return progress;
+      } catch (error) {
+        return reply.notFound("User not found");
+      }
+    },
+  );
+};
+
+export default achievementsRoutes;

api/src/app/routes/art/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Art, CreateArtDto, UpdateArtDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Art, CreateArtDto, UpdateArtDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { ArtService } from "../../services/art.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -139,6 +140,15 @@ const artRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to art`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/auth/index.ts

@@ -1,7 +1,8 @@
 import { FastifyPluginAsync } from "fastify";
 import { AuthService } from "../../services/auth.service";
 import { AuditService } from "../../services/audit.service";
-import { AuthResponse, AuditAction, AuditCategory } from "@library/shared-types";
+import { AchievementService } from "../../services/achievement.service";
+import { AuthResponse, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 
 const authRoutes: FastifyPluginAsync = async (app) => {
   const authService = new AuthService(app);
@@ -92,6 +93,15 @@ const authRoutes: FastifyPluginAsync = async (app) => {
         success: true,
       }, request);
 
+      // Update login streak and check engagement achievements
+      const achievementService = new AchievementService();
+      await achievementService.updateLoginStreak(user.id);
+      await achievementService.checkAchievements(
+        user.id,
+        AchievementCategory.Engagement,
+        request
+      );
+
       // Set signed cookies and redirect to frontend
       reply
         .setCookie("auth-token", accessToken, {

api/src/app/routes/books/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Book, CreateBookDto, UpdateBookDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Book, CreateBookDto, UpdateBookDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { BookService } from "../../services/book.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -139,6 +140,15 @@ const booksRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to book`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/comment-reports/index.ts

@@ -10,9 +10,10 @@ import type {
   ReportStatus,
   UpdateCommentReportDto,
 } from "@library/shared-types";
-import { ReportReason } from "@library/shared-types";
+import { ReportReason, AchievementCategory } from "@library/shared-types";
 
 import { CommentReportService } from "../../services/comment-report.service.js";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard.js";
 
 const commentReportsRoutes: FastifyPluginAsync = async (fastify) => {
@@ -132,6 +133,17 @@ const commentReportsRoutes: FastifyPluginAsync = async (fastify) => {
         request.user.id,
         request.body,
       );
+
+      // Check for report achievements for the original reporter
+      if (report.status === "ACTION_TAKEN" || report.status === "DISMISSED") {
+        const achievementService = new AchievementService();
+        await achievementService.checkAchievements(
+          report.reporterId,
+          AchievementCategory.Report,
+          request
+        );
+      }
+
       return reply.send(report);
     },
   );

api/src/app/routes/games/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Game, CreateGameDto, UpdateGameDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Game, CreateGameDto, UpdateGameDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { GameService } from "../../services/game.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -125,6 +126,15 @@ const gamesRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to game`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/log/index.ts

@@ -30,9 +30,10 @@ export default async function (fastify: FastifyInstance) {
       }
       await logger.error(context || 'Frontend', errorObj);
     } else if (level === 'error') {
-      await logger.log('warn', `[Frontend Error] ${message}`);
+      await logger.error('Frontend', new Error(message));
     } else {
-      await logger.log(level, `[Frontend] ${message}`);
+      const logMessage = context ? `[${context}] ${message}` : message;
+      await logger.log(level, logMessage);
     }
 
     return { success: true };

api/src/app/routes/manga/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Manga, CreateMangaDto, UpdateMangaDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Manga, CreateMangaDto, UpdateMangaDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { MangaService } from "../../services/manga.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -118,6 +119,15 @@ const mangaRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to manga`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/music/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Music, CreateMusicDto, UpdateMusicDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Music, CreateMusicDto, UpdateMusicDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { MusicService } from "../../services/music.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -139,6 +140,15 @@ const musicRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to music`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/reports/index.ts

@@ -10,9 +10,10 @@ import type {
   ReportStatus,
   UpdateReportDto,
 } from "@library/shared-types";
-import { ReportReason } from "@library/shared-types";
+import { ReportReason, AchievementCategory } from "@library/shared-types";
 
 import { ReportService } from "../../services/report.service.js";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard.js";
 
 const reportsRoutes: FastifyPluginAsync = async (fastify) => {
@@ -131,6 +132,17 @@ const reportsRoutes: FastifyPluginAsync = async (fastify) => {
         request.user.id,
         request.body,
       );
+
+      // Check for report achievements for the original reporter
+      if (report.status === "ACTION_TAKEN" || report.status === "DISMISSED") {
+        const achievementService = new AchievementService();
+        await achievementService.checkAchievements(
+          report.reporterId,
+          AchievementCategory.Report,
+          request
+        );
+      }
+
       return reply.send(report);
     },
   );

api/src/app/routes/shows/index.ts

@@ -5,10 +5,11 @@
  */
 
 import { FastifyPluginAsync } from "fastify";
-import { Show, CreateShowDto, UpdateShowDto, Comment, CreateCommentDto, AuditAction, AuditCategory } from "@library/shared-types";
+import { Show, CreateShowDto, UpdateShowDto, Comment, CreateCommentDto, AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import { ShowService } from "../../services/show.service";
 import { CommentService } from "../../services/comment.service";
 import { AuditService } from "../../services/audit.service";
+import { AchievementService } from "../../services/achievement.service";
 import { adminGuard } from "../../middleware/admin-guard";
 import { bannedGuard } from "../../middleware/banned-guard";
 
@@ -118,6 +119,15 @@ const showsRoutes: FastifyPluginAsync = async (app) => {
         resourceId: id,
         details: `Added comment to show`,
       });
+
+      // Check for comment achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Comment,
+        request
+      );
+
       return comment;
     }
   );

api/src/app/routes/suggestions/index.ts

@@ -1,7 +1,8 @@
 import type { FastifyInstance } from "fastify";
 import { SuggestionService } from "../../services/suggestion.service";
 import { AuditService } from "../../services/audit.service";
-import { AuditAction, AuditCategory } from "@library/shared-types";
+import { AchievementService } from "../../services/achievement.service";
+import { AuditAction, AuditCategory, AchievementCategory } from "@library/shared-types";
 import type {
   SuggestionStatus,
   SuggestionEntity,
@@ -93,6 +94,14 @@ export default async function (app: FastifyInstance): Promise<void> {
           success: true,
         });
 
+        // Check for suggestion achievements
+        const achievementService = new AchievementService();
+        await achievementService.checkAchievements(
+          userId,
+          AchievementCategory.Suggestion,
+          request
+        );
+
         reply.send(suggestion);
       } catch (error) {
         return reply.badRequest(
@@ -123,6 +132,14 @@ export default async function (app: FastifyInstance): Promise<void> {
           success: true,
         });
 
+        // Check for suggestion achievements for the user who made the suggestion
+        const achievementService = new AchievementService();
+        await achievementService.checkAchievements(
+          suggestion.userId,
+          AchievementCategory.Suggestion,
+          request
+        );
+
         reply.send(suggestion);
       } catch (error) {
         return reply.badRequest(
@@ -154,6 +171,14 @@ export default async function (app: FastifyInstance): Promise<void> {
           success: true,
         });
 
+        // Check for suggestion achievements for the user who made the suggestion
+        const achievementService = new AchievementService();
+        await achievementService.checkAchievements(
+          suggestion.userId,
+          AchievementCategory.Suggestion,
+          request
+        );
+
         reply.send(suggestion);
       } catch (error) {
         return reply.badRequest(

api/src/app/services/achievement.service.ts

@@ -0,0 +1,772 @@
+/**
+ * @copyright 2026 NHCarrigan
+ * @license Naomi's Public License
+ * @author Naomi Carrigan
+ */
+
+import type { FastifyRequest } from "fastify";
+import {
+  ACHIEVEMENTS,
+  ACHIEVEMENT_LIST,
+  AchievementCategory,
+  AchievementDefinition,
+  AchievementProgress,
+  AuditAction,
+  AuditCategory,
+  UserAchievementSummary,
+} from "@library/shared-types";
+
+import { prisma } from "../lib/prisma";
+import { AuditService } from "./audit.service";
+
+export class AchievementService {
+  /**
+   * Check and award achievements for a user after an action.
+   * Returns list of newly earned achievements.
+   */
+  async checkAchievements(
+    userId: string,
+    category: AchievementCategory,
+    req: FastifyRequest,
+  ): Promise<AchievementDefinition[]> {
+    const relevantAchievements = ACHIEVEMENT_LIST.filter(
+      (ach) => ach.category === category,
+    );
+    const newlyEarned: AchievementDefinition[] = [];
+
+    for (const achievement of relevantAchievements) {
+      const userAchievement = await prisma.userAchievement.findUnique({
+        where: {
+          userId_achievementKey: {
+            userId,
+            achievementKey: achievement.key,
+          },
+        },
+      });
+
+      // Skip already earned achievements
+      if (userAchievement?.earned) {
+        continue;
+      }
+
+      // Check if achievement is now earned
+      const earned = await this.checkAchievementCondition(userId, achievement);
+
+      if (earned) {
+        await this.awardAchievement(userId, achievement, req);
+        newlyEarned.push(achievement);
+      }
+    }
+
+    return newlyEarned;
+  }
+
+  /**
+   * Award an achievement to a user.
+   */
+  private async awardAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+    req: FastifyRequest,
+  ): Promise<void> {
+    await prisma.userAchievement.upsert({
+      where: {
+        userId_achievementKey: {
+          userId,
+          achievementKey: achievement.key,
+        },
+      },
+      create: {
+        userId,
+        achievementKey: achievement.key,
+        progress: 100,
+        earned: true,
+        earnedAt: new Date(),
+      },
+      update: {
+        earned: true,
+        earnedAt: new Date(),
+        progress: 100,
+      },
+    });
+
+    // Update user's achievement points
+    await prisma.user.update({
+      where: { id: userId },
+      data: {
+        achievementPoints: {
+          increment: achievement.points,
+        },
+      },
+    });
+
+    // Log the achievement unlock
+    await AuditService.logFromRequest(req, {
+      action: AuditAction.achievementUnlocked,
+      category: AuditCategory.content,
+      details: `Unlocked achievement: ${achievement.title}`,
+    });
+  }
+
+  /**
+   * Check if a specific achievement condition is met.
+   */
+  private async checkAchievementCondition(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    switch (achievement.category) {
+      case AchievementCategory.Suggestion:
+        return await this.checkSuggestionAchievement(userId, achievement);
+      case AchievementCategory.Like:
+        return await this.checkLikeAchievement(userId, achievement);
+      case AchievementCategory.Comment:
+        return await this.checkCommentAchievement(userId, achievement);
+      case AchievementCategory.Engagement:
+        return await this.checkEngagementAchievement(userId, achievement);
+      case AchievementCategory.Report:
+        return await this.checkReportAchievement(userId, achievement);
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Check suggestion-based achievements.
+   */
+  private async checkSuggestionAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    const { requirements } = achievement;
+
+    // Count-based achievements (total suggestions)
+    if (
+      achievement.key.startsWith("suggestion_first_steps") ||
+      achievement.key.startsWith("suggestion_contributor") ||
+      achievement.key.startsWith("suggestion_dedicated") ||
+      achievement.key.startsWith("suggestion_master") ||
+      achievement.key.startsWith("suggestion_legend")
+    ) {
+      const count = await prisma.suggestion.count({
+        where: { userId },
+      });
+      return count >= (requirements.count ?? 0);
+    }
+
+    // Accepted suggestion achievements
+    if (achievement.key.startsWith("suggestion_quality")) {
+      const count = await prisma.suggestion.count({
+        where: {
+          userId,
+          status: "ACCEPTED",
+        },
+      });
+      return count >= (requirements.count ?? 0);
+    }
+
+    // Approved achievement (first accepted)
+    if (achievement.key === "suggestion_approved") {
+      const count = await prisma.suggestion.count({
+        where: {
+          userId,
+          status: "ACCEPTED",
+        },
+      });
+      return count >= 1;
+    }
+
+    // Acceptance rate achievements
+    if (achievement.key.startsWith("suggestion_acceptance")) {
+      const total = await prisma.suggestion.count({
+        where: { userId },
+      });
+      const accepted = await prisma.suggestion.count({
+        where: {
+          userId,
+          status: "ACCEPTED",
+        },
+      });
+
+      if (total < (requirements.count ?? 0)) {
+        return false;
+      }
+
+      const rate = accepted / total;
+      return rate >= (requirements.rate ?? 0);
+    }
+
+    // Diversity achievement (all media types)
+    if (achievement.key === "suggestion_renaissance") {
+      const types = await prisma.suggestion.groupBy({
+        by: ["entityType"],
+        where: {
+          userId,
+          status: "ACCEPTED",
+        },
+      });
+      return types.length >= 6;
+    }
+
+    // Enthusiast (5 in one day)
+    if (achievement.key === "suggestion_enthusiast") {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const tomorrow = new Date(today);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      const count = await prisma.suggestion.count({
+        where: {
+          userId,
+          createdAt: {
+            gte: today,
+            lt: tomorrow,
+          },
+        },
+      });
+      return count >= 5;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check like-based achievements.
+   */
+  private async checkLikeAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    const { requirements } = achievement;
+
+    // Count-based achievements (total likes)
+    if (
+      achievement.key.startsWith("like_first") ||
+      achievement.key.startsWith("like_enthusiast") ||
+      achievement.key.startsWith("like_fan") ||
+      achievement.key.startsWith("like_super") ||
+      achievement.key.startsWith("like_mega") ||
+      achievement.key.startsWith("like_legendary")
+    ) {
+      const count = await prisma.like.count({
+        where: { userId },
+      });
+      return count >= (requirements.count ?? 0);
+    }
+
+    // Media-specific achievements
+    if (achievement.key === "like_book_lover") {
+      const count = await prisma.like.count({
+        where: {
+          userId,
+          entityType: "book",
+        },
+      });
+      return count >= 50;
+    }
+
+    if (achievement.key === "like_gamer") {
+      const count = await prisma.like.count({
+        where: {
+          userId,
+          entityType: "game",
+        },
+      });
+      return count >= 50;
+    }
+
+    if (achievement.key === "like_cinephile") {
+      const count = await prisma.like.count({
+        where: {
+          userId,
+          entityType: "show",
+        },
+      });
+      return count >= 50;
+    }
+
+    if (achievement.key === "like_music") {
+      const count = await prisma.like.count({
+        where: {
+          userId,
+          entityType: "music",
+        },
+      });
+      return count >= 50;
+    }
+
+    // Diversity achievement
+    if (achievement.key === "like_diverse") {
+      const types = await prisma.like.groupBy({
+        by: ["entityType"],
+        where: { userId },
+      });
+      return types.length >= 6;
+    }
+
+    // Binge liker (20+ in one day)
+    if (achievement.key === "like_binge") {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const tomorrow = new Date(today);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      const count = await prisma.like.count({
+        where: {
+          userId,
+          createdAt: {
+            gte: today,
+            lt: tomorrow,
+          },
+        },
+      });
+      return count >= 20;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check comment-based achievements.
+   */
+  private async checkCommentAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    const { requirements } = achievement;
+
+    // Count-based achievements (total comments)
+    if (
+      achievement.key.startsWith("comment_first") ||
+      achievement.key.startsWith("comment_reviewer") ||
+      achievement.key.startsWith("comment_critic") ||
+      achievement.key.startsWith("comment_expert") ||
+      achievement.key.startsWith("comment_master") ||
+      achievement.key.startsWith("comment_legend")
+    ) {
+      const count = await prisma.comment.count({
+        where: { userId },
+      });
+      return count >= (requirements.count ?? 0);
+    }
+
+    // Length-based achievements
+    if (achievement.key === "comment_detailed") {
+      const count = await prisma.comment.count({
+        where: {
+          userId,
+          content: {
+            // MongoDB doesn't have a direct length check, so we'll fetch and check
+          },
+        },
+      });
+
+      // Fetch all comments and check length
+      const comments = await prisma.comment.findMany({
+        where: { userId },
+        select: { content: true },
+      });
+
+      const longComments = comments.filter((c) => c.content.length >= 500);
+      return longComments.length >= 10;
+    }
+
+    if (achievement.key === "comment_essay") {
+      const comments = await prisma.comment.findMany({
+        where: { userId },
+        select: { content: true },
+      });
+
+      const longComments = comments.filter((c) => c.content.length >= 1000);
+      return longComments.length >= 5;
+    }
+
+    if (achievement.key === "comment_novel") {
+      const comments = await prisma.comment.findMany({
+        where: { userId },
+        select: { content: true },
+      });
+
+      const longComments = comments.filter((c) => c.content.length >= 2000);
+      return longComments.length >= 3;
+    }
+
+    // Thoughtful reviewer (50 different items)
+    if (achievement.key === "comment_thoughtful") {
+      // Count unique entity IDs
+      const comments = await prisma.comment.findMany({
+        where: { userId },
+        select: {
+          bookId: true,
+          gameId: true,
+          showId: true,
+          mangaId: true,
+          musicId: true,
+          artId: true,
+        },
+      });
+
+      const uniqueItems = new Set<string>();
+      comments.forEach((c) => {
+        const entityId =
+          c.bookId ??
+          c.gameId ??
+          c.showId ??
+          c.mangaId ??
+          c.musicId ??
+          c.artId;
+        if (entityId) {
+          uniqueItems.add(entityId);
+        }
+      });
+
+      return uniqueItems.size >= 50;
+    }
+
+    // Diversity achievement
+    if (achievement.key === "comment_diverse") {
+      const comments = await prisma.comment.findMany({
+        where: { userId },
+        select: {
+          bookId: true,
+          gameId: true,
+          showId: true,
+          mangaId: true,
+          musicId: true,
+          artId: true,
+        },
+      });
+
+      const types = new Set<string>();
+      comments.forEach((c) => {
+        if (c.bookId) {
+          types.add("book");
+        }
+        if (c.gameId) {
+          types.add("game");
+        }
+        if (c.showId) {
+          types.add("show");
+        }
+        if (c.mangaId) {
+          types.add("manga");
+        }
+        if (c.musicId) {
+          types.add("music");
+        }
+        if (c.artId) {
+          types.add("art");
+        }
+      });
+
+      return types.size >= 6;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check engagement-based achievements.
+   */
+  private async checkEngagementAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        currentStreak: true,
+        createdAt: true,
+      },
+    });
+
+    if (!user) {
+      return false;
+    }
+
+    // Welcome achievement
+    if (achievement.key === "engagement_welcome") {
+      return true; // Awarded on first login
+    }
+
+    // Streak-based achievements
+    if (achievement.key.startsWith("engagement_streak")) {
+      return user.currentStreak >= (achievement.requirements.streak ?? 0);
+    }
+
+    // Triple threat (suggestion, like, comment in same day)
+    if (achievement.key === "engagement_triple_threat") {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const tomorrow = new Date(today);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      const [hasSuggestion, hasLike, hasComment] = await Promise.all([
+        prisma.suggestion.count({
+          where: {
+            userId,
+            createdAt: { gte: today, lt: tomorrow },
+          },
+        }),
+        prisma.like.count({
+          where: {
+            userId,
+            createdAt: { gte: today, lt: tomorrow },
+          },
+        }),
+        prisma.comment.count({
+          where: {
+            userId,
+            createdAt: { gte: today, lt: tomorrow },
+          },
+        }),
+      ]);
+
+      return hasSuggestion > 0 && hasLike > 0 && hasComment > 0;
+    }
+
+    // Power user (triple threat 10 times) - would need special tracking
+    // Early adopter achievements
+    if (
+      achievement.key === "engagement_early_adopter" ||
+      achievement.key === "engagement_founding_100" ||
+      achievement.key === "engagement_founding_1000"
+    ) {
+      const userRank = await prisma.user.count({
+        where: {
+          createdAt: {
+            lt: user.createdAt,
+          },
+        },
+      });
+
+      if (achievement.key === "engagement_early_adopter") {
+        return userRank < 10;
+      }
+      if (achievement.key === "engagement_founding_100") {
+        return userRank < 100;
+      }
+      if (achievement.key === "engagement_founding_1000") {
+        return userRank < 1000;
+      }
+    }
+
+    // Account age achievements
+    if (achievement.key.startsWith("engagement_veteran")) {
+      const daysSinceCreation = Math.floor(
+        (Date.now() - user.createdAt.getTime()) / (1000 * 60 * 60 * 24),
+      );
+      return daysSinceCreation >= (achievement.requirements.dayRange ?? 0);
+    }
+
+    return false;
+  }
+
+  /**
+   * Check report-based achievements.
+   */
+  private async checkReportAchievement(
+    userId: string,
+    achievement: AchievementDefinition,
+  ): Promise<boolean> {
+    const { requirements } = achievement;
+
+    // Count ACTION_TAKEN reports
+    if (
+      achievement.key.startsWith("report_watchful") ||
+      achievement.key.startsWith("report_guardian") ||
+      achievement.key.startsWith("report_protector") ||
+      achievement.key.startsWith("report_vigilant")
+    ) {
+      const profileReports = await prisma.profileReport.count({
+        where: {
+          reporterId: userId,
+          status: "ACTION_TAKEN",
+        },
+      });
+
+      const commentReports = await prisma.commentReport.count({
+        where: {
+          reporterId: userId,
+          status: "ACTION_TAKEN",
+        },
+      });
+
+      return profileReports + commentReports >= (requirements.count ?? 0);
+    }
+
+    // Accuracy achievements
+    if (achievement.key.startsWith("report_accuracy")) {
+      const totalProfileReports = await prisma.profileReport.count({
+        where: {
+          reporterId: userId,
+          status: {
+            not: "PENDING",
+          },
+        },
+      });
+
+      const totalCommentReports = await prisma.commentReport.count({
+        where: {
+          reporterId: userId,
+          status: {
+            not: "PENDING",
+          },
+        },
+      });
+
+      const total = totalProfileReports + totalCommentReports;
+
+      if (total < (requirements.count ?? 10)) {
+        return false;
+      }
+
+      const actionTakenProfile = await prisma.profileReport.count({
+        where: {
+          reporterId: userId,
+          status: "ACTION_TAKEN",
+        },
+      });
+
+      const actionTakenComment = await prisma.commentReport.count({
+        where: {
+          reporterId: userId,
+          status: "ACTION_TAKEN",
+        },
+      });
+
+      const actionTaken = actionTakenProfile + actionTakenComment;
+      const rate = actionTaken / total;
+
+      return rate >= (requirements.rate ?? 0);
+    }
+
+    // Volume achievement (total reports)
+    if (achievement.key === "report_volume") {
+      const profileReports = await prisma.profileReport.count({
+        where: { reporterId: userId },
+      });
+
+      const commentReports = await prisma.commentReport.count({
+        where: { reporterId: userId },
+      });
+
+      return profileReports + commentReports >= 50;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get a user's achievement progress and summary.
+   */
+  async getUserAchievementSummary(
+    userId: string,
+  ): Promise<UserAchievementSummary> {
+    const userAchievements = await prisma.userAchievement.findMany({
+      where: { userId },
+      orderBy: { earnedAt: "desc" },
+    });
+
+    const earnedAchievements = userAchievements.filter((ua) => ua.earned);
+    const totalPoints = earnedAchievements.reduce((sum, ua) => {
+      const definition = ACHIEVEMENTS[ua.achievementKey];
+      return sum + (definition?.points ?? 0);
+    }, 0);
+
+    const recentAchievements: AchievementProgress[] = earnedAchievements
+      .slice(0, 5)
+      .map((ua) => ({
+        definition: ACHIEVEMENTS[ua.achievementKey],
+        progress: ua.progress,
+        earned: ua.earned,
+        earnedAt: ua.earnedAt ?? undefined,
+      }));
+
+    // Progress by category
+    const progressByCategory = Object.values(AchievementCategory).map(
+      (category) => {
+        const categoryAchievements = ACHIEVEMENT_LIST.filter(
+          (a) => a.category === category,
+        );
+        const earned = earnedAchievements.filter(
+          (ua) => ACHIEVEMENTS[ua.achievementKey]?.category === category,
+        ).length;
+
+        return {
+          category,
+          earned,
+          total: categoryAchievements.length,
+        };
+      },
+    );
+
+    return {
+      totalPoints,
+      totalEarned: earnedAchievements.length,
+      recentAchievements,
+      progressByCategory,
+    };
+  }
+
+  /**
+   * Get all achievements with progress for a user.
+   */
+  async getUserAchievementProgress(
+    userId: string,
+  ): Promise<AchievementProgress[]> {
+    const userAchievements = await prisma.userAchievement.findMany({
+      where: { userId },
+    });
+
+    const progressMap = new Map(
+      userAchievements.map((ua) => [ua.achievementKey, ua]),
+    );
+
+    return ACHIEVEMENT_LIST.map((definition) => {
+      const userAchievement = progressMap.get(definition.key);
+      return {
+        definition,
+        progress: userAchievement?.progress ?? 0,
+        earned: userAchievement?.earned ?? false,
+        earnedAt: userAchievement?.earnedAt ?? undefined,
+      };
+    });
+  }
+
+  /**
+   * Update login streak for a user.
+   */
+  async updateLoginStreak(userId: string): Promise<void> {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        currentStreak: true,
+        lastStreakCheck: true,
+      },
+    });
+
+    if (!user) {
+      return;
+    }
+
+    const now = new Date();
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+    yesterday.setHours(0, 0, 0, 0);
+
+    const lastCheck = user.lastStreakCheck;
+    const isConsecutive =
+      lastCheck &&
+      lastCheck >= yesterday &&
+      lastCheck < new Date(now.setHours(0, 0, 0, 0));
+
+    await prisma.user.update({
+      where: { id: userId },
+      data: {
+        currentStreak: isConsecutive ? user.currentStreak + 1 : 1,
+        lastStreakCheck: new Date(),
+      },
+    });
+  }
+}

api/src/app/services/like.service.ts

@@ -7,8 +7,9 @@
 import type { FastifyRequest } from 'fastify';
 import { prisma } from '../lib/prisma';
 import { AuditService } from './audit.service';
+import { AchievementService } from './achievement.service';
 import type { Like, LikeCountDto, LikedItemDto, LikeResponse } from '@library/shared-types';
-import { AuditAction, AuditCategory } from '@library/shared-types';
+import { AuditAction, AuditCategory, AchievementCategory } from '@library/shared-types';
 
 export class LikeService {
   async toggleLike(userId: string, entityType: Like['entityType'], entityId: string, req: FastifyRequest): Promise<LikeResponse> {
@@ -59,6 +60,14 @@ export class LikeService {
         details: `Liked ${entityType}`
       });
 
+      // Check for like achievements
+      const achievementService = new AchievementService();
+      await achievementService.checkAchievements(
+        userId,
+        AchievementCategory.Like,
+        req
+      );
+
       const count = await this.getLikeCount(entityType, entityId);
       return { liked: true, count };
     }

api/src/app/services/user.service.ts

@@ -260,6 +260,7 @@ export class UserService {
     inDiscord: boolean;
     profilePublic: boolean;
     createdAt: Date;
+    achievementPoints: number;
     stats: {
       suggestionsCount: number;
       suggestionsAcceptedCount: number;
@@ -316,6 +317,7 @@ export class UserService {
       inDiscord: user.inDiscord,
       profilePublic: user.profilePublic,
       createdAt: user.createdAt,
+      achievementPoints: user.achievementPoints,
       stats: {
         suggestionsCount: user.suggestions.length,
         suggestionsAcceptedCount: user.suggestions.filter(