diff --git a/AGENTS.md b/AGENTS.md
index ee493d0db..01dacd9fe 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -22,6 +22,7 @@
 - Preserve the domain-owner invariant: `domain.email` identifies the school owner and public API keys resolve that owner as the API actor. Do not use raw `UserModel.update*`, `UserModel.delete*`, `DomainModel.update*`, migrations, or scripts in a way that changes/deletes the owner user, changes the owner user's permissions, or drifts `domain.email` away from the owner user without adding explicit guards and tests.
 - Refrain from adding new GraphQL query/mutation unless required. If an existing query/mutation can be modified to implement the feature without making the query's/mutation's boundaries blurry, extend those.
 - Always keep openapi.mjs files in sync with the actual implementation of the API endpoints.
+- While adding a new collection, always confirm how the deletion/cleanup will work for it.
 
 ### Workspace map (core modules):
 
diff --git a/apps/docs-new/next-env.d.ts b/apps/docs-new/next-env.d.ts
index c4b7818fb..9edff1c7c 100644
--- a/apps/docs-new/next-env.d.ts
+++ b/apps/docs-new/next-env.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/apps/queue/src/notifications/services/channels/__tests__/email.test.ts b/apps/queue/src/notifications/services/channels/__tests__/email.test.ts
index 03dab75d7..441964ccb 100644
--- a/apps/queue/src/notifications/services/channels/__tests__/email.test.ts
+++ b/apps/queue/src/notifications/services/channels/__tests__/email.test.ts
@@ -43,6 +43,7 @@ function makePayload(overrides: Partial<any> = {}): any {
             email: "student@example.com",
             unsubscribeToken: "unsubscribe-token",
             subscribedToUpdates: true,
+            permissions: ["course:manage_any"],
         },
         activityType: Constants.ActivityType.ENROLLED,
         entityId: "entity-id",
@@ -70,6 +71,12 @@ describe("EmailChannel", () => {
     it("renders a notification email with actor avatar, CTA, footer unsubscribe, branding, and unsubscribe headers", async () => {
         await new EmailChannel().send(makePayload());
 
+        expect(mockedGetNotificationMessageAndHref).toHaveBeenCalledWith(
+            expect.objectContaining({
+                recipientPermissions: ["course:manage_any"],
+            }),
+        );
+
         expect(mockedAddMailJob).toHaveBeenCalledTimes(1);
         const mail = mockedAddMailJob.mock.calls[0][0];
 
diff --git a/apps/queue/src/notifications/services/channels/email.ts b/apps/queue/src/notifications/services/channels/email.ts
index 922db3d94..e98afdb17 100644
--- a/apps/queue/src/notifications/services/channels/email.ts
+++ b/apps/queue/src/notifications/services/channels/email.ts
@@ -32,6 +32,7 @@ export class EmailChannel implements NotificationChannel {
             entityId: payload.entityId,
             actorName,
             recipientUserId: payload.recipient.userId,
+            recipientPermissions: payload.recipient.permissions || [],
             entityTargetId: payload.entityTargetId,
             metadata: payload.metadata,
             hrefPrefix: getSiteUrl(payload.domain),
diff --git a/apps/web/.migrations/21-06-26_12-30-seed-product-discussion-notification-preferences.js b/apps/web/.migrations/21-06-26_12-30-seed-product-discussion-notification-preferences.js
new file mode 100644
index 000000000..7db67d4d0
--- /dev/null
+++ b/apps/web/.migrations/21-06-26_12-30-seed-product-discussion-notification-preferences.js
@@ -0,0 +1,131 @@
+/**
+ * Seeds granular product discussion notification preferences for existing
+ * users.
+ *
+ * Usage: DB_CONNECTION_STRING=<mongodb-connection-string> node 21-06-26_12-30-seed-product-discussion-notification-preferences.js
+ */
+import mongoose from "mongoose";
+
+const DB_CONNECTION_STRING = process.env.DB_CONNECTION_STRING;
+if (!DB_CONNECTION_STRING) {
+    throw new Error("DB_CONNECTION_STRING is not set");
+}
+
+const PRODUCT_DISCUSSION_ACTIVITY_TYPES = [
+    "course_discussion_comment_created",
+    "course_discussion_reacted",
+];
+const DEFAULT_CHANNELS = ["app", "email"];
+const BATCH_SIZE = 500;
+
+const UserSchema = new mongoose.Schema({
+    domain: { type: mongoose.Schema.Types.ObjectId, required: true },
+    userId: { type: String, required: true },
+});
+
+const NotificationPreferenceSchema = new mongoose.Schema(
+    {
+        domain: { type: mongoose.Schema.Types.ObjectId, required: true },
+        userId: { type: String, required: true },
+        activityType: { type: String, required: true },
+        channels: { type: [String], default: [] },
+    },
+    {
+        timestamps: true,
+    },
+);
+
+NotificationPreferenceSchema.index(
+    {
+        domain: 1,
+        userId: 1,
+        activityType: 1,
+    },
+    {
+        unique: true,
+    },
+);
+
+const User = mongoose.model("User", UserSchema);
+const NotificationPreference = mongoose.model(
+    "NotificationPreference",
+    NotificationPreferenceSchema,
+);
+
+function getPreferenceOps({ domain, userId }) {
+    return PRODUCT_DISCUSSION_ACTIVITY_TYPES.map((activityType) => ({
+        updateOne: {
+            filter: {
+                domain,
+                userId,
+                activityType,
+            },
+            update: {
+                $setOnInsert: {
+                    domain,
+                    userId,
+                    activityType,
+                    channels: DEFAULT_CHANNELS,
+                },
+            },
+            upsert: true,
+        },
+    }));
+}
+
+async function flushBatch(batch) {
+    if (!batch.length) {
+        return;
+    }
+
+    await NotificationPreference.bulkWrite(batch, { ordered: false });
+    batch.length = 0;
+}
+
+async function seedNotificationPreferences() {
+    const cursor = User.find(
+        {},
+        {
+            _id: 0,
+            domain: 1,
+            userId: 1,
+        },
+    )
+        .lean()
+        .cursor();
+
+    let processedUsers = 0;
+    let totalOps = 0;
+    const batch = [];
+
+    for await (const user of cursor) {
+        const ops = getPreferenceOps({
+            domain: user.domain,
+            userId: user.userId,
+        });
+
+        batch.push(...ops);
+        processedUsers += 1;
+        totalOps += ops.length;
+
+        if (batch.length >= BATCH_SIZE) {
+            await flushBatch(batch);
+        }
+    }
+
+    await flushBatch(batch);
+
+    console.log(
+        `Seeded product discussion preferences for ${processedUsers} users (${totalOps} idempotent upserts).`,
+    );
+}
+
+(async () => {
+    try {
+        await mongoose.connect(DB_CONNECTION_STRING);
+
+        await seedNotificationPreferences();
+    } finally {
+        await mongoose.connection.close();
+    }
+})();
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/layout-with-sidebar.test.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/layout-with-sidebar.test.tsx
index 6f05a1472..99e6d71a4 100644
--- a/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/layout-with-sidebar.test.tsx
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/layout-with-sidebar.test.tsx
@@ -1,10 +1,30 @@
+let mockPathname = "/course/test-course/course-1";
+let mockSearchParams = new URLSearchParams();
+let mockIsEnrolled = true;
+
 jest.mock("next/navigation", () => ({
-    usePathname: () => "/course/test-course/course-1",
-    useSearchParams: () => new URLSearchParams(),
+    usePathname: () => mockPathname,
+    useRouter: () => ({ push: jest.fn() }),
+    useSearchParams: () => mockSearchParams,
 }));
 
 jest.mock("next/link", () => {
-    return ({ children }: { children: React.ReactNode }) => children;
+    function MockLink({
+        children,
+        href,
+        ...props
+    }: {
+        children: React.ReactNode;
+        href: string;
+    }) {
+        return (
+            <a href={href} {...props}>
+                {children}
+            </a>
+        );
+    }
+
+    return MockLink;
 });
 
 jest.mock("@components/contexts", () => {
@@ -25,6 +45,10 @@ jest.mock("@components/contexts", () => {
         ThemeContext: React.createContext({
             theme: {},
         }),
+        AddressContext: React.createContext({
+            backend: "http://localhost:3000",
+            frontend: "http://localhost:3000",
+        }),
     };
 });
 
@@ -41,7 +65,12 @@ jest.mock("@components/ui/sidebar", () => ({
     SidebarMenuItem: ({ children }: any) => children,
     SidebarProvider: ({ children }: any) => children,
     SidebarTrigger: () => null,
-    useSidebar: () => ({ openMobile: false }),
+    useSidebar: () => ({
+        open: false,
+        openMobile: false,
+        isMobile: false,
+        setOpenMobile: jest.fn(),
+    }),
 }));
 
 jest.mock("@components/ui/tooltip", () => ({
@@ -63,10 +92,21 @@ jest.mock("@components/ui/button", () => ({
 
 jest.mock("@components/admin/next-theme-switcher", () => () => null);
 
+jest.mock("@/components/public/product-discussions/panel", () => () => null);
+
 jest.mock("@courselit/components-library", () => ({
     Image: () => null,
 }));
 
+jest.mock("@courselit/page-blocks", () => ({
+    TextRenderer: () => null,
+}));
+
+jest.mock("@courselit/text-editor", () => ({
+    Editor: () => null,
+    emptyDoc: {},
+}));
+
 jest.mock("@courselit/icons", () => ({
     CheckCircled: () => null,
     Circle: () => null,
@@ -77,7 +117,9 @@ jest.mock("lucide-react", () => ({
     BookOpen: () => null,
     ChevronRight: () => null,
     Clock: () => null,
+    Folder: () => null,
     LogOutIcon: () => null,
+    MessageSquare: () => null,
 }));
 
 jest.mock("@courselit/page-primitives", () => ({
@@ -86,7 +128,7 @@ jest.mock("@courselit/page-primitives", () => ({
 
 jest.mock("@ui-lib/utils", () => ({
     formattedLocaleDate: () => "Mar 22, 2026",
-    isEnrolled: () => true,
+    isEnrolled: () => mockIsEnrolled,
     isLessonCompleted: () => false,
 }));
 
@@ -95,12 +137,16 @@ import ProductPage, { generateSideBarItems } from "../layout-with-sidebar";
 import { CourseFrontend } from "../helpers";
 import constants from "@/config/constants";
 import { render, screen } from "@testing-library/react";
+import { ProfileContext } from "@components/contexts";
 
 describe("generateSideBarItems", () => {
     const originalDateNow = Date.now;
     const originalRelativeDripUnitInMillis = constants.relativeDripUnitInMillis;
 
     beforeEach(() => {
+        mockPathname = "/course/test-course/course-1";
+        mockSearchParams = new URLSearchParams();
+        mockIsEnrolled = true;
         Date.now = jest.fn(() =>
             new Date("2026-03-22T00:00:00.000Z").getTime(),
         );
@@ -794,9 +840,59 @@ describe("generateSideBarItems", () => {
         expect(items[1].badge).toBeUndefined();
         expect(items[1].items?.[0].icon).toBeUndefined();
     });
+
+    it("does not bypass learner drip rules for course managers outside preview mode", () => {
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "admin-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [
+                {
+                    id: "group-1",
+                    name: "Dripped Section",
+                    lessons: [],
+                    drip: {
+                        status: true,
+                        type: Constants.dripType[0].split("-")[0].toUpperCase(),
+                        delayInMillis: 2,
+                    },
+                },
+            ],
+        } as unknown as CourseFrontend;
+
+        const profile = {
+            userId: "admin-1",
+            permissions: [constants.permissions.manageCourse],
+            purchases: [],
+        } as unknown as Profile;
+
+        const items = generateSideBarItems(
+            course,
+            profile,
+            "/course/test-course/course-1",
+        );
+
+        expect(items[1].badge?.text).toBe("2 days");
+    });
 });
 
 describe("Course viewer layout", () => {
+    beforeEach(() => {
+        mockPathname = "/course/test-course/course-1";
+        mockSearchParams = new URLSearchParams();
+        mockIsEnrolled = true;
+    });
+
     it("renders the preview badge in the viewer header when preview mode is active", () => {
         const course = {
             title: "Course",
@@ -823,4 +919,310 @@ describe("Course viewer layout", () => {
 
         expect(screen.getByText("Preview")).toBeInTheDocument();
     });
+
+    it("shows the discussions sidebar item only when discussions are enabled", () => {
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            groups: [],
+            discussions: false,
+        } as unknown as CourseFrontend;
+
+        const profile = {
+            userId: "user-1",
+            purchases: [
+                {
+                    courseId: "course-1",
+                    accessibleGroups: [],
+                },
+            ],
+        } as unknown as Profile;
+
+        expect(
+            generateSideBarItems(
+                course,
+                profile,
+                "/course/test-course/course-1",
+            ).some((item) => item.title === "Discussions"),
+        ).toBe(false);
+
+        expect(
+            generateSideBarItems(
+                { ...course, discussions: true } as CourseFrontend,
+                profile,
+                "/course/test-course/course-1/discussions",
+            ).find((item) => item.title === "Discussions"),
+        ).toMatchObject({
+            href: "/course/test-course/course-1/discussions",
+            isActive: true,
+        });
+    });
+
+    it("hides discussion sidebar and header actions for guests", () => {
+        mockPathname = "/course/test-course/course-1/lesson-1";
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        expect(
+            generateSideBarItems(
+                course,
+                {} as Profile,
+                "/course/test-course/course-1/discussions",
+            ).some((item) => item.title === "Discussions"),
+        ).toBe(false);
+
+        render(
+            <ProfileContext.Provider value={{ profile: {} } as any}>
+                <ProductPage product={course}>
+                    <div>Public lesson body</div>
+                </ProductPage>
+            </ProfileContext.Provider>,
+        );
+
+        expect(screen.getByText("Public lesson body")).toBeInTheDocument();
+        expect(screen.queryByLabelText("Discussions")).not.toBeInTheDocument();
+    });
+
+    it("hides discussion sidebar and header actions for logged-in non-enrolled users", () => {
+        mockPathname = "/course/test-course/course-1/lesson-1";
+        mockIsEnrolled = false;
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+        const profile = {
+            userId: "user-1",
+            purchases: [],
+        } as unknown as Profile;
+
+        expect(
+            generateSideBarItems(
+                course,
+                profile,
+                "/course/test-course/course-1/discussions",
+            ).some((item) => item.title === "Discussions"),
+        ).toBe(false);
+
+        render(
+            <ProductPage product={course}>
+                <div>Public lesson body</div>
+            </ProductPage>,
+        );
+
+        expect(screen.getByText("Public lesson body")).toBeInTheDocument();
+        expect(screen.queryByLabelText("Discussions")).not.toBeInTheDocument();
+    });
+
+    it("does not show a discussions header action on the course overview page", () => {
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        render(
+            <ProductPage product={course}>
+                <div>Course body</div>
+            </ProductPage>,
+        );
+
+        expect(screen.queryByLabelText("Discussions")).not.toBeInTheDocument();
+    });
+
+    it("does not show a discussions header action on the discussions hub page", () => {
+        mockPathname = "/course/test-course/course-1/discussions";
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        render(
+            <ProductPage product={course}>
+                <div>Discussions body</div>
+            </ProductPage>,
+        );
+
+        expect(screen.queryByLabelText("Discussions")).not.toBeInTheDocument();
+    });
+
+    it("opens the discussion panel from lesson pages", () => {
+        mockPathname = "/course/test-course/course-1/lesson-1";
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        render(
+            <ProductPage product={course}>
+                <div>Lesson body</div>
+            </ProductPage>,
+        );
+
+        expect(screen.getByLabelText("Discussions")).toHaveAttribute(
+            "href",
+            "/course/test-course/course-1/lesson-1?discussion=open",
+        );
+    });
+
+    it("preserves preview session params when opening the discussion panel", () => {
+        mockPathname = "/course/test-course/course-1/lesson-1";
+        mockSearchParams = new URLSearchParams(
+            "preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1",
+        );
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: true,
+            groups: [],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        render(
+            <ProductPage product={course}>
+                <div>Lesson body</div>
+            </ProductPage>,
+        );
+
+        expect(screen.getByLabelText("Discussions")).toHaveAttribute(
+            "href",
+            "/course/test-course/course-1/lesson-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1&discussion=open",
+        );
+    });
+
+    it("preserves the open discussion panel while navigating lesson links", () => {
+        mockPathname = "/course/test-course/course-1/lesson-1";
+        mockSearchParams = new URLSearchParams("discussion=open");
+        const course = {
+            title: "Course",
+            description: "",
+            featuredImage: undefined,
+            updatedAt: new Date().toISOString(),
+            creatorId: "creator-1",
+            slug: "test-course",
+            cost: 0,
+            courseId: "course-1",
+            tags: [],
+            paymentPlans: [],
+            defaultPaymentPlan: "",
+            firstLesson: "lesson-1",
+            isPreview: false,
+            groups: [
+                {
+                    id: "group-1",
+                    name: "Section",
+                    lessons: [
+                        {
+                            lessonId: "lesson-1",
+                            title: "Lesson 1",
+                            requiresEnrollment: false,
+                        },
+                        {
+                            lessonId: "lesson-2",
+                            title: "Lesson 2",
+                            requiresEnrollment: false,
+                        },
+                    ],
+                },
+            ],
+            discussions: true,
+        } as unknown as CourseFrontend;
+
+        const { container } = render(
+            <ProductPage product={course}>
+                <div>Lesson body</div>
+            </ProductPage>,
+        );
+
+        expect(
+            container.querySelector(
+                'a[href="/course/test-course/course-1/lesson-2?discussion=open"]',
+            ),
+        ).toBeInTheDocument();
+    });
 });
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/page.test.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/page.test.tsx
new file mode 100644
index 000000000..e3a2602d5
--- /dev/null
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/__tests__/page.test.tsx
@@ -0,0 +1,196 @@
+import React from "react";
+import { render, screen, waitFor } from "@testing-library/react";
+import ProductPage from "../page";
+import {
+    AddressContext,
+    ProfileContext,
+    SiteInfoContext,
+    ThemeContext,
+} from "@components/contexts";
+import { getProduct } from "../helpers";
+import { getUserProfile } from "@/app/(with-contexts)/helpers";
+
+jest.mock("@components/contexts", () => {
+    const React = require("react");
+    return {
+        AddressContext: React.createContext({
+            backend: "",
+            frontend: "",
+        }),
+        ProfileContext: React.createContext({
+            profile: null,
+            setProfile: undefined,
+        }),
+        SiteInfoContext: React.createContext({}),
+        ThemeContext: React.createContext({
+            theme: {},
+        }),
+    };
+});
+
+jest.mock("next/navigation", () => ({
+    useSearchParams: () => new URLSearchParams(),
+}));
+
+jest.mock("next/link", () => {
+    function MockLink({
+        children,
+        href,
+        className,
+    }: {
+        children: React.ReactNode;
+        href: string;
+        className?: string;
+    }) {
+        return (
+            <a href={href} className={className}>
+                {children}
+            </a>
+        );
+    }
+
+    return MockLink;
+});
+
+jest.mock("../helpers", () => ({
+    getProduct: jest.fn(),
+}));
+
+jest.mock("@/app/(with-contexts)/helpers", () => ({
+    getUserProfile: jest.fn(),
+}));
+
+jest.mock("@courselit/components-library", () => ({
+    Link: ({ children, href, className }: any) => (
+        <a href={href} className={className}>
+            {children}
+        </a>
+    ),
+    getSymbolFromCurrency: () => "$",
+    Image: () => null,
+}));
+
+jest.mock("@courselit/page-blocks", () => ({
+    TextRenderer: () => null,
+}));
+
+jest.mock("@components/table-of-content", () => ({
+    TableOfContent: () => null,
+}));
+
+jest.mock(
+    "@components/public/base-layout/template/widget-error-boundary",
+    () => {
+        function WidgetErrorBoundary({
+            children,
+        }: {
+            children: React.ReactNode;
+        }) {
+            return <>{children}</>;
+        }
+
+        return WidgetErrorBoundary;
+    },
+);
+
+jest.mock("@courselit/page-primitives", () => ({
+    Button: ({ children }: any) => <button>{children}</button>,
+    Header1: ({ children }: any) => <h1>{children}</h1>,
+}));
+
+jest.mock("@courselit/icons", () => ({
+    ArrowRight: () => null,
+}));
+
+jest.mock("lucide-react", () => ({
+    BadgeCheck: () => null,
+}));
+
+jest.mock("@courselit/text-editor", () => ({
+    emptyDoc: { type: "doc", content: [] },
+}));
+
+function getParams() {
+    const params = Promise.resolve({
+        slug: "course-slug",
+        id: "course-1",
+    }) as any;
+    params.status = "fulfilled";
+    params.value = {
+        slug: "course-slug",
+        id: "course-1",
+    };
+    return params;
+}
+
+function renderPage(profile?: Record<string, any>) {
+    const setProfile = jest.fn();
+
+    return render(
+        <AddressContext.Provider
+            value={{ backend: "http://localhost:3000", frontend: "" }}
+        >
+            <SiteInfoContext.Provider value={{ currencyISOCode: "USD" } as any}>
+                <ProfileContext.Provider value={{ profile, setProfile } as any}>
+                    <ThemeContext.Provider value={{ theme: {} } as any}>
+                        <React.Suspense fallback={<div>Loading</div>}>
+                            <ProductPage params={getParams()} />
+                        </React.Suspense>
+                    </ThemeContext.Provider>
+                </ProfileContext.Provider>
+            </SiteInfoContext.Provider>
+        </AddressContext.Provider>,
+    );
+}
+
+describe("Course introduction page", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (getProduct as jest.Mock).mockResolvedValue({
+            title: "Course intro",
+            description: JSON.stringify({ type: "doc", content: [] }),
+            courseId: "course-1",
+            slug: "course-slug",
+            cost: 0,
+            costType: "free",
+            isPreview: false,
+            firstLesson: "lesson-1",
+        });
+        (getUserProfile as jest.Mock).mockResolvedValue(undefined);
+    });
+
+    it("shows price and checkout CTA for anonymous viewers", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(
+                screen.getByRole("heading", { name: "Course intro" }),
+            ).toBeInTheDocument();
+        });
+
+        expect(document.body).toHaveTextContent("$0");
+        expect(screen.getByText("free")).toBeInTheDocument();
+        expect(screen.getByRole("link", { name: "Buy now" })).toHaveAttribute(
+            "href",
+            "/checkout?type=course&id=course-1",
+        );
+    });
+
+    it("does not show price and checkout CTA for enrolled viewers", async () => {
+        renderPage({
+            userId: "learner-1",
+            purchases: [{ courseId: "course-1" }],
+            permissions: [],
+        });
+
+        await waitFor(() => {
+            expect(
+                screen.getByRole("heading", { name: "Course intro" }),
+            ).toBeInTheDocument();
+        });
+
+        expect(
+            screen.queryByRole("link", { name: "Buy now" }),
+        ).not.toBeInTheDocument();
+    });
+});
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/__tests__/page.test.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/__tests__/page.test.tsx
new file mode 100644
index 000000000..e04f51255
--- /dev/null
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/__tests__/page.test.tsx
@@ -0,0 +1,355 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import CourseDiscussionsPage from "../page";
+import {
+    AddressContext,
+    ProfileContext,
+    ThemeContext,
+} from "@components/contexts";
+import { FetchBuilder } from "@courselit/utils";
+import { getProduct } from "../../helpers";
+
+const mockExec = jest.fn();
+const payloads: Record<string, any>[] = [];
+const mockRouterReplace = jest.fn();
+
+jest.mock("next/link", () => {
+    function MockNextLink({
+        children,
+        href,
+        className,
+    }: {
+        children: React.ReactNode;
+        href: string;
+        className?: string;
+    }) {
+        return (
+            <a href={href} className={className}>
+                {children}
+            </a>
+        );
+    }
+
+    return MockNextLink;
+});
+
+const mockSearchParams = jest.fn(() => new URLSearchParams());
+
+jest.mock("next/navigation", () => ({
+    useSearchParams: () => mockSearchParams(),
+    useRouter: () => ({
+        replace: mockRouterReplace,
+    }),
+}));
+
+jest.mock("@components/contexts", () => {
+    const React = require("react");
+    return {
+        AddressContext: React.createContext({
+            backend: "",
+            frontend: "",
+        }),
+        ProfileContext: React.createContext({
+            profile: {
+                userId: "learner-1",
+            },
+        }),
+        ThemeContext: React.createContext({
+            theme: {},
+        }),
+    };
+});
+
+jest.mock("../../helpers", () => ({
+    getProduct: jest.fn().mockResolvedValue({
+        title: "Course with discussions",
+        groups: [
+            {
+                lessons: [
+                    {
+                        lessonId: "lesson-1",
+                        title: "Text lesson",
+                    },
+                    {
+                        lessonId: "lesson-2",
+                        title: "Video lesson",
+                    },
+                ],
+            },
+        ],
+    }),
+}));
+
+jest.mock("@courselit/page-primitives", () => ({
+    Button: ({ children, disabled, onClick }: any) => (
+        <button disabled={disabled} onClick={onClick}>
+            {children}
+        </button>
+    ),
+    Header1: ({ children, className }: any) => (
+        <h1 className={className}>{children}</h1>
+    ),
+    PageCard: ({ children }: any) => <div>{children}</div>,
+    PageCardContent: ({ children }: any) => <div>{children}</div>,
+    Text1: ({ children }: any) => <div>{children}</div>,
+    Text2: ({ children }: any) => <span>{children}</span>,
+}));
+
+jest.mock("lucide-react", () => ({
+    BookOpen: () => null,
+    MessageSquare: () => null,
+}));
+
+jest.mock("@courselit/utils", () => ({
+    truncate: (value: string) => value,
+    FetchBuilder: jest.fn().mockImplementation(() => ({
+        setUrl: jest.fn().mockReturnThis(),
+        setPayload: jest.fn(function (payload) {
+            payloads.push(payload);
+            return this;
+        }),
+        setIsGraphQLEndpoint: jest.fn().mockReturnThis(),
+        build: jest.fn().mockReturnThis(),
+        exec: mockExec,
+    })),
+}));
+
+function renderPage(
+    profile: Record<string, unknown> | null = {
+        userId: "learner-1",
+        purchases: [{ courseId: "course-1" }],
+    },
+) {
+    const params = Promise.resolve({
+        slug: "course-slug",
+        id: "course-1",
+    }) as any;
+    params.status = "fulfilled";
+    params.value = {
+        slug: "course-slug",
+        id: "course-1",
+    };
+
+    return render(
+        <AddressContext.Provider
+            value={{ backend: "http://localhost:3000", frontend: "" }}
+        >
+            <ProfileContext.Provider value={{ profile } as any}>
+                <ThemeContext.Provider value={{ theme: {} } as any}>
+                    <React.Suspense fallback={<div>Loading</div>}>
+                        <CourseDiscussionsPage params={params} />
+                    </React.Suspense>
+                </ThemeContext.Provider>
+            </ProfileContext.Provider>
+        </AddressContext.Provider>,
+    );
+}
+
+describe("CourseDiscussionsPage", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        payloads.length = 0;
+        mockSearchParams.mockReturnValue(new URLSearchParams());
+        (getProduct as jest.Mock).mockResolvedValue({
+            title: "Course with discussions",
+            groups: [
+                {
+                    lessons: [
+                        {
+                            lessonId: "lesson-1",
+                            title: "Text lesson",
+                        },
+                        {
+                            lessonId: "lesson-2",
+                            title: "Video lesson",
+                        },
+                    ],
+                },
+            ],
+        });
+        mockExec.mockImplementation(() => {
+            const payload = payloads[payloads.length - 1];
+            if (payload.variables?.cursor) {
+                return Promise.resolve({
+                    summaries: {
+                        items: [
+                            {
+                                entityId: "lesson-2",
+                                totalCount: 1,
+                                commentsCount: 1,
+                                repliesCount: 0,
+                                lastActivityAt: "2026-06-02T00:00:00.000Z",
+                            },
+                        ],
+                        nextCursor: undefined,
+                        hasMore: false,
+                    },
+                });
+            }
+
+            return Promise.resolve({
+                summaries: {
+                    items: [
+                        {
+                            entityId: "lesson-1",
+                            totalCount: 3,
+                            commentsCount: 1,
+                            repliesCount: 2,
+                            lastActivityAt: "2026-06-01T00:00:00.000Z",
+                        },
+                    ],
+                    nextCursor: "summary-cursor",
+                    hasMore: true,
+                },
+            });
+        });
+    });
+
+    it("lists lesson discussion summaries and links to the lesson with the panel open", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        expect(
+            screen.getByRole("heading", { name: "Discussions" }),
+        ).toHaveClass("max-w-full", "break-all");
+        expect(FetchBuilder).toHaveBeenCalled();
+        expect(getProduct).toHaveBeenCalledWith(
+            "course-1",
+            "http://localhost:3000",
+            false,
+        );
+        expect(payloads[0].variables).toEqual({
+            productId: "course-1",
+            cursor: undefined,
+            preview: false,
+        });
+        expect(screen.getByText("3")).toBeInTheDocument();
+        expect(screen.getByText("Text lesson").closest("a")).toHaveAttribute(
+            "href",
+            "/course/course-slug/course-1/lesson-1?discussion=open",
+        );
+    });
+
+    it("preserves course viewer preview session params while browsing discussions", async () => {
+        (getProduct as jest.Mock).mockResolvedValueOnce({
+            title: "Course with discussions",
+            isPreview: true,
+            groups: [
+                {
+                    lessons: [
+                        {
+                            lessonId: "lesson-1",
+                            title: "Text lesson",
+                        },
+                    ],
+                },
+            ],
+        });
+        mockSearchParams.mockReturnValue(
+            new URLSearchParams(
+                "preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1",
+            ),
+        );
+
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        expect(getProduct).toHaveBeenCalledWith(
+            "course-1",
+            "http://localhost:3000",
+            true,
+        );
+        expect(payloads[0].variables.preview).toBe(true);
+        expect(
+            screen.getByText("Course with discussions").closest("a"),
+        ).toHaveAttribute(
+            "href",
+            "/course/course-slug/course-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1",
+        );
+        expect(screen.getByText("Text lesson").closest("a")).toHaveAttribute(
+            "href",
+            "/course/course-slug/course-1/lesson-1?discussion=open&preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1",
+        );
+    });
+
+    it("paginates discussion summaries without showing zero-activity rows from the client", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        fireEvent.click(screen.getByText("Load more"));
+
+        await waitFor(() => {
+            expect(screen.getByText("Video lesson")).toBeInTheDocument();
+        });
+        expect(payloads[payloads.length - 1].variables).toEqual({
+            productId: "course-1",
+            cursor: "summary-cursor",
+            preview: false,
+        });
+    });
+
+    it("does not fetch or render discussion summaries for guests", async () => {
+        renderPage(null);
+
+        await waitFor(() => {
+            expect(mockRouterReplace).toHaveBeenCalledWith(
+                "/course/course-slug/course-1",
+            );
+        });
+        expect(getProduct).not.toHaveBeenCalled();
+        expect(FetchBuilder).not.toHaveBeenCalled();
+        expect(
+            screen.queryByRole("heading", { name: "Discussions" }),
+        ).not.toBeInTheDocument();
+    });
+
+    it("does not fetch or render discussion summaries for logged-in non-enrolled users", async () => {
+        renderPage({
+            userId: "learner-1",
+            purchases: [],
+        });
+
+        await waitFor(() => {
+            expect(mockRouterReplace).toHaveBeenCalledWith(
+                "/course/course-slug/course-1",
+            );
+        });
+        expect(getProduct).not.toHaveBeenCalled();
+        expect(FetchBuilder).not.toHaveBeenCalled();
+        expect(
+            screen.queryByRole("heading", { name: "Discussions" }),
+        ).not.toBeInTheDocument();
+    });
+
+    it("redirects logged-in non-enrolled users who manually add preview mode", async () => {
+        mockSearchParams.mockReturnValue(new URLSearchParams("preview=true"));
+
+        renderPage({
+            userId: "learner-1",
+            purchases: [],
+        });
+
+        await waitFor(() => {
+            expect(getProduct).toHaveBeenCalledWith(
+                "course-1",
+                "http://localhost:3000",
+                true,
+            );
+        });
+        await waitFor(() => {
+            expect(mockRouterReplace).toHaveBeenCalledWith(
+                "/course/course-slug/course-1",
+            );
+        });
+        expect(FetchBuilder).not.toHaveBeenCalled();
+    });
+});
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/page.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/page.tsx
new file mode 100644
index 000000000..54d4f5014
--- /dev/null
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/discussions/page.tsx
@@ -0,0 +1,271 @@
+"use client";
+
+import { useContext, useEffect, useMemo, useState, use } from "react";
+import {
+    AddressContext,
+    ProfileContext,
+    ThemeContext,
+} from "@components/contexts";
+import { FetchBuilder, truncate } from "@courselit/utils";
+import { getProduct } from "../helpers";
+import { isEnrolled } from "@ui-lib/utils";
+import {
+    Button,
+    Header1,
+    PageCard,
+    PageCardContent,
+    Text1,
+    Text2,
+} from "@courselit/page-primitives";
+import {
+    COURSE_DISCUSSIONS_EMPTY,
+    COURSE_DISCUSSIONS_TITLE,
+    LOAD_MORE_TEXT,
+} from "@ui-config/strings";
+import { BookOpen, MessageSquare } from "lucide-react";
+import NextLink from "next/link";
+import { useRouter, useSearchParams } from "next/navigation";
+import {
+    appendCourseViewerSessionParamsToHref,
+    getCourseViewerSessionParams,
+} from "@/lib/course-viewer-session-params";
+
+type DiscussionSummary = {
+    entityId: string;
+    totalCount: number;
+    commentsCount: number;
+    repliesCount: number;
+    lastActivityAt: string;
+};
+
+export default function CourseDiscussionsPage(props: {
+    params: Promise<{ slug: string; id: string }>;
+}) {
+    const params = use(props.params);
+    const { slug, id } = params;
+    const address = useContext(AddressContext);
+    const { profile } = useContext(ProfileContext);
+    const { theme } = useContext(ThemeContext);
+    const { replace } = useRouter();
+    const searchParams = useSearchParams();
+    const viewerSessionParams = getCourseViewerSessionParams(searchParams);
+    const isViewerEnrolled = Boolean(
+        profile?.userId &&
+            isEnrolled(id, profile as NonNullable<typeof profile>),
+    );
+    const introHref = appendCourseViewerSessionParamsToHref(
+        `/course/${slug}/${id}`,
+        { returnTo: viewerSessionParams.returnTo },
+    );
+    const [summaries, setSummaries] = useState<DiscussionSummary[]>([]);
+    const [courseTitle, setCourseTitle] = useState<string>("");
+    const [nextCursor, setNextCursor] = useState<string>();
+    const [hasMore, setHasMore] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [lessonsById, setLessonsById] = useState<Record<string, string>>({});
+    const [canUseDiscussions, setCanUseDiscussions] = useState(false);
+    const [effectivePreview, setEffectivePreview] = useState(false);
+
+    useEffect(() => {
+        setCanUseDiscussions(false);
+        setEffectivePreview(false);
+        setSummaries([]);
+        setNextCursor(undefined);
+        setHasMore(false);
+        setLessonsById({});
+
+        if (!id || !address?.backend) return;
+        if (!profile?.userId) {
+            replace(introHref);
+            return;
+        }
+        if (!isViewerEnrolled && !viewerSessionParams.preview) {
+            replace(introHref);
+            return;
+        }
+
+        let cancelled = false;
+        getProduct(id, address.backend, Boolean(viewerSessionParams.preview))
+            .then((product) => {
+                if (cancelled) return;
+                const isEffectivePreview = Boolean(product.isPreview);
+                if (!isViewerEnrolled && !isEffectivePreview) {
+                    replace(introHref);
+                    return;
+                }
+
+                setCanUseDiscussions(true);
+                setEffectivePreview(isEffectivePreview);
+                setCourseTitle(product.title || "");
+                const lessons = Object.fromEntries(
+                    product.groups
+                        .flatMap((group) => group.lessons)
+                        .map((lesson) => [lesson.lessonId, lesson.title]),
+                );
+                setLessonsById(lessons);
+                loadSummaries(undefined, isEffectivePreview);
+            })
+            .catch(() => {
+                if (!cancelled) {
+                    replace(introHref);
+                }
+            });
+
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        id,
+        address?.backend,
+        viewerSessionParams.preview,
+        viewerSessionParams.returnTo,
+        profile?.userId,
+        isViewerEnrolled,
+        introHref,
+        replace,
+    ]);
+
+    async function loadSummaries(
+        cursor?: string,
+        previewOverride = effectivePreview,
+    ) {
+        if (!canUseDiscussions && cursor) {
+            return;
+        }
+
+        setLoading(true);
+        try {
+            const response = await graph({
+                query: `
+                    query GetProductDiscussionSummaries($productId: String!, $preview: Boolean, $cursor: String) {
+                        summaries: getProductDiscussionSummaries(productId: $productId, preview: $preview, cursor: $cursor, limit: 20) {
+                            items {
+                                entityId
+                                totalCount
+                                commentsCount
+                                repliesCount
+                                lastActivityAt
+                            }
+                            nextCursor
+                            hasMore
+                        }
+                    }
+                `,
+                variables: {
+                    productId: id,
+                    preview: previewOverride,
+                    cursor,
+                },
+            });
+
+            const page = response.summaries;
+            setSummaries((current) =>
+                cursor ? [...current, ...page.items] : page.items,
+            );
+            setNextCursor(page.nextCursor);
+            setHasMore(page.hasMore);
+        } finally {
+            setLoading(false);
+        }
+    }
+
+    const rows = useMemo(
+        () =>
+            summaries.map((summary) => ({
+                ...summary,
+                title: lessonsById[summary.entityId] || summary.entityId,
+            })),
+        [summaries, lessonsById],
+    );
+
+    async function graph(payload: Record<string, unknown>) {
+        const fetch = new FetchBuilder()
+            .setUrl(`${address.backend}/api/graph`)
+            .setPayload(payload)
+            .setIsGraphQLEndpoint(true)
+            .build();
+
+        return await fetch.exec();
+    }
+
+    if (!canUseDiscussions) {
+        return null;
+    }
+
+    return (
+        <div className="flex w-full min-h-[calc(100vh-4rem)] text-foreground relative min-w-0">
+            <div className="flex-grow min-w-0 flex flex-col justify-between overflow-y-auto max-h-[calc(100vh-4rem)]">
+                <div className="flex flex-col pb-[100px] lg:max-w-[40rem] xl:max-w-[48rem] mx-auto w-full px-4 pt-4 gap-6">
+                    <div className="flex flex-col gap-1">
+                        {courseTitle && (
+                            <NextLink
+                                href={appendCourseViewerSessionParamsToHref(
+                                    `/course/${slug}/${id}`,
+                                    viewerSessionParams,
+                                )}
+                                className="flex items-center gap-2 text-sm text-muted-foreground font-semibold hover:text-foreground transition-colors w-fit mb-1"
+                            >
+                                <BookOpen className="h-4 w-4 shrink-0" />
+                                <span>{courseTitle}</span>
+                            </NextLink>
+                        )}
+                        <Header1
+                            theme={theme.theme}
+                            className="max-w-full break-all"
+                        >
+                            {COURSE_DISCUSSIONS_TITLE}
+                        </Header1>
+                    </div>
+                    {!loading && rows.length === 0 && (
+                        <Text1 theme={theme.theme}>
+                            {COURSE_DISCUSSIONS_EMPTY}
+                        </Text1>
+                    )}
+                    <div className="space-y-3">
+                        {rows.map((summary) => (
+                            <NextLink
+                                key={summary.entityId}
+                                href={appendCourseViewerSessionParamsToHref(
+                                    `/course/${slug}/${id}/${summary.entityId}?discussion=open`,
+                                    viewerSessionParams,
+                                )}
+                                className="block"
+                            >
+                                <PageCard theme={theme.theme} isLink>
+                                    <PageCardContent
+                                        theme={theme.theme}
+                                        className="flex items-center justify-between gap-4"
+                                    >
+                                        <Text1
+                                            theme={theme.theme}
+                                            className="font-semibold"
+                                        >
+                                            {truncate(summary.title, 50)}
+                                        </Text1>
+                                        <Text2
+                                            theme={theme.theme}
+                                            className="flex items-center gap-2"
+                                        >
+                                            <MessageSquare className="h-4 w-4" />
+                                            {summary.totalCount}
+                                        </Text2>
+                                    </PageCardContent>
+                                </PageCard>
+                            </NextLink>
+                        ))}
+                    </div>
+                    {hasMore && (
+                        <Button
+                            theme={theme.theme}
+                            variant="secondary"
+                            disabled={loading}
+                            onClick={() => loadSummaries(nextCursor)}
+                        >
+                            {LOAD_MORE_TEXT}
+                        </Button>
+                    )}
+                </div>
+            </div>
+        </div>
+    );
+}
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/helpers.ts b/apps/web/app/(with-contexts)/course/[slug]/[id]/helpers.ts
index a65822c84..b937c4dd8 100644
--- a/apps/web/app/(with-contexts)/course/[slug]/[id]/helpers.ts
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/helpers.ts
@@ -6,6 +6,7 @@ export type CourseFrontend = CourseWithoutGroups & {
     groups: GroupWithLessons[];
     firstLesson: string;
     isPreview: boolean;
+    discussions: boolean;
 };
 
 export type GroupWithLessons = Group & { lessons: Lesson[] };
@@ -49,6 +50,7 @@ export const getProduct = async (
                         cost,
                         courseId,
                         isPreview,
+                        discussions,
                         groups {
                             id,
                             name,
@@ -134,6 +136,7 @@ export function formatCourse(
         isPreview: Boolean(
             (post as Course & { isPreview?: boolean }).isPreview,
         ),
+        discussions: Boolean(post.discussions),
         groups: groupsWithLessons as GroupWithLessons[],
         tags: post.tags,
         firstLesson: post.firstLesson,
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/layout-with-sidebar.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/layout-with-sidebar.tsx
index f3c5fdf4d..995ca6667 100644
--- a/apps/web/app/(with-contexts)/course/[slug]/[id]/layout-with-sidebar.tsx
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/layout-with-sidebar.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { ReactNode, useContext } from "react";
+import { ReactNode, useContext, useEffect, useRef } from "react";
 import constants from "@/config/constants";
 import {
     formattedLocaleDate,
@@ -12,12 +12,14 @@ import {
     BTN_EXIT_COURSE_TOOLTIP,
     PREVIEW_COURSE_MENU_ITEM,
     SIDEBAR_TEXT_COURSE_ABOUT,
+    SIDEBAR_TEXT_COURSE_DISCUSSIONS,
 } from "@ui-config/strings";
 import { Profile, Constants } from "@courselit/common-models";
 import {
     ProfileContext,
     SiteInfoContext,
     ThemeContext,
+    AddressContext,
 } from "@components/contexts";
 import { CourseFrontend, GroupWithLessons } from "./helpers";
 import {
@@ -33,12 +35,20 @@ import {
     SidebarMenuItem,
     SidebarProvider,
     SidebarTrigger,
+    useSidebar,
 } from "@components/ui/sidebar";
 import { Image } from "@courselit/components-library";
 import Link from "next/link";
 import { truncate } from "@courselit/utils";
 import { Button } from "@components/ui/button";
-import { BookOpen, ChevronRight, Clock, LogOutIcon } from "lucide-react";
+import {
+    BookOpen,
+    ChevronRight,
+    Clock,
+    Folder,
+    LogOutIcon,
+    MessageSquare,
+} from "lucide-react";
 import {
     Tooltip,
     TooltipContent,
@@ -50,15 +60,52 @@ import {
     CollapsibleContent,
     CollapsibleTrigger,
 } from "@components/ui/collapsible";
-import { usePathname, useSearchParams } from "next/navigation";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import { Caption } from "@courselit/page-primitives";
 import NextThemeSwitcher from "@components/admin/next-theme-switcher";
 import {
     appendCourseViewerSessionParamsToHref,
     getCourseViewerSessionParams,
     getCourseViewerReturnPath,
+    setHrefQueryParam,
 } from "@/lib/course-viewer-session-params";
 import { Badge } from "@/components/ui/badge";
+import ProductDiscussionPanel from "@/components/public/product-discussions/panel";
+
+function MobileStateSync() {
+    const { open, setOpenMobile, isMobile } = useSidebar();
+    useEffect(() => {
+        setOpenMobile(open);
+    }, [open, isMobile, setOpenMobile]);
+    return null;
+}
+
+function DiscussionSidebarSync({
+    pathname,
+    router,
+    searchParams,
+}: {
+    pathname: string | null;
+    router: ReturnType<typeof useRouter>;
+    searchParams: ReturnType<typeof useSearchParams>;
+}) {
+    const { openMobile, isMobile } = useSidebar();
+    const prevOpenMobile = useRef(openMobile);
+    useEffect(() => {
+        if (isMobile && prevOpenMobile.current && !openMobile) {
+            const params = new URLSearchParams(searchParams?.toString() || "");
+            if (params.has("discussion")) {
+                params.delete("discussion");
+                const newPath = params.toString()
+                    ? `${pathname}?${params.toString()}`
+                    : pathname;
+                router.push(newPath || "");
+            }
+        }
+        prevOpenMobile.current = openMobile;
+    }, [openMobile, isMobile, searchParams, pathname, router]);
+    return null;
+}
 
 export default function ProductPage({
     product,
@@ -68,13 +115,29 @@ export default function ProductPage({
     children: React.ReactNode;
 }) {
     const { profile } = useContext(ProfileContext);
+    const pathname = usePathname();
     const searchParams = useSearchParams();
     const viewerSessionParams = getCourseViewerSessionParams(searchParams);
     const exitPath = getCourseViewerReturnPath(viewerSessionParams.returnTo);
-
-    if (!profile) {
-        return null;
-    }
+    const isDiscussionOpen = searchParams?.get("discussion") === "open";
+    const router = useRouter();
+    const address = useContext(AddressContext);
+
+    const pathSegments = pathname.split("/").filter(Boolean);
+    const isLessonPage =
+        pathSegments.length === 4 && pathSegments[0] === "course";
+    const isActualLessonPage =
+        isLessonPage && pathSegments[3] !== "discussions";
+    const canUseDiscussions =
+        Boolean(profile?.userId) &&
+        product.discussions &&
+        (product.isPreview || isEnrolled(product.courseId, profile));
+    const showDiscussionsAction = canUseDiscussions && isActualLessonPage;
+    const discussionsHref = getDiscussionHref({
+        pathname,
+        searchParams,
+        isDiscussionOpen,
+    });
 
     return (
         <SidebarProvider
@@ -88,11 +151,11 @@ export default function ProductPage({
         >
             <AppSidebar
                 course={product}
-                profile={profile}
+                profile={profile || {}}
                 viewerSessionParams={viewerSessionParams}
             />
             <SidebarInset>
-                <header className="flex h-16 shrink-0 items-center gap-2 px-4 justify-between text-foreground">
+                <header className="flex h-16 shrink-0 items-center gap-2 px-4 justify-between text-foreground transition-all duration-200">
                     <SidebarTrigger className="-ml-1" />
                     <div className="flex items-center gap-2">
                         {product.isPreview && (
@@ -100,6 +163,33 @@ export default function ProductPage({
                                 {PREVIEW_COURSE_MENU_ITEM}
                             </Badge>
                         )}
+                        {showDiscussionsAction && (
+                            <Tooltip>
+                                <TooltipTrigger asChild>
+                                    <Button
+                                        variant={
+                                            isDiscussionOpen
+                                                ? "secondary"
+                                                : "ghost"
+                                        }
+                                        size="icon"
+                                        asChild
+                                    >
+                                        <Link
+                                            href={discussionsHref}
+                                            aria-label={
+                                                SIDEBAR_TEXT_COURSE_DISCUSSIONS
+                                            }
+                                        >
+                                            <MessageSquare className="h-4 w-4" />
+                                        </Link>
+                                    </Button>
+                                </TooltipTrigger>
+                                <TooltipContent>
+                                    {SIDEBAR_TEXT_COURSE_DISCUSSIONS}
+                                </TooltipContent>
+                            </Tooltip>
+                        )}
                         <NextThemeSwitcher variant="ghost" />
                         <Tooltip>
                             <TooltipTrigger>
@@ -115,12 +205,85 @@ export default function ProductPage({
                         </Tooltip>
                     </div>
                 </header>
-                <div className="p-4">{children}</div>
+                <div className="flex flex-1 flex-col min-h-0 min-w-0 p-4">
+                    {children}
+                </div>
             </SidebarInset>
+            {isActualLessonPage && canUseDiscussions && (
+                <SidebarProvider
+                    open={isDiscussionOpen}
+                    onOpenChange={(open) => {
+                        if (!open) {
+                            const params = new URLSearchParams(
+                                searchParams?.toString() || "",
+                            );
+                            params.delete("discussion");
+                            const newPath = params.toString()
+                                ? `${pathname}?${params.toString()}`
+                                : pathname;
+                            router.push(newPath || "");
+                        }
+                    }}
+                    style={
+                        {
+                            "--sidebar-width": "20rem",
+                            "--sidebar-width-mobile": "28rem",
+                        } as React.CSSProperties
+                    }
+                    className="min-h-0 w-auto"
+                >
+                    <MobileStateSync />
+                    <DiscussionSidebarSync
+                        pathname={pathname}
+                        router={router}
+                        searchParams={searchParams}
+                    />
+                    <Sidebar
+                        side="right"
+                        collapsible="offcanvas"
+                        className="z-40"
+                    >
+                        <ProductDiscussionPanel
+                            address={address}
+                            productId={product.courseId}
+                            slug={product.slug}
+                            entityId={pathSegments[3]}
+                            className="w-full"
+                            onClose={() => {
+                                const params = new URLSearchParams(
+                                    searchParams?.toString() || "",
+                                );
+                                params.delete("discussion");
+                                const newPath = params.toString()
+                                    ? `${pathname}?${params.toString()}`
+                                    : pathname;
+                                router.push(newPath || "");
+                            }}
+                        />
+                    </Sidebar>
+                </SidebarProvider>
+            )}
         </SidebarProvider>
     );
 }
 
+function getDiscussionHref({
+    pathname,
+    searchParams,
+    isDiscussionOpen,
+}: {
+    pathname: string;
+    searchParams: ReturnType<typeof useSearchParams>;
+    isDiscussionOpen: boolean;
+}) {
+    const currentSearch = searchParams?.toString() || "";
+    return setHrefQueryParam(
+        currentSearch ? `${pathname}?${currentSearch}` : pathname,
+        "discussion",
+        isDiscussionOpen ? null : "open",
+    );
+}
+
 export function AppSidebar({
     course,
     profile,
@@ -135,7 +298,7 @@ export function AppSidebar({
     const pathname = usePathname();
     const sideBarItems = generateSideBarItems(
         course,
-        profile as Profile,
+        profile,
         pathname,
         viewerSessionParams,
     );
@@ -187,19 +350,22 @@ export function AppSidebar({
                                                 <TooltipProvider
                                                     delayDuration={1000}
                                                 >
-                                                    <Tooltip>
-                                                        <TooltipTrigger className="text-foreground">
-                                                            {truncate(
-                                                                item.title,
-                                                                item.badge
-                                                                    ? 15
-                                                                    : 26,
-                                                            )}
-                                                        </TooltipTrigger>
-                                                        <TooltipContent>
-                                                            {item.title}
-                                                        </TooltipContent>
-                                                    </Tooltip>
+                                                    <span className="flex min-w-0 items-center gap-2">
+                                                        <Folder className="h-4 w-4 shrink-0 text-foreground" />
+                                                        <Tooltip>
+                                                            <TooltipTrigger className="min-w-0 truncate text-foreground">
+                                                                {truncate(
+                                                                    item.title,
+                                                                    item.badge
+                                                                        ? 15
+                                                                        : 26,
+                                                                )}
+                                                            </TooltipTrigger>
+                                                            <TooltipContent>
+                                                                {item.title}
+                                                            </TooltipContent>
+                                                        </Tooltip>
+                                                    </span>
                                                 </TooltipProvider>
                                                 {item.badge?.text && (
                                                     <Tooltip>
@@ -301,6 +467,7 @@ export function AppSidebar({
                                         className="text-foreground"
                                     >
                                         <Link href={item.href}>
+                                            {item.icon}
                                             {item.title}
                                         </Link>
                                     </SidebarMenuButton>
@@ -330,6 +497,7 @@ export function AppSidebar({
 interface SidebarItem {
     title: string;
     href: string;
+    icon?: ReactNode;
     badge?: {
         text: string;
         description: string;
@@ -346,7 +514,7 @@ interface SidebarItem {
 
 export function generateSideBarItems(
     course: CourseFrontend,
-    profile: Profile,
+    profile: Partial<Profile>,
     pathname: string,
     viewerSessionParams?: ReturnType<typeof getCourseViewerSessionParams>,
 ): SidebarItem[] {
@@ -360,10 +528,29 @@ export function generateSideBarItems(
                 `/course/${course.slug}/${course.courseId}`,
                 viewerSessionParams,
             ),
+            icon: <BookOpen className="h-4 w-4 shrink-0" />,
             isActive: pathname === `/course/${course.slug}/${course.courseId}`,
         },
     ];
 
+    if (
+        course.discussions &&
+        profile?.userId &&
+        (course.isPreview || isEnrolled(course.courseId, profile as Profile))
+    ) {
+        items.push({
+            title: SIDEBAR_TEXT_COURSE_DISCUSSIONS,
+            href: appendCourseViewerSessionParamsToHref(
+                `/course/${course.slug}/${course.courseId}/discussions`,
+                viewerSessionParams,
+            ),
+            icon: <MessageSquare className="h-4 w-4 shrink-0" />,
+            isActive:
+                pathname ===
+                `/course/${course.slug}/${course.courseId}/discussions`,
+        });
+    }
+
     let lastGroupDripDateInMillis = getRelativeDripAnchorMillis(
         course,
         profile,
@@ -397,11 +584,11 @@ export function generateSideBarItems(
                     lessonStatusIcon = lesson.requiresEnrollment ? (
                         <Lock />
                     ) : undefined;
-                } else if (isEnrolled(course.courseId, profile)) {
+                } else if (isEnrolled(course.courseId, profile as Profile)) {
                     lessonStatusIcon = isLessonCompleted({
                         courseId: course.courseId,
                         lessonId: lesson.lessonId,
-                        profile,
+                        profile: profile as Profile,
                     }) ? (
                         <CheckCircled />
                     ) : (
@@ -435,7 +622,7 @@ export function generateSideBarItems(
             group.drip.type ===
                 Constants.dripType[0].split("-")[0].toUpperCase() &&
             !isPreview &&
-            !isGroupAccessibleToUser(course, profile as Profile, group)
+            !isGroupAccessibleToUser(course, profile, group)
         ) {
             lastGroupDripDateInMillis += group?.drip?.delayInMillis ?? 0;
         }
@@ -453,7 +640,7 @@ function getDripLabel({
 }: {
     course: CourseFrontend;
     group: GroupWithLessons;
-    profile: Profile;
+    profile: Partial<Profile>;
     lastGroupDripDateInMillis: number;
     isPreview: boolean;
 }): { text: string; description: string } | undefined {
@@ -461,10 +648,7 @@ function getDripLabel({
         return undefined;
     }
 
-    if (
-        group.drip?.status &&
-        isGroupAccessibleToUser(course, profile as Profile, group)
-    ) {
+    if (group.drip?.status && isGroupAccessibleToUser(course, profile, group)) {
         return undefined;
     }
 
@@ -483,8 +667,9 @@ function getDripLabel({
             );
             availableLabel =
                 daysUntilAvailable &&
-                !isGroupAccessibleToUser(course, profile as Profile, group)
-                    ? isEnrolled(course.courseId, profile)
+                !isGroupAccessibleToUser(course, profile, group)
+                    ? profile?.userId &&
+                      isEnrolled(course.courseId, profile as Profile)
                         ? `Available in ${daysUntilAvailable} days`
                         : `Available ${daysUntilAvailable} days after enrollment`
                     : "";
@@ -512,9 +697,9 @@ function getDripLabel({
 
 function getRelativeDripAnchorMillis(
     course: CourseFrontend,
-    profile: Profile,
+    profile: Partial<Profile>,
 ): number {
-    const purchase = profile.purchases?.find(
+    const purchase = profile?.purchases?.find(
         (purchase) => purchase.courseId === course.courseId,
     );
 
@@ -554,12 +739,12 @@ function normalizeTimestamp(value: string | number | Date): number {
 
 export function isGroupAccessibleToUser(
     course: CourseFrontend,
-    profile: Profile,
+    profile: Partial<Profile>,
     group: GroupWithLessons,
 ): boolean {
     if (!group.drip || !group.drip.status) return true;
 
-    if (!Array.isArray(profile.purchases)) return false;
+    if (!Array.isArray(profile?.purchases)) return false;
     const groupId = getGroupId(group);
     if (!groupId) return false;
 
diff --git a/apps/web/app/(with-contexts)/course/[slug]/[id]/page.tsx b/apps/web/app/(with-contexts)/course/[slug]/[id]/page.tsx
index 10c3dc7a7..3e618ff90 100644
--- a/apps/web/app/(with-contexts)/course/[slug]/[id]/page.tsx
+++ b/apps/web/app/(with-contexts)/course/[slug]/[id]/page.tsx
@@ -8,8 +8,6 @@ import {
     ENROLL_BUTTON_TEXT,
     BTN_VIEW_CERTIFICATE,
 } from "@ui-config/strings";
-import { checkPermission } from "@courselit/utils";
-import { Profile, UIConstants } from "@courselit/common-models";
 import {
     Link,
     getSymbolFromCurrency,
@@ -34,7 +32,6 @@ import {
     appendCourseViewerSessionParamsToHref,
 } from "@/lib/course-viewer-session-params";
 import { useSearchParams } from "next/navigation";
-const { permissions } = UIConstants;
 
 export default function ProductPage(props: {
     params: Promise<{ slug: string; id: string }>;
@@ -67,7 +64,7 @@ export default function ProductPage(props: {
             getUserProfile(address.backend).then((profile) => {
                 setProfile(profile);
                 setProgress(
-                    profile.purchases?.find(
+                    profile?.purchases?.find(
                         (purchase) => purchase.courseId === product.courseId,
                     ),
                 );
@@ -75,10 +72,6 @@ export default function ProductPage(props: {
         }
     }, [product]);
 
-    if (!profile) {
-        return null;
-    }
-
     if (!product || !siteInfo) {
         return null;
     }
@@ -86,7 +79,9 @@ export default function ProductPage(props: {
     const descriptionJson = product.description
         ? JSON.parse(product.description)
         : TextEditorEmptyDoc;
-    const enrolled = isEnrolled(product.courseId, profile as Profile);
+    const enrolled = Boolean(
+        profile?.userId && isEnrolled(product.courseId, profile),
+    );
     const isPreview = Boolean(product.isPreview);
 
     return (
@@ -105,32 +100,28 @@ export default function ProductPage(props: {
                     </Button>
                 </Link>
             )}
-            {!enrolled &&
-                !isPreview &&
-                checkPermission(profile.permissions ?? [], [
-                    permissions.enrollInCourse,
-                ]) && (
-                    <div>
-                        <div className="flex justify-between items-center">
-                            <div className="font-medium flex items-center">
-                                {getSymbolFromCurrency(
-                                    siteInfo.currencyISOCode ?? "",
-                                )}
-                                {product.cost}
-                                <span className="text-sm text-muted-foreground ml-1">
-                                    {product.costType ?? ""}
-                                </span>
-                            </div>
-                            <Link
-                                href={`/checkout?type=course&id=${product.courseId}`}
-                            >
-                                <Button theme={theme.theme}>
-                                    {ENROLL_BUTTON_TEXT}
-                                </Button>
-                            </Link>
+            {!enrolled && !isPreview && (
+                <div>
+                    <div className="flex justify-between items-center">
+                        <div className="font-medium flex items-center">
+                            {getSymbolFromCurrency(
+                                siteInfo.currencyISOCode ?? "",
+                            )}
+                            {product.cost}
+                            <span className="text-sm text-muted-foreground ml-1">
+                                {product.costType ?? ""}
+                            </span>
                         </div>
+                        <Link
+                            href={`/checkout?type=course&id=${product.courseId}`}
+                        >
+                            <Button theme={theme.theme}>
+                                {ENROLL_BUTTON_TEXT}
+                            </Button>
+                        </Link>
                     </div>
-                )}
+                </div>
+            )}
             {product.featuredImage && (
                 <div className="flex justify-center">
                     <div className="mt-4 mb-8 w-full md:max-w-screen-md">
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/[postId]/community-post-page.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/[postId]/community-post-page.tsx
index 2df497a12..821384f7b 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/[postId]/community-post-page.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/[postId]/community-post-page.tsx
@@ -689,7 +689,7 @@ export default function CommunityPostPage({
                         onOpenChange={setShowDeleteConfirmation}
                     >
                         <DialogContent>
-                            <DialogTitle>Delete Post</DialogTitle>
+                            <DialogTitle>Delete post</DialogTitle>
                             <DialogDescription>
                                 Are you sure you want to delete this post?
                             </DialogDescription>
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/page.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/page.tsx
index ef9ddc39f..6b63d3bb1 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/page.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/page.tsx
@@ -4,6 +4,7 @@ import DashboardContent from "@components/admin/dashboard-content";
 import { AddressContext, ProfileContext } from "@components/contexts";
 import {
     COMMUNITY_HEADER,
+    COMMUNITY_REPORTS_HEADER,
     COMMUNITY_SETTINGS,
     DANGER_ZONE_HEADER,
     MEDIA_SELECTOR_REMOVE_BTN_CAPTION,
@@ -553,7 +554,7 @@ export default function Page(props: {
                             >
                                 <Button variant="outline" className="">
                                     <FlagTriangleRight className="w-4 h-4" />{" "}
-                                    Reported content
+                                    {COMMUNITY_REPORTS_HEADER}
                                 </Button>
                             </Link>
                         </div>
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table-skeleton.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table-skeleton.tsx
index 37905c025..318be67c6 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table-skeleton.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table-skeleton.tsx
@@ -10,62 +10,52 @@ import {
 
 export function ReportsTableSkeleton() {
     return (
-        <div className="rounded-md bg-white">
-            <div className="p-4 border-b">
+        <div className="space-y-4">
+            <div>
                 <Skeleton className="h-10 w-[180px]" />
             </div>
-            <Table>
-                <TableHeader>
-                    <TableRow className="bg-gray-50/50">
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Content
-                        </TableHead>
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Type
-                        </TableHead>
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Reason
-                        </TableHead>
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Status
-                        </TableHead>
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Rejection Reason
-                        </TableHead>
-                        <TableHead className="text-sm font-medium text-gray-500">
-                            Actions
-                        </TableHead>
-                    </TableRow>
-                </TableHeader>
-                <TableBody>
-                    {Array.from({ length: 5 }).map((_, i) => (
-                        <TableRow key={i} className="border-b">
-                            <TableCell>
-                                <Skeleton className="h-4 w-[200px]" />
-                            </TableCell>
-                            <TableCell>
-                                <Skeleton className="h-4 w-16" />
-                            </TableCell>
-                            <TableCell>
-                                <Skeleton className="h-4 w-24" />
-                            </TableCell>
-                            <TableCell>
-                                <Skeleton className="h-6 w-16" />
-                            </TableCell>
-                            <TableCell>
-                                <Skeleton className="h-4 w-24" />
-                            </TableCell>
-                            <TableCell>
-                                <Skeleton className="h-8 w-20" />
-                            </TableCell>
+            <div className="overflow-x-auto rounded-md border">
+                <Table>
+                    <TableHeader>
+                        <TableRow>
+                            <TableHead>Content</TableHead>
+                            <TableHead>Type</TableHead>
+                            <TableHead>Reason</TableHead>
+                            <TableHead>Status</TableHead>
+                            <TableHead>Rejection Reason</TableHead>
+                            <TableHead>Actions</TableHead>
                         </TableRow>
-                    ))}
-                </TableBody>
-            </Table>
-            <div className="flex items-center justify-between px-4 py-3 border-t">
-                <Skeleton className="h-8 w-20" />
-                <Skeleton className="h-4 w-16" />
-                <Skeleton className="h-8 w-20" />
+                    </TableHeader>
+                    <TableBody>
+                        {Array.from({ length: 5 }).map((_, i) => (
+                            <TableRow key={i}>
+                                <TableCell>
+                                    <Skeleton className="h-4 w-[200px]" />
+                                </TableCell>
+                                <TableCell>
+                                    <Skeleton className="h-4 w-16" />
+                                </TableCell>
+                                <TableCell>
+                                    <Skeleton className="h-4 w-24" />
+                                </TableCell>
+                                <TableCell>
+                                    <Skeleton className="h-6 w-16" />
+                                </TableCell>
+                                <TableCell>
+                                    <Skeleton className="h-4 w-24" />
+                                </TableCell>
+                                <TableCell>
+                                    <Skeleton className="h-8 w-20" />
+                                </TableCell>
+                            </TableRow>
+                        ))}
+                    </TableBody>
+                </Table>
+                <div className="flex items-center justify-between border-t px-4 py-3">
+                    <Skeleton className="h-8 w-20" />
+                    <Skeleton className="h-4 w-16" />
+                    <Skeleton className="h-8 w-20" />
+                </div>
             </div>
         </div>
     );
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table.tsx
index 0ae7aef9d..24e6db729 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/reports-table.tsx
@@ -193,42 +193,21 @@ export function ReportsTable({ communityId }: { communityId: string }) {
     const getStatusBadge = (status: CommunityReportStatus) => {
         switch (status) {
             case "pending":
-                return (
-                    <Badge
-                        variant="secondary"
-                        className="bg-yellow-100 text-yellow-700 hover:bg-yellow-100"
-                    >
-                        PENDING
-                    </Badge>
-                );
+                return <Badge variant="secondary">PENDING</Badge>;
             case "accepted":
-                return (
-                    <Badge
-                        variant="default"
-                        className="bg-red-100 text-red-700 hover:bg-red-100"
-                    >
-                        ACCEPTED
-                    </Badge>
-                );
+                return <Badge variant="default">ACCEPTED</Badge>;
             case "rejected":
-                return (
-                    <Badge
-                        variant="outline"
-                        className="bg-gray-100 text-gray-700 hover:bg-gray-100"
-                    >
-                        REJECTED
-                    </Badge>
-                );
+                return <Badge variant="outline">REJECTED</Badge>;
             default:
                 return null;
         }
     };
 
     return (
-        <div className="rounded-md bg-white">
-            <div className="py-4 pr-4 border-b">
+        <div className="space-y-4">
+            <div>
                 <Select value={filter} onValueChange={setFilter}>
-                    <SelectTrigger className="w-[180px] bg-white">
+                    <SelectTrigger className="w-[180px]">
                         <SelectValue placeholder="All" />
                     </SelectTrigger>
                     <SelectContent>
@@ -239,7 +218,7 @@ export function ReportsTable({ communityId }: { communityId: string }) {
                     </SelectContent>
                 </Select>
             </div>
-            <div className="overflow-x-auto">
+            <div className="overflow-x-auto rounded-md border">
                 <PaginatedTable
                     page={page}
                     totalPages={Math.ceil(totalReports / itemsPerPage)}
@@ -247,49 +226,32 @@ export function ReportsTable({ communityId }: { communityId: string }) {
                 >
                     <Table>
                         <TableHeader>
-                            <TableRow className="bg-gray-50/50">
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Content
-                                </TableHead>
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Type
-                                </TableHead>
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Reason
-                                </TableHead>
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Status
-                                </TableHead>
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Rejection Reason
-                                </TableHead>
-                                <TableHead className="text-sm font-medium text-gray-500">
-                                    Actions
-                                </TableHead>
+                            <TableRow>
+                                <TableHead>Content</TableHead>
+                                <TableHead>Type</TableHead>
+                                <TableHead>Reason</TableHead>
+                                <TableHead>Status</TableHead>
+                                <TableHead>Rejection Reason</TableHead>
+                                <TableHead>Actions</TableHead>
                             </TableRow>
                         </TableHeader>
                         <TableBody>
                             {reports.map((report) => (
-                                <TableRow
-                                    key={report.reportId}
-                                    className="border-b"
-                                >
-                                    <TableCell className="text-sm text-gray-600 max-w-[200px] truncate">
+                                <TableRow key={report.reportId}>
+                                    <TableCell className="max-w-[200px] truncate">
                                         {report.content.content}
                                     </TableCell>
-                                    <TableCell className="text-sm text-gray-600">
+                                    <TableCell>
                                         {report.type.charAt(0).toUpperCase() +
                                             report.type.slice(1).toLowerCase()}
                                     </TableCell>
-                                    <TableCell className="text-sm text-gray-600">
-                                        {report.reason}
-                                    </TableCell>
+                                    <TableCell>{report.reason}</TableCell>
                                     <TableCell>
                                         {getStatusBadge(
                                             report.status.toLowerCase() as CommunityReportStatus,
                                         )}
                                     </TableCell>
-                                    <TableCell className="text-sm text-gray-500">
+                                    <TableCell>
                                         {report.rejectionReason || "-"}
                                     </TableCell>
                                     <TableCell>
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/notifications/__tests__/page.test.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/notifications/__tests__/page.test.tsx
index 432bae0ef..def8d6ade 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/notifications/__tests__/page.test.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/notifications/__tests__/page.test.tsx
@@ -90,6 +90,12 @@ describe("Notifications Page", () => {
         expect(
             screen.getByText("Community Membership Granted"),
         ).toBeInTheDocument();
+        expect(
+            screen.getByText("Course Discussion Comment Created"),
+        ).toBeInTheDocument();
+        expect(
+            screen.getByText("Course Discussion Reacted"),
+        ).toBeInTheDocument();
         expect(
             screen.queryByText(
                 "No notification preferences are available for your account.",
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/__tests__/product-discussions.test.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/__tests__/product-discussions.test.tsx
new file mode 100644
index 000000000..35de8d296
--- /dev/null
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/__tests__/product-discussions.test.tsx
@@ -0,0 +1,101 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import ProductDiscussions from "../product-discussions";
+
+const mockToast = jest.fn();
+const mockExec = jest.fn();
+const mockSetPayload = jest.fn();
+
+jest.mock("@courselit/components-library", () => ({
+    useToast: () => ({
+        toast: mockToast,
+    }),
+}));
+
+jest.mock("@/hooks/use-graphql-fetch", () => ({
+    useGraphQLFetch: () => ({
+        setPayload: mockSetPayload.mockReturnThis(),
+        build: jest.fn().mockReturnThis(),
+        exec: mockExec,
+    }),
+}));
+
+jest.mock("@/components/ui/label", () => ({
+    Label: ({ children }: { children: React.ReactNode }) => (
+        <label>{children}</label>
+    ),
+}));
+
+jest.mock("@/components/ui/separator", () => ({
+    Separator: () => <hr />,
+}));
+
+jest.mock("@/components/ui/switch", () => ({
+    Switch: ({ checked, disabled, onCheckedChange }: any) => (
+        <input
+            aria-label="discussions-switch"
+            type="checkbox"
+            checked={checked}
+            disabled={disabled}
+            onChange={() => onCheckedChange(!checked)}
+        />
+    ),
+}));
+
+describe("ProductDiscussions", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExec.mockResolvedValue({
+            updateCourse: {
+                courseId: "course-1",
+                discussions: true,
+            },
+        });
+    });
+
+    it("renders and saves the discussion toggle for course products", async () => {
+        render(
+            <ProductDiscussions
+                product={{
+                    courseId: "course-1",
+                    type: "course",
+                    discussions: false,
+                }}
+            />,
+        );
+
+        fireEvent.click(screen.getByLabelText("discussions-switch"));
+
+        await waitFor(() => {
+            expect(mockSetPayload).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    variables: {
+                        courseId: "course-1",
+                        discussions: true,
+                    },
+                }),
+            );
+        });
+        expect(mockToast).toHaveBeenCalledWith(
+            expect.objectContaining({
+                title: "Success",
+            }),
+        );
+    });
+
+    it("does not render for non-course products", () => {
+        render(
+            <ProductDiscussions
+                product={{
+                    courseId: "blog-1",
+                    type: "blog",
+                    discussions: false,
+                }}
+            />,
+        );
+
+        expect(
+            screen.queryByLabelText("discussions-switch"),
+        ).not.toBeInTheDocument();
+    });
+});
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/product-discussions.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/product-discussions.tsx
new file mode 100644
index 000000000..a14fb59e1
--- /dev/null
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/components/product-discussions.tsx
@@ -0,0 +1,122 @@
+"use client";
+
+import { useState } from "react";
+import { Label } from "@/components/ui/label";
+import { Switch } from "@/components/ui/switch";
+import { Separator } from "@/components/ui/separator";
+import { useToast } from "@courselit/components-library";
+import {
+    COURSE_DISCUSSIONS_ADMIN_VIEW_REPORTS,
+    COURSE_DISCUSSIONS_DESCRIPTION,
+    COURSE_DISCUSSIONS_TITLE,
+    DISCUSSIONS_DISABLED_MESSAGE,
+    DISCUSSIONS_ENABLED_MESSAGE,
+    TOAST_TITLE_ERROR,
+    TOAST_TITLE_SUCCESS,
+} from "@ui-config/strings";
+import { useGraphQLFetch } from "@/hooks/use-graphql-fetch";
+import { COURSE_TYPE_COURSE } from "@ui-config/constants";
+import { Button } from "@/components/ui/button";
+import Link from "next/link";
+
+const MUTATION_UPDATE_DISCUSSIONS = `
+    mutation UpdateDiscussions($courseId: String!, $discussions: Boolean!) {
+        updateCourse(courseData: { id: $courseId, discussions: $discussions }) {
+            courseId
+            discussions
+        }
+    }
+`;
+
+interface ProductDiscussionsProps {
+    product: any;
+}
+
+export default function ProductDiscussions({
+    product,
+}: ProductDiscussionsProps) {
+    const { toast } = useToast();
+    const fetch = useGraphQLFetch();
+    const [loading, setLoading] = useState(false);
+    const [discussions, setDiscussions] = useState(
+        product?.discussions || false,
+    );
+
+    const handleDiscussionsChange = async () => {
+        const newValue = !discussions;
+        const previousValue = discussions;
+        setDiscussions(newValue);
+
+        if (!product?.courseId) return;
+
+        try {
+            setLoading(true);
+            const response = await fetch
+                .setPayload({
+                    query: MUTATION_UPDATE_DISCUSSIONS,
+                    variables: {
+                        courseId: product.courseId,
+                        discussions: newValue,
+                    },
+                })
+                .build()
+                .exec();
+
+            if (response?.updateCourse) {
+                toast({
+                    title: TOAST_TITLE_SUCCESS,
+                    description: response.updateCourse.discussions
+                        ? DISCUSSIONS_ENABLED_MESSAGE
+                        : DISCUSSIONS_DISABLED_MESSAGE,
+                });
+            }
+        } catch (err: any) {
+            setDiscussions(previousValue);
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    if (product?.type?.toLowerCase() !== COURSE_TYPE_COURSE) {
+        return null;
+    }
+
+    return (
+        <div className="space-y-8">
+            <div className="flex items-center justify-between">
+                <div className="space-y-0.5">
+                    <Label className="text-base font-semibold">
+                        {COURSE_DISCUSSIONS_TITLE}
+                    </Label>
+                    <p className="text-sm text-muted-foreground">
+                        {COURSE_DISCUSSIONS_DESCRIPTION}
+                    </p>
+                </div>
+                <div className="flex items-center gap-4">
+                    <Switch
+                        checked={discussions}
+                        onCheckedChange={handleDiscussionsChange}
+                        disabled={loading}
+                    />
+                </div>
+            </div>
+            {discussions && (
+                <div className="flex items-center gap-4 mt-2">
+                    <Button variant="outline" size="sm" asChild>
+                        <Link
+                            href={`/dashboard/product/${product.courseId}/manage/discussions/reports`}
+                        >
+                            {COURSE_DISCUSSIONS_ADMIN_VIEW_REPORTS}
+                        </Link>
+                    </Button>
+                </div>
+            )}
+            <Separator />
+        </div>
+    );
+}
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/__tests__/reports-page.test.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/__tests__/reports-page.test.tsx
new file mode 100644
index 000000000..681ce9202
--- /dev/null
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/__tests__/reports-page.test.tsx
@@ -0,0 +1,331 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import ProductDiscussionReportsPage from "../reports/page";
+import { AddressContext } from "@components/contexts";
+
+const mockToast = jest.fn();
+const mockExec = jest.fn();
+const payloads: Record<string, any>[] = [];
+
+jest.mock("next/navigation", () => ({
+    useParams: () => ({
+        id: "product-1",
+    }),
+}));
+
+jest.mock("next/link", () => {
+    const MockLink = ({ children, href, className }: any) => (
+        <a href={href} className={className}>
+            {children}
+        </a>
+    );
+    MockLink.displayName = "MockLink";
+    return MockLink;
+});
+
+jest.mock("@/hooks/use-product", () => ({
+    __esModule: true,
+    default: () => ({
+        product: {
+            title: "Course with reports",
+            slug: "course-with-reports",
+        },
+    }),
+}));
+
+jest.mock("@components/admin/dashboard-content", () => ({
+    __esModule: true,
+    default: ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+    ),
+}));
+
+jest.mock("@components/admin/empty-state", () => ({
+    __esModule: true,
+    default: ({ title }: { title: string }) => <div>{title}</div>,
+}));
+
+jest.mock("@courselit/components-library", () => ({
+    PaginatedTable: ({ children, page, totalPages, onPageChange }: any) => (
+        <div>
+            {children}
+            {totalPages > 0 && (
+                <div>
+                    <button
+                        disabled={page === 1}
+                        onClick={() => onPageChange(page - 1)}
+                    >
+                        Previous
+                    </button>
+                    <span>
+                        {page} of {totalPages}
+                    </span>
+                    <button
+                        disabled={page === totalPages}
+                        onClick={() => onPageChange(page + 1)}
+                    >
+                        Next
+                    </button>
+                </div>
+            )}
+        </div>
+    ),
+    useToast: () => ({
+        toast: mockToast,
+    }),
+}));
+
+jest.mock("@courselit/utils", () => ({
+    truncate: (value: string) => value,
+    FetchBuilder: jest.fn().mockImplementation(() => ({
+        setUrl: jest.fn().mockReturnThis(),
+        setPayload: jest.fn(function (payload) {
+            payloads.push(payload);
+            return this;
+        }),
+        setIsGraphQLEndpoint: jest.fn().mockReturnThis(),
+        build: jest.fn().mockReturnThis(),
+        exec: mockExec,
+    })),
+}));
+
+jest.mock("@/components/ui/button", () => ({
+    Button: ({ children, disabled, onClick }: any) => (
+        <button disabled={disabled} onClick={onClick}>
+            {children}
+        </button>
+    ),
+}));
+
+jest.mock("@/components/ui/table", () => ({
+    Table: ({ children }: any) => <table>{children}</table>,
+    TableBody: ({ children }: any) => <tbody>{children}</tbody>,
+    TableCell: ({ children, className }: any) => (
+        <td className={className}>{children}</td>
+    ),
+    TableHead: ({ children, className }: any) => (
+        <th className={className}>{children}</th>
+    ),
+    TableHeader: ({ children }: any) => <thead>{children}</thead>,
+    TableRow: ({ children }: any) => <tr>{children}</tr>,
+}));
+
+jest.mock("@/components/ui/badge", () => ({
+    Badge: ({ children }: any) => <span>{children}</span>,
+}));
+
+jest.mock("@/components/ui/select", () => ({
+    Select: ({ children, value, onValueChange }: any) => (
+        <div data-testid="mock-select">
+            {React.Children.map(children, (child) =>
+                React.isValidElement(child)
+                    ? React.cloneElement(child as React.ReactElement<any>, {
+                          onValueChange,
+                          value,
+                      })
+                    : child,
+            )}
+        </div>
+    ),
+    SelectTrigger: ({ children }: any) => <div>{children}</div>,
+    SelectValue: ({ placeholder }: any) => <span>{placeholder}</span>,
+    SelectContent: ({ children, onValueChange }: any) => (
+        <div>
+            {React.Children.map(children, (child) =>
+                React.isValidElement(child)
+                    ? React.cloneElement(child as React.ReactElement<any>, {
+                          onValueChange,
+                      })
+                    : child,
+            )}
+        </div>
+    ),
+    SelectItem: ({ children, value, onValueChange }: any) => (
+        <button onClick={() => onValueChange && onValueChange(value)}>
+            {children}
+        </button>
+    ),
+}));
+
+function renderPage() {
+    return render(
+        <AddressContext.Provider
+            value={{ backend: "http://localhost:3000", frontend: "" }}
+        >
+            <ProductDiscussionReportsPage />
+        </AddressContext.Provider>,
+    );
+}
+
+describe("ProductDiscussionReportsPage", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        payloads.length = 0;
+        mockExec.mockImplementation(() => {
+            const payload = payloads[payloads.length - 1];
+            if (payload.query.includes("GetProductDiscussionReports")) {
+                return Promise.resolve({
+                    reports: {
+                        items: [
+                            {
+                                reportId: "report-1",
+                                contentType: "COMMENT",
+                                contentId: "comment-1",
+                                userId: "reporter-1",
+                                reason: "Spam",
+                                status: "accepted",
+                                createdAt: "2026-06-01T00:00:00.000Z",
+                                entityId: "lesson-1",
+                                lessonTitle: "Text lesson",
+                                contentPreview: "Reported content",
+                                authorName: "Author One",
+                                reporterName: "Reporter One",
+                            },
+                        ],
+                    },
+                    totalReports: 11,
+                });
+            }
+            if (payload.query.includes("UpdateProductDiscussionReportStatus")) {
+                return Promise.resolve({
+                    report: {
+                        reportId: "report-1",
+                        status: "rejected",
+                        rejectionReason: "Rejected by moderator",
+                    },
+                });
+            }
+            return Promise.resolve({});
+        });
+    });
+
+    it("lists reported discussion content with accepted status label", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        expect(
+            screen
+                .getAllByRole("columnheader")
+                .map((header) => header.textContent),
+        ).toEqual([
+            "Content",
+            "Lesson",
+            "Author",
+            "Reported by",
+            "Reason",
+            "Status",
+            "Date",
+            "Actions",
+        ]);
+        expect(screen.getByText("Reported content")).toBeInTheDocument();
+        expect(
+            screen.getByText("Reported content").closest("a"),
+        ).toHaveAttribute(
+            "href",
+            "/course/course-with-reports/product-1/lesson-1?discussion=open&preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1%2Fmanage%2Fdiscussions%2Freports#discussion-comment-comment-1",
+        );
+        expect(screen.getByText("Author One")).toBeInTheDocument();
+        expect(screen.getByText("Reporter One")).toBeInTheDocument();
+        expect(screen.getByText("Spam")).toBeInTheDocument();
+        expect(screen.getByText("ACCEPTED")).toBeInTheDocument();
+        expect(screen.getByText("1 of 2")).toBeInTheDocument();
+        expect(payloads[payloads.length - 1].variables).toEqual({
+            productId: "product-1",
+            status: undefined,
+            page: 1,
+            limit: 10,
+        });
+        expect(screen.queryByText("approved")).not.toBeInTheDocument();
+    });
+
+    it("links reply reports to the rendered reply target", async () => {
+        mockExec.mockResolvedValueOnce({
+            reports: {
+                items: [
+                    {
+                        reportId: "report-reply-1",
+                        contentType: "REPLY",
+                        contentId: "reply-1",
+                        userId: "reporter-1",
+                        reason: "Spam",
+                        status: "pending",
+                        createdAt: "2026-06-01T00:00:00.000Z",
+                        entityId: "lesson-1",
+                        lessonTitle: "Text lesson",
+                        contentPreview: "Reported reply",
+                        authorName: "Author One",
+                        reporterName: "Reporter One",
+                    },
+                ],
+            },
+            totalReports: 1,
+        });
+
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Reported reply")).toBeInTheDocument();
+        });
+
+        expect(screen.getByText("Reported reply").closest("a")).toHaveAttribute(
+            "href",
+            "/course/course-with-reports/product-1/lesson-1?discussion=open&preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1%2Fmanage%2Fdiscussions%2Freports#discussion-reply-reply-1",
+        );
+    });
+
+    it("loads the next numbered reports page", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        fireEvent.click(screen.getByText("Next"));
+
+        await waitFor(() => {
+            expect(payloads[payloads.length - 1].variables).toEqual({
+                productId: "product-1",
+                status: undefined,
+                page: 2,
+                limit: 10,
+            });
+        });
+    });
+
+    it("filters reports by status and cycles accepted reports with a rejection reason", async () => {
+        renderPage();
+
+        await waitFor(() => {
+            expect(screen.getByText("Text lesson")).toBeInTheDocument();
+        });
+
+        fireEvent.click(screen.getByText("Accepted"));
+
+        await waitFor(() => {
+            expect(payloads[payloads.length - 1].variables.status).toBe(
+                "ACCEPTED",
+            );
+        });
+
+        fireEvent.click(screen.getByText("Change"));
+
+        await waitFor(() => {
+            expect(screen.getByText("Confirm")).toBeInTheDocument();
+        });
+        fireEvent.click(screen.getByText("Confirm"));
+
+        await waitFor(() => {
+            expect(payloads[payloads.length - 1].variables).toEqual({
+                productId: "product-1",
+                reportId: "report-1",
+                rejectionReason: "Rejected by moderator",
+            });
+        });
+        await waitFor(() => {
+            expect(screen.getByText("REJECTED")).toBeInTheDocument();
+        });
+    });
+});
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/page.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/page.tsx
new file mode 100644
index 000000000..d1bbb188c
--- /dev/null
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/page.tsx
@@ -0,0 +1,452 @@
+"use client";
+
+import { useCallback, useContext, useEffect, useState } from "react";
+import { useParams } from "next/navigation";
+import DashboardContent from "@components/admin/dashboard-content";
+import useProduct from "@/hooks/use-product";
+import { AddressContext } from "@components/contexts";
+import { FetchBuilder, truncate } from "@courselit/utils";
+import { UIConstants } from "@courselit/common-models";
+import {
+    COURSE_DISCUSSIONS_ADMIN_AUTHOR,
+    COURSE_DISCUSSIONS_ADMIN_CONTENT,
+    COURSE_DISCUSSIONS_ADMIN_DATE,
+    COURSE_DISCUSSIONS_ADMIN_LESSON,
+    COURSE_DISCUSSIONS_ADMIN_NO_REPORTS,
+    COURSE_DISCUSSIONS_ADMIN_NO_REPORTS_DESCRIPTION,
+    COURSE_DISCUSSIONS_ADMIN_REASON,
+    COURSE_DISCUSSIONS_ADMIN_REJECTION_REASON_DEFAULT,
+    COURSE_DISCUSSIONS_ADMIN_REPORTED_BY,
+    COURSE_DISCUSSIONS_ADMIN_REPORTS,
+    COURSE_DISCUSSIONS_ADMIN_STATUS,
+    COURSE_DISCUSSIONS_TITLE,
+    MANAGE_COURSES_PAGE_HEADING,
+    TOAST_TITLE_ERROR,
+} from "@ui-config/strings";
+import AdminEmptyState from "@components/admin/empty-state";
+import { Button } from "@/components/ui/button";
+import {
+    Table,
+    TableBody,
+    TableCell,
+    TableHead,
+    TableHeader,
+    TableRow,
+} from "@/components/ui/table";
+import { Badge } from "@/components/ui/badge";
+import { PaginatedTable, useToast } from "@courselit/components-library";
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+} from "@/components/ui/select";
+import { RotateCcwIcon as RotateCCW } from "lucide-react";
+import { RejectionReasonDialog } from "./rejection-reason-dialog";
+import Link from "next/link";
+
+const { permissions } = UIConstants;
+const itemsPerPage = 10;
+
+type ReportStatus = "pending" | "accepted" | "rejected";
+
+type DiscussionReport = {
+    reportId: string;
+    contentType: "COMMENT" | "REPLY";
+    contentId: string;
+    userId: string;
+    reason: string;
+    status: ReportStatus;
+    createdAt: string;
+    entityId: string;
+    lessonTitle?: string;
+    contentPreview?: string;
+    authorName?: string;
+    reporterName?: string;
+};
+
+export default function ProductDiscussionReportsPage() {
+    const params = useParams();
+    const productId = params?.id as string;
+    const { product } = useProduct(productId);
+    const address = useContext(AddressContext);
+    const { toast } = useToast();
+    const [reports, setReports] = useState<DiscussionReport[]>([]);
+    const [page, setPage] = useState(1);
+    const [totalReports, setTotalReports] = useState(0);
+    const [status, setStatus] = useState<ReportStatus | undefined>();
+
+    const breadcrumbs = [
+        { label: MANAGE_COURSES_PAGE_HEADING, href: "/dashboard/products" },
+        {
+            label: product ? truncate(product.title || "", 20) || "..." : "...",
+            href: `/dashboard/product/${productId}`,
+        },
+        {
+            label: COURSE_DISCUSSIONS_TITLE,
+            href: `/dashboard/product/${productId}/manage`,
+        },
+        { label: COURSE_DISCUSSIONS_ADMIN_REPORTS, href: "#" },
+    ];
+
+    const graph = useCallback(
+        async (payload: Record<string, unknown>) => {
+            const fetch = new FetchBuilder()
+                .setUrl(`${address.backend}/api/graph`)
+                .setPayload(payload)
+                .setIsGraphQLEndpoint(true)
+                .build();
+
+            return await fetch.exec();
+        },
+        [address.backend],
+    );
+
+    const loadReports = useCallback(async () => {
+        try {
+            const response = await graph({
+                query: `
+                    query GetProductDiscussionReports($productId: String!, $status: ProductDiscussionReportStatus, $page: Int, $limit: Int) {
+                        reports: getProductDiscussionReports(productId: $productId, status: $status, page: $page, limit: $limit) {
+                            items {
+                                reportId
+                                contentType
+                                contentId
+                                userId
+                                reason
+                                status
+                                createdAt
+                                entityId
+                                lessonTitle
+                                contentPreview
+                                authorName
+                                reporterName
+                            }
+                        }
+                        totalReports: getProductDiscussionReportsCount(productId: $productId, status: $status)
+                    }
+                `,
+                variables: {
+                    productId,
+                    status: status?.toUpperCase(),
+                    page,
+                    limit: itemsPerPage,
+                },
+            });
+            setReports(response.reports.items);
+            setTotalReports(response.totalReports);
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        }
+    }, [graph, page, productId, status, toast]);
+
+    useEffect(() => {
+        if (productId && address?.backend) {
+            void Promise.resolve().then(loadReports);
+        }
+    }, [productId, address?.backend, loadReports]);
+
+    const [rejectionDialogOpen, setRejectionDialogOpen] = useState(false);
+    const [currentReportId, setCurrentReportId] = useState<string | null>(null);
+
+    async function handleStatusChange(report: DiscussionReport) {
+        // Status transition sequence for reports: pending -> accepted -> rejected -> pending
+        let nextStatus: ReportStatus = "pending";
+        if (report.status === "pending") {
+            nextStatus = "accepted";
+        } else if (report.status === "accepted") {
+            nextStatus = "rejected";
+        }
+
+        if (nextStatus === "rejected") {
+            setCurrentReportId(report.reportId);
+            setRejectionDialogOpen(true);
+        } else {
+            await updateReportStatus(report.reportId, nextStatus);
+        }
+    }
+
+    async function handleRejectionConfirm(reason: string) {
+        if (currentReportId) {
+            await updateReportStatus(currentReportId, "rejected", reason);
+        }
+        setRejectionDialogOpen(false);
+        setCurrentReportId(null);
+    }
+
+    async function updateReportStatus(
+        reportId: string,
+        nextStatus: ReportStatus,
+        rejectionReason?: string,
+    ) {
+        try {
+            const response = await graph({
+                query: `
+                    mutation UpdateProductDiscussionReportStatus($productId: String!, $reportId: String!, $rejectionReason: String) {
+                        report: updateProductDiscussionReportStatus(productId: $productId, reportId: $reportId, rejectionReason: $rejectionReason) {
+                            reportId
+                            status
+                            rejectionReason
+                        }
+                    }
+                `,
+                variables: {
+                    productId,
+                    reportId,
+                    rejectionReason:
+                        nextStatus === "rejected"
+                            ? rejectionReason ||
+                              COURSE_DISCUSSIONS_ADMIN_REJECTION_REASON_DEFAULT
+                            : undefined,
+                },
+            });
+            setReports((current) =>
+                current.map((item) =>
+                    item.reportId === reportId
+                        ? {
+                              ...item,
+                              status: response.report.status.toLowerCase() as ReportStatus,
+                          }
+                        : item,
+                ),
+            );
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        }
+    }
+
+    function getViewerDiscussionHref(report: DiscussionReport) {
+        if (!product?.slug) {
+            return null;
+        }
+
+        const returnTo = encodeURIComponent(
+            `/dashboard/product/${productId}/manage/discussions/reports`,
+        );
+        const targetHash = `discussion-${
+            report.contentType === "REPLY" ? "reply" : "comment"
+        }-${report.contentId}`;
+
+        return `/course/${product.slug}/${productId}/${report.entityId}?discussion=open&preview=true&returnTo=${returnTo}#${targetHash}`;
+    }
+
+    const getStatusBadge = (status: ReportStatus) => {
+        switch (status) {
+            case "pending":
+                return (
+                    <Badge variant="secondary" className="text-[10px]">
+                        PENDING
+                    </Badge>
+                );
+            case "accepted":
+                return (
+                    <Badge variant="default" className="text-[10px]">
+                        ACCEPTED
+                    </Badge>
+                );
+            case "rejected":
+                return (
+                    <Badge variant="outline" className="text-[10px]">
+                        REJECTED
+                    </Badge>
+                );
+            default:
+                return null;
+        }
+    };
+
+    return (
+        <DashboardContent
+            breadcrumbs={breadcrumbs}
+            permissions={[
+                permissions.manageAnyCourse,
+                permissions.manageCourse,
+            ]}
+        >
+            <div>
+                <div className="mb-6 flex items-center justify-between">
+                    <div>
+                        <h2 className="text-2xl font-bold tracking-tight">
+                            {COURSE_DISCUSSIONS_ADMIN_REPORTS}
+                        </h2>
+                        <p className="text-muted-foreground">
+                            Review and manage reported discussion content
+                        </p>
+                    </div>
+                </div>
+
+                <div className="space-y-4">
+                    <div>
+                        <Select
+                            value={status || "all"}
+                            onValueChange={(val) => {
+                                setPage(1);
+                                setStatus(
+                                    val === "all"
+                                        ? undefined
+                                        : (val as ReportStatus),
+                                );
+                            }}
+                        >
+                            <SelectTrigger className="w-[180px]">
+                                <SelectValue placeholder="All" />
+                            </SelectTrigger>
+                            <SelectContent>
+                                <SelectItem value="all">All</SelectItem>
+                                <SelectItem value="pending">Pending</SelectItem>
+                                <SelectItem value="accepted">
+                                    Accepted
+                                </SelectItem>
+                                <SelectItem value="rejected">
+                                    Rejected
+                                </SelectItem>
+                            </SelectContent>
+                        </Select>
+                    </div>
+
+                    <div className="overflow-x-auto">
+                        {reports.length === 0 ? (
+                            <AdminEmptyState
+                                title={COURSE_DISCUSSIONS_ADMIN_NO_REPORTS}
+                                description={
+                                    COURSE_DISCUSSIONS_ADMIN_NO_REPORTS_DESCRIPTION
+                                }
+                            />
+                        ) : (
+                            <PaginatedTable
+                                page={page}
+                                totalPages={Math.ceil(
+                                    totalReports / itemsPerPage,
+                                )}
+                                onPageChange={setPage}
+                                className="rounded-md border"
+                            >
+                                <Table>
+                                    <TableHeader>
+                                        <TableRow>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_CONTENT
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_LESSON
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_AUTHOR
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_REPORTED_BY
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_REASON
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {
+                                                    COURSE_DISCUSSIONS_ADMIN_STATUS
+                                                }
+                                            </TableHead>
+                                            <TableHead>
+                                                {COURSE_DISCUSSIONS_ADMIN_DATE}
+                                            </TableHead>
+                                            <TableHead className="text-right">
+                                                Actions
+                                            </TableHead>
+                                        </TableRow>
+                                    </TableHeader>
+                                    <TableBody>
+                                        {reports.map((report) => (
+                                            <TableRow key={report.reportId}>
+                                                <TableCell className="max-w-[200px] truncate">
+                                                    {getViewerDiscussionHref(
+                                                        report,
+                                                    ) ? (
+                                                        <Link
+                                                            href={
+                                                                getViewerDiscussionHref(
+                                                                    report,
+                                                                )!
+                                                            }
+                                                            className="font-medium underline underline-offset-4"
+                                                        >
+                                                            {report.contentPreview ||
+                                                                "View Details"}
+                                                        </Link>
+                                                    ) : (
+                                                        report.contentPreview ||
+                                                        "View Details"
+                                                    )}
+                                                </TableCell>
+                                                <TableCell className="font-medium">
+                                                    {report.lessonTitle ||
+                                                        report.entityId}
+                                                </TableCell>
+                                                <TableCell>
+                                                    {report.authorName || "-"}
+                                                </TableCell>
+                                                <TableCell>
+                                                    {report.reporterName ||
+                                                        report.userId}
+                                                </TableCell>
+                                                <TableCell>
+                                                    {report.reason}
+                                                </TableCell>
+                                                <TableCell>
+                                                    {getStatusBadge(
+                                                        report.status,
+                                                    )}
+                                                </TableCell>
+                                                <TableCell>
+                                                    {new Date(
+                                                        report.createdAt,
+                                                    ).toLocaleDateString()}
+                                                </TableCell>
+                                                <TableCell className="text-right">
+                                                    <Button
+                                                        variant="outline"
+                                                        size="sm"
+                                                        onClick={() =>
+                                                            handleStatusChange(
+                                                                report,
+                                                            )
+                                                        }
+                                                    >
+                                                        <RotateCCW className="mr-2 h-4 w-4" />
+                                                        Change
+                                                    </Button>
+                                                </TableCell>
+                                            </TableRow>
+                                        ))}
+                                    </TableBody>
+                                </Table>
+                            </PaginatedTable>
+                        )}
+                    </div>
+                </div>
+            </div>
+
+            <RejectionReasonDialog
+                isOpen={rejectionDialogOpen}
+                onClose={() => setRejectionDialogOpen(false)}
+                onConfirm={handleRejectionConfirm}
+            />
+        </DashboardContent>
+    );
+}
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/rejection-reason-dialog.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/rejection-reason-dialog.tsx
new file mode 100644
index 000000000..b9928979b
--- /dev/null
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/discussions/reports/rejection-reason-dialog.tsx
@@ -0,0 +1,68 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+
+interface RejectionReasonDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (reason: string) => void;
+}
+
+export function RejectionReasonDialog({
+    isOpen,
+    onClose,
+    onConfirm,
+}: RejectionReasonDialogProps) {
+    const [reason, setReason] = useState("");
+
+    const handleConfirm = () => {
+        onConfirm(reason);
+        setReason("");
+    };
+
+    return (
+        <Dialog open={isOpen} onOpenChange={onClose}>
+            <DialogContent className="sm:max-w-[425px]">
+                <DialogHeader>
+                    <DialogTitle>Enter Rejection Reason</DialogTitle>
+                    <DialogDescription>
+                        Please provide a reason for rejecting this report. This
+                        is optional but recommended.
+                    </DialogDescription>
+                </DialogHeader>
+                <div className="grid gap-4 py-4">
+                    <div className="grid grid-cols-4 items-center gap-4">
+                        <Label htmlFor="reason" className="text-right">
+                            Reason
+                        </Label>
+                        <Input
+                            id="reason"
+                            value={reason}
+                            onChange={(e) => setReason(e.target.value)}
+                            className="col-span-3"
+                        />
+                    </div>
+                </div>
+                <DialogFooter>
+                    <Button type="button" variant="secondary" onClick={onClose}>
+                        Cancel
+                    </Button>
+                    <Button type="submit" onClick={handleConfirm}>
+                        Confirm
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+}
diff --git a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/page.tsx b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/page.tsx
index 8638a75c5..c4324cd00 100644
--- a/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/page.tsx
+++ b/apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/page.tsx
@@ -20,6 +20,7 @@ import DownloadOptions from "./components/download-options";
 import ProductPublishing from "./components/product-publishing";
 import Certificates from "./components/certificates";
 import ProductDeletion from "./components/product-deletion";
+import ProductDiscussions from "./components/product-discussions";
 
 const { permissions } = UIConstants;
 
@@ -107,6 +108,7 @@ export default function SettingsPage() {
                     }}
                     loading={loading}
                 />
+                <ProductDiscussions product={product} />
                 <DownloadOptions
                     product={product}
                     paymentPlans={paymentPlans}
diff --git a/apps/web/components/community/comment-section.tsx b/apps/web/components/community/comment-section.tsx
index 7ec14b2b0..4e371b84b 100644
--- a/apps/web/components/community/comment-section.tsx
+++ b/apps/web/components/community/comment-section.tsx
@@ -11,46 +11,13 @@ import {
     CommunityPost,
     Membership,
 } from "@courselit/common-models";
-
-const HASH_HIGHLIGHT_CLASSES = [
-    "border-border",
-    "bg-accent/40",
-    "shadow-sm",
-    "ring-1",
-    "ring-ring/20",
-];
-
-const scrollToHashTarget = () => {
-    const hash = window.location.hash.slice(1);
-
-    if (!hash) {
-        return false;
-    }
-
-    const el = document.getElementById(hash);
-
-    if (!el) {
-        return false;
-    }
-
-    el.scrollIntoView({
-        behavior: "smooth",
-        block: "center",
-    });
-    el.classList.add(...HASH_HIGHLIGHT_CLASSES);
-    window.setTimeout(
-        () => el.classList.remove(...HASH_HIGHLIGHT_CLASSES),
-        2200,
-    );
-
-    return true;
-};
+import { focusHashTarget, scrollToHashTarget } from "@/lib/hash-target";
 
 const focusCommentTarget = (targetId: string) => {
-    const url = new URL(window.location.href);
-    url.hash = targetId;
-    window.history.pushState({}, "", url.toString());
-    window.dispatchEvent(new Event("community-comment-target-change"));
+    focusHashTarget({
+        targetId,
+        eventName: "community-comment-target-change",
+    });
 };
 
 export default function CommentSection({
diff --git a/apps/web/components/community/index.tsx b/apps/web/components/community/index.tsx
index 84bedbef3..57d725480 100644
--- a/apps/web/components/community/index.tsx
+++ b/apps/web/components/community/index.tsx
@@ -970,7 +970,7 @@ export function CommunityForum({
                         onOpenChange={setShowDeleteConfirmation}
                     >
                         <DialogContent>
-                            <DialogTitle>Delete Post</DialogTitle>
+                            <DialogTitle>Delete post</DialogTitle>
                             <DialogDescription>
                                 Are you sure you want to delete this post? This
                                 action cannot be undone.
diff --git a/apps/web/components/public/product-discussions/__tests__/panel.test.tsx b/apps/web/components/public/product-discussions/__tests__/panel.test.tsx
new file mode 100644
index 000000000..263c229af
--- /dev/null
+++ b/apps/web/components/public/product-discussions/__tests__/panel.test.tsx
@@ -0,0 +1,467 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import ProductDiscussionPanel from "../panel";
+import {
+    AddressContext,
+    ProfileContext,
+    ThemeContext,
+} from "@components/contexts";
+
+const mockToast = jest.fn();
+const mockExec = jest.fn();
+const payloads: Record<string, any>[] = [];
+const scrollIntoView = jest.fn();
+let mockSearchParams = new URLSearchParams();
+
+jest.mock("@components/contexts", () => {
+    const React = jest.requireActual("react");
+    return {
+        AddressContext: React.createContext(undefined),
+        ProfileContext: React.createContext(undefined),
+        ThemeContext: React.createContext({ theme: {} }),
+    };
+});
+
+jest.mock("next/link", () => {
+    function MockNextLink({
+        children,
+        href,
+        className,
+    }: {
+        children: React.ReactNode;
+        href: string;
+        className?: string;
+    }) {
+        return (
+            <a href={href} className={className}>
+                {children}
+            </a>
+        );
+    }
+
+    return MockNextLink;
+});
+
+jest.mock("next/navigation", () => ({
+    useSearchParams: () => mockSearchParams,
+}));
+
+jest.mock("@courselit/components-library", () => ({
+    useToast: () => ({
+        toast: mockToast,
+    }),
+}));
+
+jest.mock("@courselit/page-primitives", () => ({
+    Button: ({ children, disabled, onClick, type, className }: any) => (
+        <button
+            className={className}
+            disabled={disabled}
+            onClick={onClick}
+            type={type || "button"}
+        >
+            {children}
+        </button>
+    ),
+    Caption: ({ children, className }: any) => (
+        <span className={className}>{children}</span>
+    ),
+    Text1: ({ children, className }: any) => (
+        <span className={className}>{children}</span>
+    ),
+    Text2: ({ children, className }: any) => (
+        <span className={className}>{children}</span>
+    ),
+    Link: ({ children, className }: any) => (
+        <span className={className}>{children}</span>
+    ),
+}));
+
+jest.mock("@/components/ui/dialog", () => ({
+    Dialog: ({ children }: any) => children,
+    DialogContent: ({ children }: any) => children,
+    DialogDescription: ({ children }: any) => children,
+    DialogFooter: ({ children }: any) => children,
+    DialogTitle: ({ children }: any) => children,
+}));
+
+jest.mock("@/components/ui/button", () => ({
+    Button: ({ children, onClick }: any) => (
+        <button onClick={onClick}>{children}</button>
+    ),
+}));
+
+jest.mock("@/components/ui/avatar", () => ({
+    Avatar: ({ children, className }: any) => (
+        <span className={className}>{children}</span>
+    ),
+    AvatarImage: ({ src, alt }: any) => <img src={src} alt={alt} />,
+    AvatarFallback: ({ children }: any) => <span>{children}</span>,
+}));
+
+jest.mock("@courselit/page-blocks", () => ({
+    TextRenderer: ({ json }: { json: any }) => (
+        <div>{json?.content?.[0]?.content?.[0]?.text}</div>
+    ),
+}));
+
+jest.mock("@courselit/text-editor", () => ({
+    emptyDoc: { type: "doc", content: [] },
+    Editor: ({ onChange, placeholder }: any) => (
+        <textarea
+            aria-label={placeholder}
+            onChange={(event) =>
+                onChange({
+                    type: "doc",
+                    content: [
+                        {
+                            type: "paragraph",
+                            content: [
+                                { type: "text", text: event.target.value },
+                            ],
+                        },
+                    ],
+                })
+            }
+        />
+    ),
+}));
+
+jest.mock("@courselit/utils", () => {
+    const extractTextFromTextEditorContent = (node: unknown): string => {
+        if (!node || typeof node !== "object") {
+            return "";
+        }
+
+        const record = node as Record<string, unknown>;
+        const ownText = typeof record.text === "string" ? record.text : "";
+        const children = Array.isArray(record.content)
+            ? record.content
+                  .map((child) => extractTextFromTextEditorContent(child))
+                  .join("")
+            : "";
+
+        return `${ownText}${children}`;
+    };
+
+    return {
+        extractTextFromTextEditorContent,
+        FetchBuilder: jest.fn().mockImplementation(() => ({
+            setUrl: jest.fn().mockReturnThis(),
+            setPayload: jest.fn(function (payload) {
+                payloads.push(payload);
+                return this;
+            }),
+            setIsGraphQLEndpoint: jest.fn().mockReturnThis(),
+            build: jest.fn().mockReturnThis(),
+            exec: mockExec,
+        })),
+    };
+});
+
+jest.mock("../report-reason-dialog", () => ({
+    ReportReasonDialog: ({ isOpen, onClose, onSubmit }: any) => {
+        if (!isOpen) return null;
+        return (
+            <div>
+                <button onClick={onClose}>Cancel</button>
+                <button onClick={() => onSubmit("Mock Reason")}>Submit</button>
+            </div>
+        );
+    },
+}));
+
+jest.mock("lucide-react", () => ({
+    Flag: () => null,
+    ThumbsUp: () => null,
+    MessageSquare: () => null,
+    Trash2: () => null,
+    X: () => null,
+    Reply: () => null,
+}));
+
+const address = { backend: "http://localhost:3000", frontend: "" };
+
+const doc = (text: string) => ({
+    type: "doc",
+    content: [
+        {
+            type: "paragraph",
+            content: [{ type: "text", text }],
+        },
+    ],
+});
+
+const initialComment = {
+    productId: "course-1",
+    entityType: "LESSON",
+    entityId: "lesson-1",
+    commentId: "comment-1",
+    userId: "learner-2",
+    content: doc("Root comment"),
+    likesCount: 1,
+    hasLiked: false,
+    replyCount: 1,
+    replyNextCursor: undefined,
+    hasMoreReplies: false,
+    deleted: false,
+    createdAt: "2026-06-01T00:00:00.000Z",
+    user: {
+        name: "Learner Two",
+        avatar: { thumbnail: "/learner-two-avatar.png" },
+    },
+    replies: [
+        {
+            productId: "course-1",
+            entityType: "LESSON",
+            entityId: "lesson-1",
+            commentId: "comment-1",
+            replyId: "reply-1",
+            userId: "learner-3",
+            content: doc("First reply"),
+            likesCount: 0,
+            hasLiked: false,
+            deleted: false,
+            createdAt: "2026-06-01T00:00:00.000Z",
+            user: { name: "Learner Three" },
+        },
+    ],
+};
+
+function renderPanel() {
+    return render(
+        <AddressContext.Provider value={address}>
+            <ThemeContext.Provider value={{ theme: {} } as any}>
+                <ProfileContext.Provider
+                    value={{
+                        profile: { userId: "learner-1" },
+                        setProfile: jest.fn(),
+                    }}
+                >
+                    <ProductDiscussionPanel
+                        address={address}
+                        productId="course-1"
+                        slug="course-slug"
+                        entityId="lesson-1"
+                    />
+                </ProfileContext.Provider>
+            </ThemeContext.Provider>
+        </AddressContext.Provider>,
+    );
+}
+
+describe("ProductDiscussionPanel", () => {
+    beforeAll(() => {
+        Element.prototype.scrollIntoView = scrollIntoView;
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        payloads.length = 0;
+        mockSearchParams = new URLSearchParams();
+        window.location.hash = "";
+        mockExec.mockImplementation(() => {
+            const payload = payloads[payloads.length - 1];
+            if (payload.query.includes("GetProductDiscussionComments")) {
+                return Promise.resolve({
+                    comments: {
+                        items: [initialComment],
+                        nextCursor: undefined,
+                        hasMore: false,
+                    },
+                });
+            }
+            if (payload.query.includes("CreateProductDiscussionReply")) {
+                return Promise.resolve({
+                    reply: {
+                        productId: "course-1",
+                        entityType: "LESSON",
+                        entityId: "lesson-1",
+                        commentId: "comment-1",
+                        replyId: "reply-2",
+                        parentReplyId: "reply-1",
+                        userId: "learner-1",
+                        content: doc("Replying to a reply"),
+                        likesCount: 0,
+                        hasLiked: false,
+                        deleted: false,
+                        createdAt: "2026-06-01T00:00:00.000Z",
+                        user: { name: "Learner One" },
+                    },
+                });
+            }
+            if (payload.query.includes("CreateProductDiscussionComment")) {
+                return Promise.resolve({
+                    comment: {
+                        productId: "course-1",
+                        entityType: "LESSON",
+                        entityId: "lesson-1",
+                        commentId: "comment-2",
+                        userId: "learner-1",
+                        content: doc("A new comment"),
+                        likesCount: 0,
+                        hasLiked: false,
+                        replyCount: 0,
+                        hasMoreReplies: false,
+                        deleted: false,
+                        createdAt: "2026-06-01T00:00:00.000Z",
+                        user: { name: "Learner One" },
+                    },
+                });
+            }
+            return Promise.resolve({});
+        });
+    });
+
+    it("preserves preview session params in the view all discussions link", async () => {
+        mockSearchParams = new URLSearchParams(
+            "preview=true&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1&discussion=open",
+        );
+
+        renderPanel();
+
+        await waitFor(() => {
+            expect(screen.getByText("Root comment")).toBeInTheDocument();
+        });
+
+        expect(screen.getByAltText("Learner Two's avatar")).toHaveAttribute(
+            "src",
+            "/learner-two-avatar.png",
+        );
+
+        expect(
+            screen.getByText("View all discussions").closest("a"),
+        ).toHaveAttribute(
+            "href",
+            "/course/course-slug/course-1/discussions?preview=true&discussion=open&returnTo=%2Fdashboard%2Fproduct%2Fcourse-1",
+        );
+    });
+
+    it("loads the hash target, highlights it, and scrolls it into view", async () => {
+        window.location.hash = "#discussion-reply-reply-1";
+
+        renderPanel();
+
+        await waitFor(() => {
+            expect(screen.getByText("First reply")).toBeInTheDocument();
+        });
+
+        expect(payloads[0].variables).toEqual(
+            expect.objectContaining({
+                targetContentType: "REPLY",
+                targetContentId: "reply-1",
+            }),
+        );
+        expect(document.getElementById("discussion-reply-reply-1")).toHaveClass(
+            "bg-accent/40",
+            "rounded-xl",
+            "border",
+            "border-transparent",
+            "px-3",
+            "py-3",
+        );
+        expect(scrollIntoView).toHaveBeenCalledWith({
+            block: "center",
+            behavior: "smooth",
+        });
+    });
+
+    it("reloads, scrolls, and highlights when a notification hash arrives after mount", async () => {
+        renderPanel();
+
+        await waitFor(() => {
+            expect(screen.getByText("Root comment")).toBeInTheDocument();
+        });
+        expect(payloads[0].variables.targetContentId).toBeUndefined();
+
+        scrollIntoView.mockClear();
+        window.location.hash = "#discussion-reply-reply-1";
+        window.dispatchEvent(new HashChangeEvent("hashchange"));
+
+        await waitFor(() => {
+            expect(payloads[payloads.length - 1].variables).toEqual(
+                expect.objectContaining({
+                    targetContentType: "REPLY",
+                    targetContentId: "reply-1",
+                }),
+            );
+        });
+
+        await waitFor(() => {
+            expect(
+                document.getElementById("discussion-reply-reply-1"),
+            ).toHaveClass("bg-accent/40");
+        });
+        expect(scrollIntoView).toHaveBeenCalledWith({
+            block: "center",
+            behavior: "smooth",
+        });
+    });
+
+    it("updates the URL and highlights a newly posted comment", async () => {
+        renderPanel();
+
+        await waitFor(() => {
+            expect(screen.getByText("Root comment")).toBeInTheDocument();
+        });
+
+        fireEvent.change(screen.getByLabelText("Add a comment..."), {
+            target: { value: "A new comment" },
+        });
+        const postCommentButton = screen.getByText("Post Comment");
+        await waitFor(() => {
+            expect(postCommentButton).not.toBeDisabled();
+        });
+        fireEvent.click(postCommentButton);
+
+        await waitFor(() => {
+            expect(
+                document.getElementById("discussion-comment-comment-2"),
+            ).toHaveClass("bg-accent/40");
+        });
+        expect(window.location.hash).toBe("#discussion-comment-comment-2");
+    });
+
+    it("stores parentReplyId when replying to an existing reply", async () => {
+        renderPanel();
+
+        await waitFor(() => {
+            expect(screen.getByText("First reply")).toBeInTheDocument();
+        });
+
+        const replyButtons = screen.getAllByText("Reply");
+        fireEvent.click(replyButtons[1]);
+        await waitFor(() => {
+            expect(screen.getByLabelText("Add a reply...")).toHaveFocus();
+        });
+        expect(scrollIntoView).toHaveBeenCalledWith({
+            block: "center",
+            behavior: "smooth",
+        });
+
+        fireEvent.change(screen.getByLabelText("Add a reply..."), {
+            target: { value: "Replying to a reply" },
+        });
+        const postReplyButton = screen.getByText("Post Reply");
+        await waitFor(() => {
+            expect(postReplyButton).not.toBeDisabled();
+        });
+        fireEvent.click(postReplyButton);
+
+        await waitFor(() => {
+            expect(screen.getByText("Replying to a reply")).toBeInTheDocument();
+        });
+        expect(payloads[payloads.length - 1].variables).toEqual(
+            expect.objectContaining({
+                commentId: "comment-1",
+                parentReplyId: "reply-1",
+            }),
+        );
+        await waitFor(() => {
+            expect(
+                document.getElementById("discussion-reply-reply-2"),
+            ).toHaveClass("bg-accent/40");
+        });
+        expect(window.location.hash).toBe("#discussion-reply-reply-2");
+    });
+});
diff --git a/apps/web/components/public/product-discussions/panel.tsx b/apps/web/components/public/product-discussions/panel.tsx
new file mode 100644
index 000000000..4ff02c584
--- /dev/null
+++ b/apps/web/components/public/product-discussions/panel.tsx
@@ -0,0 +1,1114 @@
+"use client";
+
+import { useContext, useEffect, useMemo, useRef, useState } from "react";
+import type React from "react";
+import {
+    FetchBuilder,
+    extractTextFromTextEditorContent,
+} from "@courselit/utils";
+import clsx from "clsx";
+import type { Address, TextEditorContent } from "@courselit/common-models";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useForm } from "react-hook-form";
+import { z } from "zod";
+import { ThemeContext, ProfileContext } from "@components/contexts";
+import { TextRenderer } from "@courselit/page-blocks";
+import { Editor, emptyDoc as TextEditorEmptyDoc } from "@courselit/text-editor";
+import { isTextEditorNonEmpty, formattedLocaleDate } from "@ui-lib/utils";
+import {
+    Button,
+    Caption,
+    Text1,
+    Text2,
+    Link as PageLink,
+} from "@courselit/page-primitives";
+import {
+    COURSE_DISCUSSIONS_COMMENT_PLACEHOLDER,
+    COURSE_DISCUSSIONS_CONTENT_REQUIRED,
+    COURSE_DISCUSSIONS_CONTENT_TOO_LONG,
+    COURSE_DISCUSSIONS_DELETE,
+    COURSE_DISCUSSIONS_DELETE_CANCEL,
+    COURSE_DISCUSSIONS_DELETED,
+    COURSE_DISCUSSIONS_DELETE_CONFIRM,
+    COURSE_DISCUSSIONS_DELETE_CONFIRM_DESCRIPTION,
+    COURSE_DISCUSSIONS_DELETE_CONFIRM_TITLE,
+    COURSE_DISCUSSIONS_EMPTY,
+    COURSE_DISCUSSIONS_POST_COMMENT,
+    COURSE_DISCUSSIONS_POST_REPLY,
+    COURSE_DISCUSSIONS_REPLY,
+    COURSE_DISCUSSIONS_REPLY_PLACEHOLDER,
+    COURSE_DISCUSSIONS_REPORT,
+    COURSE_DISCUSSIONS_REPORTED,
+    COURSE_DISCUSSIONS_TITLE,
+    COURSE_DISCUSSIONS_VIEW_ALL,
+    LOAD_MORE_TEXT,
+    TOAST_TITLE_ERROR,
+    TOAST_TITLE_SUCCESS,
+    CAPTION_CLOSE,
+} from "@ui-config/strings";
+import { useToast } from "@courselit/components-library";
+import { ThumbsUp, MessageSquare, Trash2, Flag, X, Reply } from "lucide-react";
+import { ReportReasonDialog } from "./report-reason-dialog";
+import Link from "next/link";
+import { useSearchParams } from "next/navigation";
+import {
+    appendCourseViewerSessionParamsToHref,
+    getCourseViewerSessionParams,
+} from "@/lib/course-viewer-session-params";
+import {
+    focusHashTarget,
+    getCurrentHashTargetId,
+    scrollToHashTarget,
+} from "@/lib/hash-target";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { Button as ShadcnButton } from "@/components/ui/button";
+import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+
+type DiscussionContent = {
+    productId: string;
+    entityType: "LESSON";
+    entityId: string;
+    commentId?: string;
+    replyId?: string;
+    parentReplyId?: string;
+    userId: string;
+    content: TextEditorContent | null;
+    likesCount: number;
+    hasLiked: boolean;
+    deleted: boolean;
+    createdAt: string;
+    user?: {
+        name?: string;
+        email?: string;
+        avatar?: {
+            file?: string;
+            thumbnail?: string;
+        };
+    };
+};
+
+type DiscussionReply = DiscussionContent & {
+    commentId: string;
+    replyId: string;
+};
+
+type DiscussionComment = DiscussionContent & {
+    commentId: string;
+    replyCount: number;
+    replyNextCursor?: string;
+    hasMoreReplies: boolean;
+    replies: DiscussionReply[];
+};
+
+type DiscussionContentTarget = {
+    contentType: "COMMENT" | "REPLY";
+    contentId: string;
+};
+
+interface ProductDiscussionPanelProps {
+    address: Address;
+    productId: string;
+    slug: string;
+    entityId: string;
+    className?: string;
+    onClose?: () => void;
+}
+
+const COMMENT_FIELDS = `
+    productId
+    entityType
+    entityId
+    commentId
+    userId
+    content
+    likesCount
+    hasLiked
+    replyCount
+    replyNextCursor
+    hasMoreReplies
+    deleted
+    createdAt
+    user {
+        name
+        email
+        avatar {
+            file
+            thumbnail
+        }
+    }
+    replies {
+        productId
+        entityType
+        entityId
+        commentId
+        replyId
+        parentReplyId
+        userId
+        content
+        likesCount
+        hasLiked
+        deleted
+        createdAt
+        user {
+            name
+            email
+            avatar {
+                file
+                thumbnail
+            }
+        }
+    }
+`;
+
+const REPLY_FIELDS = `
+    productId
+    entityType
+    entityId
+    commentId
+    replyId
+    parentReplyId
+    userId
+    content
+    likesCount
+    hasLiked
+    deleted
+    createdAt
+    user {
+        name
+        email
+        avatar {
+            file
+            thumbnail
+        }
+    }
+`;
+
+const MAX_DISCUSSION_CONTENT_BYTES = 32768;
+const MAX_DISCUSSION_TEXT_LENGTH = 5000;
+
+const composerSchema = z.object({
+    content: z.custom<TextEditorContent>().superRefine((value, ctx) => {
+        const error = getComposerContentError(value);
+        if (error) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: error,
+            });
+        }
+    }),
+});
+
+type ComposerForm = z.infer<typeof composerSchema>;
+
+export default function ProductDiscussionPanel({
+    address,
+    productId,
+    slug,
+    entityId,
+    className = "",
+    onClose,
+}: ProductDiscussionPanelProps) {
+    const { theme } = useContext(ThemeContext);
+    const { toast } = useToast();
+    const searchParams = useSearchParams();
+    const viewerSessionParams = getCourseViewerSessionParams(searchParams);
+    const allDiscussionsHref = appendCourseViewerSessionParamsToHref(
+        `/course/${slug}/${productId}/discussions`,
+        viewerSessionParams,
+    );
+    const [comments, setComments] = useState<DiscussionComment[]>([]);
+    const [nextCursor, setNextCursor] = useState<string>();
+    const [hasMore, setHasMore] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [posting, setPosting] = useState(false);
+    const [loadingRepliesFor, setLoadingRepliesFor] = useState<string>();
+    const [composerContent, setComposerContent] = useState<TextEditorContent>(
+        TextEditorEmptyDoc as TextEditorContent,
+    );
+    const [composerRefresh, setComposerRefresh] = useState(0);
+    const [replyingTo, setReplyingTo] = useState<{
+        commentId: string;
+        parentReplyId?: string;
+    }>();
+    const [replyFocusToken, setReplyFocusToken] = useState(0);
+    const replyComposerRef = useRef<HTMLDivElement | null>(null);
+    const [replyContent, setReplyContent] = useState<TextEditorContent>(
+        TextEditorEmptyDoc as TextEditorContent,
+    );
+    const [replyRefresh, setReplyRefresh] = useState(0);
+    const [reportDialogOpen, setReportDialogOpen] = useState(false);
+    const [pendingReport, setPendingReport] =
+        useState<DiscussionContentTarget | null>(null);
+    const [pendingDelete, setPendingDelete] =
+        useState<DiscussionContentTarget | null>(null);
+    const [hashTargetId, setHashTargetId] = useState(() =>
+        getCurrentHashTargetId(),
+    );
+    const locallyCreatedTargetIdRef = useRef<string | null>(null);
+    const highlightedTarget = useMemo(
+        () => getDiscussionTargetFromHash(hashTargetId),
+        [hashTargetId],
+    );
+
+    useEffect(() => {
+        function syncTargetIdFromHash() {
+            setHashTargetId(getCurrentHashTargetId());
+        }
+
+        syncTargetIdFromHash();
+        window.addEventListener("hashchange", syncTargetIdFromHash);
+        return () =>
+            window.removeEventListener("hashchange", syncTargetIdFromHash);
+    }, []);
+
+    useEffect(() => {
+        setHashTargetId(getCurrentHashTargetId());
+    }, [productId, entityId]);
+
+    useEffect(
+        () => {
+            if (locallyCreatedTargetIdRef.current === hashTargetId) {
+                locallyCreatedTargetIdRef.current = null;
+                return;
+            }
+            loadComments();
+        },
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [
+            productId,
+            entityId,
+            highlightedTarget?.contentType,
+            highlightedTarget?.contentId,
+        ],
+    );
+
+    useEffect(() => {
+        if (!hashTargetId) {
+            return;
+        }
+
+        scrollToHashTarget({ targetId: hashTargetId });
+    }, [hashTargetId, comments.length]);
+
+    useEffect(() => {
+        if (!replyingTo || !replyComposerRef.current) {
+            return;
+        }
+
+        const timeout = window.setTimeout(() => {
+            const composer = replyComposerRef.current;
+            composer?.scrollIntoView({
+                block: "center",
+                behavior: "smooth",
+            });
+            const editor = composer?.querySelector<HTMLElement>(
+                '[contenteditable="true"], textarea, [role="textbox"]',
+            );
+            editor?.focus();
+        }, 0);
+
+        return () => window.clearTimeout(timeout);
+    }, [replyingTo, replyFocusToken]);
+
+    async function graph(payload: Record<string, unknown>) {
+        const fetch = new FetchBuilder()
+            .setUrl(`${address.backend}/api/graph`)
+            .setPayload(payload)
+            .setIsGraphQLEndpoint(true)
+            .build();
+
+        return await fetch.exec();
+    }
+
+    function focusCreatedContent(targetId: string) {
+        locallyCreatedTargetIdRef.current = targetId;
+        focusHashTarget({ targetId });
+        setHashTargetId(targetId);
+    }
+
+    async function loadComments(cursor?: string) {
+        setLoading(true);
+        try {
+            const response = await graph({
+                query: `
+                    query GetProductDiscussionComments($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!, $cursor: String, $targetContentType: ProductDiscussionContentType, $targetContentId: String) {
+                        comments: getProductDiscussionComments(productId: $productId, entityType: $entityType, entityId: $entityId, cursor: $cursor, limit: 20, replyPreviewLimit: 3, targetContentType: $targetContentType, targetContentId: $targetContentId) {
+                            items { ${COMMENT_FIELDS} }
+                            nextCursor
+                            hasMore
+                        }
+                    }
+                `,
+                variables: {
+                    productId,
+                    entityType: "LESSON",
+                    entityId,
+                    cursor,
+                    targetContentType: cursor
+                        ? undefined
+                        : highlightedTarget?.contentType,
+                    targetContentId: cursor
+                        ? undefined
+                        : highlightedTarget?.contentId,
+                },
+            });
+
+            const page = response.comments;
+            setComments((current) =>
+                cursor ? [...current, ...page.items] : page.items,
+            );
+            setNextCursor(page.nextCursor);
+            setHasMore(page.hasMore);
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        } finally {
+            setLoading(false);
+        }
+    }
+
+    async function postComment() {
+        if (!isTextEditorNonEmpty(composerContent)) return;
+        setPosting(true);
+        try {
+            const response = await graph({
+                query: `
+                    mutation CreateProductDiscussionComment($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!, $content: JSONObject!) {
+                        comment: createProductDiscussionComment(productId: $productId, entityType: $entityType, entityId: $entityId, content: $content) {
+                            ${COMMENT_FIELDS}
+                        }
+                    }
+                `,
+                variables: {
+                    productId,
+                    entityType: "LESSON",
+                    entityId,
+                    content: composerContent,
+                },
+            });
+            setComments((current) => [
+                { ...response.comment, replies: [] },
+                ...current,
+            ]);
+            focusCreatedContent(
+                `discussion-comment-${response.comment.commentId}`,
+            );
+            setComposerContent(TextEditorEmptyDoc as TextEditorContent);
+            setComposerRefresh((value) => value + 1);
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        } finally {
+            setPosting(false);
+        }
+    }
+
+    async function postReply() {
+        if (!replyingTo || !isTextEditorNonEmpty(replyContent)) return;
+        setPosting(true);
+        try {
+            const response = await graph({
+                query: `
+                    mutation CreateProductDiscussionReply($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!, $commentId: String!, $parentReplyId: String, $content: JSONObject!) {
+                        reply: createProductDiscussionReply(productId: $productId, entityType: $entityType, entityId: $entityId, commentId: $commentId, parentReplyId: $parentReplyId, content: $content) {
+                            ${REPLY_FIELDS}
+                        }
+                    }
+                `,
+                variables: {
+                    productId,
+                    entityType: "LESSON",
+                    entityId,
+                    commentId: replyingTo.commentId,
+                    parentReplyId: replyingTo.parentReplyId,
+                    content: replyContent,
+                },
+            });
+            setComments((current) =>
+                current.map((comment) =>
+                    comment.commentId === replyingTo.commentId
+                        ? {
+                              ...comment,
+                              replyCount: comment.replyCount + 1,
+                              replies: [...comment.replies, response.reply],
+                              hasMoreReplies: false,
+                          }
+                        : comment,
+                ),
+            );
+            focusCreatedContent(`discussion-reply-${response.reply.replyId}`);
+            setReplyingTo(undefined);
+            setReplyContent(TextEditorEmptyDoc as TextEditorContent);
+            setReplyRefresh((value) => value + 1);
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        } finally {
+            setPosting(false);
+        }
+    }
+
+    async function loadMoreReplies(comment: DiscussionComment) {
+        if (!comment.replyNextCursor) {
+            return;
+        }
+
+        setLoadingRepliesFor(comment.commentId);
+        try {
+            const response = await graph({
+                query: `
+                    query GetProductDiscussionReplies($commentId: String!, $cursor: String) {
+                        replies: getProductDiscussionReplies(commentId: $commentId, cursor: $cursor, limit: 20) {
+                            items { ${REPLY_FIELDS} }
+                            nextCursor
+                            hasMore
+                        }
+                    }
+                `,
+                variables: {
+                    commentId: comment.commentId,
+                    cursor: comment.replyNextCursor,
+                },
+            });
+            const page = response.replies;
+            setComments((current) =>
+                current.map((item) => {
+                    if (item.commentId !== comment.commentId) {
+                        return item;
+                    }
+
+                    const existingReplyIds = new Set(
+                        item.replies.map((reply) => reply.replyId),
+                    );
+                    const nextReplies = page.items.filter(
+                        (reply: DiscussionReply) =>
+                            !existingReplyIds.has(reply.replyId),
+                    );
+
+                    return {
+                        ...item,
+                        replies: [...item.replies, ...nextReplies],
+                        replyNextCursor: page.nextCursor,
+                        hasMoreReplies: page.hasMore,
+                    };
+                }),
+            );
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        } finally {
+            setLoadingRepliesFor(undefined);
+        }
+    }
+
+    async function toggleLike(
+        contentType: "COMMENT" | "REPLY",
+        contentId: string,
+        liked: boolean,
+    ) {
+        const response = await graph({
+            query: `
+                mutation ToggleProductDiscussionLike($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!, $contentType: ProductDiscussionContentType!, $contentId: String!, $liked: Boolean!) {
+                    like: toggleProductDiscussionLike(productId: $productId, entityType: $entityType, entityId: $entityId, contentType: $contentType, contentId: $contentId, liked: $liked) {
+                        contentType
+                        contentId
+                        likesCount
+                        hasLiked
+                    }
+                }
+            `,
+            variables: {
+                productId,
+                entityType: "LESSON",
+                entityId,
+                contentType,
+                contentId,
+                liked,
+            },
+        });
+        updateContent(contentType, contentId, {
+            likesCount: response.like.likesCount,
+            hasLiked: response.like.hasLiked,
+        });
+    }
+
+    async function deleteContent(
+        contentType: "COMMENT" | "REPLY",
+        contentId: string,
+    ) {
+        await graph({
+            query:
+                contentType === "COMMENT"
+                    ? `mutation DeleteProductDiscussionComment($commentId: String!) { deleteProductDiscussionComment(commentId: $commentId) { commentId deleted } }`
+                    : `mutation DeleteProductDiscussionReply($replyId: String!) { deleteProductDiscussionReply(replyId: $replyId) { replyId deleted } }`,
+            variables:
+                contentType === "COMMENT"
+                    ? { commentId: contentId }
+                    : { replyId: contentId },
+        });
+        updateContent(contentType, contentId, {
+            deleted: true,
+            content: null,
+        });
+        setPendingDelete(null);
+    }
+
+    function openDeleteDialog(
+        contentType: "COMMENT" | "REPLY",
+        contentId: string,
+    ) {
+        setPendingDelete({ contentType, contentId });
+    }
+
+    function confirmDeleteContent() {
+        if (!pendingDelete) return;
+        void deleteContent(pendingDelete.contentType, pendingDelete.contentId);
+    }
+
+    function openReportDialog(
+        contentType: "COMMENT" | "REPLY",
+        contentId: string,
+    ) {
+        setPendingReport({ contentType, contentId });
+        setReportDialogOpen(true);
+    }
+
+    function startReply(target: { commentId: string; parentReplyId?: string }) {
+        setReplyingTo(target);
+        setReplyFocusToken((value) => value + 1);
+    }
+
+    async function handleReportSubmit(reason: string) {
+        setReportDialogOpen(false);
+        if (!pendingReport) return;
+        const { contentType, contentId } = pendingReport;
+        setPendingReport(null);
+
+        try {
+            await graph({
+                query: `
+                    mutation CreateProductDiscussionReport($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!, $contentType: ProductDiscussionContentType!, $contentId: String!, $reason: String!) {
+                        createProductDiscussionReport(productId: $productId, entityType: $entityType, entityId: $entityId, contentType: $contentType, contentId: $contentId, reason: $reason) {
+                            reportId
+                        }
+                    }
+                `,
+                variables: {
+                    productId,
+                    entityType: "LESSON",
+                    entityId,
+                    contentType,
+                    contentId,
+                    reason,
+                },
+            });
+            toast({
+                title: TOAST_TITLE_SUCCESS,
+                description: COURSE_DISCUSSIONS_REPORTED,
+            });
+        } catch (err: any) {
+            toast({
+                title: TOAST_TITLE_ERROR,
+                description: err.message,
+                variant: "destructive",
+            });
+        }
+    }
+
+    function updateContent(
+        contentType: "COMMENT" | "REPLY",
+        contentId: string,
+        patch: Partial<DiscussionComment & DiscussionReply>,
+    ) {
+        setComments((current) =>
+            current.map((comment) => {
+                if (
+                    contentType === "COMMENT" &&
+                    comment.commentId === contentId
+                ) {
+                    return { ...comment, ...patch };
+                }
+
+                return {
+                    ...comment,
+                    replies: comment.replies.map((reply) =>
+                        reply.replyId === contentId
+                            ? { ...reply, ...patch }
+                            : reply,
+                    ),
+                };
+            }),
+        );
+    }
+
+    return (
+        <aside
+            className={`flex h-full min-h-0 flex-col bg-background text-foreground ${className}`}
+        >
+            <header className="border-b px-4 py-3">
+                <div className="flex items-center justify-between">
+                    <div className="flex items-center gap-2">
+                        <MessageSquare className="h-4 w-4" />
+                        <Text2
+                            theme={theme.theme}
+                            className="font-semibold text-base"
+                        >
+                            {COURSE_DISCUSSIONS_TITLE}
+                        </Text2>
+                    </div>
+                    {onClose && (
+                        <ShadcnButton
+                            variant="ghost"
+                            size="icon"
+                            onClick={onClose}
+                            aria-label={CAPTION_CLOSE}
+                            title={CAPTION_CLOSE}
+                        >
+                            <X />
+                        </ShadcnButton>
+                    )}
+                </div>
+                <Link href={allDiscussionsHref} className="block">
+                    <PageLink theme={theme.theme} className="text-xs">
+                        {COURSE_DISCUSSIONS_VIEW_ALL}
+                    </PageLink>
+                </Link>
+            </header>
+            <div className="min-h-0 flex-1 overflow-y-auto px-4 py-4">
+                {!loading && comments.length === 0 && (
+                    <Text2 theme={theme.theme}>
+                        {COURSE_DISCUSSIONS_EMPTY}
+                    </Text2>
+                )}
+                <div className="space-y-6">
+                    {comments.map((comment) => (
+                        <DiscussionItem
+                            key={comment.commentId}
+                            item={comment}
+                            itemId={`discussion-comment-${comment.commentId}`}
+                            onLike={() =>
+                                toggleLike(
+                                    "COMMENT",
+                                    comment.commentId,
+                                    !comment.hasLiked,
+                                )
+                            }
+                            onDelete={() =>
+                                openDeleteDialog("COMMENT", comment.commentId)
+                            }
+                            onReport={() =>
+                                openReportDialog("COMMENT", comment.commentId)
+                            }
+                            onReply={() =>
+                                startReply({
+                                    commentId: comment.commentId,
+                                })
+                            }
+                        >
+                            {comment.replies.map((reply) => (
+                                <DiscussionItem
+                                    key={reply.replyId}
+                                    item={reply}
+                                    itemId={`discussion-reply-${reply.replyId}`}
+                                    compact
+                                    onLike={() =>
+                                        toggleLike(
+                                            "REPLY",
+                                            reply.replyId,
+                                            !reply.hasLiked,
+                                        )
+                                    }
+                                    onDelete={() =>
+                                        openDeleteDialog("REPLY", reply.replyId)
+                                    }
+                                    onReport={() =>
+                                        openReportDialog("REPLY", reply.replyId)
+                                    }
+                                    onReply={() =>
+                                        startReply({
+                                            commentId: comment.commentId,
+                                            parentReplyId: reply.replyId,
+                                        })
+                                    }
+                                />
+                            ))}
+                            {comment.hasMoreReplies && (
+                                <Button
+                                    theme={theme.theme}
+                                    variant="secondary"
+                                    size="sm"
+                                    disabled={
+                                        loadingRepliesFor === comment.commentId
+                                    }
+                                    onClick={() => loadMoreReplies(comment)}
+                                >
+                                    {LOAD_MORE_TEXT}
+                                </Button>
+                            )}
+                            {replyingTo?.commentId === comment.commentId && (
+                                <div ref={replyComposerRef}>
+                                    <Composer
+                                        content={replyContent}
+                                        refresh={replyRefresh}
+                                        placeholder={
+                                            COURSE_DISCUSSIONS_REPLY_PLACEHOLDER
+                                        }
+                                        buttonLabel={
+                                            COURSE_DISCUSSIONS_POST_REPLY
+                                        }
+                                        address={address}
+                                        posting={posting}
+                                        onChange={setReplyContent}
+                                        onSubmit={postReply}
+                                    />
+                                </div>
+                            )}
+                        </DiscussionItem>
+                    ))}
+                </div>
+                {hasMore && (
+                    <Button
+                        theme={theme.theme}
+                        variant="secondary"
+                        className="mt-4 w-full"
+                        disabled={loading}
+                        onClick={() => loadComments(nextCursor)}
+                    >
+                        {LOAD_MORE_TEXT}
+                    </Button>
+                )}
+            </div>
+            <div className="border-t p-4">
+                <Composer
+                    content={composerContent}
+                    refresh={composerRefresh}
+                    placeholder={COURSE_DISCUSSIONS_COMMENT_PLACEHOLDER}
+                    buttonLabel={COURSE_DISCUSSIONS_POST_COMMENT}
+                    address={address}
+                    posting={posting}
+                    onChange={setComposerContent}
+                    onSubmit={postComment}
+                />
+            </div>
+            <ReportReasonDialog
+                isOpen={reportDialogOpen}
+                onClose={() => {
+                    setReportDialogOpen(false);
+                    setPendingReport(null);
+                }}
+                onSubmit={handleReportSubmit}
+            />
+            <Dialog
+                open={!!pendingDelete}
+                onOpenChange={(open) => {
+                    if (!open) {
+                        setPendingDelete(null);
+                    }
+                }}
+            >
+                <DialogContent>
+                    <DialogTitle>
+                        {COURSE_DISCUSSIONS_DELETE_CONFIRM_TITLE}
+                    </DialogTitle>
+                    <DialogDescription>
+                        {COURSE_DISCUSSIONS_DELETE_CONFIRM}{" "}
+                        {COURSE_DISCUSSIONS_DELETE_CONFIRM_DESCRIPTION}
+                    </DialogDescription>
+                    <DialogFooter>
+                        <ShadcnButton
+                            type="button"
+                            variant="secondary"
+                            onClick={() => setPendingDelete(null)}
+                        >
+                            {COURSE_DISCUSSIONS_DELETE_CANCEL}
+                        </ShadcnButton>
+                        <ShadcnButton
+                            type="button"
+                            variant="destructive"
+                            onClick={confirmDeleteContent}
+                        >
+                            {COURSE_DISCUSSIONS_DELETE}
+                        </ShadcnButton>
+                    </DialogFooter>
+                </DialogContent>
+            </Dialog>
+        </aside>
+    );
+}
+
+function getDiscussionTargetFromHash(hash: string) {
+    if (hash.startsWith("discussion-comment-")) {
+        return {
+            contentType: "COMMENT",
+            contentId: hash.replace("discussion-comment-", ""),
+        };
+    }
+
+    if (hash.startsWith("discussion-reply-")) {
+        return {
+            contentType: "REPLY",
+            contentId: hash.replace("discussion-reply-", ""),
+        };
+    }
+
+    return null;
+}
+
+function getComposerContentError(content: TextEditorContent) {
+    if (!isTextEditorNonEmpty(content)) {
+        return COURSE_DISCUSSIONS_CONTENT_REQUIRED;
+    }
+
+    if (
+        new Blob([JSON.stringify(content)]).size > MAX_DISCUSSION_CONTENT_BYTES
+    ) {
+        return COURSE_DISCUSSIONS_CONTENT_TOO_LONG;
+    }
+
+    if (
+        extractTextFromTextEditorContent(content).length >
+        MAX_DISCUSSION_TEXT_LENGTH
+    ) {
+        return COURSE_DISCUSSIONS_CONTENT_TOO_LONG;
+    }
+
+    return "";
+}
+
+function DiscussionItem({
+    item,
+    itemId,
+    compact = false,
+    children,
+    onLike,
+    onReply,
+    onDelete,
+    onReport,
+}: {
+    item: DiscussionContent;
+    itemId: string;
+    compact?: boolean;
+    children?: React.ReactNode;
+    onLike: () => void;
+    onReply: () => void;
+    onDelete: () => void;
+    onReport: () => void;
+}) {
+    const { theme } = useContext(ThemeContext);
+    const { profile } = useContext(ProfileContext);
+    const isOwn = profile?.userId === item.userId;
+    const displayName = item.user?.name || item.user?.email || item.userId;
+    const initials =
+        displayName
+            .split(" ")
+            .map((n) => n[0])
+            .join("")
+            .toUpperCase()
+            .slice(0, 2) || "?";
+
+    const displayDate = formattedLocaleDate(item.createdAt);
+
+    const avatarUrl =
+        item.user?.avatar?.thumbnail || "/courselit_backdrop_square.webp";
+
+    return (
+        <article
+            id={itemId}
+            className={`scroll-mt-4 space-y-3 rounded-xl border border-transparent px-3 py-3 transition-[background-color,border-color,box-shadow] duration-500 ${
+                compact ? "ml-8 mt-4" : ""
+            }`}
+        >
+            <div className="flex items-start justify-between gap-3">
+                <div className="flex items-center gap-3">
+                    <Avatar className="h-8 w-8">
+                        <AvatarImage
+                            src={avatarUrl}
+                            alt={`${displayName}'s avatar`}
+                        />
+                        <AvatarFallback>{initials}</AvatarFallback>
+                    </Avatar>
+                    <div className="flex flex-col items-baseline gap-1 flex-wrap min-w-0 flex-1">
+                        <Text2
+                            theme={theme.theme}
+                            className="font-semibold text-sm leading-none"
+                        >
+                            {displayName}
+                        </Text2>
+                        <Caption
+                            theme={theme.theme}
+                            className="leading-none text-xs"
+                        >
+                            {displayDate}
+                        </Caption>
+                    </div>
+                </div>
+                {!item.deleted && !isOwn && (
+                    <ShadcnButton
+                        variant="ghost"
+                        size="sm"
+                        onClick={onReport}
+                        aria-label={COURSE_DISCUSSIONS_REPORT}
+                        title={COURSE_DISCUSSIONS_REPORT}
+                    >
+                        <Flag className="h-4 w-4 text-muted-foreground" />
+                    </ShadcnButton>
+                )}
+                {!item.deleted && isOwn && (
+                    <ShadcnButton
+                        variant="ghost"
+                        size="sm"
+                        onClick={onDelete}
+                        aria-label={COURSE_DISCUSSIONS_DELETE}
+                        title={COURSE_DISCUSSIONS_DELETE}
+                    >
+                        <Trash2 className="h-4 w-4" />
+                    </ShadcnButton>
+                )}
+            </div>
+            <div className="text-sm leading-normal">
+                {item.deleted || !item.content ? (
+                    <Text1
+                        theme={theme.theme}
+                        className="italic opacity-60 text-sm"
+                    >
+                        {COURSE_DISCUSSIONS_DELETED}
+                    </Text1>
+                ) : (
+                    <TextRenderer json={item.content} theme={theme.theme} />
+                )}
+            </div>
+            {!item.deleted && (
+                <div className="flex items-center gap-3 pt-1">
+                    <ShadcnButton
+                        variant="ghost"
+                        size="sm"
+                        className={clsx(
+                            item.hasLiked
+                                ? "text-foreground"
+                                : "text-muted-foreground hover:text-foreground",
+                        )}
+                        onClick={onLike}
+                    >
+                        <ThumbsUp
+                            className={`h-4 w-4 transition-colors ${
+                                item.hasLiked
+                                    ? "fill-current text-foreground"
+                                    : ""
+                            }`}
+                        />
+                        <Caption
+                            theme={theme.theme}
+                            className="text-xs font-medium"
+                        >
+                            {item.likesCount}
+                        </Caption>
+                    </ShadcnButton>
+                    <ShadcnButton variant="ghost" size="sm" onClick={onReply}>
+                        <Reply className="h-4 w-4" />
+                        <Caption
+                            theme={theme.theme}
+                            className="text-xs font-medium"
+                        >
+                            {COURSE_DISCUSSIONS_REPLY}
+                        </Caption>
+                    </ShadcnButton>
+                </div>
+            )}
+            {children && <div className="mt-4 space-y-4">{children}</div>}
+        </article>
+    );
+}
+
+function Composer({
+    content,
+    refresh,
+    placeholder,
+    buttonLabel,
+    address,
+    posting,
+    onChange,
+    onSubmit,
+}: {
+    content: TextEditorContent;
+    refresh: number;
+    placeholder: string;
+    buttonLabel: string;
+    address: Address;
+    posting: boolean;
+    onChange: (content: TextEditorContent) => void;
+    onSubmit: () => void;
+}) {
+    const { theme } = useContext(ThemeContext);
+    const inputStyles = theme.theme?.interactives?.input;
+    const currentContentRef = useRef<TextEditorContent>(content);
+    const form = useForm<ComposerForm>({
+        resolver: zodResolver(composerSchema),
+        defaultValues: { content },
+        mode: "onChange",
+    });
+    const canSubmit = isTextEditorNonEmpty(form.watch("content"));
+    const contentError = form.formState.errors.content?.message;
+
+    useEffect(() => {
+        currentContentRef.current = content;
+        form.setValue("content", content, { shouldValidate: true });
+    }, [content, form]);
+
+    function handleEditorChange(value: unknown) {
+        const nextContent = value as TextEditorContent;
+        currentContentRef.current = nextContent;
+        form.setValue("content", nextContent, { shouldValidate: true });
+        onChange(nextContent);
+    }
+
+    return (
+        <form
+            className="space-y-2"
+            onSubmit={form.handleSubmit(() => onSubmit())}
+        >
+            <div className="max-h-[200px] overflow-y-auto rounded-[inherit]">
+                <Editor
+                    url={address.backend}
+                    initialContent={content}
+                    refresh={refresh}
+                    onChange={handleEditorChange}
+                    placeholder={placeholder}
+                    showToolbar={false}
+                    editorClassName="min-h-[80px] max-w-none"
+                    className={`${inputStyles?.border?.radius} ${inputStyles?.border?.width} ${inputStyles?.border?.style} ${inputStyles?.shadow} ${inputStyles?.custom}`}
+                />
+            </div>
+            <Button
+                theme={theme.theme}
+                type="submit"
+                className="w-full"
+                disabled={posting || !canSubmit || Boolean(contentError)}
+            >
+                {buttonLabel}
+            </Button>
+            {contentError && (
+                <Caption theme={theme.theme} className="text-destructive">
+                    {contentError}
+                </Caption>
+            )}
+        </form>
+    );
+}
diff --git a/apps/web/components/public/product-discussions/report-reason-dialog.tsx b/apps/web/components/public/product-discussions/report-reason-dialog.tsx
new file mode 100644
index 000000000..812cc7580
--- /dev/null
+++ b/apps/web/components/public/product-discussions/report-reason-dialog.tsx
@@ -0,0 +1,97 @@
+"use client";
+
+import { useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import {
+    Dialog,
+    DialogContent,
+    DialogDescription,
+    DialogFooter,
+    DialogHeader,
+    DialogTitle,
+} from "@/components/ui/dialog";
+import { Textarea } from "@/components/ui/textarea";
+import { POPUP_CANCEL_ACTION } from "@ui-config/strings";
+
+const REPORT_DIALOG_TITLE = "Report Post";
+const REPORT_DIALOG_DESCRIPTION =
+    "Please provide a reason for reporting this post.";
+const REPORT_DIALOG_PLACEHOLDER = "Reason for reporting...";
+const REPORT_DIALOG_SUBMIT = "Submit";
+
+interface ReportReasonDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSubmit: (reason: string) => void;
+}
+
+export function ReportReasonDialog({
+    isOpen,
+    onClose,
+    onSubmit,
+}: ReportReasonDialogProps) {
+    const [reason, setReason] = useState("");
+    const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+    function handleSubmit() {
+        const trimmed = reason.trim();
+        if (!trimmed) {
+            textareaRef.current?.focus();
+            return;
+        }
+        onSubmit(trimmed);
+        setReason("");
+    }
+
+    function handleClose() {
+        setReason("");
+        onClose();
+    }
+
+    return (
+        <Dialog open={isOpen} onOpenChange={handleClose}>
+            <DialogContent className="sm:max-w-[440px]">
+                <DialogHeader>
+                    <DialogTitle>{REPORT_DIALOG_TITLE}</DialogTitle>
+                    <DialogDescription>
+                        {REPORT_DIALOG_DESCRIPTION}
+                    </DialogDescription>
+                </DialogHeader>
+
+                <div className="py-2">
+                    <Textarea
+                        ref={textareaRef}
+                        id="report-reason"
+                        placeholder={REPORT_DIALOG_PLACEHOLDER}
+                        value={reason}
+                        onChange={(e) => setReason(e.target.value)}
+                        rows={4}
+                        className="resize-none"
+                        onKeyDown={(e) => {
+                            if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+                                handleSubmit();
+                            }
+                        }}
+                    />
+                </div>
+
+                <DialogFooter>
+                    <Button
+                        type="button"
+                        variant="outline"
+                        onClick={handleClose}
+                    >
+                        {POPUP_CANCEL_ACTION}
+                    </Button>
+                    <Button
+                        type="submit"
+                        disabled={!reason.trim()}
+                        onClick={handleSubmit}
+                    >
+                        {REPORT_DIALOG_SUBMIT}
+                    </Button>
+                </DialogFooter>
+            </DialogContent>
+        </Dialog>
+    );
+}
diff --git a/apps/web/graphql/communities/__tests__/logic.test.ts b/apps/web/graphql/communities/__tests__/logic.test.ts
index 77215a9dd..0ffd9dcae 100644
--- a/apps/web/graphql/communities/__tests__/logic.test.ts
+++ b/apps/web/graphql/communities/__tests__/logic.test.ts
@@ -8,23 +8,39 @@ import {
     getCommunitiesCount,
     getFeed,
     getFeedCount,
+    getCommunityReports,
+    reportCommunityContent,
 } from "../logic";
 import CommunityModel from "@models/Community";
 import CommunityPostModel from "@models/CommunityPost";
 import CommunityCommentModel from "@models/CommunityComment";
+import CommunityReportModel from "@models/CommunityReport";
 import MembershipModel from "@models/Membership";
 import PaymentPlanModel from "@models/PaymentPlan";
 import PageModel from "@models/Page";
 import DomainModel from "@models/Domain";
 import UserModel from "@models/User";
 import constants from "@/config/constants";
-import { Constants } from "@courselit/common-models";
+import { Constants, TextEditorContent } from "@courselit/common-models";
 
 jest.mock("@/services/queue");
 
 // Ensure generateUniqueId is not mocked
 jest.unmock("@courselit/utils");
 
+const doc = (text: string): TextEditorContent => ({
+    type: "doc",
+    content: [
+        {
+            type: "paragraph",
+            content: [{ type: "text", text }],
+        },
+        {
+            type: "paragraph",
+        },
+    ],
+});
+
 describe("Community Logic - Comment Count Tests", () => {
     let testDomain: any;
     let adminUser: any;
@@ -161,6 +177,10 @@ describe("Community Logic - Comment Count Tests", () => {
             domain: testDomain._id,
             communityId: community.communityId,
         });
+        await CommunityReportModel.deleteMany({
+            domain: testDomain._id,
+            communityId: community.communityId,
+        });
     });
 
     afterAll(async () => {
@@ -169,6 +189,7 @@ describe("Community Logic - Comment Count Tests", () => {
             CommunityModel.deleteMany({ domain: testDomain._id }),
             CommunityPostModel.deleteMany({ domain: testDomain._id }),
             CommunityCommentModel.deleteMany({ domain: testDomain._id }),
+            CommunityReportModel.deleteMany({ domain: testDomain._id }),
             MembershipModel.deleteMany({ domain: testDomain._id }),
             PaymentPlanModel.deleteMany({ domain: testDomain._id }),
             PageModel.deleteMany({ domain: testDomain._id }),
@@ -363,6 +384,43 @@ describe("Community Logic - Comment Count Tests", () => {
             expect(count).toBe(1);
         });
     });
+
+    describe("getCommunityReports", () => {
+        it("returns a string preview for reported rich-text posts", async () => {
+            const richTextPost = await CommunityPostModel.create({
+                domain: testDomain._id,
+                communityId: community.communityId,
+                postId: "reported-rich-text-post",
+                userId: adminUser.userId,
+                title: "Reported Rich Text Post",
+                content: doc("This is good man"),
+                category: "General",
+            });
+
+            await reportCommunityContent({
+                ctx: {
+                    user: regularUser,
+                    subdomain: testDomain,
+                } as any,
+                communityId: community.communityId,
+                contentId: richTextPost.postId,
+                type: Constants.CommunityReportType.POST,
+                reason: "Needs review",
+            });
+
+            const reports = await Promise.all(
+                await getCommunityReports({
+                    ctx: mockCtx,
+                    communityId: community.communityId,
+                    page: 1,
+                    limit: 10,
+                }),
+            );
+
+            expect(reports).toHaveLength(1);
+            expect(reports[0].content.content).toBe("This is good man");
+        });
+    });
 });
 
 describe("Community Logic - Feed Tests", () => {
diff --git a/apps/web/graphql/communities/helpers.ts b/apps/web/graphql/communities/helpers.ts
index 83e9d1623..326341260 100644
--- a/apps/web/graphql/communities/helpers.ts
+++ b/apps/web/graphql/communities/helpers.ts
@@ -24,7 +24,10 @@ import CommunityPostSubscriberModel, {
     CommunityPostSubscriber,
 } from "@models/CommunityPostSubscriber";
 import { hasCommunityPermission } from "@ui-lib/utils";
-import { normalizeTextEditorContent } from "@courselit/utils";
+import {
+    extractTextFromTextEditorContent,
+    normalizeTextEditorContent,
+} from "@courselit/utils";
 
 export type PublicPost = Omit<
     CommunityPost,
@@ -157,7 +160,7 @@ export async function getCommunityReportContent({
     }
 
     return {
-        content: content.content,
+        content: extractTextFromTextEditorContent(content.content),
         id: contentId,
         media: content.media,
     };
diff --git a/apps/web/graphql/courses/__tests__/delete-course.test.ts b/apps/web/graphql/courses/__tests__/delete-course.test.ts
index 16c17bbfd..c8153895b 100644
--- a/apps/web/graphql/courses/__tests__/delete-course.test.ts
+++ b/apps/web/graphql/courses/__tests__/delete-course.test.ts
@@ -5,12 +5,20 @@ import LessonEvaluation from "@models/LessonEvaluation";
 import MembershipModel from "@models/Membership";
 import PaymentPlanModel from "@models/PaymentPlan";
 import ActivityModel from "@models/Activity";
+import NotificationModel from "@models/Notification";
 import PageModel from "@models/Page";
 import DomainModel from "@models/Domain";
 import UserModel from "@models/User";
 import InvoiceModel from "@models/Invoice";
 import CertificateModel from "@models/Certificate";
 import CertificateTemplateModel from "@models/CertificateTemplate";
+import ProductDiscussionCommentModel from "@models/ProductDiscussionComment";
+import ProductDiscussionReplyModel from "@models/ProductDiscussionReply";
+import ProductDiscussionLikeModel from "@models/ProductDiscussionLike";
+import ProductDiscussionReportModel from "@models/ProductDiscussionReport";
+import ProductDiscussionSummaryModel from "@models/ProductDiscussionSummary";
+import ProductDiscussionSubscriberModel from "@models/ProductDiscussionSubscriber";
+import RateLimitEventModel from "@models/RateLimitEvent";
 import constants from "@/config/constants";
 import { Constants } from "@courselit/common-models";
 
@@ -101,8 +109,24 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
                 internal: { $ne: true },
             }),
             ActivityModel.deleteMany({ domain: testDomain._id }),
+            NotificationModel.deleteMany({ domain: testDomain._id }),
             PageModel.deleteMany({ domain: testDomain._id }),
             InvoiceModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionCommentModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionReplyModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionLikeModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionReportModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionSummaryModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionSubscriberModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            RateLimitEventModel.deleteMany({ domain: testDomain._id }),
         ]);
 
         // Reset user purchases
@@ -266,6 +290,163 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
             expect(deletedPage).toBeNull();
         });
 
+        it("should delete discussion-owned data and retain TTL-managed rate-limit events", async () => {
+            const productId = dcId("course-with-discussions");
+            const entityId = dcId("lesson-with-discussions");
+            const commentId = dcId("discussion-comment");
+            const replyId = dcId("discussion-reply");
+            const unrelatedProductId = dcId("unrelated-product");
+            const page = await PageModel.create({
+                domain: testDomain._id,
+                pageId: dcId("discussion-page"),
+                name: "Discussion Course Page",
+                creatorId: adminUser.userId,
+                deleteable: true,
+            });
+            await CourseModel.create({
+                domain: testDomain._id,
+                courseId: productId,
+                title: "Discussion Course",
+                creatorId: adminUser.userId,
+                deleteable: true,
+                pageId: page.pageId,
+                groups: [],
+                lessons: [],
+                type: "course",
+                privacy: "unlisted",
+                costType: "free",
+                cost: 0,
+                slug: dcId("discussion-course"),
+            });
+
+            const target = {
+                domain: testDomain._id,
+                productId,
+                entityType: "lesson",
+                entityId,
+            } as const;
+            await Promise.all([
+                ProductDiscussionCommentModel.create({
+                    ...target,
+                    commentId,
+                    userId: regularUser.userId,
+                    content: { type: "doc", content: [] },
+                }),
+                ProductDiscussionReplyModel.create({
+                    ...target,
+                    commentId,
+                    replyId,
+                    userId: regularUser.userId,
+                    content: { type: "doc", content: [] },
+                }),
+                ProductDiscussionLikeModel.create({
+                    ...target,
+                    contentType: "comment",
+                    contentId: commentId,
+                    userId: regularUser.userId,
+                }),
+                ProductDiscussionReportModel.create({
+                    ...target,
+                    reportId: dcId("discussion-report"),
+                    contentType: "comment",
+                    contentId: commentId,
+                    userId: regularUser.userId,
+                    reason: "Test report",
+                }),
+                ProductDiscussionSummaryModel.create({
+                    ...target,
+                    commentsCount: 1,
+                    repliesCount: 1,
+                    totalCount: 2,
+                    activityCountIncludingDeleted: 2,
+                    lastActivityAt: new Date(),
+                }),
+                ProductDiscussionSubscriberModel.create({
+                    ...target,
+                    subscriptionId: dcId("discussion-subscription"),
+                    userId: regularUser.userId,
+                }),
+                ActivityModel.create({
+                    domain: testDomain._id,
+                    userId: regularUser.userId,
+                    type: Constants.ActivityType
+                        .COURSE_DISCUSSION_COMMENT_CREATED,
+                    entityId: commentId,
+                    metadata: { courseId: productId },
+                }),
+                NotificationModel.create({
+                    domain: testDomain._id,
+                    notificationId: dcId("discussion-notification"),
+                    userId: regularUser.userId,
+                    forUserId: adminUser.userId,
+                    activityType:
+                        Constants.ActivityType
+                            .COURSE_DISCUSSION_COMMENT_CREATED,
+                    entityId: commentId,
+                    metadata: { courseId: productId },
+                }),
+                ActivityModel.create({
+                    domain: testDomain._id,
+                    userId: regularUser.userId,
+                    type: Constants.ActivityType
+                        .COURSE_DISCUSSION_COMMENT_CREATED,
+                    entityId: dcId("unrelated-comment"),
+                    metadata: { courseId: unrelatedProductId },
+                }),
+                NotificationModel.create({
+                    domain: testDomain._id,
+                    notificationId: dcId("unrelated-notification"),
+                    userId: regularUser.userId,
+                    forUserId: adminUser.userId,
+                    activityType:
+                        Constants.ActivityType
+                            .COURSE_DISCUSSION_COMMENT_CREATED,
+                    entityId: dcId("unrelated-comment"),
+                    metadata: { courseId: unrelatedProductId },
+                }),
+                RateLimitEventModel.create({
+                    domain: testDomain._id,
+                    userId: regularUser.userId,
+                    scope: "course_discussion",
+                    action: "comment:create",
+                    subjectId: `${productId}:lesson:${entityId}`,
+                }),
+            ]);
+
+            await deleteCourse(productId, mockCtx);
+
+            const remainingCounts = await Promise.all([
+                ProductDiscussionCommentModel.countDocuments({ productId }),
+                ProductDiscussionReplyModel.countDocuments({ productId }),
+                ProductDiscussionLikeModel.countDocuments({ productId }),
+                ProductDiscussionReportModel.countDocuments({ productId }),
+                ProductDiscussionSummaryModel.countDocuments({ productId }),
+                ProductDiscussionSubscriberModel.countDocuments({ productId }),
+                ActivityModel.countDocuments({
+                    domain: testDomain._id,
+                    "metadata.courseId": productId,
+                }),
+                NotificationModel.countDocuments({
+                    domain: testDomain._id,
+                    "metadata.courseId": productId,
+                }),
+                RateLimitEventModel.countDocuments({
+                    domain: testDomain._id,
+                    scope: "course_discussion",
+                    subjectId: `${productId}:lesson:${entityId}`,
+                }),
+                ActivityModel.countDocuments({
+                    domain: testDomain._id,
+                    "metadata.courseId": unrelatedProductId,
+                }),
+                NotificationModel.countDocuments({
+                    domain: testDomain._id,
+                    "metadata.courseId": unrelatedProductId,
+                }),
+            ]);
+            expect(remainingCounts).toEqual([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1]);
+        });
+
         it("should delete course with featured image", async () => {
             const { deleteMedia } = require("@/services/medialit");
 
@@ -765,11 +946,11 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
         });
     });
 
-    describe("Activity Deletion", () => {
-        it("should delete all activities related to the course", async () => {
+    describe("Activity and Notification Deletion", () => {
+        it("should delete all activities and notifications related to the course", async () => {
             const page = await PageModel.create({
                 domain: testDomain._id,
-                pageId: "test-page-activities",
+                pageId: "test-page-activities-notifications",
                 name: "Test Page",
                 creatorId: adminUser.userId,
                 deleteable: true,
@@ -777,7 +958,7 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
 
             const course = await CourseModel.create({
                 domain: testDomain._id,
-                courseId: "test-course-activities",
+                courseId: "test-course-activities-notifications",
                 title: "Test Course",
                 creatorId: adminUser.userId,
                 deleteable: true,
@@ -786,7 +967,7 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
                 privacy: "unlisted",
                 costType: "free",
                 cost: 0,
-                slug: "test-course-activities",
+                slug: "test-course-activities-notifications",
                 groups: [],
                 lessons: [],
             });
@@ -821,6 +1002,42 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
                 },
             });
 
+            // Notification with entityId = courseId
+            await NotificationModel.create({
+                domain: testDomain._id,
+                notificationId: dcId("notification-entity"),
+                userId: regularUser.userId,
+                forUserId: adminUser.userId,
+                activityType: "enrolled",
+                entityId: course.courseId,
+            });
+
+            // Notification with metadata.courseId
+            await NotificationModel.create({
+                domain: testDomain._id,
+                notificationId: dcId("notification-metadata"),
+                userId: regularUser.userId,
+                forUserId: adminUser.userId,
+                activityType: "lesson_completed",
+                entityId: "lesson-123",
+                metadata: {
+                    courseId: course.courseId,
+                },
+            });
+
+            // Notification with both
+            await NotificationModel.create({
+                domain: testDomain._id,
+                notificationId: dcId("notification-both"),
+                userId: regularUser.userId,
+                forUserId: adminUser.userId,
+                activityType: "course_completed",
+                entityId: course.courseId,
+                metadata: {
+                    courseId: course.courseId,
+                },
+            });
+
             await deleteCourse(course.courseId, mockCtx);
 
             const remainingActivities = await ActivityModel.find({
@@ -831,6 +1048,15 @@ describe("deleteCourse - Comprehensive Test Suite", () => {
                 ],
             });
             expect(remainingActivities).toHaveLength(0);
+
+            const remainingNotifications = await NotificationModel.find({
+                domain: testDomain._id,
+                $or: [
+                    { entityId: course.courseId },
+                    { "metadata.courseId": course.courseId },
+                ],
+            });
+            expect(remainingNotifications).toHaveLength(0);
         });
     });
 
diff --git a/apps/web/graphql/courses/__tests__/logic.test.ts b/apps/web/graphql/courses/__tests__/logic.test.ts
index 2a5f639d4..0ca3fe05c 100644
--- a/apps/web/graphql/courses/__tests__/logic.test.ts
+++ b/apps/web/graphql/courses/__tests__/logic.test.ts
@@ -1,6 +1,13 @@
 import DomainModel from "@models/Domain";
 import UserModel from "@models/User";
 import CourseModel from "@models/Course";
+import ProductDiscussionCommentModel from "@models/ProductDiscussionComment";
+import ProductDiscussionLikeModel from "@models/ProductDiscussionLike";
+import ProductDiscussionReplyModel from "@models/ProductDiscussionReply";
+import ProductDiscussionReportModel from "@models/ProductDiscussionReport";
+import ProductDiscussionSubscriberModel from "@models/ProductDiscussionSubscriber";
+import ProductDiscussionSummaryModel from "@models/ProductDiscussionSummary";
+import RateLimitEventModel from "@models/RateLimitEvent";
 import ActivityModel from "@models/Activity";
 import LessonModel from "@models/Lesson";
 import MembershipModel from "@models/Membership";
@@ -17,6 +24,29 @@ import {
 } from "../logic";
 import { getActivities } from "../../activities/logic";
 import { getLessonOrThrow } from "../../lessons/logic";
+import courseTypes from "../types";
+import schema from "../../index";
+import {
+    COURSE_DISCUSSION_RATE_LIMITS,
+    MAX_DISCUSSION_CONTENT_BYTES,
+    MAX_DISCUSSION_TEXT_LENGTH,
+    assertRateLimit,
+    createDiscussionComment,
+    createDiscussionReply,
+    createDiscussionReport,
+    deleteDiscussionComment,
+    deleteDiscussionReply,
+    listDiscussionReports,
+    getDiscussionReportsCount,
+    listDiscussionSummaries,
+    listDiscussionComments,
+    listDiscussionReplies,
+    toggleDiscussionLike,
+    updateDiscussionReportStatus,
+    validateDiscussionContent,
+    validateDiscussionTargetForLearner,
+} from "../../product-discussions/logic";
+import { recordActivity } from "@/lib/record-activity";
 import { deleteMedia, sealMedia } from "@/services/medialit";
 
 jest.mock("@/services/medialit", () => ({
@@ -28,6 +58,11 @@ jest.mock("@/services/medialit", () => ({
         }),
     ),
 }));
+jest.mock("@/lib/record-activity", () => ({
+    recordActivity: jest.fn(),
+}));
+
+const recordActivityMock = recordActivity as jest.Mock;
 
 const UPDATE_COURSE_SUITE_PREFIX = `update-course-${Date.now()}`;
 const id = (suffix: string) => `${UPDATE_COURSE_SUITE_PREFIX}-${suffix}`;
@@ -38,6 +73,1808 @@ const getCourseId = (suffix: string) => `${GET_COURSE_SUITE_PREFIX}-${suffix}`;
 const getCourseEmail = (suffix: string) =>
     `${suffix}-${GET_COURSE_SUITE_PREFIX}@example.com`;
 
+describe("product discussion persistence foundation", () => {
+    it("defines the product discussion and rate limit models with required indexes", () => {
+        const indexKeys = (model: any) =>
+            model.schema.indexes().map(([fields]: any[]) => fields);
+
+        expect(indexKeys(ProductDiscussionCommentModel)).toEqual(
+            expect.arrayContaining([
+                { domain: 1, commentId: 1 },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    createdAt: -1,
+                    commentId: -1,
+                },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    userId: 1,
+                    deleted: 1,
+                },
+            ]),
+        );
+        expect(indexKeys(ProductDiscussionReplyModel)).toEqual(
+            expect.arrayContaining([
+                { domain: 1, replyId: 1 },
+                { domain: 1, commentId: 1, createdAt: 1, replyId: 1 },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    userId: 1,
+                    deleted: 1,
+                },
+            ]),
+        );
+        expect(indexKeys(ProductDiscussionLikeModel)).toEqual(
+            expect.arrayContaining([
+                { domain: 1, contentType: 1, contentId: 1, userId: 1 },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    userId: 1,
+                },
+            ]),
+        );
+        expect(indexKeys(ProductDiscussionSummaryModel)).toEqual(
+            expect.arrayContaining([
+                { domain: 1, productId: 1, entityType: 1, entityId: 1 },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    lastActivityAt: -1,
+                    entityId: 1,
+                },
+            ]),
+        );
+        expect(indexKeys(ProductDiscussionSubscriberModel)).toEqual(
+            expect.arrayContaining([
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    userId: 1,
+                },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    subscription: 1,
+                    userId: 1,
+                },
+            ]),
+        );
+        expect(indexKeys(ProductDiscussionReportModel)).toEqual(
+            expect.arrayContaining([
+                { domain: 1, contentType: 1, contentId: 1, userId: 1 },
+                {
+                    domain: 1,
+                    productId: 1,
+                    entityType: 1,
+                    entityId: 1,
+                    status: 1,
+                    createdAt: -1,
+                    reportId: -1,
+                },
+            ]),
+        );
+        expect(indexKeys(RateLimitEventModel)).toEqual(
+            expect.arrayContaining([
+                {
+                    domain: 1,
+                    userId: 1,
+                    scope: 1,
+                    action: 1,
+                    subjectId: 1,
+                    createdAt: -1,
+                },
+                {
+                    domain: 1,
+                    userId: 1,
+                    scope: 1,
+                    subjectId: 1,
+                    fingerprint: 1,
+                    createdAt: -1,
+                },
+            ]),
+        );
+    });
+
+    it("defaults product discussions to disabled", () => {
+        const course = new CourseModel({
+            domain: "507f191e810c19729de860ea",
+            title: "Discussion default",
+            slug: "discussion-default",
+            cost: 0,
+            costType: "free",
+            privacy: "unlisted",
+            type: "course",
+            creatorId: "creator",
+        });
+
+        expect(course.discussions).toBe(false);
+    });
+
+    it("exposes discussions in the Course GraphQL type and update input", () => {
+        const courseFields = courseTypes.courseType.getFields();
+        const discussionsField = courseFields.discussions;
+        expect(discussionsField).toBeDefined();
+        expect(
+            discussionsField.resolve?.(
+                { discussions: undefined },
+                {},
+                {},
+                {} as any,
+            ),
+        ).toBe(false);
+        expect(
+            courseTypes.courseUpdateInput.getFields().discussions,
+        ).toBeDefined();
+        expect(
+            schema.getQueryType()?.getFields().getProductDiscussionComments,
+        ).toBeDefined();
+        expect(
+            schema.getQueryType()?.getFields().getProductDiscussionReports,
+        ).toBeDefined();
+        expect(
+            schema
+                .getQueryType()
+                ?.getFields()
+                .getProductDiscussionReports.args.some(
+                    (arg) => arg.name === "page",
+                ),
+        ).toBe(true);
+        expect(
+            schema.getQueryType()?.getFields().getProductDiscussionSummaries,
+        ).toBeDefined();
+        expect(
+            schema
+                .getQueryType()
+                ?.getFields()
+                .getProductDiscussionSummaries.args.some(
+                    (arg) => arg.name === "preview",
+                ),
+        ).toBe(true);
+        expect(
+            schema.getMutationType()?.getFields()
+                .createProductDiscussionComment,
+        ).toBeDefined();
+        expect(
+            schema.getMutationType()?.getFields()
+                .updateProductDiscussionReportStatus,
+        ).toBeDefined();
+    });
+});
+
+describe("product discussion validation foundation", () => {
+    let testDomain: any;
+    let learnerUser: any;
+
+    beforeAll(async () => {
+        testDomain = await DomainModel.create({
+            name: id("discussion-domain"),
+            email: email("discussion-domain"),
+        });
+
+        learnerUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("discussion-learner"),
+            email: email("discussion-learner"),
+            name: "Discussion Learner",
+            permissions: [constants.permissions.enrollInCourse],
+            active: true,
+            unsubscribeToken: id("discussion-learner-token"),
+            purchases: [
+                {
+                    courseId: id("discussion-course"),
+                    completedLessons: [],
+                    accessibleGroups: [id("discussion-group")],
+                },
+            ],
+        });
+    });
+
+    beforeEach(async () => {
+        await Promise.all([
+            CourseModel.deleteMany({ domain: testDomain._id }),
+            LessonModel.deleteMany({ domain: testDomain._id }),
+            RateLimitEventModel.deleteMany({ domain: testDomain._id }),
+        ]);
+    });
+
+    afterAll(async () => {
+        await Promise.all([
+            CourseModel.deleteMany({ domain: testDomain._id }),
+            LessonModel.deleteMany({ domain: testDomain._id }),
+            RateLimitEventModel.deleteMany({ domain: testDomain._id }),
+            UserModel.deleteMany({ domain: testDomain._id }),
+            DomainModel.deleteOne({ _id: testDomain._id }),
+        ]);
+    });
+
+    it("rejects product-level discussion targets in this release", async () => {
+        await expect(
+            validateDiscussionTargetForLearner({
+                ctx: {
+                    subdomain: testDomain,
+                    user: learnerUser,
+                    address: "",
+                },
+                productId: id("discussion-course"),
+                entityType: "product",
+                entityId: id("discussion-course"),
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("rejects lesson discussion writes when discussions are disabled", async () => {
+        await CourseModel.create({
+            domain: testDomain._id,
+            courseId: id("discussion-course"),
+            title: id("discussion-course-title"),
+            creatorId: learnerUser.userId,
+            groups: [
+                {
+                    _id: id("discussion-group"),
+                    name: "Discussion section",
+                    rank: 1,
+                    lessonsOrder: [id("discussion-lesson")],
+                },
+            ],
+            lessons: [id("discussion-lesson")],
+            type: "course",
+            privacy: "public",
+            costType: "free",
+            cost: 0,
+            slug: id("discussion-course-slug"),
+            published: true,
+            discussions: false,
+        });
+        await LessonModel.create({
+            domain: testDomain._id,
+            lessonId: id("discussion-lesson"),
+            title: "Discussion Lesson",
+            type: "text",
+            creatorId: learnerUser.userId,
+            courseId: id("discussion-course"),
+            groupId: id("discussion-group"),
+            requiresEnrollment: true,
+            published: true,
+        });
+
+        await expect(
+            validateDiscussionTargetForLearner({
+                ctx: {
+                    subdomain: testDomain,
+                    user: learnerUser,
+                    address: "",
+                },
+                productId: id("discussion-course"),
+                entityType: "lesson",
+                entityId: id("discussion-lesson"),
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("enforces Tiptap discussion content shape and limits", () => {
+        expect(() =>
+            validateDiscussionContent({
+                type: "doc",
+                content: [
+                    {
+                        type: "paragraph",
+                        content: [{ type: "text", text: "Looks good" }],
+                    },
+                ],
+            }),
+        ).not.toThrow();
+        expect(() => validateDiscussionContent({ type: "paragraph" })).toThrow(
+            responses.invalid_input,
+        );
+        expect(() =>
+            validateDiscussionContent({
+                type: "doc",
+                content: [
+                    {
+                        type: "paragraph",
+                        content: [
+                            {
+                                type: "text",
+                                text: "x".repeat(
+                                    MAX_DISCUSSION_TEXT_LENGTH + 1,
+                                ),
+                            },
+                        ],
+                    },
+                ],
+            }),
+        ).toThrow(responses.invalid_input);
+        expect(() =>
+            validateDiscussionContent({
+                type: "doc",
+                content: [
+                    {
+                        type: "paragraph",
+                        attrs: {
+                            payload: "x".repeat(
+                                MAX_DISCUSSION_CONTENT_BYTES + 1,
+                            ),
+                        },
+                    },
+                ],
+            }),
+        ).toThrow(responses.invalid_input);
+    });
+
+    it("records allowed rate limit events and rejects actions over the limit", async () => {
+        const input = {
+            domain: testDomain._id,
+            userId: learnerUser.userId,
+            scope: "course_discussion",
+            action: "comment:create",
+            subjectId: `${id("discussion-course")}:lesson:${id(
+                "discussion-lesson",
+            )}`,
+            window: COURSE_DISCUSSION_RATE_LIMITS.commentsPerMinute.window,
+            limit: 1,
+        };
+
+        await assertRateLimit(input);
+        await expect(assertRateLimit(input)).rejects.toThrow(
+            responses.action_not_allowed,
+        );
+
+        const events = await RateLimitEventModel.find({
+            domain: testDomain._id,
+            userId: learnerUser.userId,
+            scope: "course_discussion",
+            action: "comment:create",
+        });
+        expect(events).toHaveLength(1);
+    });
+
+    it("rejects lesson discussions on unpublished courses for learners but allows for creators/admins", async () => {
+        await CourseModel.create({
+            domain: testDomain._id,
+            courseId: id("discussion-course-unpublished"),
+            title: id("discussion-course-unpublished-title"),
+            creatorId: id("another-creator"),
+            groups: [
+                {
+                    _id: id("discussion-group-unpublished"),
+                    name: "Discussion section",
+                    rank: 1,
+                    lessonsOrder: [id("discussion-lesson-unpublished")],
+                },
+            ],
+            lessons: [id("discussion-lesson-unpublished")],
+            type: "course",
+            privacy: "public",
+            costType: "free",
+            cost: 0,
+            slug: id("discussion-course-unpublished-slug"),
+            published: false,
+            discussions: true,
+        });
+        await LessonModel.create({
+            domain: testDomain._id,
+            lessonId: id("discussion-lesson-unpublished"),
+            title: "Discussion Lesson",
+            type: "text",
+            creatorId: id("another-creator"),
+            courseId: id("discussion-course-unpublished"),
+            groupId: id("discussion-group-unpublished"),
+            requiresEnrollment: true,
+            published: true,
+        });
+
+        // 1. Learner user (who is not creator/admin) should be blocked:
+        await expect(
+            validateDiscussionTargetForLearner({
+                ctx: {
+                    subdomain: testDomain,
+                    user: learnerUser,
+                    address: "",
+                },
+                productId: id("discussion-course-unpublished"),
+                entityType: "lesson",
+                entityId: id("discussion-lesson-unpublished"),
+            }),
+        ).rejects.toThrow(responses.item_not_found);
+
+        // 2. Creator (who is owner/creator of the course) should be allowed:
+        const creatorUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("another-creator"),
+            email: email("another-creator"),
+            name: "Another Creator",
+            permissions: [constants.permissions.manageCourse],
+            active: true,
+            unsubscribeToken: id("another-creator-token"),
+        });
+        const result = await validateDiscussionTargetForLearner({
+            ctx: {
+                subdomain: testDomain,
+                user: creatorUser,
+                address: "",
+            },
+            productId: id("discussion-course-unpublished"),
+            entityType: "lesson",
+            entityId: id("discussion-lesson-unpublished"),
+        });
+        expect(result.product).toBeDefined();
+        expect(result.lesson).toBeDefined();
+    });
+});
+
+describe("product discussion comment and reply logic", () => {
+    let testDomain: any;
+    let learnerUser: any;
+    let secondLearnerUser: any;
+    let nonEnrolledUser: any;
+    let productAdminUser: any;
+    let ctx: any;
+
+    const courseId = id("discussion-api-course");
+    const groupId = id("discussion-api-group");
+    const lessonId = id("discussion-api-lesson");
+    const doc = (text: string) => ({
+        type: "doc" as const,
+        content: [
+            {
+                type: "paragraph",
+                content: [{ type: "text", text }],
+            },
+        ],
+    });
+
+    beforeAll(async () => {
+        testDomain = await DomainModel.create({
+            name: id("discussion-api-domain"),
+            email: email("discussion-api-domain"),
+        });
+
+        learnerUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("discussion-api-learner"),
+            email: email("discussion-api-learner"),
+            name: "Discussion API Learner",
+            permissions: [constants.permissions.enrollInCourse],
+            active: true,
+            unsubscribeToken: id("discussion-api-token"),
+            purchases: [
+                {
+                    courseId,
+                    completedLessons: [],
+                    accessibleGroups: [groupId],
+                },
+            ],
+        });
+        secondLearnerUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("discussion-api-second-learner"),
+            email: email("discussion-api-second-learner"),
+            name: "Discussion API Second Learner",
+            permissions: [constants.permissions.enrollInCourse],
+            active: true,
+            unsubscribeToken: id("discussion-api-second-token"),
+            purchases: [
+                {
+                    courseId,
+                    completedLessons: [],
+                    accessibleGroups: [groupId],
+                },
+            ],
+        });
+        nonEnrolledUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("discussion-api-non-enrolled"),
+            email: email("discussion-api-non-enrolled"),
+            name: "Discussion API Non Enrolled",
+            permissions: [constants.permissions.enrollInCourse],
+            active: true,
+            unsubscribeToken: id("discussion-api-non-enrolled-token"),
+            purchases: [],
+        });
+        productAdminUser = await UserModel.create({
+            domain: testDomain._id,
+            userId: id("discussion-api-admin"),
+            email: email("discussion-api-admin"),
+            name: "Discussion API Admin",
+            permissions: [constants.permissions.manageAnyCourse],
+            active: true,
+            unsubscribeToken: id("discussion-api-admin-token"),
+            purchases: [],
+        });
+
+        ctx = {
+            subdomain: testDomain,
+            user: learnerUser,
+            address: "",
+        };
+    });
+
+    beforeEach(async () => {
+        await Promise.all([
+            CourseModel.deleteMany({ domain: testDomain._id }),
+            LessonModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionCommentModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionReplyModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionLikeModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionReportModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionSummaryModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionSubscriberModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            RateLimitEventModel.deleteMany({ domain: testDomain._id }),
+        ]);
+        recordActivityMock.mockClear();
+
+        await CourseModel.create({
+            domain: testDomain._id,
+            courseId,
+            title: id("discussion-api-course-title"),
+            creatorId: learnerUser.userId,
+            groups: [
+                {
+                    _id: groupId,
+                    name: "Discussion API section",
+                    rank: 1,
+                    lessonsOrder: [lessonId],
+                },
+            ],
+            lessons: [lessonId],
+            type: "course",
+            privacy: "public",
+            costType: "free",
+            cost: 0,
+            slug: id("discussion-api-course-slug"),
+            published: true,
+            discussions: true,
+        });
+        await LessonModel.create({
+            domain: testDomain._id,
+            lessonId,
+            title: "Discussion API Lesson",
+            type: "text",
+            creatorId: learnerUser.userId,
+            courseId,
+            groupId,
+            requiresEnrollment: true,
+            published: true,
+        });
+    });
+
+    afterAll(async () => {
+        await Promise.all([
+            CourseModel.deleteMany({ domain: testDomain._id }),
+            LessonModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionCommentModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionReplyModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionLikeModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionReportModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionSummaryModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionSubscriberModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            RateLimitEventModel.deleteMany({ domain: testDomain._id }),
+            UserModel.deleteMany({ domain: testDomain._id }),
+            DomainModel.deleteOne({ _id: testDomain._id }),
+        ]);
+    });
+
+    it("creates a top-level comment and maintains summary/subscriber records", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("First comment"),
+        });
+
+        expect(comment.commentId).toBeDefined();
+        expect(comment.userId).toBe(learnerUser.userId);
+        expect(comment.likesCount).toBe(0);
+        expect(comment.deleted).toBe(false);
+
+        const summary = await ProductDiscussionSummaryModel.findOne({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+        });
+        expect(summary?.commentsCount).toBe(1);
+        expect(summary?.repliesCount).toBe(0);
+        expect(summary?.totalCount).toBe(1);
+        expect(summary?.activityCountIncludingDeleted).toBe(1);
+        expect(summary?.lastCommentId).toBe(comment.commentId);
+
+        const subscriber = await ProductDiscussionSubscriberModel.findOne({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            userId: learnerUser.userId,
+        });
+        expect(subscriber?.subscription).toBe(true);
+        expect(recordActivityMock).toHaveBeenCalledWith(
+            expect.objectContaining({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                type: CommonConstants.ActivityType
+                    .COURSE_DISCUSSION_COMMENT_CREATED,
+                entityId: comment.commentId,
+                metadata: expect.objectContaining({
+                    eventType: "comment_created",
+                    courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                    commentId: comment.commentId,
+                    forUserIds: [productAdminUser.userId],
+                }),
+            }),
+        );
+    });
+
+    it("rejects guests and non-enrolled users from reading public lesson discussions", async () => {
+        await LessonModel.updateOne(
+            {
+                domain: testDomain._id,
+                lessonId,
+            },
+            {
+                $set: {
+                    requiresEnrollment: false,
+                },
+            },
+        );
+
+        const comment = await ProductDiscussionCommentModel.create({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: id("guest-hidden-comment"),
+            userId: learnerUser.userId,
+            content: doc("Guests should not see this"),
+        });
+        await ProductDiscussionReplyModel.create({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            replyId: id("guest-hidden-reply"),
+            userId: secondLearnerUser.userId,
+            content: doc("Guests should not see this reply"),
+        });
+        await ProductDiscussionSummaryModel.create({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentsCount: 1,
+            repliesCount: 1,
+            totalCount: 2,
+            activityCountIncludingDeleted: 2,
+            lastActivityAt: new Date(),
+        });
+
+        const guestCtx = {
+            subdomain: testDomain,
+            user: undefined,
+            address: "",
+        } as any;
+
+        await expect(
+            validateDiscussionTargetForLearner({
+                ctx: guestCtx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+            }),
+        ).rejects.toThrow(responses.request_not_authenticated);
+        await expect(
+            listDiscussionComments({
+                ctx: guestCtx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+            }),
+        ).rejects.toThrow(responses.request_not_authenticated);
+        await expect(
+            listDiscussionReplies({
+                ctx: guestCtx,
+                commentId: comment.commentId,
+            }),
+        ).rejects.toThrow(responses.request_not_authenticated);
+        await expect(
+            listDiscussionSummaries({
+                ctx: guestCtx,
+                productId: courseId,
+            }),
+        ).rejects.toThrow(responses.request_not_authenticated);
+
+        const nonEnrolledCtx = {
+            subdomain: testDomain,
+            user: nonEnrolledUser,
+            address: "",
+        } as any;
+
+        await expect(
+            validateDiscussionTargetForLearner({
+                ctx: nonEnrolledCtx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+            }),
+        ).rejects.toThrow(responses.not_enrolled);
+        await expect(
+            listDiscussionComments({
+                ctx: nonEnrolledCtx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+            }),
+        ).rejects.toThrow(responses.not_enrolled);
+
+        const nonEnrolledSummaries = await listDiscussionSummaries({
+            ctx: nonEnrolledCtx,
+            productId: courseId,
+        });
+        expect(nonEnrolledSummaries.items).toEqual([]);
+    });
+
+    it("creates replies under the top-level comment and lists comments/replies with cursors", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Root"),
+        });
+        const firstReply = await createDiscussionReply({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            content: doc("First reply"),
+        });
+        const secondReply = await createDiscussionReply({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            parentReplyId: firstReply.replyId,
+            content: doc("Second reply"),
+        });
+
+        expect(secondReply.commentId).toBe(comment.commentId);
+        expect(secondReply.parentReplyId).toBe(firstReply.replyId);
+
+        const comments = await listDiscussionComments({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            limit: 10,
+            replyPreviewLimit: 1,
+        });
+        expect(comments.items).toHaveLength(1);
+        expect(comments.items[0].replyCount).toBe(2);
+        expect(comments.items[0].replies).toHaveLength(1);
+        expect(comments.items[0].replies[0].replyId).toBe(firstReply.replyId);
+        expect(comments.items[0].hasMoreReplies).toBe(true);
+        expect(comments.items[0].replyNextCursor).toBeDefined();
+        expect(comments.hasMore).toBe(false);
+
+        const replies = await listDiscussionReplies({
+            ctx,
+            commentId: comment.commentId,
+            limit: 1,
+        });
+        expect(replies.items).toHaveLength(1);
+        expect(replies.items[0].replyId).toBe(firstReply.replyId);
+        expect(replies.hasMore).toBe(true);
+        expect(replies.nextCursor).toBeDefined();
+
+        const targetSeededComments = await listDiscussionComments({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            targetContentType: "reply",
+            targetContentId: secondReply.replyId,
+            limit: 10,
+            replyPreviewLimit: 1,
+        });
+        expect(targetSeededComments.items[0].commentId).toBe(comment.commentId);
+        expect(
+            targetSeededComments.items[0].replies.some(
+                (reply) => reply.replyId === secondReply.replyId,
+            ),
+        ).toBe(true);
+
+        const summary = await ProductDiscussionSummaryModel.findOne({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+        });
+        expect(summary?.commentsCount).toBe(1);
+        expect(summary?.repliesCount).toBe(2);
+        expect(summary?.totalCount).toBe(3);
+        expect(summary?.activityCountIncludingDeleted).toBe(3);
+        expect(summary?.lastReplyId).toBe(secondReply.replyId);
+    });
+
+    it("dedupes discussion notification recipients across subscribers and product admins", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Notify participants"),
+        });
+        await ProductDiscussionSubscriberModel.updateOne(
+            {
+                domain: testDomain._id,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                userId: productAdminUser.userId,
+            },
+            {
+                $setOnInsert: {
+                    domain: testDomain._id,
+                    productId: courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                    userId: productAdminUser.userId,
+                },
+                $set: { subscription: true },
+            },
+            { upsert: true },
+        );
+        recordActivityMock.mockClear();
+
+        const reply = await createDiscussionReply({
+            ctx: {
+                subdomain: testDomain,
+                user: secondLearnerUser,
+                address: "",
+            },
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            content: doc("Reply notification"),
+        });
+
+        const activity = recordActivityMock.mock.calls[0][0];
+        expect(activity).toEqual(
+            expect.objectContaining({
+                userId: secondLearnerUser.userId,
+                entityId: reply.replyId,
+                metadata: expect.objectContaining({
+                    eventType: "reply_created",
+                    commentId: comment.commentId,
+                    replyId: reply.replyId,
+                }),
+            }),
+        );
+        expect(activity.metadata.forUserIds.sort()).toEqual(
+            [learnerUser.userId, productAdminUser.userId].sort(),
+        );
+    });
+
+    it("likes and unlikes comments idempotently", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Like me"),
+        });
+
+        const liked = await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: true,
+        });
+        await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: true,
+        });
+
+        expect(liked.likesCount).toBe(1);
+        expect(liked.hasLiked).toBe(true);
+        expect(
+            await ProductDiscussionLikeModel.countDocuments({
+                domain: testDomain._id,
+                contentType: "comment",
+                contentId: comment.commentId,
+            }),
+        ).toBe(1);
+        expect(
+            (
+                await ProductDiscussionCommentModel.findOne({
+                    domain: testDomain._id,
+                    commentId: comment.commentId,
+                })
+            )?.likesCount,
+        ).toBe(1);
+        expect(
+            await RateLimitEventModel.countDocuments({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "like:toggle",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+            }),
+        ).toBe(1);
+
+        const unliked = await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: false,
+        });
+        await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: false,
+        });
+
+        expect(unliked.likesCount).toBe(0);
+        expect(unliked.hasLiked).toBe(false);
+        expect(
+            await ProductDiscussionLikeModel.countDocuments({
+                domain: testDomain._id,
+                contentType: "comment",
+                contentId: comment.commentId,
+            }),
+        ).toBe(0);
+        expect(
+            await RateLimitEventModel.countDocuments({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "like:toggle",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+            }),
+        ).toBe(2);
+    });
+
+    it("records one reaction activity when another user newly likes discussion content", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("React to me"),
+        });
+        recordActivityMock.mockClear();
+
+        const secondLearnerCtx = {
+            subdomain: testDomain,
+            user: secondLearnerUser,
+            address: "",
+        };
+        await toggleDiscussionLike({
+            ctx: secondLearnerCtx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: true,
+        });
+        await toggleDiscussionLike({
+            ctx: secondLearnerCtx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: true,
+        });
+        await toggleDiscussionLike({
+            ctx: secondLearnerCtx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: false,
+        });
+
+        expect(recordActivityMock).toHaveBeenCalledTimes(1);
+        expect(recordActivityMock).toHaveBeenCalledWith({
+            domain: testDomain._id,
+            userId: secondLearnerUser.userId,
+            type: CommonConstants.ActivityType.COURSE_DISCUSSION_REACTED,
+            entityId: comment.commentId,
+            metadata: {
+                courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                contentType: "comment",
+                commentId: comment.commentId,
+                forUserIds: [learnerUser.userId],
+            },
+        });
+    });
+
+    it("enforces like toggle rate limits only for state-changing likes", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Like limited"),
+        });
+
+        await RateLimitEventModel.insertMany(
+            Array.from({
+                length: COURSE_DISCUSSION_RATE_LIMITS.likesPerMinute.limit,
+            }).map((_, index) => ({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "like:toggle",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+                createdAt: new Date(Date.now() - index),
+            })),
+        );
+
+        await expect(
+            toggleDiscussionLike({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                contentType: "comment",
+                contentId: comment.commentId,
+                liked: true,
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("enforces the daily comment and reply creation limit per discussion target", async () => {
+        await RateLimitEventModel.insertMany(
+            Array.from({
+                length: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.limit,
+            }).map((_, index) => ({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "comment:create",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+                createdAt: new Date(Date.now() - 2 * 60 * 1000 - index),
+            })),
+        );
+
+        await expect(
+            createDiscussionComment({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                content: doc("Daily limit root"),
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+
+        await RateLimitEventModel.deleteMany({
+            domain: testDomain._id,
+            action: "comment:create",
+        });
+
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Root before reply limit"),
+        });
+
+        await RateLimitEventModel.insertMany(
+            Array.from({
+                length: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.limit,
+            }).map((_, index) => ({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "reply:create",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+                createdAt: new Date(Date.now() - 2 * 60 * 1000 - index),
+            })),
+        );
+
+        await expect(
+            createDiscussionReply({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                commentId: comment.commentId,
+                content: doc("Daily limit reply"),
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("rejects duplicate discussion content from the same user in the same target", async () => {
+        await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Duplicate content"),
+        });
+
+        await expect(
+            createDiscussionComment({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                content: doc("Duplicate content"),
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("marks liked comments/replies and redacts deleted content in learner lists", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Liked root"),
+        });
+        const reply = await createDiscussionReply({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            content: doc("Liked reply"),
+        });
+
+        await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            liked: true,
+        });
+        await toggleDiscussionLike({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "reply",
+            contentId: reply.replyId,
+            liked: true,
+        });
+
+        const likedComments = await listDiscussionComments({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            limit: 10,
+            replyPreviewLimit: 2,
+        });
+        expect(likedComments.items[0].hasLiked).toBe(true);
+        expect(likedComments.items[0].replies[0].hasLiked).toBe(true);
+
+        await deleteDiscussionComment({
+            ctx,
+            commentId: comment.commentId,
+        });
+        await deleteDiscussionReply({
+            ctx,
+            replyId: reply.replyId,
+        });
+
+        const deletedComments = await listDiscussionComments({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            limit: 10,
+            replyPreviewLimit: 2,
+        });
+        expect(deletedComments.items[0].deleted).toBe(true);
+        expect(deletedComments.items[0].content).toBeNull();
+        expect(deletedComments.items[0].hasLiked).toBe(true);
+        expect(deletedComments.items[0].replies[0].deleted).toBe(true);
+        expect(deletedComments.items[0].replies[0].content).toBeNull();
+
+        const deletedReplies = await listDiscussionReplies({
+            ctx,
+            commentId: comment.commentId,
+            limit: 10,
+        });
+        expect(deletedReplies.items[0].content).toBeNull();
+        expect(deletedReplies.items[0].hasLiked).toBe(true);
+    });
+
+    it("reports comments and rejects duplicate reports by the same user", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Report me"),
+        });
+
+        const report = await createDiscussionReport({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            reason: "Spam",
+        });
+
+        expect(report.status).toBe("pending");
+        expect(report.contentId).toBe(comment.commentId);
+        await expect(
+            createDiscussionReport({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                contentType: "comment",
+                contentId: comment.commentId,
+                reason: "Still spam",
+            }),
+        ).rejects.toThrow(responses.invalid_input);
+    });
+
+    it("enforces report creation rate limits per discussion target", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Report limited"),
+        });
+        await RateLimitEventModel.insertMany(
+            Array.from({
+                length: COURSE_DISCUSSION_RATE_LIMITS.reportsPerHour.limit,
+            }).map((_, index) => ({
+                domain: testDomain._id,
+                userId: learnerUser.userId,
+                scope: "course_discussion",
+                action: "report:create",
+                subjectId: `${courseId}:lesson:${lessonId}`,
+                createdAt: new Date(Date.now() - index),
+            })),
+        );
+
+        await expect(
+            createDiscussionReport({
+                ctx,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                contentType: "comment",
+                contentId: comment.commentId,
+                reason: "Spam",
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+    });
+
+    it("soft-deletes own comments/replies and updates visible counts/subscriber state", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Delete root"),
+        });
+        const reply = await createDiscussionReply({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            commentId: comment.commentId,
+            content: doc("Delete reply"),
+        });
+
+        const deletedComment = await deleteDiscussionComment({
+            ctx,
+            commentId: comment.commentId,
+        });
+        expect(deletedComment.deleted).toBe(true);
+        expect(deletedComment.deletedBy).toBe(learnerUser.userId);
+        expect(deletedComment.deletedByRole).toBe("author");
+        expect(
+            (
+                await ProductDiscussionSubscriberModel.findOne({
+                    domain: testDomain._id,
+                    productId: courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                    userId: learnerUser.userId,
+                })
+            )?.subscription,
+        ).toBe(true);
+
+        const deletedReply = await deleteDiscussionReply({
+            ctx,
+            replyId: reply.replyId,
+        });
+        expect(deletedReply.deleted).toBe(true);
+
+        const summary = await ProductDiscussionSummaryModel.findOne({
+            domain: testDomain._id,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+        });
+        expect(summary?.commentsCount).toBe(0);
+        expect(summary?.repliesCount).toBe(0);
+        expect(summary?.totalCount).toBe(0);
+        expect(summary?.activityCountIncludingDeleted).toBe(2);
+        expect(
+            (
+                await ProductDiscussionSubscriberModel.findOne({
+                    domain: testDomain._id,
+                    productId: courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                    userId: learnerUser.userId,
+                })
+            )?.subscription,
+        ).toBe(false);
+    });
+
+    it("lets product admins list/count reports and cycle report status with moderation side effects", async () => {
+        const adminCtx = {
+            subdomain: testDomain,
+            user: productAdminUser,
+            address: "",
+        };
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Moderate me"),
+        });
+        const report = await createDiscussionReport({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: comment.commentId,
+            reason: "Spam",
+        });
+
+        const reports = await listDiscussionReports({
+            ctx: adminCtx,
+            productId: courseId,
+            status: "pending",
+            page: 1,
+            limit: 10,
+        });
+        expect(reports.items).toHaveLength(1);
+        expect(reports.items[0].reportId).toBe(report.reportId);
+        expect(
+            (
+                await listDiscussionReports({
+                    ctx: adminCtx,
+                    productId: courseId,
+                    status: "pending",
+                    page: 2,
+                    limit: 10,
+                })
+            ).items,
+        ).toHaveLength(0);
+
+        // Verify that GraphQL resolved fields on ProductDiscussionReport work properly
+        const graphql = require("graphql").graphql;
+        const gqlResult: any = await graphql({
+            schema,
+            source: `
+                query GetProductDiscussionReports($productId: String!, $page: Int, $limit: Int) {
+                    getProductDiscussionReports(productId: $productId, page: $page, limit: $limit) {
+                        items {
+                            reportId
+                            lessonTitle
+                            contentPreview
+                            authorName
+                            reporterName
+                        }
+                    }
+                }
+            `,
+            variableValues: { productId: courseId, page: 1, limit: 10 },
+            contextValue: adminCtx,
+        });
+
+        expect(gqlResult.errors).toBeUndefined();
+        const item = gqlResult.data.getProductDiscussionReports.items[0];
+        expect(item.reportId).toBe(report.reportId);
+        expect(item.lessonTitle).toBe("Discussion API Lesson");
+        expect(item.contentPreview).toBe("Moderate me");
+        expect(item.authorName).toBe("Discussion API Learner");
+        expect(item.reporterName).toBe("Discussion API Learner");
+
+        expect(
+            await getDiscussionReportsCount({
+                ctx: adminCtx,
+                productId: courseId,
+                status: "pending",
+            }),
+        ).toBe(1);
+
+        const accepted = await updateDiscussionReportStatus({
+            ctx: adminCtx,
+            productId: courseId,
+            reportId: report.reportId,
+        });
+        expect(accepted.status).toBe("accepted");
+        expect(
+            (
+                await ProductDiscussionCommentModel.findOne({
+                    domain: testDomain._id,
+                    commentId: comment.commentId,
+                })
+            )?.deletedByRole,
+        ).toBe("course_admin");
+        expect(
+            (
+                await ProductDiscussionSummaryModel.findOne({
+                    domain: testDomain._id,
+                    productId: courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                })
+            )?.totalCount,
+        ).toBe(0);
+
+        const rejected = await updateDiscussionReportStatus({
+            ctx: adminCtx,
+            productId: courseId,
+            reportId: report.reportId,
+            rejectionReason: "Not an issue",
+        });
+        expect(rejected.status).toBe("rejected");
+        expect(rejected.rejectionReason).toBe("Not an issue");
+        expect(
+            (
+                await ProductDiscussionCommentModel.findOne({
+                    domain: testDomain._id,
+                    commentId: comment.commentId,
+                })
+            )?.deleted,
+        ).toBe(false);
+        expect(
+            (
+                await ProductDiscussionSummaryModel.findOne({
+                    domain: testDomain._id,
+                    productId: courseId,
+                    entityType: "lesson",
+                    entityId: lessonId,
+                })
+            )?.totalCount,
+        ).toBe(1);
+
+        const pending = await updateDiscussionReportStatus({
+            ctx: adminCtx,
+            productId: courseId,
+            reportId: report.reportId,
+        });
+        expect(pending.status).toBe("pending");
+        expect(pending.rejectionReason).toBe("");
+    });
+
+    it("lets product admins use the course viewer path to report discussion content", async () => {
+        const adminCtx = {
+            subdomain: testDomain,
+            user: productAdminUser,
+            address: "",
+        };
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Admin can inspect this"),
+        });
+
+        await deleteDiscussionComment({
+            ctx,
+            commentId: comment.commentId,
+        });
+
+        const learnerComments = await listDiscussionComments({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            limit: 10,
+        });
+        expect(
+            learnerComments.items.find(
+                (item) => item.commentId === comment.commentId,
+            )?.content,
+        ).toBeNull();
+
+        const adminComments = await listDiscussionComments({
+            ctx: adminCtx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            limit: 10,
+        });
+        expect(
+            adminComments.items.find(
+                (item) => item.commentId === comment.commentId,
+            )?.content,
+        ).toBeNull();
+
+        await expect(
+            listDiscussionComments({
+                ctx: adminCtx,
+                productId: courseId,
+                entityType: "product",
+                entityId: courseId,
+                limit: 10,
+            }),
+        ).rejects.toThrow(responses.action_not_allowed);
+
+        const activeComment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Admin can report this"),
+        });
+
+        const report = await createDiscussionReport({
+            ctx: adminCtx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            contentType: "comment",
+            contentId: activeComment.commentId,
+            reason: "Needs moderation review",
+        });
+
+        expect(report.userId).toBe(productAdminUser.userId);
+    });
+
+    it("resolves the user profile name, avatar and iso date string in GraphQL product discussion comments", async () => {
+        const comment = await createDiscussionComment({
+            ctx,
+            productId: courseId,
+            entityType: "lesson",
+            entityId: lessonId,
+            content: doc("Profile test comment"),
+        });
+
+        const graphql = require("graphql").graphql;
+        const gqlResult: any = await graphql({
+            schema,
+            source: `
+                query GetProductDiscussionComments($productId: String!, $entityType: ProductDiscussionEntityType!, $entityId: String!) {
+                    getProductDiscussionComments(productId: $productId, entityType: $entityType, entityId: $entityId) {
+                        items {
+                            commentId
+                            createdAt
+                            user {
+                                name
+                                avatar {
+                                    file
+                                }
+                            }
+                        }
+                    }
+                }
+            `,
+            variableValues: {
+                productId: courseId,
+                entityType: "LESSON",
+                entityId: lessonId,
+            },
+            contextValue: ctx,
+        });
+
+        expect(gqlResult.errors).toBeUndefined();
+        const item = gqlResult.data.getProductDiscussionComments.items[0];
+        expect(item.commentId).toBe(comment.commentId);
+        expect(item.user.name).toBe("Discussion API Learner");
+        expect(typeof item.createdAt).toBe("string");
+        expect(item.createdAt).toMatch(
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+        );
+    });
+
+    it("lists summaries after server-side lesson access filtering for learners and all targets for admins", async () => {
+        const lockedGroupId = id("discussion-api-locked-group");
+        const lockedLessonId = id("discussion-api-locked-lesson");
+        await CourseModel.updateOne(
+            { domain: testDomain._id, courseId },
+            {
+                $push: {
+                    groups: {
+                        _id: lockedGroupId,
+                        name: "Locked section",
+                        rank: 2,
+                        lessonsOrder: [lockedLessonId],
+                        drip: { status: true },
+                    },
+                    lessons: lockedLessonId,
+                },
+            },
+        );
+        await LessonModel.create({
+            domain: testDomain._id,
+            lessonId: lockedLessonId,
+            title: "Locked Discussion API Lesson",
+            type: "text",
+            creatorId: learnerUser.userId,
+            courseId,
+            groupId: lockedGroupId,
+            requiresEnrollment: true,
+            published: true,
+        });
+        await ProductDiscussionSummaryModel.create([
+            {
+                domain: testDomain._id,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                commentsCount: 1,
+                repliesCount: 0,
+                totalCount: 1,
+                activityCountIncludingDeleted: 1,
+                lastActivityAt: new Date("2026-01-02T00:00:00.000Z"),
+                lastCommentId: id("visible-comment"),
+            },
+            {
+                domain: testDomain._id,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lockedLessonId,
+                commentsCount: 1,
+                repliesCount: 0,
+                totalCount: 1,
+                activityCountIncludingDeleted: 1,
+                lastActivityAt: new Date("2026-01-03T00:00:00.000Z"),
+                lastCommentId: id("locked-comment"),
+            },
+        ]);
+
+        const learnerSummaries = await listDiscussionSummaries({
+            ctx,
+            productId: courseId,
+            limit: 10,
+        });
+        expect(learnerSummaries.items.map((item) => item.entityId)).toEqual([
+            lessonId,
+        ]);
+
+        const adminSummaries = await listDiscussionSummaries({
+            ctx: {
+                subdomain: testDomain,
+                user: productAdminUser,
+                address: "",
+            },
+            productId: courseId,
+            limit: 10,
+        });
+        expect(
+            adminSummaries.items.map((item) => item.entityId).sort(),
+        ).toEqual([lessonId, lockedLessonId].sort());
+    });
+
+    it("lists unpublished discussion targets only for authorized preview managers", async () => {
+        await Promise.all([
+            CourseModel.updateOne(
+                { domain: testDomain._id, courseId },
+                { $set: { published: false } },
+            ),
+            LessonModel.updateOne(
+                { domain: testDomain._id, lessonId },
+                { $set: { published: false } },
+            ),
+            ProductDiscussionSummaryModel.create({
+                domain: testDomain._id,
+                productId: courseId,
+                entityType: "lesson",
+                entityId: lessonId,
+                commentsCount: 1,
+                repliesCount: 0,
+                totalCount: 1,
+                activityCountIncludingDeleted: 1,
+                lastActivityAt: new Date("2026-01-02T00:00:00.000Z"),
+                lastCommentId: id("unpublished-comment"),
+            }),
+        ]);
+
+        await expect(
+            listDiscussionSummaries({
+                ctx,
+                productId: courseId,
+                preview: true,
+            }),
+        ).rejects.toThrow(responses.item_not_found);
+
+        await expect(
+            listDiscussionSummaries({
+                ctx: {
+                    subdomain: testDomain,
+                    user: productAdminUser,
+                    address: "",
+                },
+                productId: courseId,
+            }),
+        ).rejects.toThrow(responses.item_not_found);
+
+        const previewSummaries = await listDiscussionSummaries({
+            ctx: {
+                subdomain: testDomain,
+                user: productAdminUser,
+                address: "",
+            },
+            productId: courseId,
+            preview: true,
+        });
+
+        expect(previewSummaries.items.map((item) => item.entityId)).toEqual([
+            lessonId,
+        ]);
+    });
+});
+
 describe("updateCourse", () => {
     let testDomain: any;
     let adminUser: any;
diff --git a/apps/web/graphql/courses/logic.ts b/apps/web/graphql/courses/logic.ts
index 1c2525362..b653f1852 100644
--- a/apps/web/graphql/courses/logic.ts
+++ b/apps/web/graphql/courses/logic.ts
@@ -2,7 +2,10 @@
  * Business logic for managing courses.
  */
 import CourseModel from "@/models/Course";
-import { InternalCourse } from "@courselit/orm-models";
+import {
+    deleteProductDiscussionData,
+    InternalCourse,
+} from "@courselit/orm-models";
 import UserModel from "@/models/User";
 import { Media, User } from "@courselit/common-models";
 import { responses } from "@/config/strings";
@@ -47,6 +50,7 @@ import CertificateTemplateModel, {
 } from "@models/CertificateTemplate";
 import CertificateModel from "@models/Certificate";
 import ActivityModel from "@models/Activity";
+import NotificationModel from "@models/Notification";
 import getDeletedMediaIds from "@/lib/get-deleted-media-ids";
 import { deletePageInternal } from "../pages/logic";
 import { replaceTempMediaWithSealedMediaInProseMirrorDoc } from "@/lib/replace-temp-media-with-sealed-media-in-prosemirror-doc";
@@ -368,6 +372,17 @@ export const deleteCourse = async (id: string, ctx: GQLContext) => {
             { "metadata.courseId": course.courseId },
         ],
     });
+    await NotificationModel.deleteMany({
+        domain: ctx.subdomain._id,
+        $or: [
+            { entityId: course.courseId },
+            { "metadata.courseId": course.courseId },
+        ],
+    });
+    await deleteProductDiscussionData({
+        domain: ctx.subdomain._id,
+        productId: course.courseId,
+    });
     await deleteAllLessons(course.courseId, ctx);
     if (course.featuredImage) {
         try {
diff --git a/apps/web/graphql/courses/permissions.ts b/apps/web/graphql/courses/permissions.ts
index fc92ab00a..c907544ff 100644
--- a/apps/web/graphql/courses/permissions.ts
+++ b/apps/web/graphql/courses/permissions.ts
@@ -1,31 +1,26 @@
-import constants from "@/config/constants";
-import { checkOwnershipWithoutModel } from "@/lib/graphql";
 import GQLContext from "@/models/GQLContext";
-import { checkPermission } from "@courselit/utils";
+import {
+    getCourseManagementAccess as getSharedCourseManagementAccess,
+    type CourseManagementAccess,
+} from "@courselit/common-logic";
 import mongoose from "mongoose";
 
-const { permissions } = constants;
-
 export function getCourseManagementAccess(
     course: { creatorId: mongoose.Types.ObjectId | string },
     ctx: GQLContext,
-): { canManage: boolean; isOwner: boolean } {
-    if (!ctx.user) {
-        return { canManage: false, isOwner: false };
-    }
-
-    if (checkPermission(ctx.user.permissions, [permissions.manageAnyCourse])) {
-        return { canManage: true, isOwner: true };
-    }
-
-    const isOwner = checkOwnershipWithoutModel(course, ctx);
+): CourseManagementAccess {
+    // effectively using the same checks as checkOwnershipWithoutModel
+    const userId = ctx.user
+        ? mongoose.Types.ObjectId.isValid(course.creatorId)
+            ? ctx.user._id.toString()
+            : ctx.user.userId.toString()
+        : undefined;
 
-    return {
-        canManage:
-            isOwner &&
-            checkPermission(ctx.user.permissions, [permissions.manageCourse]),
-        isOwner,
-    };
+    return getSharedCourseManagementAccess({
+        creatorId: course.creatorId.toString(),
+        userId,
+        permissions: ctx.user?.permissions,
+    });
 }
 
 export function canManageCourseInContext(
diff --git a/apps/web/graphql/courses/types/index.ts b/apps/web/graphql/courses/types/index.ts
index 1efe8db35..c5ad852e7 100644
--- a/apps/web/graphql/courses/types/index.ts
+++ b/apps/web/graphql/courses/types/index.ts
@@ -154,6 +154,10 @@ const courseType = new GraphQLObjectType({
             type: new GraphQLNonNull(GraphQLBoolean),
             resolve: (course) => Boolean((course as any).isPreview),
         },
+        discussions: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            resolve: (course) => Boolean(course.discussions),
+        },
         featuredImage: {
             type: mediaTypes.mediaType,
             resolve: (course, _, context, __) => getMedia(course.featuredImage),
@@ -200,6 +204,7 @@ const courseUpdateInput = new GraphQLInputObjectType({
         featuredImage: { type: mediaTypes.mediaInputType },
         leadMagnet: { type: GraphQLBoolean },
         certificate: { type: GraphQLBoolean },
+        discussions: { type: GraphQLBoolean },
     },
 });
 
diff --git a/apps/web/graphql/index.ts b/apps/web/graphql/index.ts
index d66fe1f2b..194a9d1e4 100644
--- a/apps/web/graphql/index.ts
+++ b/apps/web/graphql/index.ts
@@ -12,6 +12,7 @@ import communities from "./communities";
 import paymentplans from "./paymentplans";
 import notifications from "./notifications";
 import themes from "./themes";
+import productDiscussions from "./product-discussions";
 
 const schema = new graphql.GraphQLSchema({
     query: new graphql.GraphQLObjectType({
@@ -29,6 +30,7 @@ const schema = new graphql.GraphQLSchema({
             ...paymentplans.queries,
             ...notifications.queries,
             ...themes.queries,
+            ...productDiscussions.queries,
         },
     }),
     mutation: new graphql.GraphQLObjectType({
@@ -46,6 +48,7 @@ const schema = new graphql.GraphQLSchema({
             ...paymentplans.mutations,
             ...notifications.mutations,
             ...themes.mutations,
+            ...productDiscussions.mutations,
         },
     }),
 });
diff --git a/apps/web/graphql/notifications/__tests__/logic.test.ts b/apps/web/graphql/notifications/__tests__/logic.test.ts
index a69118627..4c47234db 100644
--- a/apps/web/graphql/notifications/__tests__/logic.test.ts
+++ b/apps/web/graphql/notifications/__tests__/logic.test.ts
@@ -10,6 +10,7 @@ import NotificationPreferenceModel from "@models/NotificationPreference";
 import NotificationModel from "@models/Notification";
 import CommunityModel from "@models/Community";
 import CommunityPostModel from "@models/CommunityPost";
+import CourseModel from "@models/Course";
 import constants from "@/config/constants";
 import { Constants } from "@courselit/common-models";
 
@@ -56,12 +57,14 @@ describe("Notification Preferences", () => {
         await NotificationModel.deleteMany({ domain: domain._id });
         await CommunityPostModel.deleteMany({ domain: domain._id });
         await CommunityModel.deleteMany({ domain: domain._id });
+        await CourseModel.deleteMany({ domain: domain._id });
     });
 
     afterAll(async () => {
         await NotificationModel.deleteMany({ domain: domain._id });
         await CommunityPostModel.deleteMany({ domain: domain._id });
         await CommunityModel.deleteMany({ domain: domain._id });
+        await CourseModel.deleteMany({ domain: domain._id });
         await NotificationPreferenceModel.deleteMany({ domain: domain._id });
         await UserModel.deleteMany({ domain: domain._id });
         await DomainModel.deleteOne({ _id: domain._id });
@@ -101,12 +104,30 @@ describe("Notification Preferences", () => {
                 preference.activityType ===
                 Constants.ActivityType.COMMUNITY_POST_CREATED,
         );
+        const courseDiscussionCommentPreference = preferences.find(
+            (preference) =>
+                preference.activityType ===
+                Constants.ActivityType.COURSE_DISCUSSION_COMMENT_CREATED,
+        );
+        const courseDiscussionReactionPreference = preferences.find(
+            (preference) =>
+                preference.activityType ===
+                Constants.ActivityType.COURSE_DISCUSSION_REACTED,
+        );
 
         expect(generalPreference).toBeTruthy();
         expect(generalPreference?.channels).toEqual([
             Constants.NotificationChannel.APP,
             Constants.NotificationChannel.EMAIL,
         ]);
+        expect(courseDiscussionCommentPreference?.channels).toEqual([
+            Constants.NotificationChannel.APP,
+            Constants.NotificationChannel.EMAIL,
+        ]);
+        expect(courseDiscussionReactionPreference?.channels).toEqual([
+            Constants.NotificationChannel.APP,
+            Constants.NotificationChannel.EMAIL,
+        ]);
         expect(purchasedPreference).toBeUndefined();
     });
 
@@ -292,6 +313,112 @@ describe("Notification Preferences", () => {
         expect(response?.message).toContain("Community A");
     });
 
+    it("should add preview mode to unpublished course discussion notification hrefs for managers only", async () => {
+        const course = await CourseModel.create({
+            domain: domain._id,
+            courseId: id("discussion-course"),
+            title: "Discussion Course",
+            slug: id("discussion-course-slug"),
+            cost: 0,
+            costType: "free",
+            privacy: "public",
+            type: "course",
+            creatorId: manager.userId,
+            published: false,
+            discussions: true,
+        });
+
+        const notification = await NotificationModel.create({
+            domain: domain._id,
+            notificationId: id("discussion-notification"),
+            userId: learner.userId,
+            forUserId: manager.userId,
+            activityType:
+                Constants.ActivityType.COURSE_DISCUSSION_COMMENT_CREATED,
+            entityId: id("comment"),
+            metadata: {
+                eventType: "comment_created",
+                courseId: course.courseId,
+                entityType: "lesson",
+                entityId: id("lesson"),
+                commentId: id("comment"),
+            },
+        });
+
+        const response = await getNotification({
+            ctx: {
+                user: manager,
+                subdomain: domain,
+            } as any,
+            notificationId: notification.notificationId,
+        });
+
+        expect(response).toBeTruthy();
+        expect(response?.href).toBe(
+            `/course/${course.slug}/${course.courseId}/${id(
+                "lesson",
+            )}?discussion=open&preview=true#discussion-comment-${id("comment")}`,
+        );
+        expect(response?.message).toContain("commented on Discussion Course");
+
+        const learnerNotification = await NotificationModel.create({
+            domain: domain._id,
+            notificationId: id("learner-discussion-notification"),
+            userId: manager.userId,
+            forUserId: learner.userId,
+            activityType:
+                Constants.ActivityType.COURSE_DISCUSSION_COMMENT_CREATED,
+            entityId: id("comment"),
+            metadata: notification.metadata,
+        });
+        const learnerResponse = await getNotification({
+            ctx: {
+                user: learner,
+                subdomain: domain,
+            } as any,
+            notificationId: learnerNotification.notificationId,
+        });
+
+        expect(learnerResponse?.href).toBe(
+            `/course/${course.slug}/${course.courseId}/${id(
+                "lesson",
+            )}?discussion=open#discussion-comment-${id("comment")}`,
+        );
+
+        const reactionNotification = await NotificationModel.create({
+            domain: domain._id,
+            notificationId: id("discussion-reaction-notification"),
+            userId: learner.userId,
+            forUserId: manager.userId,
+            activityType: Constants.ActivityType.COURSE_DISCUSSION_REACTED,
+            entityId: id("reply"),
+            metadata: {
+                courseId: course.courseId,
+                entityType: "lesson",
+                entityId: id("lesson"),
+                contentType: "reply",
+                commentId: id("comment"),
+                replyId: id("reply"),
+            },
+        });
+        const reactionResponse = await getNotification({
+            ctx: {
+                user: manager,
+                subdomain: domain,
+            } as any,
+            notificationId: reactionNotification.notificationId,
+        });
+
+        expect(reactionResponse?.message).toContain(
+            "reacted to your reply on Discussion Course",
+        );
+        expect(reactionResponse?.href).toBe(
+            `/course/${course.slug}/${course.courseId}/${id(
+                "lesson",
+            )}?discussion=open&preview=true#discussion-reply-${id("reply")}`,
+        );
+    });
+
     it("should return empty message and href when entity cannot be resolved", async () => {
         const notification = await NotificationModel.create({
             domain: domain._id,
diff --git a/apps/web/graphql/notifications/logic.ts b/apps/web/graphql/notifications/logic.ts
index 8666d2f03..56aa291d6 100644
--- a/apps/web/graphql/notifications/logic.ts
+++ b/apps/web/graphql/notifications/logic.ts
@@ -276,6 +276,7 @@ async function formatNotification(
             entityId: notification.entityId,
             actorName: await getUserName(notification.userId),
             recipientUserId: ctx.user.userId,
+            recipientPermissions: ctx.user.permissions,
             entityTargetId: notification.entityTargetId,
             metadata: notification.metadata,
             domainId: ctx.subdomain._id,
diff --git a/apps/web/graphql/product-discussions/index.ts b/apps/web/graphql/product-discussions/index.ts
new file mode 100644
index 000000000..f6a5745fe
--- /dev/null
+++ b/apps/web/graphql/product-discussions/index.ts
@@ -0,0 +1,9 @@
+import queries from "./query";
+import mutations from "./mutation";
+
+const productDiscussionsModule = {
+    queries,
+    mutations,
+};
+
+export default productDiscussionsModule;
diff --git a/apps/web/graphql/product-discussions/logic.ts b/apps/web/graphql/product-discussions/logic.ts
new file mode 100644
index 000000000..15d250a52
--- /dev/null
+++ b/apps/web/graphql/product-discussions/logic.ts
@@ -0,0 +1,1887 @@
+import { responses } from "@/config/strings";
+import appConstants from "@/config/constants";
+import CourseModel from "@/models/Course";
+import ProductDiscussionCommentModel from "@/models/ProductDiscussionComment";
+import ProductDiscussionLikeModel from "@/models/ProductDiscussionLike";
+import ProductDiscussionReplyModel from "@/models/ProductDiscussionReply";
+import ProductDiscussionReportModel from "@/models/ProductDiscussionReport";
+import ProductDiscussionSubscriberModel from "@/models/ProductDiscussionSubscriber";
+import ProductDiscussionSummaryModel from "@/models/ProductDiscussionSummary";
+import RateLimitEventModel from "@/models/RateLimitEvent";
+import UserModel from "@/models/User";
+import LessonModel from "@/models/Lesson";
+import GQLContext from "@/models/GQLContext";
+import { Constants, TextEditorContent } from "@courselit/common-models";
+import { getLessonDetails } from "../lessons/logic";
+import {
+    checkPermission,
+    extractTextFromTextEditorContent,
+} from "@courselit/utils";
+import mongoose from "mongoose";
+import { randomUUID } from "crypto";
+import { recordActivity } from "@/lib/record-activity";
+import {
+    checkIfAuthenticated,
+    checkOwnershipWithoutModel,
+} from "@/lib/graphql";
+import { canManageCourseInContext } from "../courses/permissions";
+
+export const MAX_DISCUSSION_CONTENT_BYTES = 32768;
+export const MAX_DISCUSSION_TEXT_LENGTH = 5000;
+
+export const COURSE_DISCUSSION_RATE_LIMITS = {
+    commentsPerMinute: { window: 60 * 1000, limit: 5 },
+    commentsPerDay: { window: 24 * 60 * 60 * 1000, limit: 50 },
+    likesPerMinute: { window: 60 * 1000, limit: 60 },
+    reportsPerHour: { window: 60 * 60 * 1000, limit: 10 },
+} as const;
+
+export type ProductDiscussionEntityType = "lesson" | "product";
+export type ProductDiscussionContentType = "comment" | "reply";
+
+const { permissions } = appConstants;
+
+type CursorEnvelope<T> = {
+    items: T[];
+    nextCursor?: string;
+    hasMore: boolean;
+};
+
+type CommentCursor = {
+    createdAt: string;
+    commentId: string;
+};
+
+type ReplyCursor = {
+    createdAt: string;
+    replyId: string;
+};
+
+type ReportCursor = {
+    createdAt: string;
+    reportId: string;
+};
+
+type SummaryCursor = {
+    lastActivityAt: string;
+    entityId: string;
+};
+
+type ProductDiscussionReportStatus = "pending" | "accepted" | "rejected";
+
+export async function validateDiscussionTargetForLearner({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+}) {
+    checkIfAuthenticated(ctx);
+
+    if (entityType === "product") {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    const product = await CourseModel.findOne({
+        domain: ctx.subdomain._id,
+        courseId: productId,
+    });
+
+    if (!product || product.type !== Constants.CourseType.COURSE) {
+        throw new Error(responses.item_not_found);
+    }
+
+    if (!product.discussions) {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    const isAdminOrCreator =
+        ctx.user &&
+        (checkPermission(ctx.user.permissions, [permissions.manageAnyCourse]) ||
+            (checkPermission(ctx.user.permissions, [
+                permissions.manageCourse,
+            ]) &&
+                checkOwnershipWithoutModel(product, ctx)));
+
+    if (!product.published && !isAdminOrCreator) {
+        throw new Error(responses.item_not_found);
+    }
+
+    if (!isAdminOrCreator && !isEnrolledInProduct(ctx, productId)) {
+        throw new Error(responses.not_enrolled);
+    }
+
+    let lesson;
+    if (isAdminOrCreator) {
+        lesson = await LessonModel.findOne({
+            lessonId: entityId,
+            domain: ctx.subdomain._id,
+            courseId: productId,
+        });
+        if (!lesson) {
+            throw new Error(responses.item_not_found);
+        }
+    } else {
+        lesson = await getLessonDetails(entityId, ctx, productId);
+    }
+
+    return {
+        product,
+        lesson,
+        productId,
+        entityType,
+        entityId,
+    };
+}
+
+export function validateDiscussionContent(content: unknown): TextEditorContent {
+    if (!content || typeof content !== "object") {
+        throw new Error(responses.invalid_input);
+    }
+
+    const doc = content as TextEditorContent;
+    if (doc.type !== "doc") {
+        throw new Error(responses.invalid_input);
+    }
+
+    const contentBytes = Buffer.byteLength(JSON.stringify(doc), "utf8");
+    if (contentBytes > MAX_DISCUSSION_CONTENT_BYTES) {
+        throw new Error(responses.invalid_input);
+    }
+
+    const text = extractTextFromTextEditorContent(doc);
+    if (!text.trim() || text.length > MAX_DISCUSSION_TEXT_LENGTH) {
+        throw new Error(responses.invalid_input);
+    }
+
+    return doc;
+}
+
+export async function assertRateLimit({
+    domain,
+    userId,
+    scope,
+    action,
+    subjectId,
+    window,
+    limit,
+    fingerprint,
+    record = true,
+}: {
+    domain: mongoose.Types.ObjectId;
+    userId: string;
+    scope: string;
+    action: string;
+    subjectId: string;
+    window: number;
+    limit: number;
+    fingerprint?: string;
+    record?: boolean;
+}) {
+    const since = new Date(Date.now() - window);
+    const existingEvents = await RateLimitEventModel.countDocuments({
+        domain,
+        userId,
+        scope,
+        action,
+        subjectId,
+        createdAt: { $gte: since },
+    });
+
+    if (existingEvents >= limit) {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    if (fingerprint) {
+        const duplicate = await RateLimitEventModel.findOne({
+            domain,
+            userId,
+            scope,
+            subjectId,
+            fingerprint,
+            createdAt: { $gte: since },
+        }).select("_id");
+
+        if (duplicate) {
+            throw new Error(responses.action_not_allowed);
+        }
+    }
+
+    if (record) {
+        await RateLimitEventModel.create({
+            domain,
+            userId,
+            scope,
+            action,
+            subjectId,
+            fingerprint,
+        });
+    }
+}
+
+export async function createDiscussionComment({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+    content,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    content: unknown;
+}) {
+    const target = await validateDiscussionTargetForLearner({
+        ctx,
+        productId,
+        entityType,
+        entityId,
+    });
+    const validatedContent = validateDiscussionContent(content);
+    const subjectId = getDiscussionSubjectId({
+        productId,
+        entityType,
+        entityId,
+    });
+
+    await assertRateLimit({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        scope: "course_discussion",
+        action: "comment:create",
+        subjectId,
+        window: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.window,
+        limit: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.limit,
+        record: false,
+    });
+
+    await assertRateLimit({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        scope: "course_discussion",
+        action: "comment:create",
+        subjectId,
+        window: COURSE_DISCUSSION_RATE_LIMITS.commentsPerMinute.window,
+        limit: COURSE_DISCUSSION_RATE_LIMITS.commentsPerMinute.limit,
+        fingerprint: getContentFingerprint(validatedContent),
+    });
+
+    const comment = await ProductDiscussionCommentModel.create({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        commentId: randomUUID(),
+        userId: ctx.user.userId,
+        content: validatedContent,
+    });
+
+    await Promise.all([
+        updateSummaryForCreate({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            commentId: comment.commentId,
+            createdAt: comment.createdAt,
+            type: "comment",
+        }),
+        upsertSubscriber({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            userId: ctx.user.userId,
+        }),
+    ]);
+
+    await recordDiscussionActivity({
+        ctx,
+        product: target.product,
+        productId,
+        entityType,
+        entityId,
+        eventType: "comment_created",
+        commentId: comment.commentId,
+    });
+
+    return comment;
+}
+
+export async function createDiscussionReply({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+    commentId,
+    parentReplyId,
+    content,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    commentId: string;
+    parentReplyId?: string;
+    content: unknown;
+}) {
+    const target = await validateDiscussionTargetForLearner({
+        ctx,
+        productId,
+        entityType,
+        entityId,
+    });
+    const validatedContent = validateDiscussionContent(content);
+    const subjectId = getDiscussionSubjectId({
+        productId,
+        entityType,
+        entityId,
+    });
+
+    const comment = await ProductDiscussionCommentModel.findOne({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        commentId,
+    });
+    if (!comment || comment.deleted) {
+        throw new Error(responses.item_not_found);
+    }
+
+    if (parentReplyId) {
+        const parentReply = await ProductDiscussionReplyModel.findOne({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            commentId,
+            replyId: parentReplyId,
+        }).select("_id");
+        if (!parentReply) {
+            throw new Error(responses.item_not_found);
+        }
+    }
+
+    await assertRateLimit({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        scope: "course_discussion",
+        action: "reply:create",
+        subjectId,
+        window: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.window,
+        limit: COURSE_DISCUSSION_RATE_LIMITS.commentsPerDay.limit,
+        record: false,
+    });
+
+    await assertRateLimit({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        scope: "course_discussion",
+        action: "reply:create",
+        subjectId,
+        window: COURSE_DISCUSSION_RATE_LIMITS.commentsPerMinute.window,
+        limit: COURSE_DISCUSSION_RATE_LIMITS.commentsPerMinute.limit,
+        fingerprint: getContentFingerprint(validatedContent),
+    });
+
+    const reply = await ProductDiscussionReplyModel.create({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        commentId,
+        replyId: randomUUID(),
+        parentReplyId,
+        userId: ctx.user.userId,
+        content: validatedContent,
+    });
+
+    await Promise.all([
+        updateSummaryForCreate({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            replyId: reply.replyId,
+            createdAt: reply.createdAt,
+            type: "reply",
+        }),
+        upsertSubscriber({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            userId: ctx.user.userId,
+        }),
+    ]);
+
+    await recordDiscussionActivity({
+        ctx,
+        product: target.product,
+        productId,
+        entityType,
+        entityId,
+        eventType: "reply_created",
+        commentId,
+        replyId: reply.replyId,
+    });
+
+    return reply;
+}
+
+export async function listDiscussionComments({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+    targetContentType,
+    targetContentId,
+    cursor,
+    limit = 10,
+    replyPreviewLimit = 2,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    targetContentType?: ProductDiscussionContentType;
+    targetContentId?: string;
+    cursor?: string;
+    limit?: number;
+    replyPreviewLimit?: number;
+}): Promise<CursorEnvelope<any>> {
+    assertLessonDiscussionTarget(entityType);
+
+    await validateDiscussionTargetForLearner({
+        ctx,
+        productId,
+        entityType,
+        entityId,
+    });
+
+    const filter: Record<string, unknown> = {
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+    };
+    const decodedCursor = cursor ? decodeCursor<CommentCursor>(cursor) : null;
+    if (decodedCursor) {
+        filter.$or = [
+            { createdAt: { $lt: new Date(decodedCursor.createdAt) } },
+            {
+                createdAt: new Date(decodedCursor.createdAt),
+                commentId: { $lt: decodedCursor.commentId },
+            },
+        ];
+    }
+
+    const targetComment = !cursor
+        ? await getTargetCommentForList({
+              domain: ctx.subdomain._id,
+              productId,
+              entityType,
+              entityId,
+              targetContentType,
+              targetContentId,
+          })
+        : null;
+
+    const comments = await ProductDiscussionCommentModel.find({
+        ...filter,
+        ...(targetComment
+            ? { commentId: { $ne: targetComment.commentId } }
+            : {}),
+    })
+        .sort({ createdAt: -1, commentId: -1 })
+        .limit(limit + 1 - (targetComment ? 1 : 0));
+    const visibleComments = [
+        ...(targetComment ? [targetComment] : []),
+        ...comments.slice(0, limit - (targetComment ? 1 : 0)),
+    ];
+    const commentIds = visibleComments.map((comment) => comment.commentId);
+    const repliesByCommentId = new Map<string, any[]>();
+    const replyCountsByCommentId = new Map<string, number>();
+
+    const commentReplyData = await Promise.all(
+        visibleComments.map(async (comment) => {
+            const [replyCount, repliesPage, targetReply] = await Promise.all([
+                ProductDiscussionReplyModel.countDocuments({
+                    domain: ctx.subdomain._id,
+                    commentId: comment.commentId,
+                }),
+                ProductDiscussionReplyModel.find({
+                    domain: ctx.subdomain._id,
+                    commentId: comment.commentId,
+                })
+                    .sort({ createdAt: 1, replyId: 1 })
+                    .limit(replyPreviewLimit + 1),
+                targetContentType === "reply" && targetContentId
+                    ? ProductDiscussionReplyModel.findOne({
+                          domain: ctx.subdomain._id,
+                          productId,
+                          entityType,
+                          entityId,
+                          commentId: comment.commentId,
+                          replyId: targetContentId,
+                      })
+                    : null,
+            ]);
+            const visibleReplies = repliesPage.slice(0, replyPreviewLimit);
+            const lastVisibleReply = visibleReplies[visibleReplies.length - 1];
+            const replies =
+                targetReply &&
+                !visibleReplies.some(
+                    (reply) => reply.replyId === targetReply.replyId,
+                )
+                    ? [targetReply, ...visibleReplies]
+                    : visibleReplies;
+
+            return {
+                commentId: comment.commentId,
+                replyCount,
+                replies,
+                hasMoreReplies: repliesPage.length > replyPreviewLimit,
+                replyNextCursor:
+                    repliesPage.length > replyPreviewLimit && lastVisibleReply
+                        ? encodeCursor({
+                              createdAt:
+                                  lastVisibleReply.createdAt.toISOString(),
+                              replyId: lastVisibleReply.replyId,
+                          })
+                        : undefined,
+            };
+        }),
+    );
+    for (const { commentId, replyCount, replies } of commentReplyData) {
+        replyCountsByCommentId.set(commentId, replyCount);
+        repliesByCommentId.set(commentId, replies);
+    }
+
+    const previewReplyIds = commentReplyData.flatMap(({ replies }) =>
+        replies.map((reply) => reply.replyId),
+    );
+    const likedContentIds = await getLikedContentIds({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        contentIds: [...commentIds, ...previewReplyIds],
+    });
+
+    const items = visibleComments.map((comment) => ({
+        ...formatDiscussionContent(comment, "comment", {
+            redactDeleted: true,
+        }),
+        hasLiked: likedContentIds.has(comment.commentId),
+        replyCount: replyCountsByCommentId.get(comment.commentId) || 0,
+        replyNextCursor: commentReplyData.find(
+            (replyData) => replyData.commentId === comment.commentId,
+        )?.replyNextCursor,
+        hasMoreReplies: Boolean(
+            commentReplyData.find(
+                (replyData) => replyData.commentId === comment.commentId,
+            )?.hasMoreReplies,
+        ),
+        replies: (repliesByCommentId.get(comment.commentId) || []).map(
+            (reply) => ({
+                ...formatDiscussionContent(reply, "reply", {
+                    redactDeleted: true,
+                }),
+                hasLiked: likedContentIds.has(reply.replyId),
+            }),
+        ),
+    }));
+
+    const hasMore = comments.length > limit - (targetComment ? 1 : 0);
+    const lastItem = visibleComments[visibleComments.length - 1];
+
+    return {
+        items,
+        hasMore,
+        nextCursor:
+            hasMore && lastItem
+                ? encodeCursor({
+                      createdAt: lastItem.createdAt.toISOString(),
+                      commentId: lastItem.commentId,
+                  })
+                : undefined,
+    };
+}
+
+export async function listDiscussionReplies({
+    ctx,
+    commentId,
+    cursor,
+    limit = 10,
+}: {
+    ctx: GQLContext;
+    commentId: string;
+    cursor?: string;
+    limit?: number;
+}): Promise<CursorEnvelope<any>> {
+    const comment = await ProductDiscussionCommentModel.findOne({
+        domain: ctx.subdomain._id,
+        commentId,
+    });
+    if (!comment) {
+        throw new Error(responses.item_not_found);
+    }
+    assertLessonDiscussionTarget(comment.entityType);
+
+    await validateDiscussionTargetForLearner({
+        ctx,
+        productId: comment.productId,
+        entityType: comment.entityType,
+        entityId: comment.entityId,
+    });
+
+    const filter: Record<string, unknown> = {
+        domain: ctx.subdomain._id,
+        commentId,
+    };
+    const decodedCursor = cursor ? decodeCursor<ReplyCursor>(cursor) : null;
+    if (decodedCursor) {
+        filter.$or = [
+            { createdAt: { $gt: new Date(decodedCursor.createdAt) } },
+            {
+                createdAt: new Date(decodedCursor.createdAt),
+                replyId: { $gt: decodedCursor.replyId },
+            },
+        ];
+    }
+
+    const replies = await ProductDiscussionReplyModel.find(filter)
+        .sort({ createdAt: 1, replyId: 1 })
+        .limit(limit + 1);
+    const visibleReplies = replies.slice(0, limit);
+    const likedContentIds = await getLikedContentIds({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        contentIds: visibleReplies.map((reply) => reply.replyId),
+    });
+    const hasMore = replies.length > limit;
+    const lastItem = visibleReplies[visibleReplies.length - 1];
+
+    return {
+        items: visibleReplies.map((reply) => ({
+            ...formatDiscussionContent(reply, "reply", {
+                redactDeleted: true,
+            }),
+            hasLiked: likedContentIds.has(reply.replyId),
+        })),
+        hasMore,
+        nextCursor:
+            hasMore && lastItem
+                ? encodeCursor({
+                      createdAt: lastItem.createdAt.toISOString(),
+                      replyId: lastItem.replyId,
+                  })
+                : undefined,
+    };
+}
+
+async function getLikedContentIds({
+    domain,
+    userId,
+    contentIds,
+}: {
+    domain: mongoose.Types.ObjectId;
+    userId: string;
+    contentIds: string[];
+}) {
+    if (!contentIds.length) {
+        return new Set<string>();
+    }
+
+    const likes = await ProductDiscussionLikeModel.find({
+        domain,
+        userId,
+        contentId: { $in: contentIds },
+    }).select("contentId");
+
+    return new Set(likes.map((like) => like.contentId));
+}
+
+async function getTargetCommentForList({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    targetContentType,
+    targetContentId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    targetContentType?: ProductDiscussionContentType;
+    targetContentId?: string;
+}) {
+    if (!targetContentType || !targetContentId) {
+        return null;
+    }
+
+    if (targetContentType === "comment") {
+        return await ProductDiscussionCommentModel.findOne({
+            domain,
+            productId,
+            entityType,
+            entityId,
+            commentId: targetContentId,
+        });
+    }
+
+    const reply = await ProductDiscussionReplyModel.findOne({
+        domain,
+        productId,
+        entityType,
+        entityId,
+        replyId: targetContentId,
+    }).select("commentId");
+    if (!reply) {
+        return null;
+    }
+
+    return await ProductDiscussionCommentModel.findOne({
+        domain,
+        productId,
+        entityType,
+        entityId,
+        commentId: reply.commentId,
+    });
+}
+
+function formatDiscussionContent(
+    item: any,
+    type: ProductDiscussionContentType,
+    { redactDeleted }: { redactDeleted: boolean },
+) {
+    const object = item.toObject();
+    const id = type === "comment" ? object.commentId : object.replyId;
+
+    return {
+        ...object,
+        content: redactDeleted && object.deleted ? null : object.content,
+        contentId: id,
+    };
+}
+
+export async function toggleDiscussionLike({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+    contentType,
+    contentId,
+    liked,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+    liked: boolean;
+}) {
+    await validateDiscussionTargetForLearner({
+        ctx,
+        productId,
+        entityType,
+        entityId,
+    });
+
+    const target = await getDiscussionContentTarget({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        contentType,
+        contentId,
+    });
+
+    const subjectId = getDiscussionSubjectId({
+        productId,
+        entityType,
+        entityId,
+    });
+
+    if (liked) {
+        const existingLike = await ProductDiscussionLikeModel.findOne({
+            domain: ctx.subdomain._id,
+            contentType,
+            contentId,
+            userId: ctx.user.userId,
+        }).select("_id");
+
+        if (!existingLike) {
+            await assertRateLimit({
+                domain: ctx.subdomain._id,
+                userId: ctx.user.userId,
+                scope: "course_discussion",
+                action: "like:toggle",
+                subjectId,
+                window: COURSE_DISCUSSION_RATE_LIMITS.likesPerMinute.window,
+                limit: COURSE_DISCUSSION_RATE_LIMITS.likesPerMinute.limit,
+            });
+            await ProductDiscussionLikeModel.create({
+                domain: ctx.subdomain._id,
+                productId,
+                entityType,
+                entityId,
+                contentType,
+                contentId,
+                commentId:
+                    contentType === "reply"
+                        ? target.commentId
+                        : target.commentId,
+                userId: ctx.user.userId,
+            });
+            await incrementLikesCount({ contentType, contentId, delta: 1 });
+            if (target.userId !== ctx.user.userId) {
+                await recordActivity({
+                    domain: ctx.subdomain._id,
+                    userId: ctx.user.userId,
+                    type: Constants.ActivityType.COURSE_DISCUSSION_REACTED,
+                    entityId: contentId,
+                    metadata: {
+                        courseId: productId,
+                        entityType,
+                        entityId,
+                        contentType,
+                        commentId: target.commentId,
+                        ...(contentType === "reply"
+                            ? { replyId: contentId }
+                            : {}),
+                        forUserIds: [target.userId],
+                    },
+                });
+            }
+        }
+    } else {
+        const deletedLike = await ProductDiscussionLikeModel.findOneAndDelete({
+            domain: ctx.subdomain._id,
+            contentType,
+            contentId,
+            userId: ctx.user.userId,
+        });
+
+        if (deletedLike) {
+            await assertRateLimit({
+                domain: ctx.subdomain._id,
+                userId: ctx.user.userId,
+                scope: "course_discussion",
+                action: "like:toggle",
+                subjectId,
+                window: COURSE_DISCUSSION_RATE_LIMITS.likesPerMinute.window,
+                limit: COURSE_DISCUSSION_RATE_LIMITS.likesPerMinute.limit,
+            });
+            await incrementLikesCount({ contentType, contentId, delta: -1 });
+        }
+    }
+
+    const updatedTarget = await getDiscussionContentTarget({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        contentType,
+        contentId,
+    });
+
+    return {
+        contentType,
+        contentId,
+        likesCount: updatedTarget.likesCount,
+        hasLiked: liked,
+    };
+}
+
+export async function createDiscussionReport({
+    ctx,
+    productId,
+    entityType,
+    entityId,
+    contentType,
+    contentId,
+    reason,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+    reason: string;
+}) {
+    try {
+        await validateDiscussionTargetForLearner({
+            ctx,
+            productId,
+            entityType,
+            entityId,
+        });
+    } catch (err) {
+        await validateProductDiscussionAdmin({ ctx, productId });
+        if (entityType !== "lesson") {
+            throw err;
+        }
+        const lesson = await LessonModel.findOne({
+            domain: ctx.subdomain._id,
+            courseId: productId,
+            lessonId: entityId,
+        }).select("_id");
+        if (!lesson) {
+            throw err;
+        }
+    }
+
+    const trimmedReason = reason.trim();
+    if (!trimmedReason) {
+        throw new Error(responses.invalid_input);
+    }
+
+    const target = await getDiscussionContentTarget({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        contentType,
+        contentId,
+    });
+
+    await assertRateLimit({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        scope: "course_discussion",
+        action: "report:create",
+        subjectId: getDiscussionSubjectId({ productId, entityType, entityId }),
+        window: COURSE_DISCUSSION_RATE_LIMITS.reportsPerHour.window,
+        limit: COURSE_DISCUSSION_RATE_LIMITS.reportsPerHour.limit,
+    });
+
+    try {
+        return await ProductDiscussionReportModel.create({
+            domain: ctx.subdomain._id,
+            productId,
+            entityType,
+            entityId,
+            reportId: randomUUID(),
+            contentType,
+            contentId,
+            commentId: target.commentId,
+            userId: ctx.user.userId,
+            reason: trimmedReason,
+        });
+    } catch (err: any) {
+        if (err?.code === 11000) {
+            throw new Error(responses.invalid_input);
+        }
+        throw err;
+    }
+}
+
+export async function deleteDiscussionComment({
+    ctx,
+    commentId,
+}: {
+    ctx: GQLContext;
+    commentId: string;
+}) {
+    checkIfAuthenticated(ctx);
+
+    const comment = await ProductDiscussionCommentModel.findOne({
+        domain: ctx.subdomain._id,
+        commentId,
+    });
+    if (!comment) {
+        throw new Error(responses.item_not_found);
+    }
+    if (comment.userId !== ctx.user.userId) {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    await validateDiscussionTargetForLearner({
+        ctx,
+        productId: comment.productId,
+        entityType: comment.entityType,
+        entityId: comment.entityId,
+    });
+
+    if (!comment.deleted) {
+        comment.deleted = true;
+        comment.deletedAt = new Date();
+        comment.deletedBy = ctx.user.userId;
+        comment.deletedByRole = "author";
+        await comment.save();
+
+        await updateSummaryForSoftDelete({
+            domain: ctx.subdomain._id,
+            productId: comment.productId,
+            entityType: comment.entityType,
+            entityId: comment.entityId,
+            type: "comment",
+        });
+        await refreshSubscriberForUser({
+            domain: ctx.subdomain._id,
+            productId: comment.productId,
+            entityType: comment.entityType,
+            entityId: comment.entityId,
+            userId: ctx.user.userId,
+        });
+    }
+
+    return comment;
+}
+
+export async function deleteDiscussionReply({
+    ctx,
+    replyId,
+}: {
+    ctx: GQLContext;
+    replyId: string;
+}) {
+    checkIfAuthenticated(ctx);
+
+    const reply = await ProductDiscussionReplyModel.findOne({
+        domain: ctx.subdomain._id,
+        replyId,
+    });
+    if (!reply) {
+        throw new Error(responses.item_not_found);
+    }
+    if (reply.userId !== ctx.user.userId) {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    await validateDiscussionTargetForLearner({
+        ctx,
+        productId: reply.productId,
+        entityType: reply.entityType,
+        entityId: reply.entityId,
+    });
+
+    if (!reply.deleted) {
+        reply.deleted = true;
+        reply.deletedAt = new Date();
+        reply.deletedBy = ctx.user.userId;
+        reply.deletedByRole = "author";
+        await reply.save();
+
+        await updateSummaryForSoftDelete({
+            domain: ctx.subdomain._id,
+            productId: reply.productId,
+            entityType: reply.entityType,
+            entityId: reply.entityId,
+            type: "reply",
+        });
+        await refreshSubscriberForUser({
+            domain: ctx.subdomain._id,
+            productId: reply.productId,
+            entityType: reply.entityType,
+            entityId: reply.entityId,
+            userId: ctx.user.userId,
+        });
+    }
+
+    return reply;
+}
+
+export async function listDiscussionReports({
+    ctx,
+    productId,
+    status,
+    page,
+    cursor,
+    limit = 10,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    status?: ProductDiscussionReportStatus;
+    page?: number;
+    cursor?: string;
+    limit?: number;
+}): Promise<CursorEnvelope<any>> {
+    await validateProductDiscussionAdmin({ ctx, productId });
+
+    const filter: Record<string, unknown> = {
+        domain: ctx.subdomain._id,
+        productId,
+    };
+    if (status) {
+        filter.status = status;
+    }
+
+    if (page) {
+        const currentPage = Math.max(1, page);
+        const reports = await ProductDiscussionReportModel.find(filter)
+            .sort({ createdAt: -1, reportId: -1 })
+            .skip((currentPage - 1) * limit)
+            .limit(limit);
+
+        return {
+            items: reports.map((report) => report.toObject()),
+            hasMore:
+                (await ProductDiscussionReportModel.countDocuments(filter)) >
+                currentPage * limit,
+        };
+    }
+
+    const decodedCursor = cursor ? decodeCursor<ReportCursor>(cursor) : null;
+    if (decodedCursor) {
+        filter.$or = [
+            { createdAt: { $lt: new Date(decodedCursor.createdAt) } },
+            {
+                createdAt: new Date(decodedCursor.createdAt),
+                reportId: { $lt: decodedCursor.reportId },
+            },
+        ];
+    }
+
+    const reports = await ProductDiscussionReportModel.find(filter)
+        .sort({ createdAt: -1, reportId: -1 })
+        .limit(limit + 1);
+    const visibleReports = reports.slice(0, limit);
+    const hasMore = reports.length > limit;
+    const lastItem = visibleReports[visibleReports.length - 1];
+
+    return {
+        items: visibleReports.map((report) => report.toObject()),
+        hasMore,
+        nextCursor:
+            hasMore && lastItem
+                ? encodeCursor({
+                      createdAt: lastItem.createdAt.toISOString(),
+                      reportId: lastItem.reportId,
+                  })
+                : undefined,
+    };
+}
+
+export async function getDiscussionReportsCount({
+    ctx,
+    productId,
+    status,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    status?: ProductDiscussionReportStatus;
+}) {
+    await validateProductDiscussionAdmin({ ctx, productId });
+
+    return await ProductDiscussionReportModel.countDocuments({
+        domain: ctx.subdomain._id,
+        productId,
+        ...(status ? { status } : {}),
+    });
+}
+
+export async function updateDiscussionReportStatus({
+    ctx,
+    productId,
+    reportId,
+    rejectionReason,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    reportId: string;
+    rejectionReason?: string;
+}) {
+    await validateProductDiscussionAdmin({ ctx, productId });
+
+    const report = await ProductDiscussionReportModel.findOne({
+        domain: ctx.subdomain._id,
+        productId,
+        reportId,
+    });
+    if (!report) {
+        throw new Error(responses.item_not_found);
+    }
+
+    const previousStatus = report.status;
+    const nextStatus = getNextReportStatus(report.status);
+
+    if (nextStatus === "rejected") {
+        if (!rejectionReason?.trim()) {
+            throw new Error(responses.invalid_input);
+        }
+        report.rejectionReason = rejectionReason.trim();
+    } else {
+        report.rejectionReason = "";
+    }
+    report.status = nextStatus;
+    await report.save();
+
+    if (nextStatus === "accepted" && previousStatus !== "accepted") {
+        await moderationSoftDelete({
+            ctx,
+            report,
+        });
+    }
+
+    if (previousStatus === "accepted" && nextStatus !== "accepted") {
+        const acceptedReportsCount =
+            await ProductDiscussionReportModel.countDocuments({
+                domain: ctx.subdomain._id,
+                contentType: report.contentType,
+                contentId: report.contentId,
+                status: "accepted",
+            });
+        if (acceptedReportsCount === 0) {
+            await moderationRestore({
+                ctx,
+                report,
+            });
+        }
+    }
+
+    return report;
+}
+
+export async function listDiscussionSummaries({
+    ctx,
+    productId,
+    preview = false,
+    cursor,
+    limit = 10,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    preview?: boolean;
+    cursor?: string;
+    limit?: number;
+}): Promise<CursorEnvelope<any>> {
+    checkIfAuthenticated(ctx);
+
+    const accessibleLessonIds = await getAccessibleDiscussionLessonIds({
+        ctx,
+        productId,
+        preview,
+    });
+
+    const filter: Record<string, unknown> = {
+        domain: ctx.subdomain._id,
+        productId,
+        entityType: "lesson",
+        activityCountIncludingDeleted: { $gt: 0 },
+    };
+    if (accessibleLessonIds) {
+        filter.entityId = { $in: accessibleLessonIds };
+    }
+
+    const decodedCursor = cursor ? decodeCursor<SummaryCursor>(cursor) : null;
+    if (decodedCursor) {
+        filter.$or = [
+            { lastActivityAt: { $lt: new Date(decodedCursor.lastActivityAt) } },
+            {
+                lastActivityAt: new Date(decodedCursor.lastActivityAt),
+                entityId: { $gt: decodedCursor.entityId },
+            },
+        ];
+    }
+
+    const summaries = await ProductDiscussionSummaryModel.find(filter)
+        .sort({ lastActivityAt: -1, entityId: 1 })
+        .limit(limit + 1);
+    const visibleSummaries = summaries.slice(0, limit);
+    const hasMore = summaries.length > limit;
+    const lastItem = visibleSummaries[visibleSummaries.length - 1];
+
+    return {
+        items: visibleSummaries.map((summary) => summary.toObject()),
+        hasMore,
+        nextCursor:
+            hasMore && lastItem
+                ? encodeCursor({
+                      lastActivityAt: lastItem.lastActivityAt.toISOString(),
+                      entityId: lastItem.entityId,
+                  })
+                : undefined,
+    };
+}
+
+function getDiscussionSubjectId({
+    productId,
+    entityType,
+    entityId,
+}: {
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+}) {
+    return `${productId}:${entityType}:${entityId}`;
+}
+
+function assertLessonDiscussionTarget(entityType: ProductDiscussionEntityType) {
+    if (entityType !== "lesson") {
+        throw new Error(responses.action_not_allowed);
+    }
+}
+
+async function getDiscussionContentTarget({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    contentType,
+    contentId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+}) {
+    const target =
+        contentType === "comment"
+            ? await ProductDiscussionCommentModel.findOne({
+                  domain,
+                  productId,
+                  entityType,
+                  entityId,
+                  commentId: contentId,
+              })
+            : await ProductDiscussionReplyModel.findOne({
+                  domain,
+                  productId,
+                  entityType,
+                  entityId,
+                  replyId: contentId,
+              });
+
+    if (!target || target.deleted) {
+        throw new Error(responses.item_not_found);
+    }
+
+    return target;
+}
+
+async function getDiscussionContentTargetForModeration({
+    domain,
+    contentType,
+    contentId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+}) {
+    const target =
+        contentType === "comment"
+            ? await ProductDiscussionCommentModel.findOne({
+                  domain,
+                  commentId: contentId,
+              })
+            : await ProductDiscussionReplyModel.findOne({
+                  domain,
+                  replyId: contentId,
+              });
+
+    if (!target) {
+        throw new Error(responses.item_not_found);
+    }
+
+    return target;
+}
+
+async function incrementLikesCount({
+    contentType,
+    contentId,
+    delta,
+}: {
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+    delta: 1 | -1;
+}) {
+    if (contentType === "comment") {
+        await ProductDiscussionCommentModel.updateOne(
+            { commentId: contentId },
+            { $inc: { likesCount: delta } },
+        );
+    } else {
+        await ProductDiscussionReplyModel.updateOne(
+            { replyId: contentId },
+            { $inc: { likesCount: delta } },
+        );
+    }
+}
+
+function getContentFingerprint(content: TextEditorContent) {
+    return Buffer.from(
+        extractTextFromTextEditorContent(content).trim().toLowerCase(),
+    ).toString("base64");
+}
+
+async function updateSummaryForCreate({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    commentId,
+    replyId,
+    createdAt,
+    type,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    commentId?: string;
+    replyId?: string;
+    createdAt: Date;
+    type: "comment" | "reply";
+}) {
+    await ProductDiscussionSummaryModel.updateOne(
+        { domain, productId, entityType, entityId },
+        {
+            $setOnInsert: {
+                domain,
+                productId,
+                entityType,
+                entityId,
+            },
+            $set: {
+                lastActivityAt: createdAt,
+                ...(commentId ? { lastCommentId: commentId } : {}),
+                ...(replyId ? { lastReplyId: replyId } : {}),
+            },
+            $inc: {
+                commentsCount: type === "comment" ? 1 : 0,
+                repliesCount: type === "reply" ? 1 : 0,
+                totalCount: 1,
+                activityCountIncludingDeleted: 1,
+            },
+        },
+        { upsert: true },
+    );
+}
+
+async function upsertSubscriber({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    userId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    userId: string;
+}) {
+    await ProductDiscussionSubscriberModel.updateOne(
+        { domain, productId, entityType, entityId, userId },
+        {
+            $setOnInsert: {
+                domain,
+                productId,
+                entityType,
+                entityId,
+                userId,
+            },
+            $set: { subscription: true },
+        },
+        { upsert: true },
+    );
+}
+
+async function updateSummaryForSoftDelete({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    type,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    type: "comment" | "reply";
+}) {
+    await ProductDiscussionSummaryModel.updateOne(
+        { domain, productId, entityType, entityId },
+        {
+            $inc: {
+                commentsCount: type === "comment" ? -1 : 0,
+                repliesCount: type === "reply" ? -1 : 0,
+                totalCount: -1,
+            },
+        },
+    );
+}
+
+async function updateSummaryForRestore({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    type,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    type: "comment" | "reply";
+}) {
+    await ProductDiscussionSummaryModel.updateOne(
+        { domain, productId, entityType, entityId },
+        {
+            $inc: {
+                commentsCount: type === "comment" ? 1 : 0,
+                repliesCount: type === "reply" ? 1 : 0,
+                totalCount: 1,
+            },
+        },
+    );
+}
+
+async function refreshSubscriberForUser({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    userId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    userId: string;
+}) {
+    const [commentsCount, repliesCount] = await Promise.all([
+        ProductDiscussionCommentModel.countDocuments({
+            domain,
+            productId,
+            entityType,
+            entityId,
+            userId,
+            deleted: false,
+        }),
+        ProductDiscussionReplyModel.countDocuments({
+            domain,
+            productId,
+            entityType,
+            entityId,
+            userId,
+            deleted: false,
+        }),
+    ]);
+
+    await ProductDiscussionSubscriberModel.updateOne(
+        { domain, productId, entityType, entityId, userId },
+        { $set: { subscription: commentsCount + repliesCount > 0 } },
+    );
+}
+
+async function recordDiscussionActivity({
+    ctx,
+    product,
+    productId,
+    entityType,
+    entityId,
+    eventType,
+    commentId,
+    replyId,
+}: {
+    ctx: GQLContext;
+    product: { creatorId: string };
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    eventType: "comment_created" | "reply_created" | "reacted";
+    commentId: string;
+    replyId?: string;
+}) {
+    const forUserIds = await getDiscussionNotificationRecipients({
+        domain: ctx.subdomain._id,
+        productId,
+        entityType,
+        entityId,
+        actorUserId: ctx.user.userId,
+        productCreatorId: product.creatorId,
+    });
+
+    await recordActivity({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        type: Constants.ActivityType.COURSE_DISCUSSION_COMMENT_CREATED,
+        entityId: replyId || commentId,
+        metadata: {
+            eventType,
+            courseId: productId,
+            entityType,
+            entityId,
+            commentId,
+            replyId,
+            forUserIds,
+        },
+    });
+}
+
+async function getDiscussionNotificationRecipients({
+    domain,
+    productId,
+    entityType,
+    entityId,
+    actorUserId,
+    productCreatorId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+    actorUserId: string;
+    productCreatorId: string;
+}) {
+    const [subscribers, productAdmins] = await Promise.all([
+        ProductDiscussionSubscriberModel.find({
+            domain,
+            productId,
+            entityType,
+            entityId,
+            subscription: true,
+        }).lean(),
+        UserModel.find(
+            {
+                domain,
+                active: true,
+                $or: [
+                    { permissions: permissions.manageAnyCourse },
+                    {
+                        userId: productCreatorId,
+                        permissions: permissions.manageCourse,
+                    },
+                ],
+            },
+            { userId: 1 },
+        ).lean(),
+    ]);
+
+    const recipientIds = new Set<string>();
+    for (const subscriber of subscribers) {
+        recipientIds.add(subscriber.userId);
+    }
+    for (const admin of productAdmins) {
+        recipientIds.add(admin.userId);
+    }
+    recipientIds.delete(actorUserId);
+
+    return Array.from(recipientIds);
+}
+
+async function validateProductDiscussionAdmin({
+    ctx,
+    productId,
+}: {
+    ctx: GQLContext;
+    productId: string;
+}) {
+    checkIfAuthenticated(ctx);
+
+    const product = await CourseModel.findOne({
+        domain: ctx.subdomain._id,
+        courseId: productId,
+    });
+
+    if (!product) {
+        throw new Error(responses.item_not_found);
+    }
+
+    const canManageAny = checkPermission(ctx.user.permissions, [
+        permissions.manageAnyCourse,
+    ]);
+    const canManageOwn =
+        product.creatorId === ctx.user.userId &&
+        checkPermission(ctx.user.permissions, [permissions.manageCourse]);
+
+    if (!canManageAny && !canManageOwn) {
+        throw new Error(responses.action_not_allowed);
+    }
+
+    return product;
+}
+
+async function getAccessibleDiscussionLessonIds({
+    ctx,
+    productId,
+    preview = false,
+}: {
+    ctx: GQLContext;
+    productId: string;
+    preview?: boolean;
+}) {
+    const product = await CourseModel.findOne({
+        domain: ctx.subdomain._id,
+        courseId: productId,
+        type: Constants.CourseType.COURSE,
+    });
+
+    if (!product || !product.discussions) {
+        throw new Error(responses.item_not_found);
+    }
+
+    const isManager = canManageCourseInContext(product, ctx);
+    const isPreview = preview && isManager;
+    if (!product.published && !isPreview) {
+        throw new Error(responses.item_not_found);
+    }
+
+    const lessons = await LessonModel.find({
+        domain: ctx.subdomain._id,
+        courseId: productId,
+        ...(isPreview ? {} : { published: true }),
+    }).lean<
+        {
+            lessonId: string;
+            groupId: string;
+            requiresEnrollment: boolean;
+        }[]
+    >();
+
+    if (isManager) {
+        return lessons.map((lesson) => lesson.lessonId);
+    }
+
+    const progress = getProductProgress(ctx, productId);
+    if (!progress) {
+        return [];
+    }
+    const accessibleGroups = new Set(progress?.accessibleGroups || []);
+
+    const dripLockedGroupIds = new Set<string>();
+    if (product && Array.isArray(product.groups)) {
+        for (const group of product.groups) {
+            const groupId = String(group.id);
+            if (group.drip?.status && !accessibleGroups.has(groupId)) {
+                dripLockedGroupIds.add(groupId);
+            }
+        }
+    }
+
+    return lessons
+        .filter((lesson) => {
+            if (dripLockedGroupIds.has(lesson.groupId)) {
+                return false;
+            }
+            return true;
+        })
+        .map((lesson) => lesson.lessonId);
+}
+
+function getProductProgress(ctx: GQLContext, productId: string) {
+    return ctx.user?.purchases?.find(
+        (purchase: any) => purchase.courseId === productId,
+    );
+}
+
+function isEnrolledInProduct(ctx: GQLContext, productId: string) {
+    return Boolean(getProductProgress(ctx, productId));
+}
+
+function getNextReportStatus(
+    status: ProductDiscussionReportStatus,
+): ProductDiscussionReportStatus {
+    if (status === "pending") {
+        return "accepted";
+    }
+    if (status === "accepted") {
+        return "rejected";
+    }
+    return "pending";
+}
+
+async function moderationSoftDelete({
+    ctx,
+    report,
+}: {
+    ctx: GQLContext;
+    report: any;
+}) {
+    const target = await getDiscussionContentTargetForModeration({
+        domain: ctx.subdomain._id,
+        contentType: report.contentType,
+        contentId: report.contentId,
+    });
+
+    if (target.deleted) {
+        return;
+    }
+
+    target.deleted = true;
+    target.deletedAt = new Date();
+    target.deletedBy = ctx.user.userId;
+    target.deletedByRole = "course_admin";
+    target.deleteReason = report.reason;
+    await target.save();
+
+    await updateSummaryForSoftDelete({
+        domain: ctx.subdomain._id,
+        productId: target.productId,
+        entityType: target.entityType,
+        entityId: target.entityId,
+        type: report.contentType,
+    });
+    await refreshSubscriberForUser({
+        domain: ctx.subdomain._id,
+        productId: target.productId,
+        entityType: target.entityType,
+        entityId: target.entityId,
+        userId: target.userId,
+    });
+}
+
+async function moderationRestore({
+    ctx,
+    report,
+}: {
+    ctx: GQLContext;
+    report: any;
+}) {
+    const target = await getDiscussionContentTargetForModeration({
+        domain: ctx.subdomain._id,
+        contentType: report.contentType,
+        contentId: report.contentId,
+    });
+
+    if (!target.deleted || target.deletedByRole !== "course_admin") {
+        return;
+    }
+
+    target.deleted = false;
+    target.restoredAt = new Date();
+    target.restoredBy = ctx.user.userId;
+    await target.save();
+
+    await updateSummaryForRestore({
+        domain: ctx.subdomain._id,
+        productId: target.productId,
+        entityType: target.entityType,
+        entityId: target.entityId,
+        type: report.contentType,
+    });
+    await refreshSubscriberForUser({
+        domain: ctx.subdomain._id,
+        productId: target.productId,
+        entityType: target.entityType,
+        entityId: target.entityId,
+        userId: target.userId,
+    });
+}
+
+function encodeCursor(
+    cursor: CommentCursor | ReplyCursor | ReportCursor | SummaryCursor,
+) {
+    return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64");
+}
+
+function decodeCursor<T>(cursor: string): T {
+    try {
+        return JSON.parse(Buffer.from(cursor, "base64").toString("utf8"));
+    } catch {
+        throw new Error(responses.invalid_input);
+    }
+}
diff --git a/apps/web/graphql/product-discussions/mutation.ts b/apps/web/graphql/product-discussions/mutation.ts
new file mode 100644
index 000000000..8d60f8405
--- /dev/null
+++ b/apps/web/graphql/product-discussions/mutation.ts
@@ -0,0 +1,216 @@
+import GQLContext from "@models/GQLContext";
+import { GraphQLBoolean, GraphQLNonNull, GraphQLString } from "graphql";
+import { GraphQLJSONObject } from "graphql-type-json";
+import {
+    createDiscussionComment,
+    createDiscussionReply,
+    createDiscussionReport,
+    deleteDiscussionComment,
+    deleteDiscussionReply,
+    ProductDiscussionContentType,
+    ProductDiscussionEntityType,
+    toggleDiscussionLike,
+    updateDiscussionReportStatus,
+} from "./logic";
+import types from "./types";
+
+const targetArgs = {
+    productId: { type: new GraphQLNonNull(GraphQLString) },
+    entityType: { type: new GraphQLNonNull(types.productDiscussionEntityType) },
+    entityId: { type: new GraphQLNonNull(GraphQLString) },
+};
+
+const mutations = {
+    createProductDiscussionComment: {
+        type: types.productDiscussionComment,
+        args: {
+            ...targetArgs,
+            content: { type: new GraphQLNonNull(GraphQLJSONObject) },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                entityType,
+                entityId,
+                content,
+            }: {
+                productId: string;
+                entityType: ProductDiscussionEntityType;
+                entityId: string;
+                content: unknown;
+            },
+            ctx: GQLContext,
+        ) =>
+            createDiscussionComment({
+                ctx,
+                productId,
+                entityType,
+                entityId,
+                content,
+            }),
+    },
+    createProductDiscussionReply: {
+        type: types.productDiscussionReply,
+        args: {
+            ...targetArgs,
+            commentId: { type: new GraphQLNonNull(GraphQLString) },
+            parentReplyId: { type: GraphQLString },
+            content: { type: new GraphQLNonNull(GraphQLJSONObject) },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                entityType,
+                entityId,
+                commentId,
+                parentReplyId,
+                content,
+            }: {
+                productId: string;
+                entityType: ProductDiscussionEntityType;
+                entityId: string;
+                commentId: string;
+                parentReplyId?: string;
+                content: unknown;
+            },
+            ctx: GQLContext,
+        ) =>
+            createDiscussionReply({
+                ctx,
+                productId,
+                entityType,
+                entityId,
+                commentId,
+                parentReplyId,
+                content,
+            }),
+    },
+    toggleProductDiscussionLike: {
+        type: types.productDiscussionLikeResult,
+        args: {
+            ...targetArgs,
+            contentType: {
+                type: new GraphQLNonNull(types.productDiscussionContentType),
+            },
+            contentId: { type: new GraphQLNonNull(GraphQLString) },
+            liked: { type: new GraphQLNonNull(GraphQLBoolean) },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                entityType,
+                entityId,
+                contentType,
+                contentId,
+                liked,
+            }: {
+                productId: string;
+                entityType: ProductDiscussionEntityType;
+                entityId: string;
+                contentType: ProductDiscussionContentType;
+                contentId: string;
+                liked: boolean;
+            },
+            ctx: GQLContext,
+        ) =>
+            toggleDiscussionLike({
+                ctx,
+                productId,
+                entityType,
+                entityId,
+                contentType,
+                contentId,
+                liked,
+            }),
+    },
+    createProductDiscussionReport: {
+        type: types.productDiscussionReport,
+        args: {
+            ...targetArgs,
+            contentType: {
+                type: new GraphQLNonNull(types.productDiscussionContentType),
+            },
+            contentId: { type: new GraphQLNonNull(GraphQLString) },
+            reason: { type: new GraphQLNonNull(GraphQLString) },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                entityType,
+                entityId,
+                contentType,
+                contentId,
+                reason,
+            }: {
+                productId: string;
+                entityType: ProductDiscussionEntityType;
+                entityId: string;
+                contentType: ProductDiscussionContentType;
+                contentId: string;
+                reason: string;
+            },
+            ctx: GQLContext,
+        ) =>
+            createDiscussionReport({
+                ctx,
+                productId,
+                entityType,
+                entityId,
+                contentType,
+                contentId,
+                reason,
+            }),
+    },
+    deleteProductDiscussionComment: {
+        type: types.productDiscussionComment,
+        args: {
+            commentId: { type: new GraphQLNonNull(GraphQLString) },
+        },
+        resolve: (
+            _: any,
+            { commentId }: { commentId: string },
+            ctx: GQLContext,
+        ) => deleteDiscussionComment({ ctx, commentId }),
+    },
+    deleteProductDiscussionReply: {
+        type: types.productDiscussionReply,
+        args: {
+            replyId: { type: new GraphQLNonNull(GraphQLString) },
+        },
+        resolve: (_: any, { replyId }: { replyId: string }, ctx: GQLContext) =>
+            deleteDiscussionReply({ ctx, replyId }),
+    },
+    updateProductDiscussionReportStatus: {
+        type: types.productDiscussionReport,
+        args: {
+            productId: { type: new GraphQLNonNull(GraphQLString) },
+            reportId: { type: new GraphQLNonNull(GraphQLString) },
+            rejectionReason: { type: GraphQLString },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                reportId,
+                rejectionReason,
+            }: {
+                productId: string;
+                reportId: string;
+                rejectionReason?: string;
+            },
+            ctx: GQLContext,
+        ) =>
+            updateDiscussionReportStatus({
+                ctx,
+                productId,
+                reportId,
+                rejectionReason,
+            }),
+    },
+};
+
+export default mutations;
diff --git a/apps/web/graphql/product-discussions/query.ts b/apps/web/graphql/product-discussions/query.ts
new file mode 100644
index 000000000..469f0480c
--- /dev/null
+++ b/apps/web/graphql/product-discussions/query.ts
@@ -0,0 +1,184 @@
+import GQLContext from "@models/GQLContext";
+import {
+    GraphQLBoolean,
+    GraphQLInt,
+    GraphQLNonNull,
+    GraphQLString,
+} from "graphql";
+import {
+    getDiscussionReportsCount,
+    listDiscussionComments,
+    listDiscussionReports,
+    listDiscussionReplies,
+    ProductDiscussionContentType,
+    listDiscussionSummaries,
+    ProductDiscussionEntityType,
+} from "./logic";
+import types from "./types";
+
+const queries = {
+    getProductDiscussionComments: {
+        type: types.productDiscussionCommentsConnection,
+        args: {
+            productId: { type: new GraphQLNonNull(GraphQLString) },
+            entityType: {
+                type: new GraphQLNonNull(types.productDiscussionEntityType),
+            },
+            entityId: { type: new GraphQLNonNull(GraphQLString) },
+            cursor: { type: GraphQLString },
+            limit: { type: GraphQLInt },
+            replyPreviewLimit: { type: GraphQLInt },
+            targetContentType: {
+                type: types.productDiscussionContentType,
+            },
+            targetContentId: { type: GraphQLString },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                entityType,
+                entityId,
+                cursor,
+                limit,
+                replyPreviewLimit,
+                targetContentType,
+                targetContentId,
+            }: {
+                productId: string;
+                entityType: ProductDiscussionEntityType;
+                entityId: string;
+                cursor?: string;
+                limit?: number;
+                replyPreviewLimit?: number;
+                targetContentType?: ProductDiscussionContentType;
+                targetContentId?: string;
+            },
+            ctx: GQLContext,
+        ) =>
+            listDiscussionComments({
+                ctx,
+                productId,
+                entityType,
+                entityId,
+                targetContentType,
+                targetContentId,
+                cursor,
+                limit,
+                replyPreviewLimit,
+            }),
+    },
+    getProductDiscussionReplies: {
+        type: types.productDiscussionRepliesConnection,
+        args: {
+            commentId: { type: new GraphQLNonNull(GraphQLString) },
+            cursor: { type: GraphQLString },
+            limit: { type: GraphQLInt },
+        },
+        resolve: (
+            _: any,
+            {
+                commentId,
+                cursor,
+                limit,
+            }: {
+                commentId: string;
+                cursor?: string;
+                limit?: number;
+            },
+            ctx: GQLContext,
+        ) =>
+            listDiscussionReplies({
+                ctx,
+                commentId,
+                cursor,
+                limit,
+            }),
+    },
+    getProductDiscussionReports: {
+        type: types.productDiscussionReportsConnection,
+        args: {
+            productId: { type: new GraphQLNonNull(GraphQLString) },
+            status: { type: types.productDiscussionReportStatusType },
+            page: { type: GraphQLInt },
+            cursor: { type: GraphQLString },
+            limit: { type: GraphQLInt },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                status,
+                page,
+                cursor,
+                limit,
+            }: {
+                productId: string;
+                status?: "pending" | "accepted" | "rejected";
+                page?: number;
+                cursor?: string;
+                limit?: number;
+            },
+            ctx: GQLContext,
+        ) =>
+            listDiscussionReports({
+                ctx,
+                productId,
+                status,
+                page,
+                cursor,
+                limit,
+            }),
+    },
+    getProductDiscussionSummaries: {
+        type: types.productDiscussionSummariesConnection,
+        args: {
+            productId: { type: new GraphQLNonNull(GraphQLString) },
+            preview: { type: GraphQLBoolean },
+            cursor: { type: GraphQLString },
+            limit: { type: GraphQLInt },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                preview,
+                cursor,
+                limit,
+            }: {
+                productId: string;
+                preview?: boolean;
+                cursor?: string;
+                limit?: number;
+            },
+            ctx: GQLContext,
+        ) =>
+            listDiscussionSummaries({
+                ctx,
+                productId,
+                preview,
+                cursor,
+                limit,
+            }),
+    },
+    getProductDiscussionReportsCount: {
+        type: GraphQLInt,
+        args: {
+            productId: { type: new GraphQLNonNull(GraphQLString) },
+            status: { type: types.productDiscussionReportStatusType },
+        },
+        resolve: (
+            _: any,
+            {
+                productId,
+                status,
+            }: {
+                productId: string;
+                status?: "pending" | "accepted" | "rejected";
+            },
+            ctx: GQLContext,
+        ) => getDiscussionReportsCount({ ctx, productId, status }),
+    },
+};
+
+export default queries;
diff --git a/apps/web/graphql/product-discussions/types.ts b/apps/web/graphql/product-discussions/types.ts
new file mode 100644
index 000000000..4b8287ce7
--- /dev/null
+++ b/apps/web/graphql/product-discussions/types.ts
@@ -0,0 +1,358 @@
+import {
+    GraphQLBoolean,
+    GraphQLEnumType,
+    GraphQLInt,
+    GraphQLList,
+    GraphQLNonNull,
+    GraphQLObjectType,
+    GraphQLString,
+} from "graphql";
+import { GraphQLJSONObject } from "graphql-type-json";
+import LessonModel from "@/models/Lesson";
+import ProductDiscussionCommentModel from "@/models/ProductDiscussionComment";
+import ProductDiscussionLikeModel from "@/models/ProductDiscussionLike";
+import ProductDiscussionReplyModel from "@/models/ProductDiscussionReply";
+import UserModel from "@/models/User";
+import userTypes from "../users/types";
+import { extractTextFromTextEditorContent } from "@courselit/utils";
+
+const productDiscussionEntityType = new GraphQLEnumType({
+    name: "ProductDiscussionEntityType",
+    values: {
+        LESSON: { value: "lesson" },
+        PRODUCT: { value: "product" },
+    },
+});
+
+const productDiscussionContentType = new GraphQLEnumType({
+    name: "ProductDiscussionContentType",
+    values: {
+        COMMENT: { value: "comment" },
+        REPLY: { value: "reply" },
+    },
+});
+
+const productDiscussionReportStatusType = new GraphQLEnumType({
+    name: "ProductDiscussionReportStatus",
+    values: {
+        PENDING: { value: "pending" },
+        ACCEPTED: { value: "accepted" },
+        REJECTED: { value: "rejected" },
+    },
+});
+
+const productDiscussionReply = new GraphQLObjectType({
+    name: "ProductDiscussionReply",
+    fields: {
+        productId: { type: new GraphQLNonNull(GraphQLString) },
+        entityType: { type: new GraphQLNonNull(productDiscussionEntityType) },
+        entityId: { type: new GraphQLNonNull(GraphQLString) },
+        commentId: { type: new GraphQLNonNull(GraphQLString) },
+        replyId: { type: new GraphQLNonNull(GraphQLString) },
+        parentReplyId: { type: GraphQLString },
+        userId: { type: new GraphQLNonNull(GraphQLString) },
+        content: { type: GraphQLJSONObject },
+        likesCount: { type: new GraphQLNonNull(GraphQLInt) },
+        hasLiked: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            resolve: async (reply, _, ctx) => {
+                if (typeof reply.hasLiked === "boolean") {
+                    return reply.hasLiked;
+                }
+                if (!ctx.user || !ctx.user.userId) {
+                    return false;
+                }
+                const like = await ProductDiscussionLikeModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: ctx.user.userId,
+                    contentId: reply.replyId,
+                });
+                return !!like;
+            },
+        },
+        deleted: { type: new GraphQLNonNull(GraphQLBoolean) },
+        createdAt: {
+            type: new GraphQLNonNull(GraphQLString),
+            resolve: (reply) =>
+                reply.createdAt instanceof Date
+                    ? reply.createdAt.toISOString()
+                    : new Date(reply.createdAt).toISOString(),
+        },
+        updatedAt: {
+            type: GraphQLString,
+            resolve: (reply) =>
+                reply.updatedAt
+                    ? reply.updatedAt instanceof Date
+                        ? reply.updatedAt.toISOString()
+                        : new Date(reply.updatedAt).toISOString()
+                    : null,
+        },
+        user: {
+            type: userTypes.userType,
+            resolve: async (reply, _, ctx) => {
+                return await UserModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: reply.userId,
+                });
+            },
+        },
+    },
+});
+
+const productDiscussionComment = new GraphQLObjectType({
+    name: "ProductDiscussionComment",
+    fields: {
+        productId: { type: new GraphQLNonNull(GraphQLString) },
+        entityType: { type: new GraphQLNonNull(productDiscussionEntityType) },
+        entityId: { type: new GraphQLNonNull(GraphQLString) },
+        commentId: { type: new GraphQLNonNull(GraphQLString) },
+        userId: { type: new GraphQLNonNull(GraphQLString) },
+        content: { type: GraphQLJSONObject },
+        likesCount: { type: new GraphQLNonNull(GraphQLInt) },
+        hasLiked: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            resolve: async (comment, _, ctx) => {
+                if (typeof comment.hasLiked === "boolean") {
+                    return comment.hasLiked;
+                }
+                if (!ctx.user || !ctx.user.userId) {
+                    return false;
+                }
+                const like = await ProductDiscussionLikeModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: ctx.user.userId,
+                    contentId: comment.commentId,
+                });
+                return !!like;
+            },
+        },
+        replyCount: {
+            type: new GraphQLNonNull(GraphQLInt),
+            resolve: async (comment, _, ctx) => {
+                if (typeof comment.replyCount === "number") {
+                    return comment.replyCount;
+                }
+                return await ProductDiscussionReplyModel.countDocuments({
+                    domain: ctx.subdomain._id,
+                    commentId: comment.commentId,
+                });
+            },
+        },
+        replyNextCursor: { type: GraphQLString },
+        hasMoreReplies: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            resolve: (comment) => Boolean(comment.hasMoreReplies),
+        },
+        replies: {
+            type: new GraphQLList(productDiscussionReply),
+            resolve: async (comment, _, ctx) => {
+                if (comment.replies) {
+                    return comment.replies;
+                }
+                return await ProductDiscussionReplyModel.find({
+                    domain: ctx.subdomain._id,
+                    commentId: comment.commentId,
+                })
+                    .sort({ createdAt: 1, replyId: 1 })
+                    .limit(2);
+            },
+        },
+        deleted: { type: new GraphQLNonNull(GraphQLBoolean) },
+        createdAt: {
+            type: new GraphQLNonNull(GraphQLString),
+            resolve: (comment) =>
+                comment.createdAt instanceof Date
+                    ? comment.createdAt.toISOString()
+                    : new Date(comment.createdAt).toISOString(),
+        },
+        updatedAt: {
+            type: GraphQLString,
+            resolve: (comment) =>
+                comment.updatedAt
+                    ? comment.updatedAt instanceof Date
+                        ? comment.updatedAt.toISOString()
+                        : new Date(comment.updatedAt).toISOString()
+                    : null,
+        },
+        user: {
+            type: userTypes.userType,
+            resolve: async (comment, _, ctx) => {
+                return await UserModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: comment.userId,
+                });
+            },
+        },
+    },
+});
+
+const productDiscussionCommentsConnection = new GraphQLObjectType({
+    name: "ProductDiscussionCommentsConnection",
+    fields: {
+        items: { type: new GraphQLList(productDiscussionComment) },
+        nextCursor: { type: GraphQLString },
+        hasMore: { type: new GraphQLNonNull(GraphQLBoolean) },
+    },
+});
+
+const productDiscussionRepliesConnection = new GraphQLObjectType({
+    name: "ProductDiscussionRepliesConnection",
+    fields: {
+        items: { type: new GraphQLList(productDiscussionReply) },
+        nextCursor: { type: GraphQLString },
+        hasMore: { type: new GraphQLNonNull(GraphQLBoolean) },
+    },
+});
+
+const productDiscussionLikeResult = new GraphQLObjectType({
+    name: "ProductDiscussionLikeResult",
+    fields: {
+        contentType: { type: new GraphQLNonNull(productDiscussionContentType) },
+        contentId: { type: new GraphQLNonNull(GraphQLString) },
+        likesCount: { type: new GraphQLNonNull(GraphQLInt) },
+        hasLiked: { type: new GraphQLNonNull(GraphQLBoolean) },
+    },
+});
+
+const productDiscussionSummary = new GraphQLObjectType({
+    name: "ProductDiscussionSummary",
+    fields: {
+        productId: { type: new GraphQLNonNull(GraphQLString) },
+        entityType: { type: new GraphQLNonNull(productDiscussionEntityType) },
+        entityId: { type: new GraphQLNonNull(GraphQLString) },
+        commentsCount: { type: new GraphQLNonNull(GraphQLInt) },
+        repliesCount: { type: new GraphQLNonNull(GraphQLInt) },
+        totalCount: { type: new GraphQLNonNull(GraphQLInt) },
+        activityCountIncludingDeleted: {
+            type: new GraphQLNonNull(GraphQLInt),
+        },
+        lastActivityAt: { type: new GraphQLNonNull(GraphQLString) },
+        lastCommentId: { type: GraphQLString },
+        lastReplyId: { type: GraphQLString },
+    },
+});
+
+const productDiscussionSummariesConnection = new GraphQLObjectType({
+    name: "ProductDiscussionSummariesConnection",
+    fields: {
+        items: { type: new GraphQLList(productDiscussionSummary) },
+        nextCursor: { type: GraphQLString },
+        hasMore: { type: new GraphQLNonNull(GraphQLBoolean) },
+    },
+});
+
+const productDiscussionReport = new GraphQLObjectType({
+    name: "ProductDiscussionReport",
+    fields: {
+        productId: { type: new GraphQLNonNull(GraphQLString) },
+        entityType: { type: new GraphQLNonNull(productDiscussionEntityType) },
+        entityId: { type: new GraphQLNonNull(GraphQLString) },
+        reportId: { type: new GraphQLNonNull(GraphQLString) },
+        contentType: { type: new GraphQLNonNull(productDiscussionContentType) },
+        contentId: { type: new GraphQLNonNull(GraphQLString) },
+        commentId: { type: GraphQLString },
+        userId: { type: new GraphQLNonNull(GraphQLString) },
+        reason: { type: new GraphQLNonNull(GraphQLString) },
+        status: { type: new GraphQLNonNull(GraphQLString) },
+        rejectionReason: { type: GraphQLString },
+        createdAt: {
+            type: new GraphQLNonNull(GraphQLString),
+            resolve: (report) =>
+                report.createdAt instanceof Date
+                    ? report.createdAt.toISOString()
+                    : new Date(report.createdAt).toISOString(),
+        },
+        updatedAt: {
+            type: GraphQLString,
+            resolve: (report) =>
+                report.updatedAt
+                    ? report.updatedAt instanceof Date
+                        ? report.updatedAt.toISOString()
+                        : new Date(report.updatedAt).toISOString()
+                    : null,
+        },
+        lessonTitle: {
+            type: GraphQLString,
+            resolve: async (report, _, ctx) => {
+                if (report.entityType !== "lesson") return null;
+                const lesson = await LessonModel.findOne({
+                    domain: ctx.subdomain._id,
+                    lessonId: report.entityId,
+                });
+                return lesson ? lesson.title : null;
+            },
+        },
+        contentPreview: {
+            type: GraphQLString,
+            resolve: async (report, _, ctx) => {
+                const item =
+                    report.contentType === "comment"
+                        ? await ProductDiscussionCommentModel.findOne({
+                              domain: ctx.subdomain._id,
+                              commentId: report.contentId,
+                          })
+                        : await ProductDiscussionReplyModel.findOne({
+                              domain: ctx.subdomain._id,
+                              replyId: report.contentId,
+                          });
+                if (!item) return null;
+                return extractTextFromTextEditorContent(item.content);
+            },
+        },
+        authorName: {
+            type: GraphQLString,
+            resolve: async (report, _, ctx) => {
+                const item =
+                    report.contentType === "comment"
+                        ? await ProductDiscussionCommentModel.findOne({
+                              domain: ctx.subdomain._id,
+                              commentId: report.contentId,
+                          })
+                        : await ProductDiscussionReplyModel.findOne({
+                              domain: ctx.subdomain._id,
+                              replyId: report.contentId,
+                          });
+                if (!item) return null;
+                const user = await UserModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: item.userId,
+                });
+                return user ? user.name || user.email : item.userId;
+            },
+        },
+        reporterName: {
+            type: GraphQLString,
+            resolve: async (report, _, ctx) => {
+                const user = await UserModel.findOne({
+                    domain: ctx.subdomain._id,
+                    userId: report.userId,
+                });
+                return user ? user.name || user.email : report.userId;
+            },
+        },
+    },
+});
+
+const productDiscussionReportsConnection = new GraphQLObjectType({
+    name: "ProductDiscussionReportsConnection",
+    fields: {
+        items: { type: new GraphQLList(productDiscussionReport) },
+        nextCursor: { type: GraphQLString },
+        hasMore: { type: new GraphQLNonNull(GraphQLBoolean) },
+    },
+});
+
+export default {
+    productDiscussionEntityType,
+    productDiscussionContentType,
+    productDiscussionReportStatusType,
+    productDiscussionComment,
+    productDiscussionReply,
+    productDiscussionCommentsConnection,
+    productDiscussionRepliesConnection,
+    productDiscussionLikeResult,
+    productDiscussionSummary,
+    productDiscussionSummariesConnection,
+    productDiscussionReport,
+    productDiscussionReportsConnection,
+};
diff --git a/apps/web/graphql/users/__tests__/ARCHITECTURE.md b/apps/web/graphql/users/__tests__/ARCHITECTURE.md
deleted file mode 100644
index d34eac73f..000000000
--- a/apps/web/graphql/users/__tests__/ARCHITECTURE.md
+++ /dev/null
@@ -1,195 +0,0 @@
-# User Deletion Architecture
-
-This document provides a quick overview of how user deletion is implemented.
-
-## Function Structure
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│              deleteUser(userId, ctx) [logic.ts]              │
-│                   Main Orchestrator Function                 │
-│                         (45 lines)                           │
-└─────────────────────────────────────────────────────────────┘
-                              │
-                              ├─────────────────────────────────┐
-                              │                                 │
-                              ▼                                 ▼
-┌──────────────────────────────────────┐    ┌──────────────────────────────────────┐
-│   PHASE 1: AUTHORIZATION & VALIDATION │    │  validateUserDeletion() [helpers.ts] │
-│   • checkIfAuthenticated()            │    │  • Check critical permissions        │
-│   • Check manageUsers permission      │───▶│  • Ensure system won't be locked     │
-│   • Verify user exists                │    │  • Prevent last admin deletion       │
-│   • Prevent self-deletion             │    │                                      │
-└──────────────────────────────────────┘    └──────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────┐
-│         PHASE 2: MIGRATE BUSINESS ENTITIES                   │
-│   migrateBusinessEntities(userToDelete, deleterUser)         │
-│                      [helpers.ts]                            │
-│                         (175 lines)                          │
-└─────────────────────────────────────────────────────────────┘
-                              │
-        ┌─────────────────────┼─────────────────────┬──────────────────────┐
-        │                     │                     │                      │
-        ▼                     ▼                     ▼                      ▼
-┌───────────────┐   ┌──────────────────┐   ┌──────────────┐   ┌────────────────────┐
-│ Course        │   │ Business Entity  │   │ Lesson       │   │ Community          │
-│ Ownership     │   │ Ownership        │   │ Ownership    │   │ Moderator Roles    │
-│               │   │                  │   │              │   │                    │
-│ • Courses     │   │ • Email Templates│   │ • Lessons    │   │ • Transfer or      │
-│ • Course Pages│   │ • Sequences      │   │   (uses _id) │   │   upgrade existing │
-│               │   │ • Pages          │   │              │   │ • Community Pages  │
-│               │   │ • User Segments  │   │              │   │                    │
-│               │   │ • Email Delivery │   │              │   │                    │
-│               │   │ • User Themes    │   │              │   │                    │
-│               │   │ • Payment Plans  │   │              │   │                    │
-│               │   │ • Ongoing Seq.   │   │              │   │                    │
-└───────────────┘   └──────────────────┘   └──────────────┘   └────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────┐
-│            PHASE 3: CLEANUP PERSONAL DATA                    │
-│            cleanupPersonalData(userToDelete)                 │
-│                      [helpers.ts]                            │
-│                         (140 lines)                          │
-└─────────────────────────────────────────────────────────────┘
-                              │
-        ┌─────────────────────┼─────────────────────┬──────────────────────┐
-        │                     │                     │                      │
-        ▼                     ▼                     ▼                      ▼
-┌───────────────┐   ┌──────────────────┐   ┌──────────────┐   ┌────────────────────┐
-│ Personal      │   │ Community        │   │ Membership & │   │ Array References   │
-│ Data          │   │ Content          │   │ Subscription │   │ & Media            │
-│               │   │                  │   │              │   │                    │
-│ • Notifs      │   │ • Posts/Comments │   │ • Cancel     │   │ • Sequence         │
-│ • Mail Status │   │   (via helper)   │   │   Subscript. │   │   entrants         │
-│ • Evaluations │   │ • Post Likes     │   │ • Delete     │   │ • Course           │
-│ • Downloads   │   │ • Comment Likes  │   │   Invoices   │   │   customers        │
-│ • Reports     │   │ • Reply Likes    │   │ • Delete     │   │ • Avatar Media     │
-│ • Certificates│   │ • Subscriptions  │   │   Membership │   │                    │
-│ • Activity    │   │                  │   │              │   │                    │
-│ • Email Events│   │                  │   │              │   │                    │
-└───────────────┘   └──────────────────┘   └──────────────┘   └────────────────────┘
-                              │
-                              ▼
-                    ┌──────────────────┐
-                    │ Delete User      │
-                    │ Document         │
-                    └──────────────────┘
-                              │
-                              ▼
-                    ┌──────────────────┐
-                    │ Return true      │
-                    └──────────────────┘
-```
-
-## Data Flow
-
-### Input
-
-- `userId`: String identifier of user to delete
-- `ctx`: GraphQL context with authentication and domain info
-
-### Processing
-
-#### Step 1: Validation
-
-```typescript
-validateUserDeletion(userToDelete, ctx)
-├─ For each CRITICAL_PERMISSION
-│  ├─ Check if userToDelete has permission
-│  └─ If yes, verify at least one other active user has it
-└─ Throw error if last user with critical permission
-```
-
-#### Step 2: Migration
-
-```typescript
-migrateBusinessEntities(userToDelete, deleterUser, ctx)
-├─ Find all courses owned by userToDelete
-│  └─ Transfer to deleterUser
-├─ Update business entities in parallel (Promise.all)
-│  ├─ Email templates → deleterUser
-│  ├─ Sequences → deleterUser
-│  ├─ Pages → deleterUser
-│  ├─ User segments → deleterUser
-│  ├─ Email deliveries → deleterUser
-│  ├─ User themes → deleterUser
-│  ├─ Payment plans → deleterUser
-│  └─ Ongoing sequences → deleterUser
-├─ Transfer lessons (uses ObjectId)
-└─ Transfer community moderator roles
-   ├─ For each community where user is moderator
-   │  ├─ Check if deleterUser already has membership
-   │  ├─ If yes: upgrade to moderator, delete old
-   │  └─ If no: transfer membership to deleterUser
-   └─ Update community pages
-```
-
-#### Step 3: Cleanup
-
-```typescript
-cleanupPersonalData(userToDelete, ctx)
-├─ Delete personal data in parallel (Promise.all)
-│  ├─ Notifications (sent & received)
-│  ├─ Mail request statuses
-│  ├─ Lesson evaluations
-│  ├─ Download links
-│  ├─ Community reports
-│  ├─ Certificates
-│  ├─ Activity logs
-│  ├─ Email events
-│  └─ Community post subscriptions
-├─ Clean community content
-│  ├─ Delete posts & comments (via helper)
-│  ├─ Remove from post likes
-│  └─ Remove from comment/reply likes
-├─ Clean memberships
-│  ├─ For each membership
-│  │  ├─ Cancel subscription if active
-│  │  ├─ Delete invoices
-│  │  └─ Delete membership
-├─ Clean array references
-│  ├─ Remove from sequence entrants
-│  └─ Remove from course customers
-├─ Delete avatar media
-└─ Delete user document
-```
-
-### Output
-
-- `Promise<boolean>`: Returns `true` on successful deletion
-
-## Error Handling
-
-```
-deleteUser
-├─ Not authenticated → Error: "Action not allowed"
-├─ No manageUsers permission → Error: "Action not allowed"
-├─ User not found → Error: "User not found"
-├─ Self-deletion attempt → Error: "Action not allowed"
-└─ Last user with critical permission → Error: "Cannot delete last user with permission: [permission]"
-```
-
-## GDPR Compliance Matrix
-
-| Data Type      | Action  | Location                             | GDPR Status  |
-| -------------- | ------- | ------------------------------------ | ------------ |
-| User Profile   | Delete  | `UserModel.deleteOne()`              | ✅ Compliant |
-| Notifications  | Delete  | `NotificationModel.deleteMany()`     | ✅ Compliant |
-| Activity Logs  | Delete  | `ActivityModel.deleteMany()`         | ✅ Compliant |
-| Email Events   | Delete  | `EmailEventModel.deleteMany()`       | ✅ Compliant |
-| Certificates   | Delete  | `CertificateModel.deleteMany()`      | ✅ Compliant |
-| Evaluations    | Delete  | `LessonEvaluationModel.deleteMany()` | ✅ Compliant |
-| Downloads      | Delete  | `DownloadLinkModel.deleteMany()`     | ✅ Compliant |
-| Reports        | Delete  | `CommunityReportModel.deleteMany()`  | ✅ Compliant |
-| Posts/Comments | Delete  | `deleteCommunityPosts()`             | ✅ Compliant |
-| Likes          | Remove  | `$pull` operations                   | ✅ Compliant |
-| Memberships    | Delete  | `MembershipModel.deleteOne()`        | ✅ Compliant |
-| Subscriptions  | Cancel  | Payment provider API                 | ✅ Compliant |
-| Invoices       | Delete  | `InvoiceModel.deleteMany()`          | ✅ Compliant |
-| Avatar         | Delete  | `deleteMedia()`                      | ✅ Compliant |
-| Courses        | Migrate | `CourseModel.updateMany()`           | ✅ Preserved |
-| Templates      | Migrate | `EmailTemplateModel.updateMany()`    | ✅ Preserved |
-| Sequences      | Migrate | `SequenceModel.updateMany()`         | ✅ Preserved |
diff --git a/apps/web/graphql/users/__tests__/delete-user.test.ts b/apps/web/graphql/users/__tests__/delete-user.test.ts
index 223e04326..ddd8b0fe1 100644
--- a/apps/web/graphql/users/__tests__/delete-user.test.ts
+++ b/apps/web/graphql/users/__tests__/delete-user.test.ts
@@ -30,6 +30,11 @@ import MembershipModel from "@models/Membership";
 import CommunityModel from "@models/Community";
 import LessonModel from "@models/Lesson";
 import DomainModel from "@models/Domain";
+import ProductDiscussionCommentModel from "@models/ProductDiscussionComment";
+import ProductDiscussionReplyModel from "@models/ProductDiscussionReply";
+import ProductDiscussionLikeModel from "@models/ProductDiscussionLike";
+import ProductDiscussionSubscriberModel from "@models/ProductDiscussionSubscriber";
+import ProductDiscussionReportModel from "@models/ProductDiscussionReport";
 import { responses, internal } from "@/config/strings";
 import constants from "@/config/constants";
 import { Constants } from "@courselit/common-models";
@@ -152,6 +157,15 @@ describe("deleteUser - Comprehensive Test Suite", () => {
             MembershipModel.deleteMany({ domain: testDomain._id }),
             CommunityModel.deleteMany({ domain: testDomain._id }),
             LessonModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionCommentModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionReplyModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionLikeModel.deleteMany({ domain: testDomain._id }),
+            ProductDiscussionSubscriberModel.deleteMany({
+                domain: testDomain._id,
+            }),
+            ProductDiscussionReportModel.deleteMany({ domain: testDomain._id }),
         ]);
 
         jest.clearAllMocks();
@@ -736,6 +750,109 @@ describe("deleteUser - Comprehensive Test Suite", () => {
             expect(subscribers).toHaveLength(0);
         });
 
+        it("should delete product discussion likes, subscriptions, and reports", async () => {
+            await Promise.all([
+                ProductDiscussionLikeModel.create({
+                    domain: testDomain._id,
+                    productId: "course-123",
+                    entityType: "lesson",
+                    entityId: "lesson-123",
+                    contentType: "comment",
+                    contentId: "comment-123",
+                    userId: targetUser.userId,
+                }),
+                ProductDiscussionSubscriberModel.create({
+                    domain: testDomain._id,
+                    productId: "course-123",
+                    entityType: "lesson",
+                    entityId: "lesson-123",
+                    subscriptionId: "sub-123",
+                    userId: targetUser.userId,
+                    subscription: true,
+                }),
+                ProductDiscussionReportModel.create({
+                    domain: testDomain._id,
+                    productId: "course-123",
+                    entityType: "lesson",
+                    entityId: "lesson-123",
+                    reportId: "report-123",
+                    contentType: "comment",
+                    contentId: "comment-123",
+                    userId: targetUser.userId,
+                    reason: "spam",
+                }),
+            ]);
+
+            await deleteUser(targetUser.userId, mockCtx);
+
+            const [likes, subscribers, reports] = await Promise.all([
+                ProductDiscussionLikeModel.find({ userId: targetUser.userId }),
+                ProductDiscussionSubscriberModel.find({
+                    userId: targetUser.userId,
+                }),
+                ProductDiscussionReportModel.find({
+                    userId: targetUser.userId,
+                }),
+            ]);
+
+            expect(likes).toHaveLength(0);
+            expect(subscribers).toHaveLength(0);
+            expect(reports).toHaveLength(0);
+        });
+
+        it("should anonymize and redact product discussion comments and replies", async () => {
+            const comment = await ProductDiscussionCommentModel.create({
+                domain: testDomain._id,
+                productId: "course-123",
+                entityType: "lesson",
+                entityId: "lesson-123",
+                commentId: "comment-user-123",
+                userId: targetUser.userId,
+                content: {
+                    type: "doc",
+                    content: [{ type: "paragraph", text: "My secret data" }],
+                },
+            });
+
+            const reply = await ProductDiscussionReplyModel.create({
+                domain: testDomain._id,
+                productId: "course-123",
+                entityType: "lesson",
+                entityId: "lesson-123",
+                commentId: "comment-user-123",
+                replyId: "reply-user-123",
+                userId: targetUser.userId,
+                content: {
+                    type: "doc",
+                    content: [{ type: "paragraph", text: "My secret reply" }],
+                },
+            });
+
+            await deleteUser(targetUser.userId, mockCtx);
+
+            const anonymizedComment =
+                await ProductDiscussionCommentModel.findOne({
+                    commentId: comment.commentId,
+                });
+            const anonymizedReply = await ProductDiscussionReplyModel.findOne({
+                replyId: reply.replyId,
+            });
+
+            expect(anonymizedComment?.userId).toBe("deleted");
+            expect(anonymizedComment?.deleted).toBe(true);
+            expect(anonymizedComment?.content).toEqual({
+                type: "doc",
+                content: [],
+            });
+
+            expect(anonymizedReply?.userId).toBe("deleted");
+            expect(anonymizedReply?.deleted).toBe(true);
+            expect(anonymizedReply?.content).toEqual({
+                type: "doc",
+                content: [],
+            });
+        });
+
         it("should call deleteCommunityPosts for user's posts and comments", async () => {
             await deleteUser(targetUser.userId, mockCtx);
 
diff --git a/apps/web/graphql/users/__tests__/logic.test.ts b/apps/web/graphql/users/__tests__/logic.test.ts
index 8d325e180..d3e96dec1 100644
--- a/apps/web/graphql/users/__tests__/logic.test.ts
+++ b/apps/web/graphql/users/__tests__/logic.test.ts
@@ -18,6 +18,7 @@ import mongoose from "mongoose";
 import {
     finalizeUserCreation,
     getCertificate,
+    getUser,
     updateUser,
     findMembership,
 } from "../logic";
@@ -40,6 +41,21 @@ const seedNotificationPreferencesForUserMock =
 const recordActivityMock = recordActivity as jest.Mock;
 const triggerSequencesMock = triggerSequences as jest.Mock;
 
+describe("getUser", () => {
+    const domainId = new mongoose.Types.ObjectId();
+
+    it("returns null for anonymous current-user lookups", async () => {
+        const result = await getUser(null, {
+            subdomain: {
+                _id: domainId,
+            },
+            user: null,
+        } as any);
+
+        expect(result).toBeNull();
+    });
+});
+
 describe("updateUser", () => {
     const domainId = new mongoose.Types.ObjectId();
     const ownerEmail = "owner-permissions@example.com";
diff --git a/apps/web/graphql/users/helpers.ts b/apps/web/graphql/users/helpers.ts
index 7a6e13da9..636703bbf 100644
--- a/apps/web/graphql/users/helpers.ts
+++ b/apps/web/graphql/users/helpers.ts
@@ -31,6 +31,11 @@ import CertificateModel from "@models/Certificate";
 import ActivityModel from "@models/Activity";
 import EmailEventModel from "@models/EmailEvent";
 import CommunityPostSubscriberModel from "@models/CommunityPostSubscriber";
+import ProductDiscussionCommentModel from "@models/ProductDiscussionComment";
+import ProductDiscussionReplyModel from "@models/ProductDiscussionReply";
+import ProductDiscussionLikeModel from "@models/ProductDiscussionLike";
+import ProductDiscussionSubscriberModel from "@models/ProductDiscussionSubscriber";
+import ProductDiscussionReportModel from "@models/ProductDiscussionReport";
 import {
     cancelAndDeleteMemberships,
     deleteCommunityPosts,
@@ -301,11 +306,53 @@ export async function cleanupPersonalData(
             domain: ctx.subdomain._id,
             userId: userToDelete.userId,
         }),
+        ProductDiscussionLikeModel.deleteMany({
+            domain: ctx.subdomain._id,
+            userId: userToDelete.userId,
+        }),
+        ProductDiscussionSubscriberModel.deleteMany({
+            domain: ctx.subdomain._id,
+            userId: userToDelete.userId,
+        }),
+        ProductDiscussionReportModel.deleteMany({
+            domain: ctx.subdomain._id,
+            userId: userToDelete.userId,
+        }),
     ]);
 
     // Delete all posts and comments created by the user
     await deleteCommunityPosts(ctx, "user", userToDelete.userId);
 
+    // Anonymize and redact product discussion comments created by the user
+    await ProductDiscussionCommentModel.updateMany(
+        { domain: ctx.subdomain._id, userId: userToDelete.userId },
+        {
+            $set: {
+                userId: "deleted",
+                content: { type: "doc", content: [] },
+                deleted: true,
+                deletedAt: new Date(),
+                deletedBy: "system",
+                deletedByRole: "author",
+            },
+        },
+    );
+
+    // Anonymize and redact product discussion replies created by the user
+    await ProductDiscussionReplyModel.updateMany(
+        { domain: ctx.subdomain._id, userId: userToDelete.userId },
+        {
+            $set: {
+                userId: "deleted",
+                content: { type: "doc", content: [] },
+                deleted: true,
+                deletedAt: new Date(),
+                deletedBy: "system",
+                deletedByRole: "author",
+            },
+        },
+    );
+
     // Remove user from likes on posts
     await CommunityPostModel.updateMany(
         { domain: ctx.subdomain._id },
diff --git a/apps/web/graphql/users/logic.ts b/apps/web/graphql/users/logic.ts
index 10e0e6888..7b61c3d73 100644
--- a/apps/web/graphql/users/logic.ts
+++ b/apps/web/graphql/users/logic.ts
@@ -79,6 +79,10 @@ export const getUser = async (
         user = await UserModel.findOne({ userId, domain: ctx.subdomain._id });
     }
 
+    if (!user && !userId) {
+        return null;
+    }
+
     if (!user) {
         throw new Error(responses.item_not_found);
     }
diff --git a/apps/web/hooks/use-product.ts b/apps/web/hooks/use-product.ts
index 12a2c15a6..f143726bb 100644
--- a/apps/web/hooks/use-product.ts
+++ b/apps/web/hooks/use-product.ts
@@ -70,6 +70,7 @@ export default function useProduct(id?: string | null): {
                         }
                     },
                     courseId,
+                    discussions,
                     cost,
                     costType,
                     featuredImage {
diff --git a/apps/web/jest.client.config.ts b/apps/web/jest.client.config.ts
index d8b14dacf..de2640aec 100644
--- a/apps/web/jest.client.config.ts
+++ b/apps/web/jest.client.config.ts
@@ -39,6 +39,7 @@ const config = {
             "<rootDir>/../../packages/components-library/src",
         "@courselit/icons": "<rootDir>/../../packages/icons/src",
         "@courselit/text-editor": "<rootDir>/../../packages/text-editor/src",
+        "@courselit/page-blocks": "<rootDir>/../../packages/page-blocks/src",
         "@courselit/common-models":
             "<rootDir>/../../packages/common-models/src",
         nanoid: "<rootDir>/__mocks__/nanoid.ts",
@@ -54,6 +55,7 @@ const config = {
         "@/templates/(.*)": "<rootDir>/templates/$1",
         "@/hooks/(.*)": "<rootDir>/hooks/$1",
         "@/app/(.*)": "<rootDir>/app/$1",
+        "@/components/(.*)": "<rootDir>/components/$1",
         "@ui-lib/(.*)": "<rootDir>/ui-lib/$1",
         "@config/(.*)": "<rootDir>/config/$1",
         "@/models/(.*)": "<rootDir>/models/$1",
diff --git a/apps/web/lib/__tests__/course-viewer-session-params.test.ts b/apps/web/lib/__tests__/course-viewer-session-params.test.ts
index 7637f8625..20b11650d 100644
--- a/apps/web/lib/__tests__/course-viewer-session-params.test.ts
+++ b/apps/web/lib/__tests__/course-viewer-session-params.test.ts
@@ -1,12 +1,14 @@
 import {
     appendCourseViewerReturnToHref,
     appendCourseViewerSessionParamsToHref,
+    COURSE_VIEWER_DISCUSSION_PARAM,
     COURSE_VIEWER_PREVIEW_PARAM,
     DEFAULT_COURSE_VIEWER_EXIT_PATH,
     getCourseViewerReturnPath,
     getCourseViewerSessionParams,
     getCourseViewerSessionParamsFromUrl,
     isSafeCourseViewerReturnPath,
+    setHrefQueryParam,
 } from "../course-viewer-session-params";
 
 describe("course-viewer-session-params", () => {
@@ -70,19 +72,33 @@ describe("course-viewer-session-params", () => {
         );
     });
 
-    it("drops unknown viewer params while reading session params", () => {
+    it("reads registered viewer params and drops unknown params", () => {
         const params = new URLSearchParams({
             [COURSE_VIEWER_PREVIEW_PARAM]: "true",
+            [COURSE_VIEWER_DISCUSSION_PARAM]: "open",
             returnTo: "/dashboard/product/product-1",
-            discussion: "open",
+            unrelated: "ignored",
         });
 
         expect(getCourseViewerSessionParams(params)).toEqual({
             preview: true,
+            discussion: true,
             returnTo: "/dashboard/product/product-1",
         });
     });
 
+    it("does not treat unknown discussion values as open", () => {
+        const params = new URLSearchParams({
+            [COURSE_VIEWER_DISCUSSION_PARAM]: "closed",
+        });
+
+        expect(getCourseViewerSessionParams(params)).toEqual({
+            preview: false,
+            discussion: false,
+            returnTo: null,
+        });
+    });
+
     it("reads registered params from a current URL header value", () => {
         expect(
             getCourseViewerSessionParamsFromUrl(
@@ -90,7 +106,43 @@ describe("course-viewer-session-params", () => {
             ),
         ).toEqual({
             preview: true,
+            discussion: false,
             returnTo: "/dashboard/product/product-1",
         });
     });
+
+    it("propagates discussion state through course viewer links", () => {
+        expect(
+            appendCourseViewerSessionParamsToHref(
+                "/course/test-course/course-1/lesson-2",
+                {
+                    discussion: true,
+                },
+            ),
+        ).toBe("/course/test-course/course-1/lesson-2?discussion=open");
+    });
+
+    it("sets a query param without dropping existing viewer session params", () => {
+        expect(
+            setHrefQueryParam(
+                "/course/test/course-1/lesson-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1",
+                "discussion",
+                "open",
+            ),
+        ).toBe(
+            "/course/test/course-1/lesson-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1&discussion=open",
+        );
+    });
+
+    it("removes a query param without dropping existing viewer session params", () => {
+        expect(
+            setHrefQueryParam(
+                "/course/test/course-1/lesson-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1&discussion=open",
+                "discussion",
+                null,
+            ),
+        ).toBe(
+            "/course/test/course-1/lesson-1?preview=true&returnTo=%2Fdashboard%2Fproduct%2Fproduct-1",
+        );
+    });
 });
diff --git a/apps/web/lib/course-viewer-session-params.ts b/apps/web/lib/course-viewer-session-params.ts
index 77e25c1a6..6b4b0a725 100644
--- a/apps/web/lib/course-viewer-session-params.ts
+++ b/apps/web/lib/course-viewer-session-params.ts
@@ -1,10 +1,13 @@
 export const COURSE_VIEWER_RETURN_TO_PARAM = "returnTo";
 export const COURSE_VIEWER_PREVIEW_PARAM = "preview";
+export const COURSE_VIEWER_DISCUSSION_PARAM = "discussion";
+export const COURSE_VIEWER_DISCUSSION_OPEN_VALUE = "open";
 export const COURSE_VIEWER_CURRENT_URL_HEADER = "x-courselit-course-viewer-url";
 export const DEFAULT_COURSE_VIEWER_EXIT_PATH = "/dashboard/my-content/products";
 
 export type CourseViewerSessionParams = {
     preview?: boolean;
+    discussion?: boolean;
     returnTo?: string | null;
 };
 
@@ -32,6 +35,9 @@ export const getCourseViewerReturnPath = (returnTo?: string | null) =>
 export const isCourseViewerPreviewRequested = (preview?: string | null) =>
     preview === "true";
 
+export const isCourseViewerDiscussionRequested = (discussion?: string | null) =>
+    discussion === COURSE_VIEWER_DISCUSSION_OPEN_VALUE;
+
 type ReadableSearchParams = {
     get: (name: string) => string | null;
 };
@@ -48,6 +54,9 @@ export const getCourseViewerSessionParams = (
         preview: isCourseViewerPreviewRequested(
             searchParams.get(COURSE_VIEWER_PREVIEW_PARAM),
         ),
+        discussion: isCourseViewerDiscussionRequested(
+            searchParams.get(COURSE_VIEWER_DISCUSSION_PARAM),
+        ),
         returnTo: isSafeCourseViewerReturnPath(returnTo) ? returnTo : null,
     };
 };
@@ -75,7 +84,11 @@ export const appendCourseViewerSessionParamsToHref = (
         return href;
     }
 
-    if (!params.preview && !isSafeCourseViewerReturnPath(params.returnTo)) {
+    if (
+        !params.preview &&
+        !params.discussion &&
+        !isSafeCourseViewerReturnPath(params.returnTo)
+    ) {
         return href;
     }
 
@@ -86,6 +99,13 @@ export const appendCourseViewerSessionParamsToHref = (
         searchParams.set(COURSE_VIEWER_PREVIEW_PARAM, "true");
     }
 
+    if (params.discussion) {
+        searchParams.set(
+            COURSE_VIEWER_DISCUSSION_PARAM,
+            COURSE_VIEWER_DISCUSSION_OPEN_VALUE,
+        );
+    }
+
     if (isSafeCourseViewerReturnPath(params.returnTo)) {
         searchParams.set(COURSE_VIEWER_RETURN_TO_PARAM, params.returnTo!);
     }
@@ -94,6 +114,24 @@ export const appendCourseViewerSessionParamsToHref = (
     return serializedParams ? `${pathname}?${serializedParams}` : pathname;
 };
 
+export const setHrefQueryParam = (
+    href: string,
+    name: string,
+    value?: string | null,
+) => {
+    const [pathname, query = ""] = href.split("?");
+    const searchParams = new URLSearchParams(query);
+
+    if (value === null || value === undefined) {
+        searchParams.delete(name);
+    } else {
+        searchParams.set(name, value);
+    }
+
+    const serializedParams = searchParams.toString();
+    return serializedParams ? `${pathname}?${serializedParams}` : pathname;
+};
+
 export const appendCourseViewerReturnToHref = (
     href: string,
     returnTo?: string | null,
diff --git a/apps/web/lib/hash-target.ts b/apps/web/lib/hash-target.ts
new file mode 100644
index 000000000..f838175e2
--- /dev/null
+++ b/apps/web/lib/hash-target.ts
@@ -0,0 +1,60 @@
+export const HASH_TARGET_HIGHLIGHT_CLASSES = [
+    "border-border",
+    "bg-accent/40",
+    "shadow-sm",
+    "ring-1",
+    "ring-ring/20",
+];
+
+export const getCurrentHashTargetId = () =>
+    typeof window === "undefined" ? "" : window.location.hash.slice(1);
+
+export function scrollToHashTarget({
+    targetId = getCurrentHashTargetId(),
+    highlightClasses = HASH_TARGET_HIGHLIGHT_CLASSES,
+    highlightMs = 2200,
+    scrollOptions = {
+        behavior: "smooth",
+        block: "center",
+    },
+}: {
+    targetId?: string;
+    highlightClasses?: string[];
+    highlightMs?: number;
+    scrollOptions?: ScrollIntoViewOptions;
+} = {}) {
+    if (!targetId) {
+        return false;
+    }
+
+    const element = document.getElementById(targetId);
+
+    if (!element) {
+        return false;
+    }
+
+    element.scrollIntoView(scrollOptions);
+    element.classList.add(...highlightClasses);
+    window.setTimeout(
+        () => element.classList.remove(...highlightClasses),
+        highlightMs,
+    );
+
+    return true;
+}
+
+export function focusHashTarget({
+    targetId,
+    eventName,
+}: {
+    targetId: string;
+    eventName?: string;
+}) {
+    const url = new URL(window.location.href);
+    url.hash = targetId;
+    window.history.pushState({}, "", url.toString());
+
+    if (eventName) {
+        window.dispatchEvent(new Event(eventName));
+    }
+}
diff --git a/apps/web/models/ProductDiscussionComment.ts b/apps/web/models/ProductDiscussionComment.ts
new file mode 100644
index 000000000..dab52c63e
--- /dev/null
+++ b/apps/web/models/ProductDiscussionComment.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionComment,
+    ProductDiscussionCommentSchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionCommentModel =
+    (mongoose.models.ProductDiscussionComment as
+        | Model<InternalProductDiscussionComment>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionComment>(
+        "ProductDiscussionComment",
+        ProductDiscussionCommentSchema,
+    );
+
+export type { InternalProductDiscussionComment };
+export default ProductDiscussionCommentModel;
diff --git a/apps/web/models/ProductDiscussionLike.ts b/apps/web/models/ProductDiscussionLike.ts
new file mode 100644
index 000000000..7fb5f9353
--- /dev/null
+++ b/apps/web/models/ProductDiscussionLike.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionLike,
+    ProductDiscussionLikeSchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionLikeModel =
+    (mongoose.models.ProductDiscussionLike as
+        | Model<InternalProductDiscussionLike>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionLike>(
+        "ProductDiscussionLike",
+        ProductDiscussionLikeSchema,
+    );
+
+export type { InternalProductDiscussionLike };
+export default ProductDiscussionLikeModel;
diff --git a/apps/web/models/ProductDiscussionReply.ts b/apps/web/models/ProductDiscussionReply.ts
new file mode 100644
index 000000000..437c9f288
--- /dev/null
+++ b/apps/web/models/ProductDiscussionReply.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionReply,
+    ProductDiscussionReplySchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionReplyModel =
+    (mongoose.models.ProductDiscussionReply as
+        | Model<InternalProductDiscussionReply>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionReply>(
+        "ProductDiscussionReply",
+        ProductDiscussionReplySchema,
+    );
+
+export type { InternalProductDiscussionReply };
+export default ProductDiscussionReplyModel;
diff --git a/apps/web/models/ProductDiscussionReport.ts b/apps/web/models/ProductDiscussionReport.ts
new file mode 100644
index 000000000..fb42c7b33
--- /dev/null
+++ b/apps/web/models/ProductDiscussionReport.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionReport,
+    ProductDiscussionReportSchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionReportModel =
+    (mongoose.models.ProductDiscussionReport as
+        | Model<InternalProductDiscussionReport>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionReport>(
+        "ProductDiscussionReport",
+        ProductDiscussionReportSchema,
+    );
+
+export type { InternalProductDiscussionReport };
+export default ProductDiscussionReportModel;
diff --git a/apps/web/models/ProductDiscussionSubscriber.ts b/apps/web/models/ProductDiscussionSubscriber.ts
new file mode 100644
index 000000000..d655b6f7b
--- /dev/null
+++ b/apps/web/models/ProductDiscussionSubscriber.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionSubscriber,
+    ProductDiscussionSubscriberSchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionSubscriberModel =
+    (mongoose.models.ProductDiscussionSubscriber as
+        | Model<InternalProductDiscussionSubscriber>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionSubscriber>(
+        "ProductDiscussionSubscriber",
+        ProductDiscussionSubscriberSchema,
+    );
+
+export type { InternalProductDiscussionSubscriber };
+export default ProductDiscussionSubscriberModel;
diff --git a/apps/web/models/ProductDiscussionSummary.ts b/apps/web/models/ProductDiscussionSummary.ts
new file mode 100644
index 000000000..25d0db1c5
--- /dev/null
+++ b/apps/web/models/ProductDiscussionSummary.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalProductDiscussionSummary,
+    ProductDiscussionSummarySchema,
+} from "@courselit/orm-models";
+
+const ProductDiscussionSummaryModel =
+    (mongoose.models.ProductDiscussionSummary as
+        | Model<InternalProductDiscussionSummary>
+        | undefined) ||
+    mongoose.model<InternalProductDiscussionSummary>(
+        "ProductDiscussionSummary",
+        ProductDiscussionSummarySchema,
+    );
+
+export type { InternalProductDiscussionSummary };
+export default ProductDiscussionSummaryModel;
diff --git a/apps/web/models/RateLimitEvent.ts b/apps/web/models/RateLimitEvent.ts
new file mode 100644
index 000000000..98b9bfd35
--- /dev/null
+++ b/apps/web/models/RateLimitEvent.ts
@@ -0,0 +1,17 @@
+import mongoose, { Model } from "mongoose";
+import {
+    InternalRateLimitEvent,
+    RateLimitEventSchema,
+} from "@courselit/orm-models";
+
+const RateLimitEventModel =
+    (mongoose.models.RateLimitEvent as
+        | Model<InternalRateLimitEvent>
+        | undefined) ||
+    mongoose.model<InternalRateLimitEvent>(
+        "RateLimitEvent",
+        RateLimitEventSchema,
+    );
+
+export type { InternalRateLimitEvent };
+export default RateLimitEventModel;
diff --git a/apps/web/ui-config/strings.ts b/apps/web/ui-config/strings.ts
index e97ffbfea..fd007cb78 100644
--- a/apps/web/ui-config/strings.ts
+++ b/apps/web/ui-config/strings.ts
@@ -130,6 +130,55 @@ export const SITE_SETTINGS_PAYMENT_METHOD_RESET_CONFIRM_DESCRIPTION =
 export const SITE_SETTINGS_PAYMENT_METHOD_RESET_CONFIRM_ACTION = "Reset";
 export const FREE_COST = "FREE";
 export const SIDEBAR_TEXT_COURSE_ABOUT = "Introduction";
+export const SIDEBAR_TEXT_COURSE_DISCUSSIONS = "Discussions";
+export const COURSE_DISCUSSIONS_TITLE = "Discussions";
+export const COURSE_DISCUSSIONS_TOOLTIP = "Discussions";
+export const COURSE_DISCUSSIONS_DESCRIPTION =
+    "Enable lesson-specific discussions for this course";
+export const DISCUSSIONS_DISABLED_MESSAGE =
+    "Discussions are disabled for this product.";
+export const DISCUSSIONS_ENABLED_MESSAGE =
+    "Discussions are enabled for this product.";
+export const COURSE_DISCUSSIONS_VIEW_ALL = "View all discussions";
+export const COURSE_DISCUSSIONS_EMPTY = "No discussions yet";
+export const COURSE_DISCUSSIONS_COMMENT_PLACEHOLDER = "Add a comment...";
+export const COURSE_DISCUSSIONS_REPLY_PLACEHOLDER = "Add a reply...";
+export const COURSE_DISCUSSIONS_POST_COMMENT = "Post Comment";
+export const COURSE_DISCUSSIONS_POST_REPLY = "Post Reply";
+export const COURSE_DISCUSSIONS_REPLY = "Reply";
+export const COURSE_DISCUSSIONS_REPORT = "Report";
+export const COURSE_DISCUSSIONS_DELETE = "Delete";
+export const COURSE_DISCUSSIONS_DELETED = "Deleted";
+export const COURSE_DISCUSSIONS_DELETE_CONFIRM_TITLE = "Delete discussion";
+export const COURSE_DISCUSSIONS_DELETE_CONFIRM =
+    "Are you sure you want to delete this?";
+export const COURSE_DISCUSSIONS_DELETE_CONFIRM_DESCRIPTION =
+    "This action cannot be undone.";
+export const COURSE_DISCUSSIONS_DELETE_CANCEL = "Cancel";
+export const COURSE_DISCUSSIONS_REPORT_REASON = "Why are you reporting this?";
+export const COURSE_DISCUSSIONS_REPORTED = "Reported";
+export const COURSE_DISCUSSIONS_CONTENT_REQUIRED = "Add a comment first.";
+export const COURSE_DISCUSSIONS_CONTENT_TOO_LONG =
+    "Discussion content is too long.";
+export const COURSE_DISCUSSIONS_ADMIN_REPORTS = "Reports";
+export const COURSE_DISCUSSIONS_ADMIN_VIEW_REPORTS = "Reported content";
+export const COURSE_DISCUSSIONS_ADMIN_NO_REPORTS = "No reports";
+export const COURSE_DISCUSSIONS_ADMIN_NO_REPORTS_DESCRIPTION =
+    "Reported discussion comments will appear here.";
+export const COURSE_DISCUSSIONS_ADMIN_STATUS = "Status";
+export const COURSE_DISCUSSIONS_ADMIN_REASON = "Reason";
+export const COURSE_DISCUSSIONS_ADMIN_TARGET = "Target";
+export const COURSE_DISCUSSIONS_ADMIN_REPORTED_BY = "Reported by";
+export const COURSE_DISCUSSIONS_ADMIN_LESSON = "Lesson";
+export const COURSE_DISCUSSIONS_ADMIN_CONTENT = "Content";
+export const COURSE_DISCUSSIONS_ADMIN_AUTHOR = "Author";
+export const COURSE_DISCUSSIONS_ADMIN_DATE = "Date";
+export const COURSE_DISCUSSIONS_ADMIN_FILTER_ALL = "All";
+export const COURSE_DISCUSSIONS_ADMIN_STATUS_PENDING = "pending";
+export const COURSE_DISCUSSIONS_ADMIN_STATUS_ACCEPTED = "accepted";
+export const COURSE_DISCUSSIONS_ADMIN_STATUS_REJECTED = "rejected";
+export const COURSE_DISCUSSIONS_ADMIN_REJECTION_REASON_DEFAULT =
+    "Rejected by moderator";
 export const REACT_COMPONENT_CRASHED =
     "We've encountered a problem in showing the content";
 export const CHECKOUT_PAGE_TITLE = "Checkout";
@@ -738,7 +787,7 @@ export const USER_DELETE_DIALOG_DELETION_HEADING = "What will be deleted";
 export const USER_DELETE_DIALOG_DELETION_ITEM_COMMUNICATION =
     "Notifications, mail statuses, lesson evaluations, download links, certificates, and activity logs.";
 export const USER_DELETE_DIALOG_DELETION_ITEM_COMMUNITY =
-    "Community posts, comments, replies, subscriptions, reports, and related likes.";
+    "Community posts, comments, replies, subscriptions, reports, and related likes. Product discussion likes, subscriptions, and reports (written comments and replies will be anonymized).";
 export const USER_DELETE_DIALOG_DELETION_ITEM_COMMERCE =
     "Memberships, invoices, course enrollments, and marketing sequence entries.";
 export const USER_DELETE_DIALOG_DELETION_ITEM_ACCOUNT =
diff --git a/docs/user-deletion-architecture.md b/docs/user-deletion-architecture.md
new file mode 100644
index 000000000..e4f52f340
--- /dev/null
+++ b/docs/user-deletion-architecture.md
@@ -0,0 +1,203 @@
+# User Deletion Architecture
+
+This document provides a quick overview of how user deletion is implemented.
+
+## Function Structure
+
+```
++-------------------------------------------------------------+
+|              deleteUser(userId, ctx) [logic.ts]              |
+|                   Main Orchestrator Function                 |
+|                         (45 lines)                           |
++-------------------------------------------------------------+
+                              |
+                              +---------------------------------+
+                              |                                 |
+                              v                                 v
++--------------------------------------+    +--------------------------------------+
+|   PHASE 1: AUTHORIZATION & VALIDATION |    |  validateUserDeletion() [helpers.ts] |
+|   * checkIfAuthenticated()            |    |  * Check critical permissions        |
+|   * Check manageUsers permission      |--->|  * Ensure system won't be locked     |
+|   * Verify user exists                |    |  * Prevent last admin deletion       |
+|   * Prevent self-deletion             |    |                                      |
++--------------------------------------+    +--------------------------------------+
+                              |
+                              v
++-------------------------------------------------------------+
+|         PHASE-2: MIGRATE BUSINESS ENTITIES                   |
+|   migrateBusinessEntities(userToDelete, deleterUser)         |
+|                      [helpers.ts]                            |
+|                         (175 lines)                          |
++-------------------------------------------------------------+
+                              |
+        +---------------------+---------------------+----------------------+
+        |                     |                     |                      |
+        v                     v                     v                      v
++---------------+   +------------------+   +--------------+   +--------------------+
+| Course        |   | Business Entity  |   | Lesson       |   | Community          |
+| Ownership     |   | Ownership        |   | Ownership    |   | Moderator Roles    |
+|               |   |                  |   |              |   |                    |
+| * Courses     |   | * Email Templates|   | * Lessons    |   | * Transfer or      |
+| * Course Pages|   | * Sequences      |   |   (uses _id) |   |   upgrade existing |
+|               |   | * Pages          |   |              |   | * Community Pages  |
+|               |   | * User Segments  |   |              |   |                    |
+|               |   | * Email Delivery |   |              |   |                    |
+|               |   | * User Themes    |   |              |   |                    |
+|               |   | * Payment Plans  |   |              |   |                    |
+|               |   | * Ongoing Seq.   |   |              |   |                    |
++---------------+   +------------------+   +--------------+   +--------------------+
+                              |
+                              v
++-------------------------------------------------------------+
+|            PHASE-3: CLEANUP PERSONAL DATA                    |
+|            cleanupPersonalData(userToDelete)                 |
+|                      [helpers.ts]                            |
+|                         (140 lines)                          |
++-------------------------------------------------------------+
+                              |
+        +--------------------------+-------------------------+---------------------+
+        |                          |                         |                     |
+        v                          v                         v                     v
++---------------+   +-----------------------------+   +--------------+   +--------------------+
+| Personal      |   | Community &                 |   | Membership & |   | Array References   |
+| Data          |   | Discussion Content          |   | Subscription |   | & Media            |
+|               |   |                             |   |              |   |                    |
+| * Notifs      |   | * Posts/Comments            |   | * Cancel     |   | * Sequence         |
+| * Mail Status |   |   (via helper)              |   |   Subscript. |   |   entrants         |
+| * Evaluations |   | * Community Likes/Subs      |   | * Delete     |   | * Course           |
+| * Downloads   |   | * Discussion Likes/Subs     |   |   Invoices   |   |   customers        |
+| * Reports     |   | * Discussion Reports        |   | * Delete     |   | * Avatar Media     |
+| * Certificates|   | * Discussion Comments/      |   |   Membership |   |                    |
+| * Activity    |   |   Replies (Anonymized)      |   |              |   |                    |
+| * Email Events|   |                             |   |              |   |                    |
++---------------+   +-----------------------------+   +--------------+   +--------------------+
+                              |
+                              v
+                    +------------------+
+                    | Delete User      |
+                    | Document         |
+                    +------------------+
+                              |
+                              v
+                    +------------------+
+                    | Return true      |
+                    +------------------+
+```
+
+## Data Flow
+
+### Input
+
+- `userId`: String identifier of user to delete
+- `ctx`: GraphQL context with authentication and domain info
+
+### Processing
+
+#### Step 1: Validation
+
+```typescript
+validateUserDeletion(userToDelete, ctx)
+|-- For each CRITICAL_PERMISSION
+|   |-- Check if userToDelete has permission
+|   `-- If yes, verify at least one other active user has it
+`-- Throw error if last user with critical permission
+```
+
+#### Step 2: Migration
+
+```typescript
+migrateBusinessEntities(userToDelete, deleterUser, ctx)
+|-- Find all courses owned by userToDelete
+|   `-- Transfer to deleterUser
+|-- Update business entities in parallel (Promise.all)
+|   |-- Email templates -> deleterUser
+|   |-- Sequences -> deleterUser
+|   |-- Pages -> deleterUser
+|   |-- User segments -> deleterUser
+|   |-- Email deliveries -> deleterUser
+|   |-- User themes -> deleterUser
+|   |-- Payment plans -> deleterUser
+|   `-- Ongoing sequences -> deleterUser
+|-- Transfer lessons (uses ObjectId)
+`-- Transfer community moderator roles
+   |-- For each community where user is moderator
+   |   |-- Check if deleterUser already has membership
+   |   |-- If yes: upgrade to moderator, delete old
+   |   `-- If no: transfer membership to deleterUser
+   `-- Update community pages
+```
+
+#### Step 3: Cleanup
+
+```typescript
+cleanupPersonalData(userToDelete, ctx)
+|-- Delete personal data in parallel (Promise.all)
+|   |-- Notifications (sent & received)
+|   |-- Mail request statuses
+|   |-- Lesson evaluations
+|   |-- Download links
+|   |-- Community reports
+|   |-- Certificates
+|   |-- Activity logs
+|   |-- Email events
+|   |-- Community post subscriptions
+|   |-- Product discussion likes
+|   |-- Product discussion subscriptions
+|   `-- Product discussion reports
+|-- Clean community content
+|   |-- Delete posts & comments (via helper)
+|   |-- Remove from post likes
+|   `-- Remove from comment/reply likes
+|-- Anonymize and redact product discussion comments and replies
+|-- Clean memberships
+|   |-- For each membership
+|   |   |-- Cancel subscription if active
+|   |   |-- Delete invoices
+|   |   `-- Delete membership
+|-- Clean array references
+|   |-- Remove from sequence entrants
+|   `-- Remove from course customers
+|-- Delete avatar media
+`-- Delete user document
+```
+
+### Output
+
+- `Promise<boolean>`: Returns `true` on successful deletion
+
+## Error Handling
+
+```
+deleteUser
+|-- Not authenticated -> Error: "Action not allowed"
+|-- No manageUsers permission -> Error: "Action not allowed"
+|-- User not found -> Error: "User not found"
+|-- Self-deletion attempt -> Error: "Action not allowed"
+`-- Last user with critical permission -> Error: "Cannot delete last user with permission: [permission]"
+```
+
+## GDPR Compliance Matrix
+
+| Data Type                   | Action    | Location                                                                                 | GDPR Status   |
+| --------------------------- | --------- | ---------------------------------------------------------------------------------------- | ------------- |
+| User Profile                | Delete    | `UserModel.deleteOne()`                                                                  | [x] Compliant |
+| Notifications               | Delete    | `NotificationModel.deleteMany()`                                                         | [x] Compliant |
+| Activity Logs               | Delete    | `ActivityModel.deleteMany()`                                                             | [x] Compliant |
+| Email Events                | Delete    | `EmailEventModel.deleteMany()`                                                           | [x] Compliant |
+| Certificates                | Delete    | `CertificateModel.deleteMany()`                                                          | [x] Compliant |
+| Evaluations                 | Delete    | `LessonEvaluationModel.deleteMany()`                                                     | [x] Compliant |
+| Downloads                   | Delete    | `DownloadLinkModel.deleteMany()`                                                         | [x] Compliant |
+| Reports                     | Delete    | `CommunityReportModel.deleteMany()`                                                      | [x] Compliant |
+| Posts/Comments              | Delete    | `deleteCommunityPosts()`                                                                 | [x] Compliant |
+| Likes                       | Remove    | `$pull` operations                                                                       | [x] Compliant |
+| Memberships                 | Delete    | `MembershipModel.deleteOne()`                                                            | [x] Compliant |
+| Subscriptions               | Cancel    | Payment provider API                                                                     | [x] Compliant |
+| Invoices                    | Delete    | `InvoiceModel.deleteMany()`                                                              | [x] Compliant |
+| Avatar                      | Delete    | `deleteMedia()`                                                                          | [x] Compliant |
+| Discussion Likes            | Delete    | `ProductDiscussionLikeModel.deleteMany()`                                                | [x] Compliant |
+| Discussion Subs             | Delete    | `ProductDiscussionSubscriberModel.deleteMany()`                                          | [x] Compliant |
+| Discussion Reports          | Delete    | `ProductDiscussionReportModel.deleteMany()`                                              | [x] Compliant |
+| Discussion Comments/Replies | Anonymize | `ProductDiscussionCommentModel.updateMany()`, `ProductDiscussionReplyModel.updateMany()` | [x] Compliant |
+| Courses                     | Migrate   | `CourseModel.updateMany()`                                                               | [x] Preserved |
+| Templates                   | Migrate   | `EmailTemplateModel.updateMany()`                                                        | [x] Preserved |
+| Sequences                   | Migrate   | `SequenceModel.updateMany()`                                                             | [x] Preserved |
diff --git a/docs/wip/course-discussions-prd.md b/docs/wip/course-discussions-prd.md
new file mode 100644
index 000000000..1dcb775d7
--- /dev/null
+++ b/docs/wip/course-discussions-prd.md
@@ -0,0 +1,1044 @@
+# Course Discussions PRD
+
+## Document Control
+
+- Status: Draft
+- Last updated: June 10, 2026
+- Owner: Web/Product team
+- Target workspace: `apps/web` (`@courselit/web`)
+
+## Assumptions
+
+1. This PRD covers discussions only for products whose type is `course`.
+2. Discussions are lesson-scoped; there is no course-wide freeform discussion board in this release.
+3. Existing community schemas and collections must not be reused for persistence, even where the UX is similar.
+4. Existing community comment, report, notification, and highlight behavior may be used as implementation references.
+5. Course viewer participants can participate only when they can access the course and lesson through learner access or product management permissions.
+6. Product admins are users who can manage the product through existing product permissions.
+7. Course preview mode is available to product admins through the course viewer based on existing product management permissions.
+8. Product management permissions allow course viewer discussion participation for manageable lessons even when the actor is not enrolled as a learner; preview derives from the same permissions and must preserve those session params while navigating.
+9. Replies are stored and displayed as one-level replies under the original top-level comment. Replying to a reply adds the new reply to that same reply list.
+10. The feature should use existing GraphQL patterns unless a REST endpoint is already the natural integration point for the touched surface.
+11. Discussions are available only to enrolled learners or product managers. A public lesson may be visible to guests or logged-in non-enrolled users when `requiresEnrollment` is `false`, but discussion entry points, hub rows, comments, replies, and composers must remain hidden until the actor is enrolled in the product or has product management permissions while accessing via preview mode.
+
+## Objective
+
+Add lesson-specific threaded discussions to course products so learners can ask questions, reply to each other, and return to the relevant lesson from notifications or the course discussion index.
+
+Success means:
+
+1. Product admins can enable or disable discussions per product.
+2. Course viewer participants see the current lesson's discussion in a right sidebar on desktop and a full-screen panel on mobile.
+3. Course viewer participants can create top-level comments, reply to comments or replies, like comments/replies, delete their own content, and report other participants' content.
+4. Product admins receive notifications for new discussion activity and can moderate reported content under the product manage area.
+5. Course discussion participants receive notifications for new comments/replies in the same lesson discussion.
+6. Notification links open the exact lesson, open the discussion panel, scroll to the relevant comment or reply, and temporarily highlight it.
+7. `/course/[slug]/[id]/discussions` lists lesson discussions and navigates to the relevant lesson with the discussion panel open.
+8. The course viewer sidebar includes icons for introduction, discussions, sections, and lessons.
+
+## Goals
+
+1. Make discussion participation available directly inside the learning flow.
+2. Keep discussions tied to lesson context rather than creating a separate community-like product.
+3. Give admins a lightweight moderation queue for reported lesson discussion content.
+4. Preserve CourseLit's multi-tenant and permission boundaries.
+5. Avoid coupling this feature to community persistence models.
+
+## Non-Goals
+
+- Reusing `Community`, `CommunityPost`, `CommunityComment`, `CommunityReport`, or subscriber collections for course discussion data.
+- Multi-level nested threads beyond one top-level comment plus flat replies.
+- Course-wide categories, post feeds, membership workflows, or community-style product pages.
+- Reactions beyond the existing requested comment/reply flow, unless already present in a reused UI component and explicitly kept.
+- Real-time websockets or live cursors in the first release.
+- Instructor-only private notes.
+- Public API support unless explicitly added in a later API PRD.
+- Product-level blog comments in this release. They are planned for a future release, but the discussion foundation in this version must remain stable enough to support them without schema migration.
+- Blog-specific UX beyond product-level comments.
+
+## Existing Surfaces
+
+- Product manage route:
+    - `apps/web/app/(with-contexts)/dashboard/(sidebar)/product/[id]/manage/page.tsx`
+    - existing settings components under `.../manage/components`
+- Course viewer shell:
+    - `apps/web/app/(with-contexts)/course/[slug]/[id]/layout-with-sidebar.tsx`
+    - lesson page at `apps/web/app/(with-contexts)/course/[slug]/[id]/[lesson]/page.tsx`
+    - lesson renderer entry through `@components/public/lesson-viewer`
+- Community report reference:
+    - `apps/web/app/(with-contexts)/dashboard/(sidebar)/community/[id]/manage/reports/*`
+    - `apps/web/models/CommunityReport.ts`
+- Community threaded comment reference:
+    - `apps/web/models/CommunityComment.ts`
+- Notification reference:
+    - `apps/web/graphql/notifications/*`
+    - `@courselit/common-logic` notification message and href helpers
+
+## User Stories
+
+1. As a product admin, I can enable discussions from the product manage screen so learners can discuss eligible discussion targets.
+2. As a course viewer participant, I can open the discussion panel while viewing a lesson and see comments for only that lesson.
+3. As a course viewer participant, I can reply to a top-level comment or to an existing reply, and my reply appears in that comment's reply list.
+4. As a course viewer participant, I can delete my own comment or reply without deleting the rest of the thread.
+5. As a course viewer participant, I can report a comment or reply for admin review.
+6. As a course viewer participant, I can like or unlike a comment or reply.
+7. As a product admin, I can review reported discussion content under `/dashboard/product/[id]/manage/...` and resolve or reject reports.
+8. As a notified participant, I can click an email or in-app notification and land on the relevant lesson with the discussion content highlighted.
+9. As a course viewer participant, I can open `/course/[slug]/[id]/discussions`, see lesson discussion counts for lessons available in my current viewer mode, and jump into the relevant lesson discussion.
+
+## Product Requirements
+
+### Course Admin Toggle
+
+- Add a Discussions section to product manage settings.
+- The toggle must be available only for course products.
+- The setting must be persisted on the course/product record, `course.discussions` can be a boolean flag to represent if discussions are enabled for the course.
+- Disabling discussions must hide discussion entry points in the course viewer and prevent new comment/reply/report mutations.
+- Existing comments and reports must be retained when disabled.
+- Re-enabling discussions must restore existing discussion history.
+- Use strings from `apps/web/config/strings.ts`; do not inline user-facing copy in TSX files.
+
+### Product Manager Participation
+
+- Product managers must use the course viewer discussion panel for normal discussion interaction.
+- Do not add a dashboard discussion browser or management area for reading, browsing, commenting, replying, liking, deleting, or reporting ordinary discussion content.
+- The dashboard product manage area may include only the course-level discussions toggle and the reported-content queue at `/dashboard/product/[id]/manage/discussions/reports`.
+- Course viewer `/course/[slug]/[id]/discussions` remains the discussion index for all course viewer participants, including product managers.
+- Product managers must navigate from the course viewer discussion index into a lesson and use the lesson discussion panel for discussion actions.
+- Product admins can participate from the course viewer when they either have learner access to the lesson or product management permissions for the product.
+- Product management permissions grant non-enrolled course viewer participation for manageable lessons; preview mode derives from those permissions and must keep its session params intact across course viewer navigation.
+- Product admin discussion actions should behave like normal course viewer participation: they can comment, reply, like, report, and delete their own content for manageable lessons.
+
+### Lesson Discussion Panel
+
+- Add a discussion icon button to the course viewer header.
+- Hide the discussion icon button and panel for guests and logged-in non-enrolled users, even when the current lesson has `requiresEnrollment: false` and the lesson content itself is publicly viewable.
+- On desktop, opening discussions shows a right sidebar for the current lesson.
+- On mobile, opening discussions shows a full-screen panel or sheet.
+- The panel header includes:
+    - icon
+    - `Discussions`
+    - link to all discussions
+    - close button
+- The panel body lists top-level comments newest or oldest consistently; the implementation plan should choose the order and apply it everywhere.
+- Replies render under the top-level comment in a flat list.
+- Deleted comments/replies render as a deleted placeholder and keep the thread structure intact.
+- Course viewer views must not return or render the original content of deleted comments/replies.
+- Each visible comment and reply shows its like count and whether the current course viewer participant has liked it.
+- Course viewer participants can like or unlike visible comments and replies.
+- Deleted comments/replies cannot be liked or unliked.
+- Clicking on the `Reply` button should scroll to and focus the `TextEditor`.
+- The composer sits at the bottom of the panel and disables submit until form content is non-empty.
+- Comment and reply authoring must use `TextEditor` so content is stored as Tiptap documents.
+- The discussion composer must use `TextEditor` without showing the editor toolbar.
+- Comment and reply display must use `TextRenderer`.
+- Forms must use `react-hook-form`, `zod`, and refs for current form state in line with repo form conventions.
+
+### Threading Rules
+
+- A top-level comment starts a discussion thread for a lesson.
+- A reply always belongs to a top-level comment.
+- When the user replies to an existing reply, the new reply is added to the same top-level comment's reply list.
+- When the user replies to an existing reply, store that reply's ID in `parentReplyId` for context, but do not render replies as nested threads.
+- If `parentReplyId` is provided, it must reference a reply with the same `domain`, `productId`, `entityType`, `entityId`, and `commentId`.
+- URLs and notification metadata must distinguish top-level comments and replies so the target can be highlighted exactly.
+
+### Pagination And Loading
+
+- Lesson discussion comments must be paginated from the first release.
+- Use cursor pagination for comments with a stable sort, for example `{ createdAt: -1, commentId: -1 }`.
+- The lesson discussion panel must not load all comments for a lesson at once.
+- Comment responses should include:
+    - comment fields
+    - `likesCount`
+    - `hasLiked`
+    - `replyCount`
+    - a limited reply preview
+- Reply previews should return only the first page of replies for each visible comment, using a small fixed limit.
+- Replies must also be pageable by `commentId` for "view more replies" / incremental loading.
+- Reply pagination must use a stable sort, for example `{ createdAt: 1, replyId: 1 }`.
+- Course viewer discussion index, discussion panels, and report screens must use pagination for lesson summaries, comments, replies, and reports.
+- Deep-link targets from notifications must be loadable even when the target comment/reply is outside the initially loaded page.
+- Paginated API responses must use a consistent cursor envelope:
+
+```ts
+{
+    items: T[];
+    nextCursor?: string;
+    hasMore: boolean;
+}
+```
+
+- Comment cursors must encode the last item's `createdAt` and `commentId`.
+- Reply cursors must encode the last item's `createdAt` and `replyId`.
+- Discussion summary cursors must encode the last item's `lastActivityAt` and `entityId`.
+- Report cursors must encode the last item's `createdAt` and `reportId`.
+- Cursor values must be opaque to clients.
+
+### All Discussions Page
+
+- Add route: `/course/[slug]/[id]/discussions`.
+- The route appears in the course viewer sidebar only when discussions are enabled.
+- The route and sidebar entry must be hidden from guests and logged-in non-enrolled users. If an ineligible actor opens the route directly, redirect them to the course introduction page without listing discussion metadata.
+- The page lists only lessons that are currently available in the actor's course viewer access mode.
+- For enrolled non-preview learners, available lessons are determined by existing course enrollment, drip, visibility, and lesson access rules.
+- For effective preview sessions, available lessons are the lessons visible in that preview response, including preview-visible lessons that the actor could not access as an enrolled learner.
+- For guests and logged-in non-enrolled users, no lesson discussion summaries or counts are returned, including for public lessons with `requiresEnrollment: false`.
+- For available lessons, show lessons with at least one visible or deleted discussion item, plus counts.
+- Do not show available lessons with zero discussion activity.
+- Do not show discussion activity for lessons outside the actor's current viewer mode. For non-preview learners, this includes lessons that have not dripped yet; for effective preview sessions, this includes lessons omitted from the preview response.
+- Server logic must resolve the actor's available lesson IDs before querying discussion summaries/counts.
+- Discussion summaries/counts must be queried only for that available lesson allowlist; do not query all lesson discussion counts and filter them client-side.
+- Empty state: if no discussions exist, show a concise in-context empty state.
+- Clicking a lesson row navigates to `/course/[slug]/[id]/[lessonId]?discussion=open#discussion-[contentId]` or the final agreed URL shape.
+- The destination must open the discussion panel and scroll to the relevant content when a target exists.
+
+### Sidebar Icons
+
+- Add icons to course viewer navigation:
+    - introduction/about
+    - discussions
+    - section headers
+    - lessons
+- Use existing icon libraries already used by the course viewer (`lucide-react` and `@courselit/icons`) rather than adding a dependency.
+- Ensure active, locked, completed, and discussion states remain visually distinct in the learner course viewer.
+- Do not add admin controls for active, locked, or completed states as part of this feature. Those states remain derived from the current route, existing course access/drip rules, and learner progress.
+- The only new admin-facing sidebar-related control in this release is the course-level discussions toggle.
+
+### Moderation
+
+- Add only a reported-content route under the product manage route: `/dashboard/product/[id]/manage/discussions/reports`.
+- `/dashboard/product/[id]/manage/discussions/reports` is the report queue.
+- The report queue should show only reported content and report workflow controls.
+- General browsing, lesson-level discussion review, commenting, replying, liking, deleting own content, and reporting content happen in the course viewer discussion panel.
+- Soft delete and restore actions happen only in `/dashboard/product/[id]/manage/discussions/reports`.
+- Reuse the community report screen as UX reference, adapted to product/course naming.
+- Admins can filter reports by status.
+- Course discussion reports must follow the same status cycle as community reports: `pending` -> `accepted` -> `rejected` -> `pending`.
+- The UI must label the status as `accepted`; do not use `approved` for this feature.
+- Moving a report to `accepted` soft-deletes/hides the reported comment or reply and retains a deleted placeholder.
+- Moving an accepted report away from `accepted` restores the reported content only when there are no other accepted reports for the same `contentType` and `contentId`.
+- Report queue views may show original deleted content, but must label it clearly as deleted.
+- Report queue views must allow restoring deleted comments/replies through the same report status cycle.
+- Admins can reject a report with an optional or required reason, matching the community report precedent.
+- Reported content rows must show:
+    - lesson title
+    - top-level comment/reply content preview
+    - reporter
+    - author
+    - reason
+    - status
+    - created date
+    - action controls
+- The moderation screen must enforce product management permissions and tenant isolation.
+
+### Abuse And Rate Limits
+
+- Add a reusable app-level rate-limit helper that can be applied to course discussions and later reused by other mutation-heavy features such as communities.
+- Course discussions should be the first consumer of this helper.
+- Back the helper with a generic `RateLimitEvent` persistence model.
+- Suggested helper shape:
+    - `assertRateLimit({ domain, userId, scope, action, subjectId, window, limit })`
+    - `scope` examples: `"course_discussion"`, `"community"`
+    - `action` examples: `"comment:create"`, `"reply:create"`, `"like:toggle"`, `"report:create"`
+    - for discussions, `subjectId` should be `${productId}:${entityType}:${entityId}`
+    - for other scopes, `subjectId` can be a community ID, post ID, or another bounded resource ID
+- Enforce limits server-side in mutation logic for:
+    - creating top-level comments
+    - creating replies
+    - liking/unliking comments or replies
+    - reporting comments or replies
+- Use Mongo-backed checks/counts against `RateLimitEvent` for this release; do not add new Redis/token-bucket infrastructure.
+- Define named constants for limits instead of inline numbers.
+- Suggested starting limits:
+    - max 5 comments/replies per minute per user per discussion target
+    - max 50 comments/replies per day per user per discussion target
+    - max 60 like/unlike actions per minute per user per discussion target
+    - max 10 reports per hour per user per discussion target
+- Reject duplicate identical comment/reply content by the same user in the same discussion target within a short window.
+- Return a clear rate-limit error when a limit is exceeded.
+- Rate-limit checks must include `domain`, `userId`, `scope`, `action`, and a target-specific `subjectId`.
+- Keep the helper generic, but keep Course Discussion limit constants feature-specific so future community adoption can choose its own thresholds.
+
+## Data Design
+
+Create original schemas and models. Do not reuse community collections.
+
+All new discussion-owned schemas must use the `ProductDiscussion` prefix because the persistence model is product-scoped and target-based, even though this release only exposes lesson discussions for course products. Do not introduce `CourseDiscussion*` schema/model names. Generic cross-feature schemas, such as `RateLimitEvent`, may keep generic names.
+
+### Entity Targets
+
+This PRD implements discussions with a target-based shape so the same substrate can support lesson-level course discussions now and product-level blog comments in a future release.
+
+Discussion targets use:
+
+```ts
+entityType: "lesson" | "product";
+productId: string;
+entityId: string; // lessonId for course lessons, productId for blog product comments
+```
+
+Supported targets:
+
+- `entityType = "lesson"` supports course lesson discussions.
+- `entityType = "product"` is reserved for future product-level discussions, including blog product comments, and should be supported by the schema/foundation from this version.
+- For `entityType = "lesson"`, `productId` maps to the course product ID and `entityId` maps to `lessonId`.
+- For `entityType = "product"`, `productId` maps to the blog product ID and `entityId` maps to the same blog product ID.
+- This release should not ship blog comment UI or product-level discussion routes unless explicitly added to scope later.
+- This release must create discussion records only with `entityType = "lesson"`.
+- API/UI support for creating, listing, notifying, or deep-linking `entityType = "product"` records is out of scope until the future blog-comments release.
+- Do not introduce schema or helper assumptions that would require migration when product-level blog comments are implemented.
+
+All discussion-owned schemas in this PRD should store `productId`, `entityType`, and `entityId` now to avoid a future migration for blog comments.
+
+### Product Discussion Setting
+
+Add a discussion setting to the existing product model. This release exposes the setting only for products whose type is `course`:
+
+```ts
+discussions: boolean;
+```
+
+Default:
+
+- `discussions: false` for existing and new course products.
+- Discussions are opt-in per product and must remain off until a product admin enables them.
+
+- No migration is required if the code treats missing `discussions` as `false`.
+
+### RateLimitEvent
+
+Generic app-level rate-limit event model. This is not course-discussion-specific and should be reusable by communities and other mutation-heavy features.
+
+```ts
+{
+    domain: ObjectId;
+    userId: string;
+    scope: string;
+    action: string;
+    subjectId: string;
+    fingerprint?: string;
+    createdAt: Date;
+}
+```
+
+Indexes:
+
+- `{ domain: 1, userId: 1, scope: 1, action: 1, subjectId: 1, createdAt: -1 }`
+- `{ domain: 1, userId: 1, scope: 1, subjectId: 1, fingerprint: 1, createdAt: -1 }`
+- TTL index on `createdAt` to expire rate-limit events after 25 hours. This covers the longest current enforcement window of 24 hours while allowing for MongoDB TTL cleanup delay.
+
+Usage:
+
+- `assertRateLimit(...)` records a `RateLimitEvent` after an action passes its checks.
+- Duplicate content checks can use `fingerprint`, for example a hash of normalized plain text scoped by `subjectId`.
+- Course discussion rate-limit constants should use `scope: "course_discussion"` and `subjectId = ${productId}:${entityType}:${entityId}`.
+
+### ProductDiscussionComment
+
+One document per top-level comment.
+
+```ts
+{
+    domain: ObjectId;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    commentId: string;
+    userId: string;
+    content: TextEditorContent;
+    likesCount: number;
+    deleted: boolean;
+    deletedAt?: Date;
+    deletedBy?: string;
+    deletedByRole?: "author" | "course_admin";
+    deleteReason?: string;
+    restoredAt?: Date;
+    restoredBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, commentId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, createdAt: -1, commentId: -1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, updatedAt: -1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, userId: 1, deleted: 1 }`
+
+### ProductDiscussionReply
+
+One document per reply. Replies always belong to a top-level comment.
+
+```ts
+{
+    domain: ObjectId;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    commentId: string;
+    replyId: string;
+    parentReplyId?: string;
+    userId: string;
+    content: TextEditorContent;
+    likesCount: number;
+    deleted: boolean;
+    deletedAt?: Date;
+    deletedBy?: string;
+    deletedByRole?: "author" | "course_admin";
+    deleteReason?: string;
+    restoredAt?: Date;
+    restoredBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, replyId: 1 }`
+- `{ domain: 1, commentId: 1, createdAt: 1, replyId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, createdAt: -1, replyId: -1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, userId: 1, deleted: 1 }`
+
+### ProductDiscussionLike
+
+One document per user like on a comment or reply.
+
+```ts
+{
+    domain: ObjectId;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    contentType: "comment" | "reply";
+    contentId: string;
+    commentId?: string;
+    userId: string;
+    createdAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, contentType: 1, contentId: 1, userId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, userId: 1 }`
+- `{ domain: 1, contentType: 1, contentId: 1 }`
+
+Notes:
+
+- Store comment and reply content as Tiptap `TextEditorContent` documents, not plain strings.
+- Store replies in their own collection while keeping the UI and API behavior as one-level replies under a top-level comment.
+- Use `parentReplyId` only as context for replies to replies; it must not create nested rendering or recursive reply queries.
+- Store likes in `ProductDiscussionLike`; do not store user ID arrays on comments or replies.
+- For comment likes, `contentId` is the `commentId`.
+- For reply likes, `contentId` is the `replyId` and `commentId` stores the parent top-level comment for context.
+- Store denormalized `likesCount` on comments and replies for efficient reads.
+- Like/unlike operations must update `ProductDiscussionLike` and the target comment/reply `likesCount` consistently and idempotently.
+- `hasLiked` must be computed from `ProductDiscussionLike` for the current user.
+- Reply queries must be scoped by `domain` and `commentId`, and should preserve stable reply ordering.
+- Soft delete operations must set `deleted`, `deletedAt`, `deletedBy`, and `deletedByRole`.
+- `deleteReason` is optional and can be used for admin moderation context.
+- Restore operations must set `deleted: false`, `restoredAt`, and `restoredBy`.
+
+### ProductDiscussionSummary
+
+One document per discussion target summary. This avoids expensive aggregation for course viewer `/discussions` and lesson discussion panels.
+
+```ts
+{
+    domain: ObjectId;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    commentsCount: number;
+    repliesCount: number;
+    totalCount: number;
+    activityCountIncludingDeleted: number;
+    lastActivityAt: Date;
+    lastCommentId?: string;
+    lastReplyId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, productId: 1, entityType: 1, entityId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, lastActivityAt: -1, entityId: 1 }`
+
+Summary maintenance:
+
+- Create or update the summary when a top-level comment or reply is created.
+- Summary records are created only after first activity, so `lastActivityAt` is required and always reflects the most recent created comment/reply, even if all activity later becomes soft-deleted.
+- Increment `commentsCount` for a new top-level comment.
+- Increment `repliesCount` for a new reply.
+- Maintain `totalCount = commentsCount + repliesCount`.
+- Increment `activityCountIncludingDeleted` for every new top-level comment or reply.
+- Update `lastActivityAt`, `lastCommentId`, and `lastReplyId` on new activity.
+- Soft-delete and restore operations must not update `lastActivityAt`, `lastCommentId`, or `lastReplyId`.
+- Decrement `commentsCount` when a top-level comment is soft-deleted.
+- Decrement `repliesCount` when a reply is soft-deleted.
+- Increment the appropriate counter again when an admin restores a deleted comment or reply.
+- Keep `totalCount = commentsCount + repliesCount` after create, soft-delete, and restore operations.
+- Counts represent currently visible, non-deleted discussion activity. Deleted placeholders preserve conversation context but do not contribute to summary counts.
+- `activityCountIncludingDeleted` is append-only for newly created comments/replies; soft-delete and restore operations must not decrement or increment it.
+- Course viewer `/discussions` can use `activityCountIncludingDeleted > 0` to show available lessons that contain only deleted placeholders, while visible counts continue to come from `commentsCount`, `repliesCount`, and `totalCount`.
+- Course viewer `/discussions` must filter summaries by the server-resolved available lesson ID allowlist for the actor's current viewer mode.
+- Product managers can read summaries for manageable lessons through the course viewer discussion index.
+
+### ProductDiscussionSubscriber
+
+One document per user subscription to a lesson discussion, mirroring the existing `CommunityPostSubscriber` pattern.
+
+```ts
+{
+    domain: ObjectId;
+    subscriptionId: string;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    userId: string;
+    subscription: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, productId: 1, entityType: 1, entityId: 1, userId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, subscription: 1, userId: 1 }`
+
+Subscriber maintenance:
+
+- Add or reactivate a subscription for a course viewer participant when they create a top-level comment or reply in a lesson discussion.
+- Use active `ProductDiscussionSubscriber` records to find lesson discussion notification recipients instead of scanning comments and replies.
+- Soft-deleting a user's comment/reply does not automatically unsubscribe them.
+- If all of a user's comments/replies in a lesson discussion are deleted, set `subscription: false`.
+- Restoring one of the user's comments/replies in a lesson discussion should reactivate their subscription.
+- Product admins are notification recipients through product management permissions, not through this subscriber collection unless they also participate from the course viewer through learner access or product management permissions.
+
+### ProductDiscussionReport
+
+```ts
+{
+    domain: ObjectId;
+    productId: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    reportId: string;
+    contentType: "comment" | "reply";
+    contentId: string;
+    commentId?: string;
+    userId: string;
+    reason: string;
+    status: "pending" | "accepted" | "rejected";
+    rejectionReason?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+```
+
+Indexes:
+
+- unique `{ domain: 1, contentType: 1, contentId: 1, userId: 1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1, status: 1, createdAt: -1, reportId: -1 }`
+- `{ domain: 1, productId: 1, entityType: 1, entityId: 1 }`
+
+Report target rules:
+
+- For comment reports, `contentId` is the `commentId`.
+- For reply reports, `contentId` is the `replyId` and `commentId` stores the parent top-level comment for context.
+- Duplicate reports by the same user for the same `contentType` and `contentId` are rejected or idempotently returned.
+
+## API And GraphQL Requirements
+
+Prefer extending existing GraphQL boundaries if that keeps boundaries clear.
+
+Required operations:
+
+- get course discussion setting as part of course/product reads used by manage and viewer screens
+- update course discussion setting
+- list paginated discussion comments for a lesson, including `replyCount`, `likesCount`, `hasLiked`, and limited reply previews
+- list paginated replies by `commentId`, including `likesCount` and `hasLiked`
+- list paginated discussion summary/counts by lesson for `/discussions`
+- create top-level comment
+- create reply
+- like or unlike top-level comment
+- like or unlike reply
+- delete own comment
+- delete own reply
+- report comment or reply
+- list course discussion reports
+- count course discussion reports by status
+- update course discussion report status, applying soft-delete/restore side effects through the community-style status cycle
+- maintain lesson discussion subscriber records
+
+Validation:
+
+- product must exist in the current domain
+- product type must be `course` for `entityType = "lesson"`
+- `entityType = "product"` is schema-supported but must be rejected by course discussion API/UI write and read operations in this release
+- discussions must be enabled for course viewer write operations
+- for `entityType = "lesson"`, `entityId` must be a lesson that belongs to the product
+- course discussion read and write operations require an enrolled learner or product manager; guests and logged-in non-enrolled users must not receive discussion summaries, comments, replies, like state, or composer affordances, even for public lessons with `requiresEnrollment: false`
+- actor must have access to the target entity before reading or writing discussion content:
+    - for `entityType = "lesson"` in normal learner mode, enforce existing course enrollment, drip, visibility, and lesson access rules
+    - for `entityType = "lesson"`, allow access when the actor has product management permissions for the product, even when the actor is not enrolled
+    - preview mode must be permission-backed, not merely requested; the server must verify that the current actor can manage the course in context before granting preview access
+- course viewer write mutations must pass course discussion rate-limit checks
+- comment and reply content must validate as a non-empty Tiptap document
+- comment and reply content must validate as a Tiptap document shape before persistence, including `type: "doc"`
+- comment and reply content must enforce a maximum serialized JSON size before persistence, measured with `Buffer.byteLength(JSON.stringify(content), "utf8")`
+- comment and reply content must enforce a maximum extracted plain-text length before persistence
+- Use named constants for discussion content limits:
+    - `MAX_DISCUSSION_CONTENT_BYTES = 32768`
+    - `MAX_DISCUSSION_TEXT_LENGTH = 5000`
+- `parentReplyId`, when provided, must belong to a reply in the same domain, course, `entityType`, `entityId`, and top-level comment
+- lesson discussion summaries for `/discussions` must exclude lessons that are not available in the actor's current course viewer mode
+- `/discussions` summary generation must resolve available lesson IDs first and use them as a server-side query filter before reading discussion counts
+- product admins can read and participate in manageable discussions from the course viewer without learner enrollment
+- product admins can create course viewer comments/replies when they either pass learner access checks or have product management permissions for the product
+- product admin moderation deletes must happen through the report queue, soft-delete comments/replies, and preserve placeholders
+- delete operations must record `deletedBy`, `deletedByRole`, and `deletedAt`
+- product admin report status updates that restore content must make the content visible in eligible course viewer contexts again and record `restoredBy` and `restoredAt`
+- summary counters must be updated when comments/replies are created, soft-deleted, or restored
+- lesson discussion subscriber records must be updated when comments/replies are created, soft-deleted, or restored
+- authors can delete their own content
+- course viewer participants can like/unlike available, non-deleted comments and replies
+- product admins can report any manageable discussion content from the course viewer discussion panel
+- product admins can soft-delete or restore discussion content only through report/moderation flows
+- duplicate reports by the same user for the same `contentType` and `contentId` are rejected or idempotently returned
+
+Future product-level blog comment validation:
+
+- for `entityType = "product"`, `entityId` must match `productId`
+- for `entityType = "product"`, enforce existing product/blog visibility and access rules before reading or writing discussion content
+
+## Notification Requirements
+
+Add granular activity types for course discussion comments/replies and reactions.
+
+- Add `COURSE_DISCUSSION_COMMENT_CREATED` for both top-level comments and replies.
+- Store the specific comment event kind in metadata as `eventType: "comment_created" | "reply_created"`.
+- Add `COURSE_DISCUSSION_REACTED` for newly created likes on comments or replies.
+- A reaction activity must notify only the liked content's author, exclude self-likes, and must not be emitted for unlikes or idempotent repeated likes.
+- Seed default notification preferences for both activity types using the existing notification preference system.
+- Show `Course discussion comment created` and `Course discussion reacted` in the existing General notification preferences screen.
+- Both preference rows must support the same App and Email channel toggles as the existing community activity rows.
+- Product admins and learners should use these preference rows to control discussion notifications independently.
+- Respect recipient notification preferences before creating in-app or email notifications.
+- Build the recipient list as a unique set of `userId`s before sending notifications.
+- Exclude the actor from recipients.
+- Deduplicate recipients in application logic when a user appears through multiple paths, for example as both participant and product admin.
+- DB-level notification idempotency/deduplication is out of scope for this release.
+- Use the existing community-style notification implementation pattern:
+    - call `recordActivity(...)` from `apps/web` after comment/reply creation
+    - pass recipient IDs through `metadata.forUserIds`
+    - let the existing `dispatch-notification` queue process notification preferences and app/email channels
+- Do not introduce a new notification batching/fanout system for this release.
+
+Recipients for a new top-level comment:
+
+- active `ProductDiscussionSubscriber` users for the same discussion target
+- all product admins for the product
+- exclude the actor
+
+Recipients for a reply:
+
+- active `ProductDiscussionSubscriber` users for the same discussion target
+- all product admins for the product
+- exclude the actor
+
+Recipient for a reaction:
+
+- the liked comment/reply author only
+- exclude the actor, so self-likes do not create activity
+
+Product admin recipient resolution must use the same product-management permission source used to authorize dashboard product management access.
+
+Notification payload metadata:
+
+```ts
+{
+    productId: string;
+    productSlug: string;
+    entityType: "lesson" | "product";
+    entityId: string;
+    commentId: string;
+    replyId?: string;
+    eventType?: "comment_created" | "reply_created";
+    contentType?: "comment" | "reply";
+}
+```
+
+Notification href:
+
+- For `entityType = "lesson"`, must navigate to the lesson.
+- For `entityType = "product"`, href generation is reserved for the future product-level discussion surface.
+- This release must not create `entityType = "product"` notification hrefs unless product-level comments are explicitly added to scope.
+- Must open the discussion panel.
+- Must include a stable target for scroll and highlight.
+- For recipients who can manage the product, include `preview=true` so notification links remain valid for unpublished products or lessons. Determine management access from the recipient's current permissions and product ownership; never grant preview from URL state alone.
+- Example shape:
+    - `/course/[slug]/[id]/[lessonId]?discussion=open#discussion-comment-[commentId]`
+    - `/course/[slug]/[id]/[lessonId]?discussion=open#discussion-reply-[replyId]`
+    - manager target: `/course/[slug]/[id]/[lessonId]?discussion=open&preview=true#discussion-comment-[commentId]`
+
+Email:
+
+- Email notification links must use the same href target.
+- Link generation should live in the shared notification helper used by in-app notification formatting.
+
+Highlight:
+
+- On page load, if a discussion hash exists, open the panel, scroll the target into view, and apply a temporary highlight.
+- Reuse the community comment highlight approach where practical.
+- Remove or fade the highlight after a short timeout.
+
+## Permissions And Tenant Safety
+
+- Every query/mutation must include `domain` in persistence filters.
+- Do not allow cross-domain access by productId, entityType, entityId, commentId, replyId, or reportId.
+- Preserve the domain-owner invariant; this feature must not update owner users or domain email.
+- Product admin capabilities must follow existing product management permissions.
+- For `entityType = "lesson"`, normal learner access must follow existing enrollment, visibility, drip, and lesson access rules.
+- For `entityType = "lesson"`, product management permissions can grant non-enrolled product admins course viewer participation for manageable lessons.
+- For `entityType = "product"`, course viewer read/write APIs must reject access in this release because product-level comments are future-only.
+- Public lesson access is not discussion access. GraphQL discussion queries and mutations must verify enrollment or product management permissions before resolving discussion-owned data or user-specific fields such as `hasLiked`.
+- Deleted content remains addressable for moderation and notification context, but user-facing content text is hidden.
+- Deleted content remains stored for admin moderation/audit visibility unless a future hard-delete policy is introduced.
+- Course viewer APIs must redact deleted comment/reply content and return only deleted placeholders.
+- Admin dashboard APIs may return deleted comment/reply content, but the UI must display a clear deleted label.
+- Hard-deleting a product must delete all records for that `productId` from `ProductDiscussionComment`, `ProductDiscussionReply`, `ProductDiscussionLike`, `ProductDiscussionReport`, `ProductDiscussionSummary`, and `ProductDiscussionSubscriber`.
+- Hard-deleting a product must also delete its product discussion `Activity` and `Notification` records by `{ domain, "metadata.courseId": productId }`. This cleanup is intentionally based on product ownership metadata rather than a fixed activity-type list so legacy and future discussion activity types cannot leave dead notification links.
+- `Activity` and `Notification` must each define an index on `{ domain: 1, "metadata.courseId": 1 }` for bounded product cleanup.
+- Product deletion must not scan or explicitly delete generic `RateLimitEvent` records. These short-lived records expire through their 25-hour TTL index.
+- Product discussion cleanup must run from every product hard-deletion path, including the interactive `deleteCourse` flow and `packages/scripts/src/cleanup-domain.ts`.
+- Deleting a user must perform the following to ensure GDPR compliance while preserving thread layout and summary counts:
+    - Hard-delete all `ProductDiscussionLike`, `ProductDiscussionSubscriber`, and `ProductDiscussionReport` documents authored/created by the deleted user.
+    - Anonymize all `ProductDiscussionComment` and `ProductDiscussionReply` documents authored by the user by setting their `userId` to `"deleted"`, marking them `deleted: true`, and clearing their `content` field to `{ type: "doc", content: [] }`.
+
+## UX Requirements
+
+- Use shadcn UI conventions for dashboard/admin surfaces.
+- Use `@courselit/page-primitives` for every public course viewer discussion UI surface outside `/dashboard` so controls inherit the active theme.
+- Use existing course viewer visual language for learner and preview surfaces.
+- Use `TextEditor` without its toolbar for comment/reply composition and `TextRenderer` for rendering stored comment/reply Tiptap documents.
+- Enforce comment/reply content limits on the client for user feedback, but treat server-side validation as authoritative.
+- Put all new strings in `apps/web/config/strings.ts`.
+- Use the existing admin empty state component for dashboard empty states where applicable.
+- Do not add a marketing/landing page.
+- Ensure the discussion panel does not overlap core lesson controls on desktop.
+- On mobile, the full-screen panel must trap focus appropriately and return focus to the trigger on close.
+- Long comments must wrap without overflowing the panel.
+- Loading, empty, error, disabled, deleted, and reported states must be explicit.
+
+## Testing Strategy
+
+Required tests:
+
+- GraphQL logic tests under existing `logic.test.ts` files for new discussion behavior.
+- Model/helper tests for threading, Tiptap document validation/formatting, and notification recipient selection.
+- Course manage UI tests for toggle visibility and save behavior.
+- Course viewer discussion index and panel tests for non-enrolled product admins with product management permissions.
+- Course viewer tests for:
+    - discussion sidebar visibility
+    - mobile full-screen behavior where feasible
+    - `/discussions` route listing and navigation URL
+    - URL query/hash opening and highlight behavior
+- Moderation tests for report listing, status updates, duplicate reports, and permission checks.
+- Restore tests for report-gated admin restoration and course viewer visibility after restore.
+- Rate-limit tests for comment, reply, like/unlike, report, and duplicate content windows.
+- Notification tests for href generation and recipient selection.
+
+Run:
+
+- `pnpm test`
+- `pnpm lint`
+- `pnpm prettier`
+
+If REST endpoints or public API OpenAPI fragments are touched:
+
+- update `openapi.mjs`
+- run the relevant OpenAPI generation/check command for `apps/web`
+
+## Rollout Plan
+
+### Phase 1: Data And Server Logic
+
+- Add original discussion models:
+    - `ProductDiscussionComment`
+    - `ProductDiscussionReply`
+    - `ProductDiscussionLike`
+    - `ProductDiscussionReport`
+    - `ProductDiscussionSummary`
+    - `ProductDiscussionSubscriber`
+- Add course discussion setting.
+- Add reusable rate-limit helper backed by `RateLimitEvent`.
+- Add discussion GraphQL operations and permission checks.
+- Add notification activity type, default notification preferences, preference UI support, recipient selection, href metadata, and tests.
+
+### Phase 2: Course Viewer UI
+
+- Add course viewer sidebar icons.
+- Add discussion trigger and responsive panel.
+- Add lesson discussion list, composer, reply flow, like/unlike flow, delete flow, and report flow.
+- Add URL open/scroll/highlight behavior.
+- Add `/course/[slug]/[id]/discussions` route.
+
+### Phase 3: Admin UI
+
+- Add product manage discussions toggle.
+- Add only the reported-content queue under product manage at `/dashboard/product/[id]/manage/discussions/reports`.
+- Add report table, filters, status updates, report-gated soft delete, restore, and moderation actions.
+
+### Phase 4: Verification And Polish
+
+- Run full tests, lint, and formatter.
+- Manually verify desktop and mobile normal learner, product manager course viewer interaction, and admin report queue flows.
+- Verify notification emails and in-app notifications navigate to the target content.
+- Verify disabled discussions preserve existing data but block new writes.
+
+## Task Breakdown
+
+### Task 1: Product Discussion Persistence Models
+
+Description: Add the discussion-owned Mongo models and indexes, plus the generic `RateLimitEvent` model.
+
+Acceptance criteria:
+
+- `ProductDiscussionComment`, `ProductDiscussionReply`, `ProductDiscussionLike`, `ProductDiscussionReport`, `ProductDiscussionSummary`, `ProductDiscussionSubscriber`, and `RateLimitEvent` are defined with the fields and indexes in this PRD.
+- Discussion models use `productId`, `entityType`, and `entityId`; no `CourseDiscussion*` models are introduced.
+- `ProductDiscussionSummary.lastActivityAt` is required and summary counters include `activityCountIncludingDeleted`.
+- A shared product discussion cleanup helper hard-deletes all discussion-owned records plus product-linked activity and notification records, and is used by both interactive product deletion and domain cleanup. Generic rate-limit events remain TTL-managed.
+
+Verification:
+
+- Model/index tests or schema assertions cover required indexes where the repo has precedent.
+- Existing test suite still passes for model imports.
+
+Dependencies: None.
+
+Estimated scope: Medium.
+
+### Task 2: Product Discussion Setting
+
+Description: Add the `discussions` setting to product reads and updates for course products.
+
+Acceptance criteria:
+
+- Missing `discussions` is treated as `false`.
+- The manage settings screen can save the toggle for course products only.
+- Viewer reads hide discussion entry points when discussions are disabled.
+
+Verification:
+
+- GraphQL tests cover default false and update behavior.
+- Course manage UI test covers toggle visibility and save behavior.
+
+Dependencies: Task 1.
+
+Estimated scope: Medium.
+
+### Task 3: Shared Discussion Validation And Rate Limits
+
+Description: Implement reusable server helpers for target validation, Tiptap content validation, duplicate-content checks, and rate limiting.
+
+Acceptance criteria:
+
+- `entityType = "lesson"` validates product ownership, lesson membership, enabled discussions, and the actor's current course viewer access mode.
+- Normal learner mode enforces enrollment/drip/access rules.
+- Product management permissions allow product admins to participate in manageable lesson discussions without learner enrollment.
+- `entityType = "product"` is rejected by this release's discussion API/UI paths.
+- Comment/reply content enforces `MAX_DISCUSSION_CONTENT_BYTES = 32768` and `MAX_DISCUSSION_TEXT_LENGTH = 5000`.
+- Rate limits use `scope = "course_discussion"` and `subjectId = ${productId}:${entityType}:${entityId}`.
+
+Verification:
+
+- Logic tests cover access rejection, disabled discussions, invalid Tiptap documents, size limits, duplicate content, and rate-limit failures.
+
+Dependencies: Tasks 1-2.
+
+Estimated scope: Medium.
+
+### Task 4: Comment And Reply APIs
+
+Description: Add paginated read APIs and write/delete APIs for comments and replies.
+
+Acceptance criteria:
+
+- Comments use cursor pagination and include `likesCount`, `hasLiked`, `replyCount`, and limited reply previews.
+- Replies are pageable by `commentId` with stable ordering.
+- Creating comments/replies updates summaries and subscriber records.
+- Author delete soft-deletes content, updates visible counters, preserves placeholders, and updates subscriber state when needed.
+
+Verification:
+
+- GraphQL logic tests cover pagination, deep-link target loading, create, reply-to-reply flattening with `parentReplyId`, delete, counter updates, course viewer redaction of deleted content, and preview access participation.
+
+Dependencies: Task 3.
+
+Estimated scope: Medium.
+
+### Task 5: Likes And Reports APIs
+
+Description: Add like/unlike and report APIs for comments and replies.
+
+Acceptance criteria:
+
+- Likes use `ProductDiscussionLike` with unique `{ domain, contentType, contentId, userId }`.
+- Like/unlike updates target `likesCount` idempotently and rejects deleted/inaccessible content.
+- Reports use `ProductDiscussionReport` with duplicate report protection.
+
+Verification:
+
+- GraphQL logic tests cover comment likes, reply likes, duplicate likes, unlike idempotency, report creation, duplicate reports, tenant isolation, and deleted-content rejection.
+
+Dependencies: Task 4.
+
+Estimated scope: Medium.
+
+### Checkpoint: Server Foundation
+
+- `pnpm test` passes for discussion-related logic.
+- Cursor response shapes and indexes match this PRD.
+- Tenant and access checks are covered before course viewer UI begins.
+
+### Task 6: Course Viewer Discussion Panel
+
+Description: Build the course viewer discussion trigger, desktop sidebar, mobile full-screen panel, composer, comment list, replies, likes, delete, and report flows.
+
+Acceptance criteria:
+
+- Public course viewer UI uses `@courselit/page-primitives` and existing viewer visual language.
+- Composer uses toolbarless `TextEditor`; rendering uses `TextRenderer`.
+- Deleted placeholders, loading, empty, disabled, error, and reported states are explicit.
+- Desktop and mobile layouts do not overlap lesson controls.
+
+Verification:
+
+- Course viewer tests cover panel visibility, create/reply/like/delete/report interactions where feasible.
+- Manual desktop and mobile checks pass.
+
+Dependencies: Tasks 4-5.
+
+Estimated scope: Medium.
+
+### Task 7: Course Viewer All Discussions Page And Deep Links
+
+Description: Add `/course/[slug]/[id]/discussions` and notification/hash-driven opening/highlighting behavior.
+
+Acceptance criteria:
+
+- The page lists only server-filtered lesson summaries available in the actor's current course viewer mode.
+- In normal learner mode, this means accessible/dripped lessons.
+- Guests and logged-in non-enrolled users see no discussion hub rows or counts, including for public lessons with `requiresEnrollment: false`.
+- For product admins, this means lessons they can manage through product management permissions.
+- Lessons with zero activity are hidden; lessons with only deleted placeholders can appear via `activityCountIncludingDeleted`.
+- Clicking a row navigates to the relevant lesson and opens the discussion panel.
+- Hash targets scroll to and temporarily highlight the exact comment or reply, including targets outside the first page.
+
+Verification:
+
+- Tests cover normal learner accessible lesson filtering, no future-lesson leakage outside preview, preview-visible lesson filtering, row navigation, panel opening, and highlight behavior.
+- Tests cover that guests and logged-in non-enrolled users do not see the discussion sidebar entry, do not receive `/discussions` summaries, and do not receive lesson comments/replies for public lessons with `requiresEnrollment: false`.
+
+Dependencies: Task 6.
+
+Estimated scope: Medium.
+
+### Task 8: Notifications And Preferences
+
+Description: Add discussion notification activity, preference row, recipient resolution, and href generation.
+
+Acceptance criteria:
+
+- `COURSE_DISCUSSION_COMMENT_CREATED` and `COURSE_DISCUSSION_REACTED` are added with default preferences.
+- General notification preferences show `Course discussion comment created` and `Course discussion reacted`, each with App and Email toggles.
+- Recipients include active subscribers and product admins from the dashboard product-management permission source, excluding the actor and deduped in application logic.
+- Lesson notification hrefs open the correct lesson discussion target and include stable highlight anchors.
+
+Verification:
+
+- Notification tests cover preference handling, recipient selection, admin/participant dedupe, actor exclusion, and href generation.
+
+Dependencies: Tasks 4 and 7.
+
+Estimated scope: Medium.
+
+### Task 9: Reported Content Queue And Moderation
+
+Description: Add `/dashboard/product/[id]/manage/discussions/reports` with community-style status flow and report-gated soft delete/restore.
+
+Acceptance criteria:
+
+- This is the only discussion-specific management route under product manage.
+- The route shows only reported content and report workflow controls.
+- There is no dashboard discussion browser for normal discussion reading, commenting, replying, liking, deleting, or reporting.
+- Reports can be filtered by status.
+- Status cycle is `pending -> accepted -> rejected -> pending`, with UI label `accepted`.
+- Moving to `accepted` soft-deletes the target and updates visible counters/subscribers.
+- Moving away from `accepted` restores only when no other accepted report exists for the same target.
+
+Verification:
+
+- Moderation tests cover status transitions, counter changes, restore behavior, duplicate accepted reports, permission checks, and course viewer visibility changes.
+
+Dependencies: Tasks 4-5.
+
+Estimated scope: Medium.
+
+### Checkpoint: End-To-End Feature
+
+- Course viewer participant can create, reply, like, report, delete, browse `/discussions`, and follow deep links.
+- Guests and logged-in non-enrolled users cannot see or interact with course discussions, even when they can view a public lesson whose `requiresEnrollment` is `false`.
+- Product admin with product management permissions can participate in manageable lesson discussions without learner enrollment.
+- Product admin can enable discussions, browse discussions and report content from the course viewer, then moderate reports and restore content from the reported-content queue.
+- Notification preferences and delivery are verified for app and email channels.
+
+### Task 11: Final Verification And Release Prep
+
+Description: Run full verification, tighten UI details, and prepare for release.
+
+Acceptance criteria:
+
+- Disabled discussions hide entry points and block new writes while preserving data.
+- Product-level `entityType = "product"` records remain schema-supported but rejected by this release's APIs.
+- No community persistence collections are used for product discussion data.
+- All new strings are in `apps/web/config/strings.ts`.
+
+Verification:
+
+- Run `pnpm test`.
+- Run `pnpm lint`.
+- Run `pnpm prettier`.
+- Manual smoke test desktop and mobile normal learner, preview, product manager course viewer interaction, and report queue flows.
+
+Dependencies: Tasks 1-9.
+
+Estimated scope: Small.
+
+## Success Criteria
+
+- Product admins can enable and disable discussions for a product.
+- When enabled, every lesson available in the actor's current course viewer mode can host a lesson-specific discussion for `entityType = "lesson"`.
+- Replies are always flattened under the top-level comment.
+- Course viewer participants can like and unlike visible comments and replies, and like state/counts update consistently.
+- `/course/[slug]/[id]/discussions` lists lesson discussion activity and deep-links correctly.
+- `/course/[slug]/[id]/discussions` never reveals discussion activity outside the actor's current course viewer mode. Non-preview learners must not see lessons that have not dripped; effective preview sessions may show preview-visible lessons even without learner enrollment.
+- `/course/[slug]/[id]/discussions` never reveals discussion activity to guests or logged-in non-enrolled users, including for public lessons with `requiresEnrollment: false`.
+- New comments and replies notify discussion participants and product admins, excluding the actor.
+- Email and in-app notification links open the exact lesson discussion target and highlight it temporarily.
+- Course viewer participants can report content and delete their own content.
+- Product admins can browse discussions and report content from the course viewer without learner enrollment.
+- Product admins can soft-delete/restore comments and replies only from report/moderation views.
+- No community persistence collection is used for course discussion data.
+- Tenant, course, lesson, and permission checks are covered by tests.
+
+## Open Questions
+
+- None at this time.
diff --git a/packages/common-logic/src/index.ts b/packages/common-logic/src/index.ts
index 3bbdb28bd..1c01ac737 100644
--- a/packages/common-logic/src/index.ts
+++ b/packages/common-logic/src/index.ts
@@ -1,3 +1,4 @@
 export * from "./utils/convert-filters-to-db-conditions";
+export * from "./utils/course-management-access";
 export * from "./utils/get-notification-message-and-href";
 export { default as jwtUtils } from "./utils/jwt-utils";
diff --git a/packages/common-logic/src/utils/course-management-access.ts b/packages/common-logic/src/utils/course-management-access.ts
new file mode 100644
index 000000000..14a1adeeb
--- /dev/null
+++ b/packages/common-logic/src/utils/course-management-access.ts
@@ -0,0 +1,40 @@
+import { UIConstants } from "@courselit/common-models";
+import { checkPermission } from "@courselit/utils";
+
+export type CourseManagementAccess = {
+    canManage: boolean;
+    isOwner: boolean;
+};
+
+export function getCourseManagementAccess({
+    creatorId,
+    userId,
+    permissions,
+}: {
+    creatorId: string;
+    userId?: string;
+    permissions?: string[];
+}): CourseManagementAccess {
+    if (!userId) {
+        return { canManage: false, isOwner: false };
+    }
+
+    if (
+        checkPermission(permissions || [], [
+            UIConstants.permissions.manageAnyCourse,
+        ])
+    ) {
+        return { canManage: true, isOwner: true };
+    }
+
+    const isOwner = creatorId === userId;
+
+    return {
+        canManage:
+            isOwner &&
+            checkPermission(permissions || [], [
+                UIConstants.permissions.manageCourse,
+            ]),
+        isOwner,
+    };
+}
diff --git a/packages/common-logic/src/utils/get-notification-message-and-href.ts b/packages/common-logic/src/utils/get-notification-message-and-href.ts
index 52b001fbf..43bfd6d94 100644
--- a/packages/common-logic/src/utils/get-notification-message-and-href.ts
+++ b/packages/common-logic/src/utils/get-notification-message-and-href.ts
@@ -1,6 +1,7 @@
 import { ActivityType, Constants } from "@courselit/common-models";
 import { truncate } from "@courselit/utils";
 import { createNotificationEntityResolver } from "./notification-entity-resolver";
+import { getCourseManagementAccess } from "./course-management-access";
 
 export interface NotificationReplyEntity {
     replyId: string;
@@ -33,6 +34,8 @@ export interface NotificationCommunityEntity {
 export interface NotificationCourseEntity {
     courseId: string;
     title: string;
+    slug?: string;
+    creatorId?: string;
 }
 
 export interface NotificationEntityResolver {
@@ -61,6 +64,7 @@ export async function getNotificationMessageAndHref({
     entityId,
     actorName,
     recipientUserId,
+    recipientPermissions = [],
     resolver,
     entityTargetId,
     metadata,
@@ -71,6 +75,7 @@ export async function getNotificationMessageAndHref({
     entityId: string;
     actorName: string;
     recipientUserId: string;
+    recipientPermissions?: string[];
     resolver?: NotificationEntityResolver;
     entityTargetId?: string;
     metadata?: Record<string, unknown>;
@@ -384,6 +389,57 @@ export async function getNotificationMessageAndHref({
             };
         }
 
+        case Constants.ActivityType.COURSE_DISCUSSION_COMMENT_CREATED:
+        case Constants.ActivityType.COURSE_DISCUSSION_REACTED: {
+            const productId = metadata?.courseId as string | undefined;
+            const entityType = metadata?.entityType as string | undefined;
+            const lessonId = metadata?.entityId as string | undefined;
+            const commentId = metadata?.commentId as string | undefined;
+            const replyId = metadata?.replyId as string | undefined;
+            const eventType = metadata?.eventType as string | undefined;
+            const contentType = metadata?.contentType as string | undefined;
+
+            if (!productId || entityType !== "lesson" || !lessonId) {
+                return { message: "", href: "" };
+            }
+
+            const course = await entityResolver.getCourse(productId, domainId);
+            if (!course?.slug) {
+                return { message: "", href: "" };
+            }
+
+            const targetId = replyId || commentId;
+            const targetHash = replyId
+                ? `discussion-reply-${replyId}`
+                : commentId
+                  ? `discussion-comment-${commentId}`
+                  : undefined;
+            const query = new URLSearchParams({ discussion: "open" });
+            if (
+                getCourseManagementAccess({
+                    creatorId: String(course.creatorId),
+                    userId: recipientUserId,
+                    permissions: recipientPermissions,
+                }).canManage
+            ) {
+                query.set("preview", "true");
+            }
+
+            return {
+                message:
+                    activityType ===
+                    Constants.ActivityType.COURSE_DISCUSSION_REACTED
+                        ? `${actorName} reacted to your ${contentType === "reply" ? "reply" : "comment"} on ${truncate(course.title, 20).trim()}`
+                        : `${actorName} ${eventType === "reply_created" ? "replied" : "commented"} on ${truncate(course.title, 20).trim()}`,
+                href: toHref(
+                    `/course/${course.slug}/${course.courseId}/${lessonId}?${query.toString()}${
+                        targetId && targetHash ? `#${targetHash}` : ""
+                    }`,
+                    hrefPrefix,
+                ),
+            };
+        }
+
         default:
             return {
                 message: `${actorName} triggered ${humanizeActivityType(activityType)}`,
diff --git a/packages/common-logic/src/utils/notification-entity-resolver.ts b/packages/common-logic/src/utils/notification-entity-resolver.ts
index c31153a2d..75be886f6 100644
--- a/packages/common-logic/src/utils/notification-entity-resolver.ts
+++ b/packages/common-logic/src/utils/notification-entity-resolver.ts
@@ -114,9 +114,16 @@ export function createNotificationEntityResolver(
                         _id: 0,
                         courseId: 1,
                         title: 1,
+                        slug: 1,
+                        creatorId: 1,
                     },
                 )
-                .lean<{ courseId: string; title: string } | null>();
+                .lean<{
+                    courseId: string;
+                    title: string;
+                    slug?: string;
+                    creatorId?: string;
+                } | null>();
         },
     };
 }
diff --git a/packages/common-models/src/constants.ts b/packages/common-models/src/constants.ts
index 11f0977ae..c343509a9 100644
--- a/packages/common-models/src/constants.ts
+++ b/packages/common-models/src/constants.ts
@@ -152,26 +152,16 @@ export const ActivityType = {
     COMMUNITY_REPLY_LIKED: "community_reply_liked",
     COMMUNITY_MEMBERSHIP_REQUESTED: "community_membership_requested",
     COMMUNITY_MEMBERSHIP_GRANTED: "community_membership_granted",
+    COURSE_DISCUSSION_COMMENT_CREATED: "course_discussion_comment_created",
+    COURSE_DISCUSSION_REACTED: "course_discussion_reacted",
 } as const;
 export const ActivityPermissionMap = {
     [ActivityType.ENROLLED]: "course:manage_any",
     [ActivityType.PURCHASED]: "course:manage_any",
     [ActivityType.DOWNLOADED]: "course:manage_any",
-    // [ActivityType.LESSON_STARTED]: "course:manage_any",
-    // [ActivityType.LESSON_COMPLETED]: "course:manage_any",
-    // [ActivityType.COURSE_COMPLETED]: "course:manage_any",
-    // [ActivityType.QUIZ_ATTEMPTED]: "course:manage_any",
-    // [ActivityType.QUIZ_PASSED]: "course:manage_any",
-    // [ActivityType.VIDEO_STARTED]: "course:manage_any",
-    // [ActivityType.VIDEO_FINISHED]: "course:manage_any",
-    // [ActivityType.CERTIFICATE_ISSUED]: "course:manage_any",
-    // [ActivityType.CERTIFICATE_DOWNLOADED]: "course:manage_any",
-    // [ActivityType.REVIEWED]: "course:manage_any",
     [ActivityType.NEWSLETTER_SUBSCRIBED]: "user:manage",
     [ActivityType.NEWSLETTER_UNSUBSCRIBED]: "user:manage",
     [ActivityType.USER_CREATED]: "user:manage",
-    // [ActivityType.TAG_ADDED]: "user:manage",
-    // [ActivityType.TAG_REMOVED]: "user:manage",
     [ActivityType.COMMUNITY_JOINED]: "community:manage",
     [ActivityType.COMMUNITY_LEFT]: "community:manage",
     [ActivityType.COMMUNITY_POST_CREATED]: "",
@@ -183,6 +173,8 @@ export const ActivityPermissionMap = {
     [ActivityType.COMMUNITY_REPLY_LIKED]: "",
     [ActivityType.COMMUNITY_MEMBERSHIP_REQUESTED]: "community:manage",
     [ActivityType.COMMUNITY_MEMBERSHIP_GRANTED]: "",
+    [ActivityType.COURSE_DISCUSSION_COMMENT_CREATED]: "",
+    [ActivityType.COURSE_DISCUSSION_REACTED]: "",
 } as const;
 export const CourseType = {
     COURSE: "course",
diff --git a/packages/common-models/src/course.ts b/packages/common-models/src/course.ts
index 00fb53fb6..2facafb93 100644
--- a/packages/common-models/src/course.ts
+++ b/packages/common-models/src/course.ts
@@ -31,6 +31,7 @@ export interface Course {
     createdAt: Date;
     updatedAt: Date;
     leadMagnet?: boolean;
+    discussions?: boolean;
     lessons?: Lesson[];
     user: User;
     paymentPlans?: PaymentPlan[];
diff --git a/packages/components-library/src/paginated-table.tsx b/packages/components-library/src/paginated-table.tsx
index a2a2b9516..969cddc04 100644
--- a/packages/components-library/src/paginated-table.tsx
+++ b/packages/components-library/src/paginated-table.tsx
@@ -27,46 +27,44 @@ const PaginatedTableContainer = ({
 }: ComponentProps<"div"> & PaginatedTableProps) => (
     <div className={cn(className)} {...props}>
         {children}
-        <Pagination>
-            <PaginationContent>
-                <PaginationItem>
-                    <PaginationPrevious
-                        onClick={() => onPageChange(page - 1)}
-                        aria-disabled={page === 1}
-                        tabIndex={page === 1 ? -1 : undefined}
-                        className={
-                            page === 1
-                                ? "pointer-events-none opacity-50"
-                                : undefined
-                        }
-                    />
-                </PaginationItem>
-                <PaginationItem>
-                    <PaginationLink>{page}</PaginationLink>
-                </PaginationItem>
-                <PaginationItem>
-                    <PaginationNext
-                        onClick={() => onPageChange(page + 1)}
-                        aria-disabled={page === totalPages || totalPages === 0}
-                        tabIndex={
-                            page === totalPages || totalPages === 0
-                                ? -1
-                                : undefined
-                        }
-                        className={
-                            page === totalPages || totalPages === 0
-                                ? "pointer-events-none opacity-50"
-                                : undefined
-                        }
-                    />
-                </PaginationItem>
-                <PaginationItem>
-                    <PaginationLink className="pointer-events-none">
-                        of {totalPages}
-                    </PaginationLink>
-                </PaginationItem>
-            </PaginationContent>
-        </Pagination>
+        {totalPages > 0 && (
+            <Pagination>
+                <PaginationContent>
+                    <PaginationItem>
+                        <PaginationPrevious
+                            onClick={() => onPageChange(page - 1)}
+                            aria-disabled={page === 1}
+                            tabIndex={page === 1 ? -1 : undefined}
+                            className={
+                                page === 1
+                                    ? "pointer-events-none opacity-50"
+                                    : undefined
+                            }
+                        />
+                    </PaginationItem>
+                    <PaginationItem>
+                        <PaginationLink>{page}</PaginationLink>
+                    </PaginationItem>
+                    <PaginationItem>
+                        <PaginationNext
+                            onClick={() => onPageChange(page + 1)}
+                            aria-disabled={page === totalPages}
+                            tabIndex={page === totalPages ? -1 : undefined}
+                            className={
+                                page === totalPages
+                                    ? "pointer-events-none opacity-50"
+                                    : undefined
+                            }
+                        />
+                    </PaginationItem>
+                    <PaginationItem>
+                        <PaginationLink className="pointer-events-none">
+                            of {totalPages}
+                        </PaginationLink>
+                    </PaginationItem>
+                </PaginationContent>
+            </Pagination>
+        )}
     </div>
 );
 
diff --git a/packages/orm-models/package.json b/packages/orm-models/package.json
index c4c069fdb..ef0b733aa 100644
--- a/packages/orm-models/package.json
+++ b/packages/orm-models/package.json
@@ -33,19 +33,20 @@
         "url": "https://github.com/codelitdev/courselit/issues"
     },
     "devDependencies": {
+        "@types/node": "^26.0.0",
         "@typescript-eslint/eslint-plugin": "^8.46.0",
         "@typescript-eslint/parser": "^8.46.0",
-        "tsconfig": "workspace:^",
         "eslint": "^8.12.0",
         "rimraf": "^4.1.1",
+        "tsconfig": "workspace:^",
         "tsup": "6.6.0",
         "typescript": "^4.9.5"
     },
     "dependencies": {
         "@courselit/common-models": "workspace:^",
-        "@courselit/utils": "workspace:^",
         "@courselit/email-editor": "workspace:^",
         "@courselit/page-models": "workspace:^",
+        "@courselit/utils": "workspace:^",
         "mongoose": "^8.22.1"
     }
 }
diff --git a/packages/orm-models/src/index.ts b/packages/orm-models/src/index.ts
index f83fd2bd2..70c2a3b0d 100644
--- a/packages/orm-models/src/index.ts
+++ b/packages/orm-models/src/index.ts
@@ -35,3 +35,6 @@ export * from "./models/notification-preference";
 export * from "./models/download-link";
 export * from "./models/apikey";
 export * from "./models/user-theme";
+export * from "./models/product-discussion";
+export * from "./models/rate-limit-event";
+export * from "./product-discussion-cleanup";
diff --git a/packages/orm-models/src/models/activity.ts b/packages/orm-models/src/models/activity.ts
index 6b5b821ff..daaf53740 100644
--- a/packages/orm-models/src/models/activity.ts
+++ b/packages/orm-models/src/models/activity.ts
@@ -29,3 +29,4 @@ export const ActivitySchema = new mongoose.Schema<Activity>(
 );
 
 ActivitySchema.index({ domain: 1, type: 1, createdAt: 1 });
+ActivitySchema.index({ domain: 1, "metadata.courseId": 1 });
diff --git a/packages/orm-models/src/models/course.ts b/packages/orm-models/src/models/course.ts
index 734cd1f6b..5a1d1934a 100644
--- a/packages/orm-models/src/models/course.ts
+++ b/packages/orm-models/src/models/course.ts
@@ -20,6 +20,7 @@ export interface InternalCourse extends Omit<Course, "paymentPlans"> {
     sales: number;
     customers: string[];
     certificate?: boolean;
+    discussions: boolean;
 }
 
 export const CourseSchema = new mongoose.Schema<InternalCourse>(
@@ -81,6 +82,7 @@ export const CourseSchema = new mongoose.Schema<InternalCourse>(
         defaultPaymentPlan: { type: String },
         leadMagnet: { type: Boolean, required: true, default: false },
         certificate: Boolean,
+        discussions: { type: Boolean, required: true, default: false },
     },
     {
         timestamps: true,
diff --git a/packages/orm-models/src/models/notification.ts b/packages/orm-models/src/models/notification.ts
index 8657863de..a0e573a0a 100644
--- a/packages/orm-models/src/models/notification.ts
+++ b/packages/orm-models/src/models/notification.ts
@@ -69,6 +69,8 @@ export const NotificationSchema = new mongoose.Schema(
     },
 );
 
+NotificationSchema.index({ domain: 1, "metadata.courseId": 1 });
+
 NotificationSchema.statics.paginate = async function (userId, options) {
     const page = options.page || 1;
     const limit = options.limit || 10;
diff --git a/packages/orm-models/src/models/product-discussion.ts b/packages/orm-models/src/models/product-discussion.ts
new file mode 100644
index 000000000..f52d9376c
--- /dev/null
+++ b/packages/orm-models/src/models/product-discussion.ts
@@ -0,0 +1,377 @@
+import { TextEditorContent } from "@courselit/common-models";
+import { generateUniqueId } from "@courselit/utils";
+import mongoose from "mongoose";
+
+export type ProductDiscussionEntityType = "lesson" | "product";
+export type ProductDiscussionContentType = "comment" | "reply";
+export type ProductDiscussionDeletedByRole = "author" | "course_admin";
+export type ProductDiscussionReportStatus = "pending" | "accepted" | "rejected";
+
+interface ProductDiscussionTarget {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+    entityType: ProductDiscussionEntityType;
+    entityId: string;
+}
+
+export interface InternalProductDiscussionComment
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    commentId: string;
+    userId: string;
+    content: TextEditorContent;
+    likesCount: number;
+    deleted: boolean;
+    deletedAt?: Date;
+    deletedBy?: string;
+    deletedByRole?: ProductDiscussionDeletedByRole;
+    deleteReason?: string;
+    restoredAt?: Date;
+    restoredBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface InternalProductDiscussionReply
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    commentId: string;
+    replyId: string;
+    parentReplyId?: string;
+    userId: string;
+    content: TextEditorContent;
+    likesCount: number;
+    deleted: boolean;
+    deletedAt?: Date;
+    deletedBy?: string;
+    deletedByRole?: ProductDiscussionDeletedByRole;
+    deleteReason?: string;
+    restoredAt?: Date;
+    restoredBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface InternalProductDiscussionLike
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+    commentId?: string;
+    userId: string;
+    createdAt: Date;
+}
+
+export interface InternalProductDiscussionSummary
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    commentsCount: number;
+    repliesCount: number;
+    totalCount: number;
+    activityCountIncludingDeleted: number;
+    lastActivityAt: Date;
+    lastCommentId?: string;
+    lastReplyId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface InternalProductDiscussionSubscriber
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    subscriptionId: string;
+    userId: string;
+    subscription: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface InternalProductDiscussionReport
+    extends ProductDiscussionTarget,
+        mongoose.Document {
+    reportId: string;
+    contentType: ProductDiscussionContentType;
+    contentId: string;
+    commentId?: string;
+    userId: string;
+    reason: string;
+    status: ProductDiscussionReportStatus;
+    rejectionReason?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+const targetFields = {
+    domain: { type: mongoose.Schema.Types.ObjectId, required: true },
+    productId: { type: String, required: true },
+    entityType: {
+        type: String,
+        required: true,
+        enum: ["lesson", "product"],
+    },
+    entityId: { type: String, required: true },
+};
+
+const contentField = {
+    type: mongoose.Schema.Types.Mixed,
+    required: true,
+};
+
+export const ProductDiscussionCommentSchema =
+    new mongoose.Schema<InternalProductDiscussionComment>(
+        {
+            ...targetFields,
+            commentId: {
+                type: String,
+                required: true,
+                default: generateUniqueId,
+            },
+            userId: { type: String, required: true },
+            content: contentField,
+            likesCount: { type: Number, required: true, default: 0 },
+            deleted: { type: Boolean, required: true, default: false },
+            deletedAt: Date,
+            deletedBy: String,
+            deletedByRole: {
+                type: String,
+                enum: ["author", "course_admin"],
+            },
+            deleteReason: String,
+            restoredAt: Date,
+            restoredBy: String,
+        },
+        {
+            timestamps: true,
+        },
+    );
+
+ProductDiscussionCommentSchema.index(
+    { domain: 1, commentId: 1 },
+    { unique: true },
+);
+ProductDiscussionCommentSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    createdAt: -1,
+    commentId: -1,
+});
+ProductDiscussionCommentSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    updatedAt: -1,
+});
+ProductDiscussionCommentSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    userId: 1,
+    deleted: 1,
+});
+
+export const ProductDiscussionReplySchema =
+    new mongoose.Schema<InternalProductDiscussionReply>(
+        {
+            ...targetFields,
+            commentId: { type: String, required: true },
+            replyId: {
+                type: String,
+                required: true,
+                default: generateUniqueId,
+            },
+            parentReplyId: String,
+            userId: { type: String, required: true },
+            content: contentField,
+            likesCount: { type: Number, required: true, default: 0 },
+            deleted: { type: Boolean, required: true, default: false },
+            deletedAt: Date,
+            deletedBy: String,
+            deletedByRole: {
+                type: String,
+                enum: ["author", "course_admin"],
+            },
+            deleteReason: String,
+            restoredAt: Date,
+            restoredBy: String,
+        },
+        {
+            timestamps: true,
+        },
+    );
+
+ProductDiscussionReplySchema.index({ domain: 1, replyId: 1 }, { unique: true });
+ProductDiscussionReplySchema.index({
+    domain: 1,
+    commentId: 1,
+    createdAt: 1,
+    replyId: 1,
+});
+ProductDiscussionReplySchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    createdAt: -1,
+    replyId: -1,
+});
+ProductDiscussionReplySchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    userId: 1,
+    deleted: 1,
+});
+
+export const ProductDiscussionLikeSchema =
+    new mongoose.Schema<InternalProductDiscussionLike>(
+        {
+            ...targetFields,
+            contentType: {
+                type: String,
+                required: true,
+                enum: ["comment", "reply"],
+            },
+            contentId: { type: String, required: true },
+            commentId: String,
+            userId: { type: String, required: true },
+        },
+        {
+            timestamps: { createdAt: true, updatedAt: false },
+        },
+    );
+
+ProductDiscussionLikeSchema.index(
+    { domain: 1, contentType: 1, contentId: 1, userId: 1 },
+    { unique: true },
+);
+ProductDiscussionLikeSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    userId: 1,
+});
+ProductDiscussionLikeSchema.index({
+    domain: 1,
+    contentType: 1,
+    contentId: 1,
+});
+
+export const ProductDiscussionSummarySchema =
+    new mongoose.Schema<InternalProductDiscussionSummary>(
+        {
+            ...targetFields,
+            commentsCount: { type: Number, required: true, default: 0 },
+            repliesCount: { type: Number, required: true, default: 0 },
+            totalCount: { type: Number, required: true, default: 0 },
+            activityCountIncludingDeleted: {
+                type: Number,
+                required: true,
+                default: 0,
+            },
+            lastActivityAt: { type: Date, required: true },
+            lastCommentId: String,
+            lastReplyId: String,
+        },
+        {
+            timestamps: true,
+        },
+    );
+
+ProductDiscussionSummarySchema.index(
+    { domain: 1, productId: 1, entityType: 1, entityId: 1 },
+    { unique: true },
+);
+ProductDiscussionSummarySchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    lastActivityAt: -1,
+    entityId: 1,
+});
+
+export const ProductDiscussionSubscriberSchema =
+    new mongoose.Schema<InternalProductDiscussionSubscriber>(
+        {
+            ...targetFields,
+            subscriptionId: {
+                type: String,
+                required: true,
+                default: generateUniqueId,
+            },
+            userId: { type: String, required: true },
+            subscription: { type: Boolean, required: true, default: true },
+        },
+        {
+            timestamps: true,
+        },
+    );
+
+ProductDiscussionSubscriberSchema.index(
+    { domain: 1, productId: 1, entityType: 1, entityId: 1, userId: 1 },
+    { unique: true },
+);
+ProductDiscussionSubscriberSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    subscription: 1,
+    userId: 1,
+});
+
+export const ProductDiscussionReportSchema =
+    new mongoose.Schema<InternalProductDiscussionReport>(
+        {
+            ...targetFields,
+            reportId: {
+                type: String,
+                required: true,
+                default: generateUniqueId,
+            },
+            contentType: {
+                type: String,
+                required: true,
+                enum: ["comment", "reply"],
+            },
+            contentId: { type: String, required: true },
+            commentId: String,
+            userId: { type: String, required: true },
+            reason: { type: String, required: true },
+            status: {
+                type: String,
+                required: true,
+                enum: ["pending", "accepted", "rejected"],
+                default: "pending",
+            },
+            rejectionReason: String,
+        },
+        {
+            timestamps: true,
+        },
+    );
+
+ProductDiscussionReportSchema.index(
+    { domain: 1, contentType: 1, contentId: 1, userId: 1 },
+    { unique: true },
+);
+ProductDiscussionReportSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+    status: 1,
+    createdAt: -1,
+    reportId: -1,
+});
+ProductDiscussionReportSchema.index({
+    domain: 1,
+    productId: 1,
+    entityType: 1,
+    entityId: 1,
+});
diff --git a/packages/orm-models/src/models/rate-limit-event.ts b/packages/orm-models/src/models/rate-limit-event.ts
new file mode 100644
index 000000000..8c438418b
--- /dev/null
+++ b/packages/orm-models/src/models/rate-limit-event.ts
@@ -0,0 +1,48 @@
+import mongoose from "mongoose";
+
+export const RATE_LIMIT_EVENT_TTL_SECONDS = 25 * 60 * 60; // 25 hours
+
+export interface InternalRateLimitEvent extends mongoose.Document {
+    domain: mongoose.Types.ObjectId;
+    userId: string;
+    scope: string;
+    action: string;
+    subjectId: string;
+    fingerprint?: string;
+    createdAt: Date;
+}
+
+export const RateLimitEventSchema = new mongoose.Schema<InternalRateLimitEvent>(
+    {
+        domain: { type: mongoose.Schema.Types.ObjectId, required: true },
+        userId: { type: String, required: true },
+        scope: { type: String, required: true },
+        action: { type: String, required: true },
+        subjectId: { type: String, required: true },
+        fingerprint: String,
+    },
+    {
+        timestamps: { createdAt: true, updatedAt: false },
+    },
+);
+
+RateLimitEventSchema.index({
+    domain: 1,
+    userId: 1,
+    scope: 1,
+    action: 1,
+    subjectId: 1,
+    createdAt: -1,
+});
+RateLimitEventSchema.index({
+    domain: 1,
+    userId: 1,
+    scope: 1,
+    subjectId: 1,
+    fingerprint: 1,
+    createdAt: -1,
+});
+RateLimitEventSchema.index(
+    { createdAt: 1 },
+    { expireAfterSeconds: RATE_LIMIT_EVENT_TTL_SECONDS },
+);
diff --git a/packages/orm-models/src/product-discussion-cleanup.ts b/packages/orm-models/src/product-discussion-cleanup.ts
new file mode 100644
index 000000000..3ae46b0d6
--- /dev/null
+++ b/packages/orm-models/src/product-discussion-cleanup.ts
@@ -0,0 +1,51 @@
+import mongoose from "mongoose";
+
+import {
+    ProductDiscussionCommentSchema,
+    ProductDiscussionLikeSchema,
+    ProductDiscussionReplySchema,
+    ProductDiscussionReportSchema,
+    ProductDiscussionSubscriberSchema,
+    ProductDiscussionSummarySchema,
+} from "./models/product-discussion";
+
+function getModel(name: string, schema: mongoose.Schema) {
+    return mongoose.models[name] || mongoose.model(name, schema);
+}
+
+export async function deleteProductDiscussionData({
+    domain,
+    productId,
+}: {
+    domain: mongoose.Types.ObjectId;
+    productId: string;
+}) {
+    const target = { domain, productId };
+
+    await Promise.all([
+        getModel(
+            "ProductDiscussionComment",
+            ProductDiscussionCommentSchema,
+        ).deleteMany(target),
+        getModel(
+            "ProductDiscussionReply",
+            ProductDiscussionReplySchema,
+        ).deleteMany(target),
+        getModel(
+            "ProductDiscussionLike",
+            ProductDiscussionLikeSchema,
+        ).deleteMany(target),
+        getModel(
+            "ProductDiscussionReport",
+            ProductDiscussionReportSchema,
+        ).deleteMany(target),
+        getModel(
+            "ProductDiscussionSummary",
+            ProductDiscussionSummarySchema,
+        ).deleteMany(target),
+        getModel(
+            "ProductDiscussionSubscriber",
+            ProductDiscussionSubscriberSchema,
+        ).deleteMany(target),
+    ]);
+}
diff --git a/packages/page-primitives/src/themes/neobrutalism.ts b/packages/page-primitives/src/themes/neobrutalism.ts
index 346204cc5..748e5f0b6 100644
--- a/packages/page-primitives/src/themes/neobrutalism.ts
+++ b/packages/page-primitives/src/themes/neobrutalism.ts
@@ -194,7 +194,7 @@ const themeStyles: ThemeStyle = {
                 radius: "rounded-none",
             },
             shadow: "shadow-sm",
-            custom: "transition-all duration-150 ease-in-out hover:shadow-none hover:translate-x-1 hover:translate-y-1",
+            custom: "transition-all duration-150 ease-in-out hover:shadow-none",
             disabled: {
                 background: "#F3F4F6",
                 cursor: "cursor-not-allowed",
diff --git a/packages/scripts/src/cleanup-domain.ts b/packages/scripts/src/cleanup-domain.ts
index 04662236d..480fc4ff7 100644
--- a/packages/scripts/src/cleanup-domain.ts
+++ b/packages/scripts/src/cleanup-domain.ts
@@ -32,6 +32,7 @@ import {
     DownloadLinkSchema,
     ApiKeySchema,
     UserThemeSchema,
+    deleteProductDiscussionData,
 } from "@courselit/orm-models";
 import type {
     InternalCertificateTemplate,
@@ -203,6 +204,10 @@ async function deleteProduct({
         domain,
         courseId: product.courseId,
     });
+    await deleteProductDiscussionData({
+        domain,
+        productId: product.courseId,
+    });
     await deleteLessons(product.courseId, domain);
     if (product.featuredImage) {
         await deleteMedia(product.featuredImage.mediaId);
diff --git a/packages/text-editor/src/editor.tsx b/packages/text-editor/src/editor.tsx
index e9dd519c7..af9f4635d 100644
--- a/packages/text-editor/src/editor.tsx
+++ b/packages/text-editor/src/editor.tsx
@@ -30,6 +30,8 @@ export interface EditorProps {
     autoFocus?: boolean;
     imageSizeLimit?: number;
     onError?: (...args: any[]) => void;
+    className?: string;
+    editorClassName?: string;
 }
 
 interface EditorType extends FC<PropsWithChildren<EditorProps>> {
@@ -50,6 +52,8 @@ const Editor: EditorType = Object.assign(
         autoFocus,
         imageSizeLimit,
         onError,
+        className,
+        editorClassName,
     }) => {
         const [isUploading, setIsUploading] = useState(false);
         const fileInputRef = useRef<HTMLInputElement | null>(null);
@@ -75,7 +79,7 @@ const Editor: EditorType = Object.assign(
                 editable,
                 editorProps: {
                     attributes: {
-                        class: "tiptap-content",
+                        class: `tiptap-content ${editorClassName ?? ""}`,
                         "data-placeholder": placeholder ?? "",
                     },
                 },
@@ -195,7 +199,9 @@ const Editor: EditorType = Object.assign(
         }
 
         return (
-            <div className="tiptap-editor flex flex-col gap-4 border">
+            <div
+                className={`tiptap-editor flex flex-col gap-4 border ${className ?? ""}`}
+            >
                 {editable && showToolbar && (
                     <div
                         className="sticky top-0 bg-background"
@@ -211,10 +217,16 @@ const Editor: EditorType = Object.assign(
                     </div>
                 )}
                 <div className="flex w-full justify-center">
-                    <div className="flex w-full max-w-3xl flex-col gap-4">
+                    <div
+                        className={`flex w-full flex-col gap-4 ${
+                            editorClassName?.includes("max-w-")
+                                ? ""
+                                : "max-w-3xl"
+                        }`}
+                    >
                         <EditorContent
                             editor={editor}
-                            className="min-h-[200px]"
+                            className={`${editorClassName ?? ""} ${editorClassName?.includes("min-h-") ? "" : "min-h-[200px]"}`}
                         />
                         <input
                             ref={fileInputRef}
diff --git a/packages/text-editor/styles.css b/packages/text-editor/styles.css
index 72da29216..ce0c831d5 100644
--- a/packages/text-editor/styles.css
+++ b/packages/text-editor/styles.css
@@ -4,8 +4,11 @@
     gap: 0.75rem;
 }
 
-.tiptap-editor .ProseMirror {
+.tiptap-editor .ProseMirror:not([class*="min-h-"]) {
     min-height: 12.5rem;
+}
+
+.tiptap-editor .ProseMirror {
     padding: 1rem;
     border-radius: 0.5rem;
     outline: none;
@@ -151,6 +154,7 @@
 }
 
 .tiptap-editor .bubble-menu {
+    position: absolute;
     display: flex;
     align-items: center;
     gap: 0.375rem;
diff --git a/packages/utils/src/extract-text-from-text-editor-content.ts b/packages/utils/src/extract-text-from-text-editor-content.ts
new file mode 100644
index 000000000..44c7ea923
--- /dev/null
+++ b/packages/utils/src/extract-text-from-text-editor-content.ts
@@ -0,0 +1,19 @@
+export default function extractTextFromTextEditorContent(
+    content: unknown,
+): string {
+    if (typeof content === "string") {
+        return content;
+    }
+
+    if (!content || typeof content !== "object") {
+        return "";
+    }
+
+    const record = content as Record<string, unknown>;
+    const ownText = typeof record.text === "string" ? record.text : "";
+    const children = Array.isArray(record.content)
+        ? record.content.map(extractTextFromTextEditorContent).join("")
+        : "";
+
+    return `${ownText}${children}`;
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
index c3d918a81..5dd21ffda 100644
--- a/packages/utils/src/index.ts
+++ b/packages/utils/src/index.ts
@@ -14,3 +14,4 @@ export { isVideo } from "./is-video";
 export { extractMediaIDs } from "./extract-media-ids";
 export { default as extractVideoId } from "./extract-video-id";
 export { default as normalizeTextEditorContent } from "./normalize-text-editor-content";
+export { default as extractTextFromTextEditorContent } from "./extract-text-from-text-editor-content";
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8dd3fbf14..508ee5a35 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -27,7 +27,7 @@ importers:
     devDependencies:
       '@changesets/cli':
         specifier: ^2.29.7
-        version: 2.29.7(@types/node@25.6.0)
+        version: 2.29.7(@types/node@26.0.0)
       '@testing-library/dom':
         specifier: ^10.4.0
         version: 10.4.0
@@ -66,7 +66,7 @@ importers:
         version: 9.1.7
       jest:
         specifier: ^29.7.0
-        version: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+        version: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       jest-environment-jsdom:
         specifier: ^29.7.0
         version: 29.7.0
@@ -81,10 +81,10 @@ importers:
         version: 3.5.3
       tailwindcss:
         specifier: ^3.0.0
-        version: 3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+        version: 3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+        version: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
@@ -275,13 +275,13 @@ importers:
         version: 10.1.4(@aws-sdk/credential-providers@3.797.0)(socks@2.8.4)
       ts-jest:
         specifier: ^29.4.4
-        version: 29.4.4(@babel/core@7.26.10)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.10))(esbuild@0.19.12)(jest-util@29.7.0)(jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)))(typescript@5.9.3)
+        version: 29.4.4(@babel/core@7.26.10)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.10))(esbuild@0.19.12)(jest-util@29.7.0)(jest@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)))(typescript@5.9.3)
       tsconfig:
         specifier: workspace:^
         version: link:../../packages/tsconfig
       tsup:
         specifier: ^7.2.0
-        version: 7.3.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))(typescript@5.9.3)
+        version: 7.3.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))(typescript@5.9.3)
       tsx:
         specifier: ^4.21.0
         version: 4.21.0
@@ -791,7 +791,7 @@ importers:
         version: 2.6.0
       tailwindcss-animate:
         specifier: ^1.0.7
-        version: 1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)))
+        version: 1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)))
       tus-js-client:
         specifier: ^4.3.1
         version: 4.3.1
@@ -938,7 +938,7 @@ importers:
         version: link:../tsconfig
       tsup:
         specifier: 6.6.0
-        version: 6.6.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@4.9.5))(typescript@4.9.5)
+        version: 6.6.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5))(typescript@4.9.5)
       typescript:
         specifier: ^4.9.5
         version: 4.9.5
@@ -964,6 +964,9 @@ importers:
         specifier: ^8.22.1
         version: 8.23.1(@aws-sdk/credential-providers@3.797.0)(socks@2.8.4)
     devDependencies:
+      '@types/node':
+        specifier: ^26.0.0
+        version: 26.0.0
       '@typescript-eslint/eslint-plugin':
         specifier: ^8.46.0
         version: 8.46.4(@typescript-eslint/parser@8.46.4(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
@@ -981,7 +984,7 @@ importers:
         version: link:../tsconfig
       tsup:
         specifier: 6.6.0
-        version: 6.6.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@4.9.5))(typescript@4.9.5)
+        version: 6.6.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5))(typescript@4.9.5)
       typescript:
         specifier: ^4.9.5
         version: 4.9.5
@@ -1066,7 +1069,7 @@ importers:
         version: link:../tsconfig
       tsup:
         specifier: 6.6.0
-        version: 6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))(typescript@5.9.3)
       typescript:
         specifier: ^5.1.6
         version: 5.9.3
@@ -1148,13 +1151,13 @@ importers:
         version: link:../tailwind-config
       tailwindcss:
         specifier: '3'
-        version: 3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+        version: 3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       tsconfig:
         specifier: workspace:^
         version: link:../tsconfig
       tsup:
         specifier: 6.6.0
-        version: 6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))(typescript@5.9.3)
+        version: 6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -1194,11 +1197,11 @@ importers:
     dependencies:
       tailwindcss-animate:
         specifier: ^1.0.7
-        version: 1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)))
+        version: 1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)))
     devDependencies:
       tailwindcss:
         specifier: ^3.4.1
-        version: 3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+        version: 3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
 
   packages/text-editor:
     dependencies:
@@ -4372,95 +4375,111 @@ packages:
 
   '@react-email/body@0.2.0':
     resolution: {integrity: sha512-9GCWmVmKUAoRfloboCd+RKm6X17xn7eGL7HnpAZUnjBXBilWCxsKnLMTC/ixSHDKS/A/057M1Tx6ZUXd89sVBw==}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/button@0.2.0':
     resolution: {integrity: sha512-8i+v6cMxr2emz4ihCrRiYJPp2/sdYsNNsBzXStlcA+/B9Umpm5Jj3WJKYpgTPM+aeyiqlG/MMI1AucnBm4f1oQ==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/code-block@0.2.0':
     resolution: {integrity: sha512-eIrPW9PIFgDopQU0e/OPpwCW2QWQDtNZDSsiN4sJO8KdMnWWnXJicnRfzrit5rHwFo+Y98i+w/Y5ScnBAFr1dQ==}
     engines: {node: '>=22.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/code-inline@0.0.5':
     resolution: {integrity: sha512-MmAsOzdJpzsnY2cZoPHFPk6uDO/Ncpb4Kh1hAt9UZc1xOW3fIzpe1Pi9y9p6wwUmpaeeDalJxAxH6/fnTquinA==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/column@0.0.13':
     resolution: {integrity: sha512-Lqq17l7ShzJG/d3b1w/+lVO+gp2FM05ZUo/nW0rjxB8xBICXOVv6PqjDnn3FXKssvhO5qAV20lHM6S+spRhEwQ==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/components@1.0.1':
     resolution: {integrity: sha512-HnL0Y/up61sOBQT2cQg9N/kCoW0bP727gDs2MkFWQYELg6+iIHidMDvENXFC0f1ZE6hTB+4t7sszptvTcJWsDA==}
     engines: {node: '>=22.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/container@0.0.15':
     resolution: {integrity: sha512-Qo2IQo0ru2kZq47REmHW3iXjAQaKu4tpeq/M8m1zHIVwKduL2vYOBQWbC2oDnMtWPmkBjej6XxgtZByxM6cCFg==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/font@0.0.9':
     resolution: {integrity: sha512-4zjq23oT9APXkerqeslPH3OZWuh5X4crHK6nx82mVHV2SrLba8+8dPEnWbaACWTNjOCbcLIzaC9unk7Wq2MIXw==}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/head@0.0.12':
     resolution: {integrity: sha512-X2Ii6dDFMF+D4niNwMAHbTkeCjlYYnMsd7edXOsi0JByxt9wNyZ9EnhFiBoQdqkE+SMDcu8TlNNttMrf5sJeMA==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/heading@0.0.15':
     resolution: {integrity: sha512-xF2GqsvBrp/HbRHWEfOgSfRFX+Q8I5KBEIG5+Lv3Vb2R/NYr0s8A5JhHHGf2pWBMJdbP4B2WHgj/VUrhy8dkIg==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/hr@0.0.11':
     resolution: {integrity: sha512-S1gZHVhwOsd1Iad5IFhpfICwNPMGPJidG/Uysy1AwmspyoAP5a4Iw3OWEpINFdgh9MHladbxcLKO2AJO+cA9Lw==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/html@0.0.11':
     resolution: {integrity: sha512-qJhbOQy5VW5qzU74AimjAR9FRFQfrMa7dn4gkEXKMB/S9xZN8e1yC1uA9C15jkXI/PzmJ0muDIWmFwatm5/+VA==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/img@0.0.11':
     resolution: {integrity: sha512-aGc8Y6U5C3igoMaqAJKsCpkbm1XjguQ09Acd+YcTKwjnC2+0w3yGUJkjWB2vTx4tN8dCqQCXO8FmdJpMfOA9EQ==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/link@0.0.12':
     resolution: {integrity: sha512-vF+xxQk2fGS1CN7UPQDbzvcBGfffr+GjTPNiWM38fhBfsLv6A/YUfaqxWlmL7zLzVmo0K2cvvV9wxlSyNba1aQ==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/markdown@0.0.17':
     resolution: {integrity: sha512-6op3AfsBC9BJKkhG+eoMFRFWlr0/f3FYbtQrK+VhGzJocEAY0WINIFN+W8xzXr//3IL0K/aKtnH3FtpIuescQQ==}
     engines: {node: '>=22.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/preview@0.0.13':
     resolution: {integrity: sha512-F7j9FJ0JN/A4d7yr+aw28p4uX7VLWs7hTHtLo7WRyw4G+Lit6Zucq4UWKRxJC8lpsUdzVmG7aBJnKOT+urqs/w==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
@@ -4474,18 +4493,21 @@ packages:
   '@react-email/row@0.0.12':
     resolution: {integrity: sha512-HkCdnEjvK3o+n0y0tZKXYhIXUNPDx+2vq1dJTmqappVHXS5tXS6W5JOPZr5j+eoZ8gY3PShI2LWj5rWF7ZEtIQ==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/section@0.0.16':
     resolution: {integrity: sha512-FjqF9xQ8FoeUZYKSdt8sMIKvoT9XF8BrzhT3xiFKdEMwYNbsDflcjfErJe3jb7Wj/es/lKTbV5QR1dnLzGpL3w==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
   '@react-email/tailwind@2.0.1':
     resolution: {integrity: sha512-/xq0IDYVY7863xPY7cdI45Xoz7M6CnIQBJcQvbqN7MNVpopfH9f+mhjayV1JGfKaxlGWuxfLKhgi9T2shsnEFg==}
     engines: {node: '>=22.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       '@react-email/body': 0.2.0
       '@react-email/button': 0.2.0
@@ -4524,6 +4546,7 @@ packages:
   '@react-email/text@0.1.5':
     resolution: {integrity: sha512-o5PNHFSE085VMXayxH+SJ1LSOtGsTv+RpNKnTiJDrJUwoBu77G3PlKOsZZQHCNyD28WsQpl9v2WcJLbQudqwPg==}
     engines: {node: '>=18.0.0'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       react: ^18.0 || ^19.0 || ^19.0.0-rc
 
@@ -5524,6 +5547,9 @@ packages:
   '@types/node@25.6.0':
     resolution: {integrity: sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==}
 
+  '@types/node@26.0.0':
+    resolution: {integrity: sha512-vf2YFi1iY9lHGwNJMs01biZFbKJkrZR1T6/MlzjhJLPdntOHLhTrDSnSVcdtvjihi4VQNlrFRIxLsDBlQpAipA==}
+
   '@types/nodemailer@6.4.17':
     resolution: {integrity: sha512-I9CCaIp6DTldEg7vyUTZi8+9Vo0hi1/T8gv3C89yk1rSAAzoKQ8H8ki/jBYJSFoH/BisgLP8tkZMlQ91CIquww==}
 
@@ -5721,6 +5747,7 @@ packages:
 
   '@ungap/structured-clone@1.3.0':
     resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+    deprecated: Potential CWE-502 - Update to 1.3.1 or higher
 
   '@unrs/resolver-binding-darwin-arm64@1.7.0':
     resolution: {integrity: sha512-vIWAU56r2lZAmUsljp6m9+hrTlwNkZH6pqnSPff2WxzofV+jWRSHLmZRUS+g+VE+LlyPByifmGGHpJmhWetatg==}
@@ -10564,6 +10591,7 @@ packages:
   recharts@2.15.3:
     resolution: {integrity: sha512-EdOPzTwcFSuqtvkDoaM5ws/Km1+WTAO2eizL7rqiG0V2UVhTnz0m7J2i0CjVPUCdEkZImaWvXLbZDS2H5t6GFQ==}
     engines: {node: '>=14'}
+    deprecated: 1.x and 2.x branches are no longer active. Bump to Recharts v3 to receive latest features and bugfixes. See https://github.com/recharts/recharts/wiki/3.0-migration-guide
     peerDependencies:
       react: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
       react-dom: ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
@@ -11647,6 +11675,9 @@ packages:
   undici-types@7.19.2:
     resolution: {integrity: sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==}
 
+  undici-types@8.3.0:
+    resolution: {integrity: sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==}
+
   unherit@3.0.1:
     resolution: {integrity: sha512-akOOQ/Yln8a2sgcLj4U0Jmx0R5jpIg2IUyRrWOzmEbjBtGzBdHtSeFKgoEcoH4KYIG/Pb8GQ/BwtYm0GCq1Sqg==}
 
@@ -11781,6 +11812,7 @@ packages:
 
   uuid@9.0.1:
     resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   uvu@0.5.6:
@@ -13122,7 +13154,7 @@ snapshots:
     dependencies:
       '@changesets/types': 6.1.0
 
-  '@changesets/cli@2.29.7(@types/node@25.6.0)':
+  '@changesets/cli@2.29.7(@types/node@26.0.0)':
     dependencies:
       '@changesets/apply-release-plan': 7.0.13
       '@changesets/assemble-release-plan': 6.0.9
@@ -13138,7 +13170,7 @@ snapshots:
       '@changesets/should-skip-package': 0.1.2
       '@changesets/types': 6.1.0
       '@changesets/write': 0.4.0
-      '@inquirer/external-editor': 1.0.3(@types/node@25.6.0)
+      '@inquirer/external-editor': 1.0.3(@types/node@26.0.0)
       '@manypkg/get-packages': 1.1.3
       ansi-colors: 4.1.3
       ci-info: 3.9.0
@@ -13961,12 +13993,12 @@ snapshots:
   '@img/sharp-win32-x64@0.34.5':
     optional: true
 
-  '@inquirer/external-editor@1.0.3(@types/node@25.6.0)':
+  '@inquirer/external-editor@1.0.3(@types/node@26.0.0)':
     dependencies:
       chardet: 2.1.1
       iconv-lite: 0.7.0
     optionalDependencies:
-      '@types/node': 25.6.0
+      '@types/node': 26.0.0
 
   '@ioredis/commands@1.2.0': {}
 
@@ -14033,7 +14065,7 @@ snapshots:
       - supports-color
       - ts-node
 
-  '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))':
+  '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))':
     dependencies:
       '@jest/console': 29.7.0
       '@jest/reporters': 29.7.0
@@ -14047,7 +14079,7 @@ snapshots:
       exit: 0.1.2
       graceful-fs: 4.2.11
       jest-changed-files: 29.7.0
-      jest-config: 29.7.0(@types/node@20.19.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      jest-config: 29.7.0(@types/node@20.19.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       jest-haste-map: 29.7.0
       jest-message-util: 29.7.0
       jest-regex-util: 29.6.3
@@ -18015,6 +18047,10 @@ snapshots:
     dependencies:
       undici-types: 7.19.2
 
+  '@types/node@26.0.0':
+    dependencies:
+      undici-types: 8.3.0
+
   '@types/nodemailer@6.4.17':
     dependencies:
       '@types/node': 20.19.0
@@ -19516,13 +19552,13 @@ snapshots:
       - supports-color
       - ts-node
 
-  create-jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  create-jest@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       '@jest/types': 29.6.3
       chalk: 4.1.2
       exit: 0.1.2
       graceful-fs: 4.2.11
-      jest-config: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      jest-config: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       jest-util: 29.7.0
       prompts: 2.4.2
     transitivePeerDependencies:
@@ -21848,16 +21884,16 @@ snapshots:
       - supports-color
       - ts-node
 
-  jest-cli@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  jest-cli@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
-      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
       chalk: 4.1.2
-      create-jest: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      create-jest: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       exit: 0.1.2
       import-local: 3.2.0
-      jest-config: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      jest-config: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       jest-util: 29.7.0
       jest-validate: 29.7.0
       yargs: 17.7.2
@@ -21929,7 +21965,7 @@ snapshots:
       - babel-plugin-macros
       - supports-color
 
-  jest-config@29.7.0(@types/node@20.19.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  jest-config@29.7.0(@types/node@20.19.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       '@babel/core': 7.26.10
       '@jest/test-sequencer': 29.7.0
@@ -21955,12 +21991,12 @@ snapshots:
       strip-json-comments: 3.1.1
     optionalDependencies:
       '@types/node': 20.19.0
-      ts-node: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
     transitivePeerDependencies:
       - babel-plugin-macros
       - supports-color
 
-  jest-config@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  jest-config@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       '@babel/core': 7.26.10
       '@jest/test-sequencer': 29.7.0
@@ -21985,8 +22021,8 @@ snapshots:
       slash: 3.0.0
       strip-json-comments: 3.1.1
     optionalDependencies:
-      '@types/node': 25.6.0
-      ts-node: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+      '@types/node': 26.0.0
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
     transitivePeerDependencies:
       - babel-plugin-macros
       - supports-color
@@ -22233,12 +22269,12 @@ snapshots:
       - supports-color
       - ts-node
 
-  jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  jest@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
-      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       '@jest/types': 29.6.3
       import-local: 3.2.0
-      jest-cli: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      jest-cli: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
     transitivePeerDependencies:
       - '@types/node'
       - babel-plugin-macros
@@ -24181,13 +24217,13 @@ snapshots:
       postcss: 8.5.3
       ts-node: 10.9.2(@types/node@20.19.0)(typescript@4.9.5)
 
-  postcss-load-config@3.1.4(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  postcss-load-config@3.1.4(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       lilconfig: 2.1.0
       yaml: 1.10.2
     optionalDependencies:
       postcss: 8.5.3
-      ts-node: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
 
   postcss-load-config@3.1.4(postcss@8.5.6)(ts-node@10.9.2(@types/node@20.19.0)(typescript@5.9.3)):
     dependencies:
@@ -24213,6 +24249,14 @@ snapshots:
       postcss: 8.5.6
       ts-node: 10.9.2(@types/node@25.6.0)(typescript@4.9.5)
 
+  postcss-load-config@3.1.4(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5)):
+    dependencies:
+      lilconfig: 2.1.0
+      yaml: 1.10.2
+    optionalDependencies:
+      postcss: 8.5.6
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@4.9.5)
+
   postcss-load-config@4.0.2(postcss@8.5.3)(ts-node@10.9.2(@types/node@17.0.21)(typescript@5.9.3)):
     dependencies:
       lilconfig: 3.1.3
@@ -24229,21 +24273,21 @@ snapshots:
       postcss: 8.5.3
       ts-node: 10.9.2(@types/node@20.19.0)(typescript@4.9.5)
 
-  postcss-load-config@4.0.2(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  postcss-load-config@4.0.2(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       lilconfig: 3.1.3
       yaml: 2.7.1
     optionalDependencies:
       postcss: 8.5.3
-      ts-node: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
 
-  postcss-load-config@4.0.2(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  postcss-load-config@4.0.2(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       lilconfig: 3.1.3
       yaml: 2.7.1
     optionalDependencies:
       postcss: 8.5.6
-      ts-node: 10.9.2(@types/node@25.6.0)(typescript@5.9.3)
+      ts-node: 10.9.2(@types/node@26.0.0)(typescript@5.9.3)
 
   postcss-nested@6.2.0(postcss@8.5.3):
     dependencies:
@@ -25870,9 +25914,9 @@ snapshots:
     dependencies:
       tailwindcss: 3.4.17(ts-node@10.9.2(@types/node@20.19.0)(typescript@4.9.5))
 
-  tailwindcss-animate@1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))):
+  tailwindcss-animate@1.0.7(tailwindcss@3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))):
     dependencies:
-      tailwindcss: 3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      tailwindcss: 3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
 
   tailwindcss@3.4.17(ts-node@10.9.2(@types/node@17.0.21)(typescript@5.9.3)):
     dependencies:
@@ -25928,7 +25972,7 @@ snapshots:
     transitivePeerDependencies:
       - ts-node
 
-  tailwindcss@3.4.17(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)):
+  tailwindcss@3.4.17(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)):
     dependencies:
       '@alloc/quick-lru': 5.2.0
       arg: 5.0.2
@@ -25947,7 +25991,7 @@ snapshots:
       postcss: 8.5.3
       postcss-import: 15.1.0(postcss@8.5.3)
       postcss-js: 4.0.1(postcss@8.5.3)
-      postcss-load-config: 4.0.2(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      postcss-load-config: 4.0.2(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       postcss-nested: 6.2.0(postcss@8.5.3)
       postcss-selector-parser: 6.1.2
       resolve: 1.22.10
@@ -26108,12 +26152,12 @@ snapshots:
 
   ts-interface-checker@0.1.13: {}
 
-  ts-jest@29.4.4(@babel/core@7.26.10)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.10))(esbuild@0.19.12)(jest-util@29.7.0)(jest@29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3)))(typescript@5.9.3):
+  ts-jest@29.4.4(@babel/core@7.26.10)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.26.10))(esbuild@0.19.12)(jest-util@29.7.0)(jest@29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3)))(typescript@5.9.3):
     dependencies:
       bs-logger: 0.2.6
       fast-json-stable-stringify: 2.1.0
       handlebars: 4.7.9
-      jest: 29.7.0(@types/node@25.6.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      jest: 29.7.0(@types/node@26.0.0)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       json5: 2.2.3
       lodash.memoize: 4.1.2
       make-error: 1.3.6
@@ -26264,14 +26308,33 @@ snapshots:
       yn: 3.1.1
     optional: true
 
-  ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3):
+  ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.11
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 25.6.0
+      '@types/node': 26.0.0
+      acorn: 8.14.1
+      acorn-walk: 8.3.4
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 4.9.5
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+    optional: true
+
+  ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.11
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 26.0.0
       acorn: 8.14.1
       acorn-walk: 8.3.4
       arg: 4.1.3
@@ -26329,7 +26392,7 @@ snapshots:
       - supports-color
       - ts-node
 
-  tsup@6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))(typescript@5.9.3):
+  tsup@6.6.0(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))(typescript@5.9.3):
     dependencies:
       bundle-require: 4.2.1(esbuild@0.17.19)
       cac: 6.7.14
@@ -26339,7 +26402,7 @@ snapshots:
       execa: 5.1.1
       globby: 11.1.0
       joycon: 3.1.1
-      postcss-load-config: 3.1.4(postcss@8.5.3)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      postcss-load-config: 3.1.4(postcss@8.5.3)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       resolve-from: 5.0.0
       rollup: 3.29.5
       source-map: 0.8.0-beta.0
@@ -26421,7 +26484,30 @@ snapshots:
       - supports-color
       - ts-node
 
-  tsup@7.3.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))(typescript@5.9.3):
+  tsup@6.6.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5))(typescript@4.9.5):
+    dependencies:
+      bundle-require: 4.2.1(esbuild@0.17.19)
+      cac: 6.7.14
+      chokidar: 3.6.0
+      debug: 4.4.1
+      esbuild: 0.17.19
+      execa: 5.1.1
+      globby: 11.1.0
+      joycon: 3.1.1
+      postcss-load-config: 3.1.4(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@4.9.5))
+      resolve-from: 5.0.0
+      rollup: 3.29.5
+      source-map: 0.8.0-beta.0
+      sucrase: 3.35.0
+      tree-kill: 1.2.2
+    optionalDependencies:
+      postcss: 8.5.6
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+      - ts-node
+
+  tsup@7.3.0(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))(typescript@5.9.3):
     dependencies:
       bundle-require: 4.2.1(esbuild@0.19.12)
       cac: 6.7.14
@@ -26431,7 +26517,7 @@ snapshots:
       execa: 5.1.1
       globby: 11.1.0
       joycon: 3.1.1
-      postcss-load-config: 4.0.2(postcss@8.5.6)(ts-node@10.9.2(@types/node@25.6.0)(typescript@5.9.3))
+      postcss-load-config: 4.0.2(postcss@8.5.6)(ts-node@10.9.2(@types/node@26.0.0)(typescript@5.9.3))
       resolve-from: 5.0.0
       rollup: 4.40.0
       source-map: 0.8.0-beta.0
@@ -26591,6 +26677,8 @@ snapshots:
 
   undici-types@7.19.2: {}
 
+  undici-types@8.3.0: {}
+
   unherit@3.0.1: {}
 
   unified@10.1.2: