feat(dashboard): add moderation log page + message edit history

- Backend moderation module: GET /api/moderation/stats (per-status + failed rate)
  + GET /api/moderation/actions (filter by status/actionType, cursor paging),
  joins messages for target username + content
- Message GET /api/messages/detail/:id now returns edit_count + edit_history
  (old_content snapshots from message_edits, newest first)
- FE: new /moderation page — summary cards (total/executed/failed/pending +
  failed-rate), status+type filter chips, timeline rows with action icon,
  target user, reason, status badge, timestamps, error text
- FE: message detail shows 'Riwayat edit' panel with previous versions

services/backend/src/http/app.ts

@@ -13,6 +13,7 @@ import { createDashboardRouter } from "../modules/dashboard/index.js";
 import { createHealthRouter } from "../modules/health/index.js";
 import { createMediaRouter } from "../modules/media/index.js";
 import { createMessagesRouter } from "../modules/messages/index.js";
+import { createModerationRouter } from "../modules/moderation/index.js";
 import { createRecordingsRouter } from "../modules/recordings/index.js";
 import { createUiStateRouter } from "../modules/ui-state/index.js";
 import { createVoiceRouter } from "../modules/voice/index.js";
@@ -69,6 +70,7 @@ export function createHttpApp(): Express {
   app.use("/api", createUiStateRouter());
   app.use("/api", createMediaRouter());
   app.use("/api", createVoiceRouter());
+  app.use("/api", createModerationRouter());
 
   // 404 handler
   app.use((_req: Request, res: Response) => {

services/backend/src/modules/messages/messages.repository.ts

@@ -9,6 +9,7 @@ import {
   notInArray,
   or,
   type SQL,
+  sql,
 } from "drizzle-orm";
 import { config } from "../../shared/config/index.js";
 import { getDatabase } from "../../shared/database/index.js";
@@ -114,6 +115,27 @@ export class MessagesRepository {
     return mapMessageRow(row as Record<string, unknown>);
   }
 
+  /**
+   * Edit history for a message: previous content snapshots (newest first).
+   * Stored in message_edits by the gateway's message-capture module.
+   */
+  async getEditHistory(
+    messageId: string,
+  ): Promise<Array<{ old_content: string; edited_at: number }>> {
+    const db = getDatabase();
+    const result = await db.execute(sql`
+      SELECT old_content, edited_at
+      FROM message_edits
+      WHERE message_id = ${messageId}
+      ORDER BY edited_at DESC
+      LIMIT 50
+    `);
+    return ((result.rows as Record<string, unknown>[]) || []).map((r) => ({
+      old_content: String(r.old_content ?? ""),
+      edited_at: Number(r.edited_at ?? 0),
+    }));
+  }
+
   async findByChannel(
     channelId: string,
     query: MessageQuery,

services/backend/src/modules/messages/messages.service.ts

@@ -34,7 +34,12 @@ export class MessagesService {
       throw new NotFoundError(`Message with ID ${id} not found`);
     }
 
-    return message;
+    const editHistory = await messagesRepository.getEditHistory(id);
+    return {
+      ...message,
+      edit_count: editHistory.length,
+      edit_history: editHistory,
+    };
   }
 
   async getAttachmentsByChannel(channelId: string, query: MessageQuery) {

services/backend/src/modules/moderation/index.ts

@@ -0,0 +1 @@
+export { createModerationRouter } from "./moderation.routes.js";

services/backend/src/modules/moderation/moderation.repository.ts

@@ -0,0 +1,141 @@
+import { sql } from "drizzle-orm";
+import { getDatabase } from "../../shared/database/index.js";
+
+export interface ListModerationQuery {
+  status?: string;
+  actionType?: string;
+  limit?: number;
+  cursor?: number;
+}
+
+const ACTION_TYPES = [
+  "delete_message",
+  "mute_user",
+  "warn_user",
+  "kick_user",
+  "ban_user",
+] as const;
+const STATUSES = ["pending", "executed", "failed"] as const;
+
+export class ModerationRepository {
+  async getStats() {
+    const db = getDatabase();
+    const result = await db.execute(sql`
+      SELECT action_type, status, COUNT(*)::int AS c
+      FROM moderation_actions
+      GROUP BY action_type, status
+    `);
+
+    const rows = (result.rows as Record<string, unknown>[]) || [];
+    let executed = 0;
+    let failed = 0;
+    let pending = 0;
+
+    const byAction: Record<
+      string,
+      { executed: number; failed: number; pending: number }
+    > = {};
+
+    for (const r of rows) {
+      const actionType = String(r.action_type ?? "unknown");
+      const status = String(r.status ?? "unknown");
+      const count = Number(r.c ?? 0);
+      byAction[actionType] ??= { executed: 0, failed: 0, pending: 0 };
+      if (status === "executed") {
+        executed += count;
+        byAction[actionType].executed += count;
+      } else if (status === "failed") {
+        failed += count;
+        byAction[actionType].failed += count;
+      } else {
+        pending += count;
+        byAction[actionType].pending += count;
+      }
+    }
+
+    const total = executed + failed + pending;
+
+    return {
+      total,
+      executed,
+      failed,
+      pending,
+      failed_rate: total > 0 ? Number(((failed / total) * 100).toFixed(1)) : 0,
+      by_action: byAction,
+    };
+  }
+
+  async listActions(query: ListModerationQuery) {
+    const db = getDatabase();
+    const limit = Math.min(Math.max(query.limit ?? 50, 1), 200);
+    const conditions: string[] = [];
+
+    if (
+      query.status &&
+      (STATUSES as readonly string[]).includes(query.status)
+    ) {
+      conditions.push(`a.status = '${query.status}'`);
+    }
+    if (
+      query.actionType &&
+      (ACTION_TYPES as readonly string[]).includes(query.actionType)
+    ) {
+      conditions.push(`a.action_type = '${query.actionType}'`);
+    }
+    if (query.cursor) {
+      conditions.push(`a.created_at < ${Number(query.cursor)}`);
+    }
+
+    const whereClause =
+      conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+
+    const result = await db.execute(
+      sql.raw(`
+      SELECT
+        a.id,
+        a.message_id,
+        a.user_id,
+        a.guild_id,
+        a.action_type,
+        a.reason,
+        a.executed_by,
+        a.status,
+        a.error,
+        a.created_at,
+        a.executed_at,
+        m.username,
+        LEFT(m.content, 300) AS content
+      FROM moderation_actions a
+      LEFT JOIN messages m ON m.id = a.message_id
+      ${whereClause}
+      ORDER BY a.created_at DESC
+      LIMIT ${limit + 1}
+    `),
+    );
+
+    const rows = (result.rows as Record<string, unknown>[]) || [];
+    const data = rows.slice(0, limit).map((r) => ({
+      id: String(r.id ?? ""),
+      message_id: r.message_id ? String(r.message_id) : null,
+      user_id: r.user_id ? String(r.user_id) : null,
+      guild_id: String(r.guild_id ?? ""),
+      action_type: String(r.action_type ?? "unknown"),
+      reason: r.reason ? String(r.reason) : null,
+      executed_by: r.executed_by ? String(r.executed_by) : null,
+      status: String(r.status ?? "unknown"),
+      error: r.error ? String(r.error) : null,
+      created_at: r.created_at ? Number(r.created_at) : null,
+      executed_at: r.executed_at ? Number(r.executed_at) : null,
+      username: r.username ? String(r.username) : null,
+      content: r.content ? String(r.content) : null,
+    }));
+
+    const lastRow = rows[limit - 1] as Record<string, unknown> | undefined;
+    const nextCursor =
+      rows.length > limit ? String(lastRow?.created_at ?? "") : null;
+
+    return { data, nextCursor };
+  }
+}
+
+export const moderationRepository = new ModerationRepository();

services/backend/src/modules/moderation/moderation.routes.ts

@@ -0,0 +1,43 @@
+import type { Request, Response, Router } from "express";
+import express from "express";
+import { createChildLogger } from "../../shared/logger/index.js";
+import { asyncHandler } from "../../shared/middlewares/index.js";
+import { moderationService } from "./moderation.service.js";
+
+const logger = createChildLogger("moderation.routes");
+
+export function createModerationRouter(): Router {
+  const router = express.Router();
+
+  // GET /api/moderation/stats — moderation action summary
+  router.get(
+    "/moderation/stats",
+    asyncHandler(async (_req: Request, res: Response) => {
+      const stats = await moderationService.getStats();
+      res.json(stats);
+    }),
+  );
+
+  // GET /api/moderation/actions — paginated moderation action log
+  router.get(
+    "/moderation/actions",
+    asyncHandler(async (req: Request, res: Response) => {
+      const limit = Number(req.query.limit) || 50;
+      const status = req.query.status as string | undefined;
+      const actionType = req.query.actionType as string | undefined;
+      const cursor = req.query.cursor as string | undefined;
+
+      const result = await moderationService.listActions({
+        limit,
+        status,
+        actionType,
+        cursor: cursor ? Number(cursor) : undefined,
+      });
+
+      logger.debug({ count: result.data.length }, "Moderation actions listed");
+      res.json(result);
+    }),
+  );
+
+  return router;
+}

services/backend/src/modules/moderation/moderation.service.ts

@@ -0,0 +1,21 @@
+import { createChildLogger } from "../../shared/logger/index.js";
+import {
+  type ListModerationQuery,
+  moderationRepository,
+} from "./moderation.repository.js";
+
+const logger = createChildLogger("moderation.service");
+
+export class ModerationService {
+  async getStats() {
+    logger.debug("Fetching moderation stats");
+    return moderationRepository.getStats();
+  }
+
+  async listActions(query: ListModerationQuery) {
+    logger.debug({ query }, "Listing moderation actions");
+    return moderationRepository.listActions(query);
+  }
+}
+
+export const moderationService = new ModerationService();