diff --git a/app/helpers/statistics.test.ts b/app/helpers/statistics.test.ts
new file mode 100644
index 0000000..b884255
--- /dev/null
+++ b/app/helpers/statistics.test.ts
@@ -0,0 +1,203 @@
+import { describe, it, expect } from "vitest";
+import {
+  descriptiveStats,
+  correlation,
+  linearRegression,
+  zScore,
+  percentile,
+  outliers,
+  movingAverage,
+  histogram,
+  confidence,
+  tTest,
+} from "./statistics";
+
+describe("statistics helpers", () => {
+  const sampleData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+  const smallData = [1, 2, 3];
+
+  describe("descriptiveStats", () => {
+    it("calculates basic statistics correctly", () => {
+      const stats = descriptiveStats(sampleData);
+
+      expect(stats.mean).toBe(5.5);
+      expect(stats.median).toBe(5.5);
+      expect(stats.min).toBe(1);
+      expect(stats.max).toBe(10);
+      expect(stats.count).toBe(10);
+      expect(stats.sum).toBe(55);
+      expect(stats.range).toBe(9);
+    });
+
+    it("throws error for empty data", () => {
+      expect(() => descriptiveStats([])).toThrow(
+        "Cannot calculate statistics for empty dataset",
+      );
+    });
+  });
+
+  describe("correlation", () => {
+    it("calculates correlation correctly", () => {
+      const x = [1, 2, 3, 4, 5];
+      const y = [2, 4, 6, 8, 10];
+
+      const result = correlation(x, y);
+
+      expect(result.coefficient).toBeCloseTo(1, 10);
+      expect(result.direction).toBe("positive");
+      expect(result.strength).toBe("very strong");
+    });
+
+    it("throws error for mismatched array lengths", () => {
+      expect(() => correlation([1, 2], [1, 2, 3])).toThrow(
+        "Arrays must have the same length",
+      );
+    });
+  });
+
+  describe("linearRegression", () => {
+    it("calculates linear regression correctly", () => {
+      const x = [1, 2, 3, 4, 5];
+      const y = [2, 4, 6, 8, 10];
+
+      const result = linearRegression(x, y);
+
+      expect(result.slope).toBe(2);
+      expect(result.intercept).toBe(0);
+      expect(result.predict(6)).toBe(12);
+    });
+
+    it("throws error for insufficient data points", () => {
+      expect(() => linearRegression([1], [2])).toThrow(
+        "Need at least 2 data points for regression",
+      );
+    });
+  });
+
+  describe("zScore", () => {
+    it("calculates z-score correctly", () => {
+      const score = zScore(7, 5, 2);
+      expect(score).toBe(1);
+    });
+
+    it("throws error for zero standard deviation", () => {
+      expect(() => zScore(5, 5, 0)).toThrow(
+        "Standard deviation cannot be zero",
+      );
+    });
+  });
+
+  describe("percentile", () => {
+    it("calculates percentiles correctly", () => {
+      const p50 = percentile(sampleData, 0.5);
+      const p25 = percentile(sampleData, 0.25);
+
+      expect(p50).toBe(5.5);
+      expect(p25).toBeCloseTo(3.25, 0);
+    });
+
+    it("throws error for invalid percentile values", () => {
+      expect(() => percentile(sampleData, 1.5)).toThrow(
+        "Percentile must be between 0 and 1",
+      );
+      expect(() => percentile(sampleData, -0.1)).toThrow(
+        "Percentile must be between 0 and 1",
+      );
+    });
+  });
+
+  describe("outliers", () => {
+    it("detects outliers using IQR method", () => {
+      const dataWithOutliers = [1, 2, 3, 4, 5, 100];
+      const result = outliers(dataWithOutliers, "iqr");
+
+      expect(result).toContain(100);
+    });
+
+    it("detects outliers using z-score method", () => {
+      const dataWithOutliers = [1, 2, 3, 4, 5, 100];
+      const result = outliers(dataWithOutliers, "zscore");
+
+      expect(result).toContain(100);
+    });
+
+    it("returns empty array for empty data", () => {
+      expect(outliers([])).toEqual([]);
+    });
+  });
+
+  describe("movingAverage", () => {
+    it("calculates moving average correctly", () => {
+      const result = movingAverage([1, 2, 3, 4, 5], 3);
+
+      expect(result).toEqual([2, 3, 4]);
+    });
+
+    it("throws error for invalid window size", () => {
+      expect(() => movingAverage(sampleData, 0)).toThrow("Invalid window size");
+      expect(() => movingAverage(sampleData, 15)).toThrow(
+        "Invalid window size",
+      );
+    });
+  });
+
+  describe("histogram", () => {
+    it("creates histogram correctly", () => {
+      const result = histogram(smallData, 2);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].count + result[1].count).toBe(3);
+    });
+
+    it("returns empty array for empty data", () => {
+      expect(histogram([])).toEqual([]);
+    });
+  });
+
+  describe("confidence", () => {
+    it("calculates confidence interval correctly", () => {
+      const result = confidence(sampleData, 0.95);
+
+      expect(result.mean).toBe(5.5);
+      expect(result.lower).toBeLessThan(result.mean);
+      expect(result.upper).toBeGreaterThan(result.mean);
+    });
+
+    it("throws error for empty data", () => {
+      expect(() => confidence([])).toThrow(
+        "Cannot calculate confidence interval for empty dataset",
+      );
+    });
+
+    it("throws error for invalid confidence level", () => {
+      expect(() => confidence(sampleData, 0)).toThrow(
+        "Confidence level must be between 0 and 1",
+      );
+      expect(() => confidence(sampleData, 1)).toThrow(
+        "Confidence level must be between 0 and 1",
+      );
+    });
+  });
+
+  describe("tTest", () => {
+    it("performs t-test correctly", () => {
+      const sample1 = [1, 2, 3, 4, 5];
+      const sample2 = [6, 7, 8, 9, 10];
+
+      const result = tTest(sample1, sample2);
+
+      expect(typeof result.tStatistic).toBe("number");
+      expect(typeof result.pValue).toBe("number");
+      expect(typeof result.significant).toBe("boolean");
+    });
+
+    it("throws error for empty samples", () => {
+      expect(() => tTest([], [1, 2, 3])).toThrow(
+        "Cannot perform t-test on empty samples",
+      );
+      expect(() => tTest([1, 2, 3], [])).toThrow(
+        "Cannot perform t-test on empty samples",
+      );
+    });
+  });
+});
diff --git a/app/helpers/statistics.ts b/app/helpers/statistics.ts
new file mode 100644
index 0000000..86318e2
--- /dev/null
+++ b/app/helpers/statistics.ts
@@ -0,0 +1,262 @@
+import * as ss from "simple-statistics";
+
+export interface StatisticalSummary {
+  mean: number;
+  median: number;
+  mode: number | null;
+  standardDeviation: number;
+  variance: number;
+  min: number;
+  max: number;
+  range: number;
+  count: number;
+  sum: number;
+  quantiles: {
+    q1: number;
+    q3: number;
+    iqr: number;
+  };
+}
+
+export interface CorrelationResult {
+  coefficient: number;
+  strength: "very weak" | "weak" | "moderate" | "strong" | "very strong";
+  direction: "positive" | "negative" | "none";
+}
+
+export interface RegressionResult {
+  slope: number;
+  intercept: number;
+  rSquared: number;
+  predict: (x: number) => number;
+}
+
+export function descriptiveStats(data: number[]): StatisticalSummary {
+  if (data.length === 0) {
+    throw new Error("Cannot calculate statistics for empty dataset");
+  }
+
+  const mean = ss.mean(data);
+  const median = ss.median(data);
+  const standardDeviation = ss.standardDeviation(data);
+  const variance = ss.variance(data);
+  const min = ss.min(data);
+  const max = ss.max(data);
+  const sum = ss.sum(data);
+  const q1 = ss.quantile(data, 0.25);
+  const q3 = ss.quantile(data, 0.75);
+
+  let mode: number | null = null;
+  try {
+    mode = ss.mode(data);
+  } catch {
+    mode = null;
+  }
+
+  return {
+    mean,
+    median,
+    mode,
+    standardDeviation,
+    variance,
+    min,
+    max,
+    range: max - min,
+    count: data.length,
+    sum,
+    quantiles: {
+      q1,
+      q3,
+      iqr: q3 - q1,
+    },
+  };
+}
+
+export function correlation(x: number[], y: number[]): CorrelationResult {
+  if (x.length !== y.length) {
+    throw new Error("Arrays must have the same length");
+  }
+  if (x.length === 0) {
+    throw new Error("Cannot calculate correlation for empty datasets");
+  }
+
+  const coefficient = ss.sampleCorrelation(x, y);
+  const absCoeff = Math.abs(coefficient);
+
+  let strength: CorrelationResult["strength"];
+  if (absCoeff < 0.2) strength = "very weak";
+  else if (absCoeff < 0.4) strength = "weak";
+  else if (absCoeff < 0.6) strength = "moderate";
+  else if (absCoeff < 0.8) strength = "strong";
+  else strength = "very strong";
+
+  const direction =
+    coefficient > 0 ? "positive" : coefficient < 0 ? "negative" : "none";
+
+  return {
+    coefficient,
+    strength,
+    direction,
+  };
+}
+
+export function linearRegression(x: number[], y: number[]): RegressionResult {
+  if (x.length !== y.length) {
+    throw new Error("Arrays must have the same length");
+  }
+  if (x.length < 2) {
+    throw new Error("Need at least 2 data points for regression");
+  }
+
+  const points = x.map((xi, i) => [xi, y[i]]);
+  const regression = ss.linearRegression(points);
+  const rSquared = ss.rSquared(points, ss.linearRegressionLine(regression));
+
+  return {
+    slope: regression.m,
+    intercept: regression.b,
+    rSquared,
+    predict: (xVal: number) => regression.m * xVal + regression.b,
+  };
+}
+
+export function zScore(
+  value: number,
+  mean: number,
+  standardDeviation: number,
+): number {
+  if (standardDeviation === 0) {
+    throw new Error("Standard deviation cannot be zero");
+  }
+  return (value - mean) / standardDeviation;
+}
+
+export function percentile(data: number[], p: number): number {
+  if (p < 0 || p > 1) {
+    throw new Error("Percentile must be between 0 and 1");
+  }
+  return ss.quantile(data, p);
+}
+
+export function outliers(
+  data: number[],
+  method: "iqr" | "zscore" = "iqr",
+): number[] {
+  if (data.length === 0) {
+    return [];
+  }
+
+  if (method === "iqr") {
+    const q1 = ss.quantile(data, 0.25);
+    const q3 = ss.quantile(data, 0.75);
+    const iqr = q3 - q1;
+    const lowerBound = q1 - 1.5 * iqr;
+    const upperBound = q3 + 1.5 * iqr;
+
+    return data.filter((value) => value < lowerBound || value > upperBound);
+  }
+
+  if (method === "zscore") {
+    const mean = ss.mean(data);
+    const stdDev = ss.standardDeviation(data);
+    return data.filter((value) => Math.abs(zScore(value, mean, stdDev)) > 2);
+  }
+
+  return [];
+}
+
+export function movingAverage(data: number[], windowSize: number): number[] {
+  if (windowSize <= 0 || windowSize > data.length) {
+    throw new Error("Invalid window size");
+  }
+
+  const result: number[] = [];
+  for (let i = 0; i <= data.length - windowSize; i++) {
+    const window = data.slice(i, i + windowSize);
+    result.push(ss.mean(window));
+  }
+  return result;
+}
+
+export function histogram(
+  data: number[],
+  bins: number = 10,
+): Array<{ bin: string; count: number; frequency: number }> {
+  if (data.length === 0) {
+    return [];
+  }
+
+  const min = ss.min(data);
+  const max = ss.max(data);
+  const binWidth = (max - min) / bins;
+  const binCounts = new Array(bins).fill(0);
+
+  data.forEach((value) => {
+    const binIndex = Math.min(Math.floor((value - min) / binWidth), bins - 1);
+    binCounts[binIndex]++;
+  });
+
+  return binCounts.map((count, index) => {
+    const binStart = min + index * binWidth;
+    const binEnd = binStart + binWidth;
+    return {
+      bin: `${binStart.toFixed(2)}-${binEnd.toFixed(2)}`,
+      count,
+      frequency: count / data.length,
+    };
+  });
+}
+
+export function confidence(
+  data: number[],
+  level: number = 0.95,
+): { mean: number; marginOfError: number; lower: number; upper: number } {
+  if (data.length === 0) {
+    throw new Error("Cannot calculate confidence interval for empty dataset");
+  }
+  if (level <= 0 || level >= 1) {
+    throw new Error("Confidence level must be between 0 and 1");
+  }
+
+  const mean = ss.mean(data);
+  const standardError = ss.standardDeviation(data) / Math.sqrt(data.length);
+  const criticalValue = 1.96;
+  const marginOfError = criticalValue * standardError;
+
+  return {
+    mean,
+    marginOfError,
+    lower: mean - marginOfError,
+    upper: mean + marginOfError,
+  };
+}
+
+export function tTest(
+  sample1: number[],
+  sample2: number[],
+): { tStatistic: number; pValue: number; significant: boolean } {
+  if (sample1.length === 0 || sample2.length === 0) {
+    throw new Error("Cannot perform t-test on empty samples");
+  }
+
+  const mean1 = ss.mean(sample1);
+  const mean2 = ss.mean(sample2);
+  const var1 = ss.variance(sample1);
+  const var2 = ss.variance(sample2);
+  const n1 = sample1.length;
+  const n2 = sample2.length;
+
+  const pooledVariance = ((n1 - 1) * var1 + (n2 - 1) * var2) / (n1 + n2 - 2);
+  const standardError = Math.sqrt(pooledVariance * (1 / n1 + 1 / n2));
+  const tStatistic = (mean1 - mean2) / standardError;
+
+  const pValue =
+    2 * (1 - ss.cumulativeStdNormalProbability(Math.abs(tStatistic)));
+  const significant = pValue < 0.05;
+
+  return {
+    tStatistic,
+    pValue,
+    significant,
+  };
+}
diff --git a/app/models/activity.server.ts b/app/models/activity.server.ts
index 2eda603..29f5aec 100644
--- a/app/models/activity.server.ts
+++ b/app/models/activity.server.ts
@@ -1,15 +1,143 @@
 import type { DB } from "#~/db.server";
 import db from "#~/db.server";
 import { getOrFetchUser } from "#~/helpers/userInfoCache.js";
+import { fillDateGaps } from "#~/helpers/dateUtils";
+import { sql } from "kysely";
 
 type MessageStats = DB["message_stats"];
 
+// // Default allowed channel categories for analytics
+// const ALLOWED_CATEGORIES: string[] = [
+//   "Need Help",
+//   "React General",
+//   "Advanced Topics",
+// ];
+
+// // Default allowed channels (currently empty but can be configured)
+// const ALLOWED_CHANNELS: string[] = [];
+
+/**
+ * Creates a base query for message_stats filtered by guild, date range, and optionally user
+ */
+export function createMessageStatsQuery(
+  guildId: MessageStats["guild_id"],
+  start: string,
+  end: string,
+  userId?: MessageStats["author_id"],
+) {
+  let query = db
+    .selectFrom("message_stats")
+    .where("guild_id", "=", guildId)
+    .where("sent_at", ">=", new Date(start).getTime())
+    .where("sent_at", "<=", new Date(end + "T23:59:59").getTime());
+
+  if (userId) {
+    query = query.where("author_id", "=", userId);
+  }
+
+  return query;
+}
+
+/**
+ * Gets complete user message analytics using composed queries
+ */
+export async function getUserMessageAnalytics(
+  guildId: string,
+  userId: string,
+  start: string,
+  end: string,
+) {
+  // Build daily stats query
+  const dailyQuery = createMessageStatsQuery(guildId, start, end, userId)
+    .select(({ fn, eb, lit }) => [
+      fn.countAll<number>().as("messages"),
+      fn.sum<number>("word_count").as("word_count"),
+      fn.sum<number>("react_count").as("react_count"),
+      fn("round", [fn.avg("word_count"), lit(3)]).as("avg_words"),
+      eb
+        .fn("date", [eb("sent_at", "/", lit(1000)), sql.lit("unixepoch")])
+        .as("date"),
+    ])
+    // .where((eb) =>
+    //   eb.or([
+    //     eb("channel_id", "in", ALLOWED_CHANNELS),
+    //     eb("channel_category", "in", ALLOWED_CATEGORIES),
+    //   ]),
+    // )
+    .orderBy("date", "asc")
+    .groupBy("date");
+
+  // Build category stats query
+  const categoryQuery = createMessageStatsQuery(guildId, start, end, userId)
+    .select(({ fn }) => [
+      fn.count<number>("channel_category").as("messages"),
+      "channel_category",
+    ])
+    // .where((eb) =>
+    //   eb.or([
+    //     eb("channel_id", "in", ALLOWED_CHANNELS),
+    //     eb("channel_category", "in", ALLOWED_CATEGORIES),
+    //   ]),
+    // )
+    .groupBy("channel_category");
+
+  // Build channel stats query
+  const channelQuery = createMessageStatsQuery(guildId, start, end, userId)
+    // @ts-expect-error - Kysely selector typing is complex
+    .select(({ fn }) => [
+      fn.count<number>("channel_id").as("messages"),
+      "channel_id",
+      "channel.name",
+    ])
+    .leftJoin(
+      "channel_info as channel",
+      "channel.id",
+      "message_stats.channel_id",
+    )
+    // .where((eb) =>
+    //   eb.or([
+    //     eb("channel_id", "in", ALLOWED_CHANNELS),
+    //     eb("channel_category", "in", ALLOWED_CATEGORIES),
+    //   ]),
+    // )
+    .orderBy("messages", "desc")
+    .groupBy("channel_id");
+
+  const [dailyResults, categoryBreakdown, channelBreakdown, userInfo] =
+    await Promise.all([
+      dailyQuery.execute(),
+      categoryQuery.execute(),
+      channelQuery.execute(),
+      getOrFetchUser(userId),
+    ]);
+
+  type DailyBreakdown = {
+    messages: number;
+    word_count: number;
+    react_count: number;
+    avg_words: number;
+    date: string;
+  };
+  // Only daily breakdown needs date gap filling
+  const dailyBreakdown = fillDateGaps<DailyBreakdown>(
+    dailyResults as DailyBreakdown[],
+    start,
+    end,
+    {
+      messages: 0,
+      word_count: 0,
+      react_count: 0,
+      avg_words: 0,
+    },
+  );
+
+  return { dailyBreakdown, categoryBreakdown, channelBreakdown, userInfo };
+}
+
 export async function getTopParticipants(
   guildId: MessageStats["guild_id"],
   intervalStart: string,
   intervalEnd: string,
-  channels: string[],
-  channelCategories: string[],
 ) {
   const config = {
     count: 100,
@@ -17,29 +145,25 @@ export async function getTopParticipants(
     wordThreshold: 2200,
   };
 
-  const baseQuery = db
-    .selectFrom("message_stats")
+  const baseQuery = createMessageStatsQuery(guildId, intervalStart, intervalEnd)
     .selectAll()
-    .select(({ fn, val, eb }) => [
-      fn("date", [eb("sent_at", "/", 1000), val("unixepoch")]).as("date"),
-    ])
-    .where("guild_id", "=", guildId)
-    .where(({ between, and, or, eb }) =>
-      and([
-        between(
-          "sent_at",
-          new Date(intervalStart).getTime(),
-          new Date(intervalEnd).getTime(),
-        ),
-        or([
-          eb("channel_id", "in", channels),
-          eb("channel_category", "in", channelCategories),
-        ]),
-      ]),
-    );
+    .select(({ fn, eb, lit }) => [
+      fn("date", [eb("sent_at", "/", lit(1000)), sql.lit("unixepoch")]).as(
+        "date",
+      ),
+    ]);
 
-  // get shortlist, volume threshold of 1000 words
+  // Apply channel filtering inline
+  // const filteredQuery = baseQuery.where((eb) =>
+  //   eb.or([
+  //     eb("channel_id", "in", ALLOWED_CHANNELS),
+  //     eb("channel_category", "in", ALLOWED_CATEGORIES),
+  //   ]),
+  // );
+
+  // get shortlist using inline selectors
   const topMembersQuery = db
+    // .with("interval_message_stats", () => filteredQuery)
     .with("interval_message_stats", () => baseQuery)
     .selectFrom("interval_message_stats")
     .select(({ fn }) => [
@@ -54,8 +178,8 @@ export async function getTopParticipants(
     .groupBy("author_id")
     .having(({ eb, or, fn }) =>
       or([
-        eb(fn.count("author_id"), ">=", config.messageThreshold),
-        eb(fn.sum("word_count"), ">=", config.wordThreshold),
+        eb(fn.count<number>("author_id"), ">=", config.messageThreshold),
+        eb(fn.sum<number>("word_count"), ">=", config.wordThreshold),
       ]),
     )
     .limit(config.count);
@@ -63,6 +187,7 @@ export async function getTopParticipants(
   const topMembers = await topMembersQuery.execute();
 
   const dailyParticipationQuery = db
+    // .with("interval_message_stats", () => filteredQuery)
     .with("interval_message_stats", () => baseQuery)
     .selectFrom("interval_message_stats")
     .select(({ fn }) => [
@@ -82,15 +207,48 @@ export async function getTopParticipants(
       topMembers.map((m) => m.author_id),
     );
   console.log(dailyParticipationQuery.compile().sql);
-  const dailyParticipation = fillDateGaps(
-    groupByAuthor(await dailyParticipationQuery.execute()),
-    intervalStart,
-    intervalEnd,
-  );
+  const rawDailyParticipation = await dailyParticipationQuery.execute();
+  // Group by author and fill date gaps inline
+  const groupedData = rawDailyParticipation.reduce((acc, record) => {
+    const { author_id, date } = record;
+    if (!acc[author_id]) acc[author_id] = [];
+    acc[author_id].push({ ...record, date: date as string });
+    return acc;
+  }, {} as GroupedResult);
 
-  const scores = topMembers.map((m) =>
-    scoreMember(m, dailyParticipation[m.author_id]),
-  );
+  const dailyParticipation: GroupedResult = {};
+  for (const authorId in groupedData) {
+    dailyParticipation[authorId] = fillDateGaps(
+      groupedData[authorId],
+      intervalStart,
+      intervalEnd,
+      { message_count: 0, word_count: 0, channel_count: 0, category_count: 0 },
+    );
+  }
+
+  const scores = topMembers.map((m) => {
+    const member = m as MemberData;
+    const participation = dailyParticipation[member.author_id];
+    const categoryCounts = participation
+      .map((p) => p.category_count)
+      .sort((a, b) => a - b);
+    const zeroDays = participation.filter((p) => p.message_count === 0).length;
+
+    return {
+      score: {
+        channelScore: scoreValue(member.channel_count, scoreLookups.channels),
+        messageScore: scoreValue(member.message_count, scoreLookups.messages),
+        wordScore: scoreValue(member.total_word_count, scoreLookups.words),
+        consistencyScore: Math.ceil(
+          categoryCounts[Math.floor(categoryCounts.length / 2)],
+        ),
+      },
+      metadata: {
+        percentZeroDays: zeroDays / participation.length,
+      },
+      data: { participation, member },
+    };
+  });
 
   const withUsernames = await Promise.all(
     scores.map(async (scores) => {
@@ -116,94 +274,18 @@ type MemberData = {
   category_count: number;
   channel_count: number;
 };
-function isBetween(test: number, a: number, b: number) {
-  return test >= a && test < b;
-}
-function scoreValue(test: number, lookup: [number, number][], x?: string) {
-  return lookup.reduce((score, _, i, list) => {
-    const check = isBetween(
-      test,
-      list[i][0] ?? Infinity,
-      list[i + 1]?.[0] ?? Infinity,
-    );
-    if (check && x)
-      console.log(
-        test,
-        "is between",
-        list[i][0],
-        "and",
-        list[i + 1]?.[0] ?? Infinity,
-        "scoring",
-        list[i][1],
-      );
-    return check ? list[i][1] : score;
+function scoreValue(test: number, lookup: [number, number][]) {
+  return lookup.reduce((score, [min, value], i, list) => {
+    const max = list[i + 1]?.[0] ?? Infinity;
+    return test >= min && test < max ? value : score;
   }, 0);
 }
-function median(list: number[]) {
-  const mid = list.length / 2;
-  return list.length % 2 === 1
-    ? (list[Math.floor(mid)] + list[Math.ceil(mid)]) / 2
-    : list[mid];
-}
+// prettier-ignore
 const scoreLookups = {
-  words: [
-    [0, 0],
-    [2000, 1],
-    [5000, 2],
-    [7500, 3],
-    [20000, 4],
-  ],
-  messages: [
-    [0, 0],
-    [150, 1],
-    [350, 2],
-    [800, 3],
-    [1500, 4],
-  ],
-  channels: [
-    [0, 0],
-    [3, 1],
-    [7, 2],
-    [9, 3],
-  ],
-} as Record<string, [number, number][]>;
-function scoreMember(member: MemberData, participation: ParticipationData[]) {
-  return {
-    score: {
-      channelScore: scoreValue(member.channel_count, scoreLookups.channels),
-      messageScore: scoreValue(member.message_count, scoreLookups.messages),
-      wordScore: scoreValue(
-        member.total_word_count,
-        scoreLookups.words,
-        "words",
-      ),
-      consistencyScore: Math.ceil(
-        median(participation.map((p) => p.category_count)),
-      ),
-    },
-    metadata: {
-      percentZeroDays:
-        participation.reduce(
-          (count, val) => (val.message_count === 0 ? count + 1 : count),
-          0,
-        ) / participation.length,
-    },
-    data: {
-      participation,
-      member,
-    },
-  };
-}
-
-type RawParticipationData = {
-  author_id: string;
-  // hack fix for weird types coming out of query
-  date: string | unknown;
-  message_count: number;
-  word_count: number;
-  channel_count: number;
-  category_count: number;
-};
+  words: [ [0, 0], [2000, 1], [5000, 2], [7500, 3], [20000, 4], ],
+  messages: [ [0, 0], [150, 1], [350, 2], [800, 3], [1500, 4], ],
+  channels: [ [0, 0], [3, 1], [7, 2], [9, 3], ],
+} as { words: [number, number][]; messages: [number, number][]; channels: [number, number][] };
 
 type ParticipationData = {
   date: string;
@@ -214,66 +296,3 @@ type ParticipationData = {
 };
 
 type GroupedResult = Record<string, ParticipationData[]>;
-
-function groupByAuthor(records: RawParticipationData[]): GroupedResult {
-  return records.reduce((acc, record) => {
-    const { author_id, date } = record;
-
-    if (!acc[author_id]) {
-      acc[author_id] = [];
-    }
-
-    // hack fix for weird types coming out of query
-    acc[author_id].push({ ...record, date: date as string });
-
-    return acc;
-  }, {} as GroupedResult);
-}
-
-const generateDateRange = (start: string, end: string): string[] => {
-  const dates: string[] = [];
-  const currentDate = new Date(start);
-
-  while (currentDate <= new Date(end)) {
-    dates.push(currentDate.toISOString().split("T")[0]);
-    currentDate.setDate(currentDate.getDate() + 1);
-  }
-  return dates;
-};
-
-function fillDateGaps(
-  groupedResult: GroupedResult,
-  startDate: string,
-  endDate: string,
-): GroupedResult {
-  // Helper to generate a date range in YYYY-MM-DD format
-
-  const dateRange = generateDateRange(startDate, endDate);
-
-  const filledResult: GroupedResult = {};
-
-  for (const authorId in groupedResult) {
-    const authorData = groupedResult[authorId];
-    const dateToEntryMap: Record<string, (typeof authorData)[number]> = {};
-
-    // Map existing entries by date
-    authorData.forEach((entry) => {
-      dateToEntryMap[entry.date] = entry;
-    });
-
-    // Fill missing dates with zeroed-out data
-    filledResult[authorId] = dateRange.map((date) => {
-      return (
-        dateToEntryMap[date] || {
-          date,
-          message_count: 0,
-          word_count: 0,
-          channel_count: 0,
-          category_count: 0,
-        }
-      );
-    });
-  }
-
-  return filledResult;
-}
diff --git a/app/routes/__auth/dashboard.tsx b/app/routes/__auth/dashboard.tsx
index 8e8b17e..4c43508 100644
--- a/app/routes/__auth/dashboard.tsx
+++ b/app/routes/__auth/dashboard.tsx
@@ -14,13 +14,7 @@ export async function loader({ params, request }: Route.LoaderArgs) {
     return data(null, { status: 400 });
   }
 
-  const output = await getTopParticipants(
-    guildId,
-    start,
-    end,
-    [],
-    ["Need Help", "React General", "Advanced Topics"],
-  );
+  const output = await getTopParticipants(guildId, start, end);
 
   return output;
 }
diff --git a/app/routes/__auth/sh-user.tsx b/app/routes/__auth/sh-user.tsx
index ec430ff..df9870b 100644
--- a/app/routes/__auth/sh-user.tsx
+++ b/app/routes/__auth/sh-user.tsx
@@ -1,5 +1,4 @@
 import type { Route } from "./+types/sh-user";
-import db from "#~/db.server";
 import { type LoaderFunctionArgs, Link, useSearchParams } from "react-router";
 import {
   ComposedChart,
@@ -20,9 +19,7 @@ import {
   Radar,
 } from "recharts";
 import { useMemo } from "react";
-import { sql } from "kysely";
-import { getOrFetchUser } from "#~/helpers/userInfoCache";
-import { fillDateGaps } from "#~/helpers/dateUtils";
+import { getUserMessageAnalytics } from "#~/models/activity.server";
 
 export async function loader({ request, params }: LoaderFunctionArgs) {
   const { guildId, userId } = params;
@@ -34,90 +31,19 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
   const start = url.searchParams.get("start");
   const end = url.searchParams.get("end");
 
-  // TODO: this should be configurable
-  // const allowedChannels: string[] = [];
-  // const allowedCategories = ["Need Help", "React General", "Advanced Topics"];
   if (!start || !end) {
     throw new Error("cannot load data without start and end range");
   }
 
-  const reportSlice = db
-    .selectFrom("message_stats")
-    .where("guild_id", "=", guildId)
-    .where("author_id", "=", userId)
-    .where("sent_at", ">=", new Date(start).getTime())
-    .where("sent_at", "<=", new Date(end + "T23:59:59").getTime());
-
-  const dailyBreakdownQuery = reportSlice
-    .select((eb) => [
-      eb.fn.countAll<number>().as("messages"),
-      eb.fn.sum<number>("word_count").as("word_count"),
-      eb.fn.sum<number>("react_count").as("react_count"),
-      eb
-        .fn<number>("round", [eb.fn.avg("word_count"), eb.lit(3)])
-        .as("avg_words"),
-      eb
-        .fn<string>("date", [
-          eb("sent_at", "/", eb.lit(1000)),
-          sql.lit("unixepoch"),
-        ])
-        .as("date"),
-    ])
-    // .where((eb) =>
-    //   eb.or([
-    //     eb("channel_id", "in", allowedChannels),
-    //     eb("channel_category", "in", allowedCategories),
-    //   ]),
-    // )
-    .orderBy("date", "asc")
-    .groupBy("date");
-
-  const categoryBreakdownQuery = reportSlice
-    .select((eb) => [
-      eb.fn.count("channel_category").as("messages"),
-      "channel_category",
-    ])
-    // .orderBy("messages", "desc")
-    .groupBy("channel_category");
-
-  const channelBreakdownQuery = reportSlice
-    .leftJoin(
-      "channel_info as channel",
-      "channel.id",
-      "message_stats.channel_id",
-    )
-    .select((eb) => [
-      eb.fn.count("channel_id").as("messages"),
-      "channel.name",
-      "channel_id",
-    ])
-    .orderBy("messages", "desc")
-    .groupBy("channel_id");
-
-  const [dailyBreakdown, categoryBreakdown, channelBreakdown, userInfo] =
-    await Promise.all([
-      dailyBreakdownQuery.execute(),
-      categoryBreakdownQuery.execute(),
-      channelBreakdownQuery.execute(),
-      getOrFetchUser(userId),
-    ]);
-
-  // Fill date gaps in daily breakdown data with zero values
-  const filledDailyBreakdown = fillDateGaps(dailyBreakdown, start, end, {
-    messages: 0,
-    word_count: 0,
-    react_count: 0,
-    avg_words: 0,
-  });
-
-  return {
-    dailyBreakdown: filledDailyBreakdown,
-    categoryBreakdown,
-    channelBreakdown,
-    userInfo,
-  };
+  // Use shared analytics function with channel filtering disabled for user view
+  return await getUserMessageAnalytics(guildId, userId, start, end);
 }
 
+const num = new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 1,
+  minimumFractionDigits: 0,
+});
+
 export default function UserProfile({
   params,
   loaderData: data,
@@ -127,168 +53,193 @@ export default function UserProfile({
   const end = qs.get("end");
 
   const derivedData = useMemo(() => {
-    const totalMessages = data.categoryBreakdown.reduce(
-      (a, c) => a + Number(c.messages),
-      0,
-    );
-    const totalReactions = data.dailyBreakdown.reduce(
-      (a, c) => a + Number(c.react_count),
-      0,
-    );
-    const totalWords = data.dailyBreakdown.reduce(
-      (a, c) => a + Number(c.word_count),
-      0,
-    );
-    return { totalMessages, totalWords, totalReactions };
-  }, [data]);
+    // Calculate days between start and end dates
+    const startDate = start ? new Date(start) : null;
+    const endDate = end ? new Date(end) : null;
+    const daysBetween =
+      startDate && endDate
+        ? Math.ceil(
+            (endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24),
+          ) + 1
+        : 0;
+
+    return {
+      totalMessages: data.categoryBreakdown.reduce(
+        (a, c) => a + Number(c.messages),
+        0,
+      ),
+      totalReactions: data.dailyBreakdown.reduce(
+        (a, c) => a + Number(c.react_count),
+        0,
+      ),
+      totalWords: data.dailyBreakdown.reduce(
+        (a, c) => a + Number(c.word_count),
+        0,
+      ),
+      daysBetween,
+    };
+  }, [data, start, end]);
 
   return (
-    <div className="h-full px-6 py-8">
+    <>
       <style>{`
-      text {fill: #ccc;}
-      .recharts-default-tooltip {
-        background-color: rgb(55,65,81) !important;
-      }
-      `}</style>
-      <div className="mx-auto max-w-screen-lg">
-        <h1 className="pt-2 text-center text-4xl font-bold">
-          {data.userInfo?.username}
-        </h1>
-        {data.userInfo?.global_name &&
-          data.userInfo?.global_name !== data.userInfo?.username && (
-            <div className="pt-2 text-center text-xl text-gray-300">
-              ({data.userInfo?.global_name})
-            </div>
-          )}
+text {
+  fill: #ccc;
+}
+.recharts-default-tooltip {
+  background-color: rgb(55,65,81) !important;
+}`}</style>
+
+      <div className="flex h-16 items-center justify-between border-b border-gray-700 px-4">
         <Link
           to={{
             pathname: `/app/${params.guildId}/sh`,
             search: `?start=${start}&end=${end}`,
           }}
-          className="mb-4 inline-block rounded bg-gray-600 px-4 py-2 text-white transition-colors hover:bg-gray-500"
+          className="rounded bg-gray-600 px-4 py-2 text-white transition-colors hover:bg-gray-500"
         >
-          ← Back to Dashboard
+          ← Dashboard
         </Link>
-        <details>
-          <summary>raw data</summary>
-          <textarea
-            className="border"
-            style={{ width: "100%", height: "200px" }}
-            readOnly
-            defaultValue={JSON.stringify(derivedData, null, 2)}
-          />
-        </details>
-
-        <ResponsiveContainer width="100%" height={300}>
-          <RadarChart
-            cx="50%"
-            cy="50%"
-            outerRadius="80%"
-            data={data.categoryBreakdown}
-          >
-            <PolarGrid />
-            <PolarAngleAxis dataKey="channel_category" />
-            <PolarRadiusAxis />
-            <Tooltip />
-            <Radar
-              name="Channels"
-              dataKey="messages"
-              stroke="#8884d8"
-              fill="#8884d8"
-              fillOpacity={0.6}
-            />
-            <Legend fill="lightgray" />
-          </RadarChart>
-        </ResponsiveContainer>
-
-        <ResponsiveContainer width="100%" height={200}>
-          <ComposedChart
-            width={500}
-            height={300}
-            data={data.channelBreakdown}
-            margin={{
-              top: 20,
-              right: 50,
-              bottom: 20,
-              left: 20,
-            }}
-          >
-            <CartesianGrid strokeDasharray="1 3" stroke="#ddd" />
-            <XAxis dataKey="name" />
-            <YAxis domain={[0, 250]} />
-            <Tooltip />
-            <Legend fill="lightgray" />
-            <Bar dataKey="messages" fill="#8884d8" />
-          </ComposedChart>
-        </ResponsiveContainer>
 
-        <ResponsiveContainer width="100%" height={300}>
-          <ComposedChart
-            width={500}
-            height={200}
-            data={data.dailyBreakdown}
-            syncId="dailyStats"
-            margin={{
-              top: 20,
-              right: 20,
-              bottom: 20,
-              left: 20,
-            }}
-          >
-            <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
-            <XAxis dataKey="date" scale="band" />
-            <YAxis domain={[0, 125]} />
-            <Tooltip />
-            <Legend />
-            <Legend fill="lightgray" />
-            <Bar dataKey="messages" fill="#4d48e2" />
-          </ComposedChart>
-        </ResponsiveContainer>
-
-        <ResponsiveContainer width="100%" height={300}>
-          <ComposedChart
-            width={500}
-            height={200}
-            data={data.dailyBreakdown}
-            syncId="dailyStats"
-            margin={{
-              top: 20,
-              right: 20,
-              bottom: 20,
-              left: 20,
-            }}
-          >
-            <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
-            <XAxis dataKey="date" scale="band" />
-            <YAxis domain={[0, 1250]} />
-            <Tooltip />
-            <Legend />
-            <Bar dataKey="word_count" stackId="1" fill="red" />
-          </ComposedChart>
-        </ResponsiveContainer>
+        <h1 className="text-4xl font-bold">
+          {data.userInfo?.username}
+          <small className="text-gray-300">
+            {data.userInfo?.global_name &&
+              data.userInfo?.global_name !== data.userInfo?.username && (
+                <div className="pt-2 text-center text-xl text-gray-300">
+                  <small>In {derivedData.daysBetween} days</small> (
+                  {data.userInfo?.global_name}) <small>:</small>
+                </div>
+              )}
+          </small>
+        </h1>
+        <div className="px-4"> </div>
+      </div>
 
-        <ResponsiveContainer width="100%" height={300}>
-          <ComposedChart
-            width={500}
-            height={200}
-            data={data.dailyBreakdown}
-            syncId="dailyStats"
-            margin={{
-              top: 20,
-              right: 20,
-              bottom: 20,
-              left: 20,
-            }}
-          >
-            <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
-            <XAxis dataKey="date" scale="band" />
-            <YAxis domain={[0, 25]} />
-            <Tooltip />
-            <Legend />
-            <Bar dataKey="react_count" fill="green" />
-          </ComposedChart>
-        </ResponsiveContainer>
+      <div className="h-full px-6 py-8">
+        <div>
+          {/* (top 5: 👀❤️✨‼️🫡) (top langs: JS, Go, Rust) */}
+          <p>
+            Sent {num.format(derivedData.totalMessages)} messages in{" "}
+            {data.channelBreakdown.length} channels consisting of{" "}
+            {num.format(derivedData.totalWords)} words (
+            {num.format(derivedData.totalWords / derivedData.totalMessages)}{" "}
+            words/message).
+          </p>
+          <p></p>
+          <p>Received {num.format(derivedData.totalReactions)} reactions.</p>
+        </div>
+        <div className="mx-auto max-w-screen-lg">
+          <ResponsiveContainer width="100%" height={200}>
+            <ComposedChart
+              width={500}
+              height={300}
+              data={data.channelBreakdown}
+              margin={{
+                top: 20,
+                right: 50,
+                bottom: 20,
+                left: 20,
+              }}
+            >
+              <CartesianGrid strokeDasharray="1 3" stroke="#ddd" />
+              <XAxis dataKey="name" />
+              <YAxis domain={[0, 250]} />
+              <Tooltip />
+              <Legend fill="lightgray" />
+              <Bar dataKey="messages" fill="#8884d8" />
+            </ComposedChart>
+          </ResponsiveContainer>
+          <ResponsiveContainer width="100%" height={300}>
+            <RadarChart
+              cx="50%"
+              cy="50%"
+              outerRadius="80%"
+              data={data.categoryBreakdown}
+            >
+              <PolarGrid />
+              <PolarAngleAxis dataKey="channel_category" />
+              <PolarRadiusAxis />
+              <Tooltip />
+              <Radar
+                name="Channels"
+                dataKey="messages"
+                stroke="#8884d8"
+                fill="#8884d8"
+                fillOpacity={0.6}
+              />
+              <Legend fill="lightgray" />
+            </RadarChart>
+          </ResponsiveContainer>
+
+          <ResponsiveContainer width="100%" height={300}>
+            <ComposedChart
+              width={500}
+              height={200}
+              data={data.dailyBreakdown}
+              syncId="dailyStats"
+              margin={{
+                top: 20,
+                right: 20,
+                bottom: 20,
+                left: 20,
+              }}
+            >
+              <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
+              <XAxis dataKey="date" scale="band" />
+              <YAxis domain={[0, 125]} />
+              <Tooltip />
+              <Legend />
+              <Legend fill="lightgray" />
+              <Bar dataKey="messages" fill="#4d48e2" />
+            </ComposedChart>
+          </ResponsiveContainer>
+
+          <ResponsiveContainer width="100%" height={300}>
+            <ComposedChart
+              width={500}
+              height={200}
+              data={data.dailyBreakdown}
+              syncId="dailyStats"
+              margin={{
+                top: 20,
+                right: 20,
+                bottom: 20,
+                left: 20,
+              }}
+            >
+              <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
+              <XAxis dataKey="date" scale="band" />
+              <YAxis domain={[0, 1250]} />
+              <Tooltip />
+              <Legend />
+              <Bar dataKey="word_count" stackId="1" fill="red" />
+            </ComposedChart>
+          </ResponsiveContainer>
+
+          <ResponsiveContainer width="100%" height={300}>
+            <ComposedChart
+              width={500}
+              height={200}
+              data={data.dailyBreakdown}
+              syncId="dailyStats"
+              margin={{
+                top: 20,
+                right: 20,
+                bottom: 20,
+                left: 20,
+              }}
+            >
+              <CartesianGrid strokeDasharray="7 3" stroke="#ddd" />
+              <XAxis dataKey="date" scale="band" />
+              <YAxis domain={[0, 25]} />
+              <Tooltip />
+              <Legend />
+              <Bar dataKey="react_count" fill="green" />
+            </ComposedChart>
+          </ResponsiveContainer>
+        </div>
       </div>
-    </div>
+    </>
   );
 }
diff --git a/notes/2025-06-28_10_discord-permissions.md b/notes/2025-06-28_10_discord-permissions.md
index 6a0e747..8266572 100644
--- a/notes/2025-06-28_10_discord-permissions.md
+++ b/notes/2025-06-28_10_discord-permissions.md
@@ -5,26 +5,31 @@
 Instead of Administrator (8), we need specific permissions:
 
 ### Core Moderation (116294643952)
+
 - ViewChannels (1024)
-- SendMessages (2048) 
+- SendMessages (2048)
 - ManageMessages (8192)
 - ReadMessageHistory (65536)
 - ModerateMembers (1099511627776) // timeout/ban
 
-### Role & Channel Management (268435456) 
+### Role & Channel Management (268435456)
+
 - ManageRoles (268435456)
 - ManageChannels (16)
 
 ### Threads for Tickets (17179869184)
+
 - CreatePublicThreads (34359738368)
 - CreatePrivateThreads (68719476736)
 - ManageThreads (17179869184)
 
 ### Combined: 385929748752
+
 - All permissions needed for full bot functionality
 
 ## Permission Values Used
+
 - Basic functionality: 268435456 (ManageRoles + basic message perms)
 - Full functionality: 385929748752 (all permissions)
 
-The OAuth flow uses the basic set initially, with option to request more later.
\ No newline at end of file
+The OAuth flow uses the basic set initially, with option to request more later.
diff --git a/notes/2025-06-28_11_unified-oauth-implementation.md b/notes/2025-06-28_11_unified-oauth-implementation.md
index d3d50f9..d78efcd 100644
--- a/notes/2025-06-28_11_unified-oauth-implementation.md
+++ b/notes/2025-06-28_11_unified-oauth-implementation.md
@@ -3,27 +3,32 @@
 ## ✅ What We Built
 
 ### 1. **Dual OAuth Flow Support**
+
 - **New Users**: Combined user auth + bot installation in single flow
 - **Existing Users**: Separate "Add Bot" flow for additional servers
 - **Fallback**: Preserved existing login-only functionality
 
 ### 2. **Enhanced Auth Routes**
+
 - `/auth?flow=signup` - New user with bot installation
 - `/auth?flow=add-bot&guild_id=X` - Add bot to specific server
 - `/auth` (POST) - Existing login flow preserved
 
 ### 3. **Onboarding Experience**
+
 - Created `/onboard` route for post-installation setup
 - Automated free subscription initialization
 - Guided setup interface with clear next steps
 - Direct links to dashboard and configuration
 
 ### 4. **Improved Landing Page**
+
 - Added prominent "Add to Discord Server" button
 - Preserved existing login flow for returning users
 - Better value proposition messaging
 
 ### 5. **Smart Permission Handling**
+
 - Replaced Administrator (8) with specific permissions (1099512100352)
 - Includes: ManageRoles, SendMessages, ManageMessages, ReadMessageHistory, ModerateMembers
 - More security-conscious approach
@@ -31,23 +36,27 @@
 ## Key Integration Points
 
 ### **URL Structure**
+
 ```
 /auth?flow=signup                    → Combined OAuth
-/auth?flow=add-bot&guild_id=123     → Bot-only installation  
+/auth?flow=add-bot&guild_id=123     → Bot-only installation
 /onboard?guild_id=123               → Post-installation setup
 ```
 
 ### **Automatic Features**
+
 - Free subscription auto-created for new guilds
 - Redirects to onboard flow after bot installation
 - Preserves existing user session management
 
 ### **Subscription Integration**
+
 - Auto-initializes free tier via `SubscriptionService.initializeFreeSubscription()`
 - Ready for future premium upgrade flows
 - Tracks which guilds have bot installed
 
 ## Next Step: Replace Manual Setup
+
 The `/setup` Discord command can now be deprecated in favor of the web-based onboarding flow. Users get a much smoother experience from landing page → Discord → configuration → using the bot.
 
-This eliminates the biggest friction point in user onboarding!
\ No newline at end of file
+This eliminates the biggest friction point in user onboarding!
diff --git a/notes/2025-06-28_12_oauth-success.md b/notes/2025-06-28_12_oauth-success.md
index 11fbed9..f4e22a9 100644
--- a/notes/2025-06-28_12_oauth-success.md
+++ b/notes/2025-06-28_12_oauth-success.md
@@ -14,16 +14,19 @@ The unified OAuth implementation is now fully functional:
 ## Key Fixes Applied
 
 ### **Cookie Size Issue (RESOLVED)**
+
 - **Problem**: Discord tokens can be >23KB, exceeding browser limits
 - **Solution**: Moved token storage from cookie to database session
 - **Result**: OAuth flow completes without errors
 
 ### **Multi-Flow Support (WORKING)**
+
 - `flow=signup` → Combined user auth + bot installation
 - `flow=add-bot` → Bot-only for existing users
 - Backward compatibility with existing login flow
 
 ### **Automatic Features (WORKING)**
+
 - Free subscription auto-creation via `SubscriptionService.initializeFreeSubscription()`
 - Proper permission scoping (specific permissions vs Administrator)
 - Seamless redirect to onboarding experience
@@ -31,15 +34,17 @@ The unified OAuth implementation is now fully functional:
 ## Major UX Achievement
 
 **Before**: Manual process requiring Discord knowledge
+
 1. User finds bot invite link manually
 2. Adds bot with unclear permissions
 3. Runs `/setup` command in Discord
 4. Manually configures roles/channels
 
 **After**: Seamless web-guided experience
+
 1. Click "Add to Discord Server" button
 2. Discord OAuth handles everything
 3. Land on success page with clear next steps
 4. Optional web-based configuration
 
-This eliminates the biggest friction point in Discord bot onboarding! 🚀
\ No newline at end of file
+This eliminates the biggest friction point in Discord bot onboarding! 🚀
diff --git a/notes/2025-06-28_13_stripe-payment-flow copy.md b/notes/2025-06-28_13_stripe-payment-flow copy.md
index 27735d9..2edb33f 100644
--- a/notes/2025-06-28_13_stripe-payment-flow copy.md	
+++ b/notes/2025-06-28_13_stripe-payment-flow copy.md	
@@ -3,11 +3,13 @@
 ## ✅ What We Built
 
 ### **Payment Flow Routes**
+
 1. **`/upgrade`** - Upgrade page with Free vs Pro comparison
-2. **`/payment/success`** - Payment confirmation and subscription activation  
+2. **`/payment/success`** - Payment confirmation and subscription activation
 3. **`/payment/cancel`** - Payment cancellation handling
 
 ### **Integration Points**
+
 - **Upgrade Flow**: `/upgrade` → `/redirects/stripe` (your existing route) → Stripe → success/cancel
 - **Subscription Integration**: Auto-updates subscription tier upon payment success
 - **Onboard Integration**: Added upgrade prompt to onboard page for free users
@@ -15,28 +17,33 @@
 ### **Key Features**
 
 #### **Upgrade Page (`/upgrade`)**
+
 - Side-by-side Free vs Pro plan comparison
 - Clear feature differentiation
 - "Upgrade to Pro" button that redirects to `/redirects/stripe?guild_id=X`
 - Shows current subscription status
 
 #### **Payment Success (`/payment/success`)**
+
 - Verifies Stripe session (placeholder for now)
 - Updates subscription to "paid" tier
 - Shows confirmation with feature list
 - Links to dashboard and home
 
 #### **Payment Cancel (`/payment/cancel`)**
+
 - Handles cancelled payments gracefully
 - Shows what user is missing out on
 - "Try Again" and "Dashboard" options
 - Maintains current subscription
 
 #### **Onboard Enhancement**
+
 - Shows upgrade prompt for free tier users
 - Seamless flow from bot installation → upgrade option
 
 ## **URL Structure**
+
 ```
 /upgrade?guild_id=X              → Upgrade page
 /redirects/stripe?guild_id=X     → Your existing Stripe redirect
@@ -45,15 +52,17 @@
 ```
 
 ## **Subscription Integration**
+
 - Auto-creates "paid" subscriptions on payment success
 - Integrates with existing `SubscriptionService`
 - Ready for actual Stripe webhook processing
 - Sets 30-day billing periods
 
 ## **Ready for Production**
+
 - Placeholder Stripe service ready for real SDK integration
 - Proper error handling and user feedback
 - Responsive design matching existing UI
 - Type-safe implementation
 
-The foundation for monetization is now complete with both subscription infrastructure and payment flows! 💰
\ No newline at end of file
+The foundation for monetization is now complete with both subscription infrastructure and payment flows! 💰
diff --git a/notes/2025-06-28_1_initial-analysis.md b/notes/2025-06-28_1_initial-analysis.md
index 44a8d18..8e9f38b 100644
--- a/notes/2025-06-28_1_initial-analysis.md
+++ b/notes/2025-06-28_1_initial-analysis.md
@@ -1,12 +1,14 @@
 # Initial Product Analysis - 2025-06-28
 
 ## Current State
-- **Product**: Euno Discord moderation bot 
+
+- **Product**: Euno Discord moderation bot
 - **Tech Stack**: React Router v7, Kysely/SQLite, Discord.js, TypeScript
 - **Infrastructure**: K8s on DigitalOcean, GitHub Actions CI/CD
 - **License**: AGPL-3.0 (copyleft - important for commercialization)
 
 ## Key Features Identified
+
 - Discord moderation capabilities (automod, reporting, tickets)
 - Activity tracking and analytics (charts/metrics)
 - User authentication via Discord OAuth
@@ -14,6 +16,7 @@
 - Database with message stats, channel info, user tracking
 
 ## Architecture Notes
+
 - Well-structured codebase with clear separation
 - Modern tech stack suitable for scaling
 - Kubernetes deployment ready
@@ -21,7 +24,8 @@
 - Web portal exists but not internet-accessible
 
 ## First Impressions
+
 - Solid technical foundation
 - Good development practices (migrations, types, testing)
 - Ready for horizontal scaling
-- Missing key product/business elements
\ No newline at end of file
+- Missing key product/business elements
diff --git a/notes/2025-06-28_debugging-report.md b/notes/2025-06-28_debugging-report.md
index 6190f31..0a14176 100644
--- a/notes/2025-06-28_debugging-report.md
+++ b/notes/2025-06-28_debugging-report.md
@@ -1,9 +1,11 @@
 # Debugging & Testing Report - 2025-06-28
 
 ## ✅ Summary
+
 Comprehensive testing completed successfully. All core payment flow functionality is working correctly.
 
 ## 🔧 Issues Fixed
+
 1. **TypeScript Compilation Error**: Fixed payment.success.tsx importing credits service from wrong branch
 2. **Unused Import**: Removed unused `Form` import from onboard.tsx
 3. **Lint Formatting**: Auto-fixed ESLint formatting issues
@@ -11,6 +13,7 @@ Comprehensive testing completed successfully. All core payment flow functionalit
 ## 🧪 Testing Results
 
 ### Database Setup
+
 - ✅ Created test user session in database
 - ✅ Created test guilds: `test-guild-123` (free) and `test-guild-pro` (paid)
 - ✅ Verified database operations work correctly
@@ -18,22 +21,26 @@ Comprehensive testing completed successfully. All core payment flow functionalit
 ### Route Testing (with valid session cookies)
 
 #### Authentication & Error Handling
+
 - ✅ Protected routes redirect to login without auth
 - ✅ Routes return 400 for missing required parameters
 - ✅ Session authentication working correctly
 
 #### Onboard Flow
+
 - ✅ **Free Guild** → Shows new "Pro vs Free" choice with Pro marked "Recommended"
 - ✅ **Pro Guild** → Shows "Welcome to Euno Pro!" congratulatory experience
 - ✅ Visual hierarchy works: Pro plan prominently featured
 
 #### Payment Flow
+
 - ✅ **Upgrade Page** → Renders Free vs Pro comparison correctly
 - ✅ **Payment Success** → Shows "Payment Successful!" and "Subscription Activated"
 - ✅ **Payment Cancel** → Shows "Payment Cancelled" with retry option
 - ✅ **Database Integration** → Payment success correctly updates guild from 'free' to 'paid'
 
 #### OAuth Flow
+
 - ✅ Landing page renders correctly
 - ✅ OAuth signup flow generates proper Discord authorization URL
 - ✅ Permissions and scopes configured correctly
@@ -41,25 +48,30 @@ Comprehensive testing completed successfully. All core payment flow functionalit
 ## 🎯 Key Successes
 
 ### New Onboard Flow for Conversion
+
 The redesigned onboard experience is working perfectly:
+
 - **Immediate Choice**: Pro vs Free decision is front and center
 - **Visual Hierarchy**: Pro plan has "Recommended" badge and stronger styling
 - **Clear CTAs**: "$15/month" pricing shown upfront
 - **Separate Pro Experience**: Existing Pro users get congratulatory flow
 
 ### Payment Infrastructure
+
 - **Complete Flow**: upgrade → payment → success/cancel all functional
 - **Database Integration**: Subscriptions properly updated on payment
 - **Error Handling**: Proper validation and error responses
 - **Session Management**: Authentication working correctly
 
 ## 🚨 No Major Issues Found
+
 - All routes responding correctly
 - Database operations working
 - Authentication properly protecting routes
 - Error handling functioning as expected
 
 ## 📋 Testing Coverage
+
 - [x] Authentication flows
 - [x] Payment success/failure paths
 - [x] Subscription tier management
@@ -68,10 +80,12 @@ The redesigned onboard experience is working perfectly:
 - [x] UI rendering verification
 
 ## 🎉 Production Readiness
+
 The payment flow is ready for production use with actual Stripe integration. The infrastructure supports:
+
 - Immediate Pro conversion during onboarding
 - Proper subscription management
 - Error handling and edge cases
 - Clean separation of free vs paid experiences
 
-**Recommendation**: Ready to proceed with real Stripe configuration and user testing.
\ No newline at end of file
+**Recommendation**: Ready to proceed with real Stripe configuration and user testing.
diff --git a/notes/2025-07-03_1_discord-api-integration.md b/notes/2025-07-03_1_discord-api-integration.md
index 3554550..eb6e857 100644
--- a/notes/2025-07-03_1_discord-api-integration.md
+++ b/notes/2025-07-03_1_discord-api-integration.md
@@ -5,6 +5,7 @@ This document explains how Euno interacts with Discord's API and the patterns us
 ## Token Types & Management
 
 ### Bot Token
+
 - **Source**: `DISCORD_HASH` environment variable
 - **Usage**: Server operations, guild data fetching, bot commands
 - **Client**: `rest` from `#~/discord/api.js`
@@ -16,6 +17,7 @@ const guildRoles = await rest.get(Routes.guildRoles(guildId));
 ```
 
 ### User OAuth Token
+
 - **Source**: User session storage via OAuth flow
 - **Usage**: User-specific operations, permission checking
 - **Scopes**: `"identify email guilds guilds.members.read"` (user) or includes `"bot applications.commands"` (bot install)
@@ -23,54 +25,60 @@ const guildRoles = await rest.get(Routes.guildRoles(guildId));
 
 ```typescript
 const userToken = await retrieveDiscordToken(request);
-const userRest = new REST({ version: "10" }).setToken(userToken.token.access_token);
+const userRest = new REST({ version: "10" }).setToken(
+  userToken.token.access_token,
+);
 const userGuilds = await userRest.get(Routes.userGuilds());
 ```
 
 ## Common API Patterns
 
 ### Guild Data Fetching
+
 ```typescript
 // Get guild roles (excluding @everyone, sorted by hierarchy)
 const guildRoles = await rest.get(Routes.guildRoles(guildId));
 const roles = guildRoles
-  .filter(role => role.name !== "@everyone")
+  .filter((role) => role.name !== "@everyone")
   .sort((a, b) => b.position - a.position);
 
 // Get text channels only, sorted by position
 const guildChannels = await rest.get(Routes.guildChannels(guildId));
 const channels = guildChannels
-  .filter(channel => channel.type === 0) // Text channels
+  .filter((channel) => channel.type === 0) // Text channels
   .sort((a, b) => a.position - b.position);
 ```
 
 ### Command Management
+
 ```typescript
 // Deploy commands to specific guild
-await rest.put(
-  Routes.applicationGuildCommands(applicationId, guildId), 
-  { body: commands }
-);
+await rest.put(Routes.applicationGuildCommands(applicationId, guildId), {
+  body: commands,
+});
 
 // Delete specific command
 await rest.delete(
-  Routes.applicationGuildCommand(applicationId, guildId, commandId)
+  Routes.applicationGuildCommand(applicationId, guildId, commandId),
 );
 ```
 
 ## OAuth Flow
 
 ### User Authentication
+
 - **Endpoint**: `/auth/discord`
 - **Scopes**: User identification and guild access
 - **Storage**: Session-based with database persistence
 
 ### Bot Installation
+
 - **Endpoint**: `/auth/discord/bot`
 - **Scopes**: Includes bot permissions for server installation
 - **Permissions**: Configurable bot permissions for guild operations
 
 ### Token Management
+
 - User tokens stored in sessions with automatic refresh
 - Bot token configured once via environment variables
 - Token validation and refresh handled in `session.server.ts`
@@ -78,6 +86,7 @@ await rest.delete(
 ## Error Handling
 
 ### API Call Patterns
+
 ```typescript
 try {
   const data = await rest.get(Routes.guild(guildId));
@@ -90,6 +99,7 @@ try {
 ```
 
 ### Common Issues
+
 - **403 Forbidden**: Bot lacks permissions in guild
 - **404 Not Found**: Guild/channel/role doesn't exist
 - **401 Unauthorized**: Token expired or invalid
@@ -98,6 +108,7 @@ try {
 ## Client Setup
 
 ### Main Bot Client
+
 ```typescript
 // app/discord/client.server.ts
 const client = new Client({
@@ -106,11 +117,12 @@ const client = new Client({
     GatewayIntentBits.GuildMembers,
     GatewayIntentBits.GuildMessages,
     // ... other intents
-  ]
+  ],
 });
 ```
 
 ### REST Client
+
 ```typescript
 // app/discord/api.ts
 export const rest = new REST({ version: "10" }).setToken(discordToken);
@@ -119,7 +131,7 @@ export const rest = new REST({ version: "10" }).setToken(discordToken);
 ## Dependencies
 
 - `discord.js`: ^14.16.0 - Main Discord library
-- `@discordjs/rest`: ^2.4.0 - REST API client  
+- `@discordjs/rest`: ^2.4.0 - REST API client
 - `discord-api-types`: 0.37.97 - TypeScript types
 - `simple-oauth2`: ^5.1.0 - OAuth 2.0 client
 
@@ -138,4 +150,4 @@ DISCORD_HASH=your_bot_token
 2. **Handle rate limiting** - discord.js REST client handles this automatically
 3. **Validate permissions** - Check bot has necessary permissions before API calls
 4. **Error gracefully** - Always provide fallbacks when Discord API is unavailable
-5. **Filter data appropriately** - Exclude @everyone role, filter channel types, etc.
\ No newline at end of file
+5. **Filter data appropriately** - Exclude @everyone role, filter channel types, etc.
diff --git a/notes/2025-07-03_2_session-server-functions.md b/notes/2025-07-03_2_session-server-functions.md
index 3cafa7a..0aeb726 100644
--- a/notes/2025-07-03_2_session-server-functions.md
+++ b/notes/2025-07-03_2_session-server-functions.md
@@ -39,4 +39,4 @@ const userRest = new REST({ version: "10" }).setToken(
 - Use `getUser()` for optional checks (landing pages, conditional redirects)
 - Use `requireUser()` for protected routes that need authentication
 - Always use both user and bot tokens for `fetchGuilds()` function
-- Bot token is more reliable for guild operations, but user token needed for user-specific data
\ No newline at end of file
+- Bot token is more reliable for guild operations, but user token needed for user-specific data
diff --git a/notes/2025-07-04_1_authorization-architecture-analysis.md b/notes/2025-07-04_1_authorization-architecture-analysis.md
new file mode 100644
index 0000000..da815ea
--- /dev/null
+++ b/notes/2025-07-04_1_authorization-architecture-analysis.md
@@ -0,0 +1,148 @@
+# Authorization Architecture Analysis
+
+## Current Authentication System
+
+### Session Management
+- **Dual Session Architecture**: Uses both cookie-based and database-based sessions
+  - Cookie session: Stores minimal data directly in encrypted cookie
+  - Database session: Stores sensitive data (Discord tokens) in database with session ID
+- **Session Models**: 
+  - `CookieSession`: Lightweight, stores basic info
+  - `DbSession`: Secure storage for Discord tokens and OAuth state
+- **Security**: Discord tokens never stored in cookies, only in database
+
+### OAuth Flow
+- **Discord OAuth Integration**: Complete OAuth2 flow with multiple modes
+  - User flow: Standard user authentication
+  - Bot flow: Bot installation with permissions
+  - Signup flow: New user registration
+- **State Management**: Uses UUID-based state parameter for CSRF protection
+- **Scopes**: 
+  - User: `identify email guilds guilds.members.read`
+  - Bot: `identify email guilds guilds.members.read bot applications.commands`
+
+### Current Authorization Patterns
+
+#### User Authentication
+- **User Model**: Basic user entity with Discord external ID
+- **Session Functions**:
+  - `getUser()`: Get current user from session
+  - `requireUser()`: Enforce authentication, redirect to login if needed
+  - `requireUserId()`: Get user ID with authentication check
+
+#### Guild-Based Authorization
+- **Guild Permissions**: Discord permission-based authorization
+- **Permission Mapping**:
+  - `MOD`: ModerateMembers permission
+  - `ADMIN`: Administrator permission  
+  - `MANAGER`: ManageChannels, ManageGuild, or ManageRoles permissions
+  - `MANAGE_CHANNELS`: ManageChannels permission
+  - `MANAGE_GUILD`: ManageGuild permission
+  - `MANAGE_ROLES`: ManageRoles permission
+
+#### Guild Access Control
+- **Guild Filtering**: 
+  - Users can only access guilds where they have `MANAGER` level permissions
+  - Bot must be installed in guild for management access
+- **Authorization Array**: Each guild has `authz` array with user's permissions
+- **Caching**: TTL cache (5 min) for guild data to reduce Discord API calls
+
+### Database Schema
+
+#### Users Table
+```sql
+- id: UUID (primary key)
+- email: text
+- externalId: text (Discord user ID)
+- authProvider: text (default: "discord")
+```
+
+#### Sessions Table
+```sql
+- id: UUID (primary key)
+- data: JSON (session data)
+- expires: datetime
+```
+
+#### Guilds Table
+```sql
+- id: string (Discord guild ID)
+- settings: JSON (guild configuration)
+```
+
+#### Guild Subscriptions Table
+```sql
+- guild_id: string (primary key)
+- stripe_customer_id: text
+- stripe_subscription_id: text
+- product_tier: text (default: "free")
+- status: text (default: "active")
+- current_period_end: datetime
+- created_at: datetime
+- updated_at: datetime
+```
+
+### Current Access Control Mechanisms
+
+#### Route-Level Protection
+- **Auth Layout**: `__auth.tsx` enforces authentication for protected routes
+- **User Requirement**: Routes under auth layout require valid user session
+- **Guild Context**: Guild-specific routes include guild ID in URL parameters
+
+#### Permission Checking
+- **Discord Permissions**: Leverages Discord's native permission system
+- **Guild Membership**: Validates user membership and permissions in target guild
+- **Bot Presence**: Requires bot installation for management features
+
+#### Subscription-Based Access
+- **Product Tiers**: Free vs. Paid tiers
+- **Feature Gating**: `SubscriptionService.hasFeature()` (currently returns false)
+- **Subscription Status**: Active/inactive subscription management
+
+### Current Gaps and Limitations
+
+#### Missing Role-Based Access Control
+- No internal role system beyond Discord permissions
+- No fine-grained feature permissions
+- No user role management interface
+
+#### Limited Authorization Middleware
+- No declarative permission decorators
+- No middleware for route-level permission checks
+- Manual permission validation in loaders
+
+#### No Audit Trail
+- No logging of permission changes
+- No access attempt tracking
+- Limited observability for authorization decisions
+
+#### Feature Flag System
+- Subscription service exists but feature checking is stubbed
+- No granular feature control
+- No A/B testing or gradual rollouts
+
+#### Guild-Level Permissions
+- Guild settings stored as JSON blob
+- No structured permission model for guild features
+- No delegation of permissions to non-admin users
+
+### Current Authorization Flow
+
+1. **User Authentication**: Discord OAuth → User creation/retrieval → Session establishment
+2. **Guild Authorization**: Fetch user's guilds → Filter by permissions → Cache results
+3. **Route Access**: Check session → Validate guild access → Load guild-specific data
+4. **Feature Access**: Check subscription tier → Validate feature access (stubbed)
+
+### Strengths
+- Secure Discord integration with proper token handling
+- Caching layer for performance
+- Subscription management foundation
+- Clean separation of cookie vs. database sessions
+
+### Areas for Extension
+- Role-based access control system
+- Permission middleware and decorators
+- Feature flag implementation
+- Audit logging
+- Guild-level permission delegation
+- Fine-grained resource access control
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index a4f52b8..9ecd989 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -35,8 +35,9 @@
         "react": "^18.2.0",
         "react-dom": "^18.0.0",
         "react-router": "^7.1.0",
-        "recharts": "^2.15.4",
-        "simple-oauth2": "^5.1.0"
+        "recharts": "^2.15.3",
+        "simple-oauth2": "^5.1.0",
+        "simple-statistics": "^7.8.8"
       },
       "devDependencies": {
         "@eslint/js": "^9.17.0",
@@ -10817,6 +10818,15 @@
         "joi": "^17.6.4"
       }
     },
+    "node_modules/simple-statistics": {
+      "version": "7.8.8",
+      "resolved": "https://registry.npmjs.org/simple-statistics/-/simple-statistics-7.8.8.tgz",
+      "integrity": "sha512-CUtP0+uZbcbsFpqEyvNDYjJCl+612fNgjT8GaVuvMG7tBuJg8gXGpsP5M7X658zy0IcepWOZ6nPBu1Qb9ezA1w==",
+      "license": "ISC",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/slice-ansi": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz",
diff --git a/package.json b/package.json
index 316654b..ee0f81c 100644
--- a/package.json
+++ b/package.json
@@ -62,7 +62,8 @@
     "react-dom": "^18.0.0",
     "react-router": "^7.1.0",
     "recharts": "^2.15.3",
-    "simple-oauth2": "^5.1.0"
+    "simple-oauth2": "^5.1.0",
+    "simple-statistics": "^7.8.8"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
diff --git a/scripts/README.md b/scripts/README.md
index 229d4e9..dc19389 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -1,9 +1,11 @@
 # Payment Flow Testing Scripts
 
 ## Overview
+
 These scripts provide automated testing for the Euno payment flow using HTTP assertions.
 
 ## Files
+
 - `test-payment-flow.sh` - Main testing script
 - `test-example.sh` - Example usage with sample session data
 - `README.md` - This documentation
@@ -11,19 +13,25 @@ These scripts provide automated testing for the Euno payment flow using HTTP ass
 ## Usage
 
 ### Quick Start
+
 1. Get valid session cookies by logging into the app
 2. Set environment variables:
+
 ```bash
 export COOKIE_SESSION="__client-session=your_cookie_here"
 export DB_SESSION="__session=your_db_session_here"
 ```
+
 3. Run the tests:
+
 ```bash
 ./scripts/test-payment-flow.sh
 ```
 
 ### Getting Session Cookies
+
 To get session cookies, you can:
+
 1. Log into the app normally through Discord OAuth
 2. Check browser dev tools for the cookies
 3. Or add temporary logging to session.server.ts (as done in completeOauthLogin)
@@ -31,32 +39,38 @@ To get session cookies, you can:
 ### What Gets Tested
 
 #### 🔐 Authentication & Security
+
 - Landing page accessibility
 - Auth protection on protected routes
 - Parameter validation and error handling
 
-#### 🎯 Onboard Flow  
+#### 🎯 Onboard Flow
+
 - Free guild shows "Pro vs Free" choice
 - Pro guild shows congratulatory experience
 - Proper visual hierarchy (Pro marked as "Recommended")
 
 #### 💳 Payment Flow
+
 - Upgrade page renders correctly
 - Payment success updates database subscription
 - Payment cancel shows retry options
 - Database state changes correctly
 
 #### 🔍 OAuth Integration
+
 - OAuth flow redirects to Discord correctly
 - Proper bot permissions included
 - Correct scopes for bot installation
 
 #### 📊 Error Handling
+
 - Missing parameters return 400 errors
 - Invalid routes redirect to login
 - Graceful error responses
 
 ### Example Output
+
 ```
 🧪 Euno Payment Flow Integration Test
 ======================================
@@ -83,20 +97,24 @@ Payment flow is working correctly and ready for production.
 ```
 
 ### Configuration Options
+
 - `BASE_URL` - Server to test (default: http://localhost:3000)
 - `DB_FILE` - Database file location (default: ./mod-bot.sqlite3)
 
 ### Test Data
+
 The script automatically:
+
 - Creates temporary test guilds with different subscription tiers
 - Tests database operations with these guilds
 - Cleans up all test data when complete
 
 ### Assertions Made
+
 1. **HTTP Status Codes** - Ensures routes return expected status
 2. **Content Verification** - Checks key UI elements are present
 3. **Database State** - Verifies subscription changes persist
 4. **Redirect Behavior** - Confirms OAuth and auth flows work
 5. **Error Responses** - Validates proper error handling
 
-This provides confidence that the payment flow works end-to-end before deploying to production.
\ No newline at end of file
+This provides confidence that the payment flow works end-to-end before deploying to production.