diff --git a/Common/Models/DatabaseModels/IncidentEpisode.ts b/Common/Models/DatabaseModels/IncidentEpisode.ts
index 7758b57e23..7baf045a48 100644
--- a/Common/Models/DatabaseModels/IncidentEpisode.ts
+++ b/Common/Models/DatabaseModels/IncidentEpisode.ts
@@ -1,3 +1,4 @@
+import IncidentGroupingRule from "./IncidentGroupingRule";
 import IncidentSeverity from "./IncidentSeverity";
 import IncidentState from "./IncidentState";
 import Label from "./Label";
@@ -1052,6 +1053,73 @@ export default class IncidentEpisode extends BaseModel {
   })
   public groupingKey?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentEpisode,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentEpisode,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "incidentGroupingRuleId",
+    type: TableColumnType.Entity,
+    modelType: IncidentGroupingRule,
+    title: "Incident Grouping Rule",
+    description:
+      "Relation to the Incident Grouping Rule that created this episode (if applicable)",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentGroupingRule;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "incidentGroupingRuleId" })
+  public incidentGroupingRule?: IncidentGroupingRule = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentEpisode,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentEpisode,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    title: "Incident Grouping Rule ID",
+    description:
+      "ID of the Incident Grouping Rule that created this episode (if applicable)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public incidentGroupingRuleId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
diff --git a/Common/Models/DatabaseModels/IncidentEpisodeMember.ts b/Common/Models/DatabaseModels/IncidentEpisodeMember.ts
index ecc3ff8246..4d7a422d0d 100644
--- a/Common/Models/DatabaseModels/IncidentEpisodeMember.ts
+++ b/Common/Models/DatabaseModels/IncidentEpisodeMember.ts
@@ -1,5 +1,6 @@
 import Incident from "./Incident";
 import IncidentEpisode from "./IncidentEpisode";
+import IncidentGroupingRule from "./IncidentGroupingRule";
 import Project from "./Project";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -397,6 +398,43 @@ export default class IncidentEpisodeMember extends BaseModel {
   })
   public addedByUserId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateIncidentEpisodeMember,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentEpisodeMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "matchedRuleId",
+    type: TableColumnType.Entity,
+    modelType: IncidentGroupingRule,
+    title: "Matched Grouping Rule",
+    description:
+      "Relation to the Incident Grouping Rule that matched this incident (if applicable)",
+  })
+  @ManyToOne(
+    () => {
+      return IncidentGroupingRule;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "matchedRuleId" })
+  public matchedRule?: IncidentGroupingRule = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,
diff --git a/Common/Models/DatabaseModels/IncidentGroupingRule.ts b/Common/Models/DatabaseModels/IncidentGroupingRule.ts
new file mode 100644
index 0000000000..9777686327
--- /dev/null
+++ b/Common/Models/DatabaseModels/IncidentGroupingRule.ts
@@ -0,0 +1,1430 @@
+import IncidentSeverity from "./IncidentSeverity";
+import Label from "./Label";
+import Monitor from "./Monitor";
+import OnCallDutyPolicy from "./OnCallDutyPolicy";
+import Project from "./Project";
+import Team from "./Team";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import EnableWorkflow from "../../Types/Database/EnableWorkflow";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import {
+  Column,
+  Entity,
+  Index,
+  JoinColumn,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+} from "typeorm";
+
+export interface IncidentGroupingRuleMatchCriteria {
+  monitorIds?: Array<string>;
+  monitorCustomFields?: Record<string, string>;
+  incidentSeverityIds?: Array<string>;
+  labelIds?: Array<string>;
+  incidentTitlePattern?: string;
+  incidentDescriptionPattern?: string;
+}
+
+export interface IncidentGroupingRuleGroupByFields {
+  monitorId?: boolean;
+  incidentSeverityId?: boolean;
+  incidentTitle?: boolean;
+  customFieldValues?: Array<string>;
+}
+
+@EnableDocumentation()
+@TenantColumn("projectId")
+@TableAccessControl({
+  create: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.CreateIncidentGroupingRule,
+  ],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadIncidentGroupingRule,
+  ],
+  delete: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.DeleteIncidentGroupingRule,
+  ],
+  update: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.EditIncidentGroupingRule,
+  ],
+})
+@CrudApiEndpoint(new Route("/incident-grouping-rule"))
+@Entity({
+  name: "IncidentGroupingRule",
+})
+@EnableWorkflow({
+  create: true,
+  delete: true,
+  update: true,
+  read: true,
+})
+@TableMetadata({
+  tableName: "IncidentGroupingRule",
+  singularName: "Incident Grouping Rule",
+  pluralName: "Incident Grouping Rules",
+  icon: IconProp.Layers,
+  tableDescription:
+    "Configure rules for automatically grouping related incidents into episodes",
+})
+export default class IncidentGroupingRule extends BaseModel {
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    title: "Name",
+    description: "Name of this incident grouping rule",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public name?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Description",
+    description: "Description of this incident grouping rule",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
+  })
+  public description?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    required: true,
+    type: TableColumnType.Number,
+    title: "Priority",
+    description:
+      "Priority of this rule. Lower number = higher priority. Rules are evaluated in priority order.",
+    defaultValue: 1,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 1,
+  })
+  public priority?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Is Enabled",
+    description: "Whether this rule is enabled",
+    defaultValue: true,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: true,
+  })
+  public isEnabled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "Match Criteria",
+    description:
+      "JSON object defining the criteria for matching incidents to this rule",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public matchCriteria?: IncidentGroupingRuleMatchCriteria = undefined;
+
+  // Match Criteria Fields (individual columns for form support)
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: Monitor,
+    title: "Monitors",
+    description:
+      "Only group incidents from these monitors. Leave empty to match incidents from any monitor.",
+  })
+  @ManyToMany(
+    () => {
+      return Monitor;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentGroupingRuleMonitor",
+    inverseJoinColumn: {
+      name: "monitorId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentGroupingRuleId",
+      referencedColumnName: "_id",
+    },
+  })
+  public monitors?: Array<Monitor> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: IncidentSeverity,
+    title: "Incident Severities",
+    description:
+      "Only group incidents with these severities. Leave empty to match incidents of any severity.",
+  })
+  @ManyToMany(
+    () => {
+      return IncidentSeverity;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentGroupingRuleIncidentSeverity",
+    inverseJoinColumn: {
+      name: "incidentSeverityId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentGroupingRuleId",
+      referencedColumnName: "_id",
+    },
+  })
+  public incidentSeverities?: Array<IncidentSeverity> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: Label,
+    title: "Incident Labels",
+    description:
+      "Only group incidents that have at least one of these labels. Leave empty to match incidents regardless of incident labels.",
+  })
+  @ManyToMany(
+    () => {
+      return Label;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentGroupingRuleIncidentLabel",
+    inverseJoinColumn: {
+      name: "labelId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentGroupingRuleId",
+      referencedColumnName: "_id",
+    },
+  })
+  public incidentLabels?: Array<Label> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: Label,
+    title: "Monitor Labels",
+    description:
+      "Only group incidents from monitors that have at least one of these labels. Leave empty to match incidents regardless of monitor labels.",
+  })
+  @ManyToMany(
+    () => {
+      return Label;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentGroupingRuleMonitorLabel",
+    inverseJoinColumn: {
+      name: "labelId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentGroupingRuleId",
+      referencedColumnName: "_id",
+    },
+  })
+  public monitorLabels?: Array<Label> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Incident Title Pattern",
+    description:
+      "Regular expression pattern to match incident titles. Leave empty to match any title. Example: 'CPU.*high' matches titles containing 'CPU' followed by 'high'.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+    length: ColumnLength.LongText,
+  })
+  public incidentTitlePattern?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Incident Description Pattern",
+    description:
+      "Regular expression pattern to match incident descriptions. Leave empty to match any description.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+    length: ColumnLength.LongText,
+  })
+  public incidentDescriptionPattern?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Monitor Name Pattern",
+    description:
+      "Regular expression pattern to match monitor names. Leave empty to match any monitor name. Example: 'prod-.*' matches monitors starting with 'prod-'.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+    length: ColumnLength.LongText,
+  })
+  public monitorNamePattern?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Monitor Description Pattern",
+    description:
+      "Regular expression pattern to match monitor descriptions. Leave empty to match any monitor description.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+    length: ColumnLength.LongText,
+  })
+  public monitorDescriptionPattern?: string = undefined;
+
+  // Group By Fields (how to group matching incidents)
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Monitor",
+    description:
+      "When enabled, incidents from different monitors will be grouped into separate episodes. When disabled, incidents from any monitor can be grouped together.",
+    defaultValue: true,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: true,
+  })
+  public groupByMonitor?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Incident Severity",
+    description:
+      "When enabled, incidents with different severities will be grouped into separate episodes. When disabled, incidents of any severity can be grouped together.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupBySeverity?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Incident Title",
+    description:
+      "When enabled, incidents with different titles will be grouped into separate episodes. When disabled, incidents with any title can be grouped together.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByIncidentTitle?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Group By Service",
+    description:
+      "When enabled, incidents from monitors belonging to different services will be grouped into separate episodes. When disabled, incidents can be grouped together regardless of which service the monitor belongs to.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public groupByService?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Enable Time Window",
+    description:
+      "Enable time-based grouping. When enabled, incidents are grouped within the specified time window. When disabled, all matching incidents are grouped into a single ongoing episode regardless of time.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public enableTimeWindow?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Time Window (Minutes)",
+    description:
+      "Rolling time window in minutes. Incidents are grouped if they arrive within this gap from the last incident.",
+    defaultValue: 60,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 60,
+  })
+  public timeWindowMinutes?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "Group By Fields",
+    description:
+      "JSON object defining the fields to group incidents by (e.g., monitorId, severity)",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public groupByFields?: IncidentGroupingRuleGroupByFields = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Episode Title Template",
+    description:
+      "Template for generating episode titles. Supports placeholders like {{incidentSeverity}}, {{monitorName}}, {{incidentTitle}}, {{incidentDescription}}",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+  })
+  public episodeTitleTemplate?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "Episode Description Template",
+    description:
+      "Template for generating episode descriptions. Supports placeholders like {{incidentSeverity}}, {{monitorName}}, {{incidentTitle}}, {{incidentDescription}}",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+  })
+  public episodeDescriptionTemplate?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Enable Resolve Delay",
+    description:
+      "Enable grace period before auto-resolving episode after all incidents resolve. Helps prevent rapid state changes during incident flapping.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public enableResolveDelay?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Resolve Delay (Minutes)",
+    description:
+      "Grace period in minutes before auto-resolving an episode after all incidents are resolved",
+    defaultValue: 0,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 0,
+  })
+  public resolveDelayMinutes?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Enable Reopen Window",
+    description:
+      "Enable reopening recently resolved episodes instead of creating new ones. Useful when related issues recur shortly after resolution.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public enableReopenWindow?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Reopen Window (Minutes)",
+    description:
+      "Time window in minutes to reopen a recently resolved episode instead of creating a new one",
+    defaultValue: 0,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 0,
+  })
+  public reopenWindowMinutes?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Boolean,
+    title: "Enable Inactivity Timeout",
+    description:
+      "Enable auto-resolving episodes after a period of inactivity. Helps automatically close episodes when no new incidents arrive.",
+    defaultValue: false,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public enableInactivityTimeout?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Number,
+    title: "Inactivity Timeout (Minutes)",
+    description:
+      "Time in minutes after which an inactive episode will be auto-resolved",
+    defaultValue: 60,
+    isDefaultValueColumn: true,
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 60,
+  })
+  public inactivityTimeoutMinutes?: number = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: OnCallDutyPolicy,
+    title: "On-Call Duty Policies",
+    description:
+      "List of on-call duty policies to execute for episodes created by this rule.",
+  })
+  @ManyToMany(
+    () => {
+      return OnCallDutyPolicy;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "IncidentGroupingRuleOnCallDutyPolicy",
+    inverseJoinColumn: {
+      name: "onCallDutyPolicyId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "incidentGroupingRuleId",
+      referencedColumnName: "_id",
+    },
+  })
+  public onCallDutyPolicies?: Array<OnCallDutyPolicy> = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "defaultAssignToUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Default Assign To User",
+    description: "Default user to assign episodes created by this rule",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "defaultAssignToUserId" })
+  public defaultAssignToUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    title: "Default Assign To User ID",
+    description: "Default User ID to assign episodes created by this rule",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public defaultAssignToUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "defaultAssignToTeamId",
+    type: TableColumnType.Entity,
+    modelType: Team,
+    title: "Default Assign To Team",
+    description: "Default team to assign episodes created by this rule",
+  })
+  @ManyToOne(
+    () => {
+      return Team;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "defaultAssignToTeamId" })
+  public defaultAssignToTeam?: Team = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditIncidentGroupingRule,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    title: "Default Assign To Team ID",
+    description: "Default Team ID to assign episodes created by this rule",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public defaultAssignToTeamId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.CreateIncidentGroupingRule,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentGroupingRule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+}
diff --git a/Common/Models/DatabaseModels/Index.ts b/Common/Models/DatabaseModels/Index.ts
index a71ec2146d..31a2a9e7fe 100644
--- a/Common/Models/DatabaseModels/Index.ts
+++ b/Common/Models/DatabaseModels/Index.ts
@@ -205,6 +205,7 @@ import IncidentEpisodeOwnerUser from "./IncidentEpisodeOwnerUser";
 import IncidentEpisodeOwnerTeam from "./IncidentEpisodeOwnerTeam";
 import IncidentEpisodeInternalNote from "./IncidentEpisodeInternalNote";
 import IncidentEpisodeFeed from "./IncidentEpisodeFeed";
+import IncidentGroupingRule from "./IncidentGroupingRule";
 
 import TableView from "./TableView";
 import Dashboard from "./Dashboard";
@@ -306,6 +307,7 @@ const AllModelTypes: Array<{
   IncidentEpisodeOwnerTeam,
   IncidentEpisodeInternalNote,
   IncidentEpisodeFeed,
+  IncidentGroupingRule,
 
   MonitorStatusTimeline,
 
diff --git a/Common/Server/Services/IncidentGroupingEngineService.ts b/Common/Server/Services/IncidentGroupingEngineService.ts
new file mode 100644
index 0000000000..6f9b7c972a
--- /dev/null
+++ b/Common/Server/Services/IncidentGroupingEngineService.ts
@@ -0,0 +1,1021 @@
+import ObjectID from "../../Types/ObjectID";
+import IncidentGroupingRule from "../../Models/DatabaseModels/IncidentGroupingRule";
+import Incident from "../../Models/DatabaseModels/Incident";
+import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
+import IncidentEpisodeMember, {
+  IncidentEpisodeMemberAddedBy,
+} from "../../Models/DatabaseModels/IncidentEpisodeMember";
+import Label from "../../Models/DatabaseModels/Label";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
+import ServiceMonitor from "../../Models/DatabaseModels/ServiceMonitor";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import OneUptimeDate from "../../Types/Date";
+import QueryHelper from "../Types/Database/QueryHelper";
+import IncidentGroupingRuleService from "./IncidentGroupingRuleService";
+import IncidentEpisodeService from "./IncidentEpisodeService";
+import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
+import MonitorService from "./MonitorService";
+import ServiceMonitorService from "./ServiceMonitorService";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
+import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/IncidentEpisodeFeed";
+import { Green500 } from "../../Types/BrandColors";
+
+export interface GroupingResult {
+  grouped: boolean;
+  episodeId?: ObjectID;
+  isNewEpisode?: boolean;
+  wasReopened?: boolean;
+}
+
+class IncidentGroupingEngineServiceClass {
+  @CaptureSpan()
+  public async processIncident(incident: Incident): Promise<GroupingResult> {
+    logger.debug(`Processing incident ${incident.id} for grouping`);
+
+    try {
+      if (!incident.id || !incident.projectId) {
+        logger.warn("Incident missing id or projectId, skipping grouping");
+        return { grouped: false };
+      }
+
+      // If incident already has an episode, don't reprocess
+      if (incident.incidentEpisodeId) {
+        return { grouped: true, episodeId: incident.incidentEpisodeId };
+      }
+
+      // Get enabled rules sorted by priority
+      const rules: Array<IncidentGroupingRule> =
+        await IncidentGroupingRuleService.findBy({
+          query: {
+            projectId: incident.projectId,
+            isEnabled: true,
+          },
+          sort: {
+            priority: SortOrder.Ascending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            _id: true,
+            name: true,
+            priority: true,
+            // Match criteria fields
+            monitors: {
+              _id: true,
+            },
+            incidentSeverities: {
+              _id: true,
+            },
+            incidentLabels: {
+              _id: true,
+            },
+            monitorLabels: {
+              _id: true,
+            },
+            incidentTitlePattern: true,
+            incidentDescriptionPattern: true,
+            monitorNamePattern: true,
+            monitorDescriptionPattern: true,
+            // Group by fields
+            groupByMonitor: true,
+            groupBySeverity: true,
+            groupByIncidentTitle: true,
+            groupByService: true,
+            // Time settings
+            enableTimeWindow: true,
+            timeWindowMinutes: true,
+            episodeTitleTemplate: true,
+            episodeDescriptionTemplate: true,
+            enableResolveDelay: true,
+            resolveDelayMinutes: true,
+            enableReopenWindow: true,
+            reopenWindowMinutes: true,
+            enableInactivityTimeout: true,
+            inactivityTimeoutMinutes: true,
+            defaultAssignToUserId: true,
+            defaultAssignToTeamId: true,
+            onCallDutyPolicies: {
+              _id: true,
+            },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        logger.debug(
+          `No enabled grouping rules found for project ${incident.projectId}`,
+        );
+        return { grouped: false };
+      }
+
+      logger.debug(
+        `Found ${rules.length} enabled grouping rules for project ${incident.projectId}`,
+      );
+
+      // Find first matching rule
+      for (const rule of rules) {
+        const matches: boolean = await this.doesIncidentMatchRule(
+          incident,
+          rule,
+        );
+
+        if (matches) {
+          logger.debug(
+            `Incident ${incident.id} matches rule ${rule.name || rule.id}`,
+          );
+
+          // Try to find existing episode or create new one
+          const result: GroupingResult = await this.groupIncidentWithRule(
+            incident,
+            rule,
+          );
+          return result;
+        }
+      }
+
+      logger.debug(`Incident ${incident.id} did not match any grouping rules`);
+      return { grouped: false };
+    } catch (error) {
+      logger.error(`Error processing incident for grouping: ${error}`);
+      return { grouped: false };
+    }
+  }
+
+  @CaptureSpan()
+  private async doesIncidentMatchRule(
+    incident: Incident,
+    rule: IncidentGroupingRule,
+  ): Promise<boolean> {
+    logger.debug(
+      `Checking if incident ${incident.id} matches rule ${rule.name || rule.id}`,
+    );
+
+    // Check monitor IDs - if monitors are specified, incident must be from one of them
+    if (rule.monitors && rule.monitors.length > 0) {
+      if (!incident.monitors || incident.monitors.length === 0) {
+        return false;
+      }
+      const ruleMonitorIds: Array<string> = rule.monitors.map((m: Monitor) => {
+        return m.id?.toString() || "";
+      });
+      const incidentMonitorIds: Array<string> = incident.monitors.map(
+        (m: Monitor) => {
+          return m.id?.toString() || "";
+        },
+      );
+      const hasMatchingMonitor: boolean = ruleMonitorIds.some(
+        (monitorId: string) => {
+          return incidentMonitorIds.includes(monitorId);
+        },
+      );
+      if (!hasMatchingMonitor) {
+        return false;
+      }
+    }
+
+    // Check incident severity IDs - if severities are specified, incident must have one of them
+    if (rule.incidentSeverities && rule.incidentSeverities.length > 0) {
+      if (!incident.incidentSeverityId) {
+        return false;
+      }
+      const severityIds: Array<string> = rule.incidentSeverities.map(
+        (s: IncidentSeverity) => {
+          return s.id?.toString() || "";
+        },
+      );
+      const incidentSeverityIdStr: string =
+        incident.incidentSeverityId.toString();
+      if (!severityIds.includes(incidentSeverityIdStr)) {
+        return false;
+      }
+    }
+
+    // Check incident label IDs - if incident labels are specified, incident must have at least one of them
+    if (rule.incidentLabels && rule.incidentLabels.length > 0) {
+      if (!incident.labels || incident.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.incidentLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const incidentLabelIds: Array<string> = incident.labels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const hasMatchingLabel: boolean = ruleLabelIds.some((labelId: string) => {
+        return incidentLabelIds.includes(labelId);
+      });
+      if (!hasMatchingLabel) {
+        return false;
+      }
+    }
+
+    // Check monitor-related criteria (labels, name pattern, description pattern)
+    const hasMonitorCriteria: boolean = Boolean(
+      (rule.monitorLabels && rule.monitorLabels.length > 0) ||
+        rule.monitorNamePattern ||
+        rule.monitorDescriptionPattern,
+    );
+
+    if (hasMonitorCriteria) {
+      if (!incident.monitors || incident.monitors.length === 0) {
+        return false;
+      }
+
+      // Check at least one monitor matches all criteria
+      let anyMonitorMatches: boolean = false;
+
+      for (const incidentMonitor of incident.monitors) {
+        if (!incidentMonitor.id) {
+          continue;
+        }
+
+        // Load monitor with all needed fields
+        const monitor: Monitor | null = await MonitorService.findOneById({
+          id: incidentMonitor.id,
+          select: {
+            name: true,
+            description: true,
+            labels: {
+              _id: true,
+            },
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (!monitor) {
+          continue;
+        }
+
+        let monitorMatches: boolean = true;
+
+        // Check monitor labels
+        if (rule.monitorLabels && rule.monitorLabels.length > 0) {
+          if (!monitor.labels || monitor.labels.length === 0) {
+            monitorMatches = false;
+          } else {
+            const ruleMonitorLabelIds: Array<string> = rule.monitorLabels.map(
+              (l: Label) => {
+                return l.id?.toString() || "";
+              },
+            );
+            const monitorLabelIds: Array<string> = monitor.labels.map(
+              (l: Label) => {
+                return l.id?.toString() || "";
+              },
+            );
+            const hasMatchingMonitorLabel: boolean = ruleMonitorLabelIds.some(
+              (labelId: string) => {
+                return monitorLabelIds.includes(labelId);
+              },
+            );
+            if (!hasMatchingMonitorLabel) {
+              monitorMatches = false;
+            }
+          }
+        }
+
+        // Check monitor name pattern (regex)
+        if (monitorMatches && rule.monitorNamePattern) {
+          if (!monitor.name) {
+            monitorMatches = false;
+          } else {
+            try {
+              const regex: RegExp = new RegExp(rule.monitorNamePattern, "i");
+              if (!regex.test(monitor.name)) {
+                monitorMatches = false;
+              }
+            } catch {
+              logger.warn(
+                `Invalid regex pattern in rule ${rule.id}: ${rule.monitorNamePattern}`,
+              );
+              monitorMatches = false;
+            }
+          }
+        }
+
+        // Check monitor description pattern (regex)
+        if (monitorMatches && rule.monitorDescriptionPattern) {
+          if (!monitor.description) {
+            monitorMatches = false;
+          } else {
+            try {
+              const regex: RegExp = new RegExp(
+                rule.monitorDescriptionPattern,
+                "i",
+              );
+              if (!regex.test(monitor.description)) {
+                monitorMatches = false;
+              }
+            } catch {
+              logger.warn(
+                `Invalid regex pattern in rule ${rule.id}: ${rule.monitorDescriptionPattern}`,
+              );
+              monitorMatches = false;
+            }
+          }
+        }
+
+        if (monitorMatches) {
+          anyMonitorMatches = true;
+          break;
+        }
+      }
+
+      if (!anyMonitorMatches) {
+        return false;
+      }
+    }
+
+    // Check incident title pattern (regex)
+    if (rule.incidentTitlePattern) {
+      if (!incident.title) {
+        return false;
+      }
+      try {
+        const regex: RegExp = new RegExp(rule.incidentTitlePattern, "i");
+        if (!regex.test(incident.title)) {
+          return false;
+        }
+      } catch {
+        logger.warn(
+          `Invalid regex pattern in rule ${rule.id}: ${rule.incidentTitlePattern}`,
+        );
+        return false;
+      }
+    }
+
+    // Check incident description pattern (regex)
+    if (rule.incidentDescriptionPattern) {
+      if (!incident.description) {
+        return false;
+      }
+      try {
+        const regex: RegExp = new RegExp(rule.incidentDescriptionPattern, "i");
+        if (!regex.test(incident.description)) {
+          return false;
+        }
+      } catch {
+        logger.warn(
+          `Invalid regex pattern in rule ${rule.id}: ${rule.incidentDescriptionPattern}`,
+        );
+        return false;
+      }
+    }
+
+    // If no criteria specified (all fields empty), rule matches all incidents
+    logger.debug(
+      `Rule ${rule.name || rule.id} matched incident ${incident.id} (all criteria passed)`,
+    );
+    return true;
+  }
+
+  @CaptureSpan()
+  private async groupIncidentWithRule(
+    incident: Incident,
+    rule: IncidentGroupingRule,
+  ): Promise<GroupingResult> {
+    // Build the grouping key based on groupBy fields
+    const groupingKey: string = await this.buildGroupingKey(incident, rule);
+
+    // Create mutex key to prevent race conditions when creating episodes
+    const mutexKey: string = `${incident.projectId?.toString()}-${rule.id?.toString()}-${groupingKey}`;
+
+    let mutex: SemaphoreMutex | null = null;
+
+    try {
+      /*
+       * Acquire mutex to prevent concurrent episode creation for the same grouping key
+       * This is critical - we must have the lock before proceeding to prevent race conditions
+       */
+      logger.debug(
+        `Acquiring mutex for grouping key: ${mutexKey} for incident ${incident.id}`,
+      );
+      mutex = await Semaphore.lock({
+        key: mutexKey,
+        namespace: "IncidentGroupingEngine.groupIncidentWithRule",
+        lockTimeout: 30000, // 30 seconds - enough time to complete episode creation
+        acquireTimeout: 60000, // Wait up to 60 seconds to acquire the lock
+      });
+      logger.debug(
+        `Acquired mutex for grouping key: ${mutexKey} for incident ${incident.id}`,
+      );
+
+      // Calculate time window cutoff (only if time window is enabled)
+      let timeWindowCutoff: Date | null = null;
+      if (rule.enableTimeWindow) {
+        const timeWindowMinutes: number = rule.timeWindowMinutes || 60;
+        timeWindowCutoff = OneUptimeDate.getSomeMinutesAgo(timeWindowMinutes);
+      }
+
+      // Find existing active episode that matches
+      const existingEpisode: IncidentEpisode | null =
+        await this.findMatchingActiveEpisode(
+          incident.projectId!,
+          rule.id!,
+          groupingKey,
+          timeWindowCutoff,
+        );
+
+      if (existingEpisode && existingEpisode.id) {
+        // Add incident to existing episode
+        await this.addIncidentToEpisode(
+          incident,
+          existingEpisode.id,
+          IncidentEpisodeMemberAddedBy.Rule,
+          rule.id!,
+        );
+
+        // Update episode severity if incident has higher severity
+        if (incident.incidentSeverityId) {
+          await IncidentEpisodeService.updateEpisodeSeverity(
+            existingEpisode.id,
+            incident.incidentSeverityId,
+            true, // onlyIfHigher
+          );
+        }
+
+        return {
+          grouped: true,
+          episodeId: existingEpisode.id,
+          isNewEpisode: false,
+        };
+      }
+
+      // Check if we can reopen a recently resolved episode (only if enabled)
+      if (rule.enableReopenWindow) {
+        const reopenWindowMinutes: number = rule.reopenWindowMinutes || 0;
+        if (reopenWindowMinutes > 0) {
+          const reopenCutoff: Date =
+            OneUptimeDate.getSomeMinutesAgo(reopenWindowMinutes);
+          const recentlyResolvedEpisode: IncidentEpisode | null =
+            await this.findRecentlyResolvedEpisode(
+              incident.projectId!,
+              rule.id!,
+              groupingKey,
+              reopenCutoff,
+            );
+
+          if (recentlyResolvedEpisode && recentlyResolvedEpisode.id) {
+            // Reopen the episode
+            await IncidentEpisodeService.reopenEpisode(
+              recentlyResolvedEpisode.id,
+            );
+
+            // Add incident to reopened episode
+            await this.addIncidentToEpisode(
+              incident,
+              recentlyResolvedEpisode.id,
+              IncidentEpisodeMemberAddedBy.Rule,
+              rule.id!,
+            );
+
+            // Update episode severity if incident has higher severity
+            if (incident.incidentSeverityId) {
+              await IncidentEpisodeService.updateEpisodeSeverity(
+                recentlyResolvedEpisode.id,
+                incident.incidentSeverityId,
+                true, // onlyIfHigher
+              );
+            }
+
+            return {
+              grouped: true,
+              episodeId: recentlyResolvedEpisode.id,
+              isNewEpisode: false,
+              wasReopened: true,
+            };
+          }
+        }
+      }
+
+      // Create new episode
+      const newEpisode: IncidentEpisode | null = await this.createNewEpisode(
+        incident,
+        rule,
+        groupingKey,
+      );
+
+      if (newEpisode && newEpisode.id) {
+        // Add incident to new episode
+        await this.addIncidentToEpisode(
+          incident,
+          newEpisode.id,
+          IncidentEpisodeMemberAddedBy.Rule,
+          rule.id!,
+        );
+
+        return { grouped: true, episodeId: newEpisode.id, isNewEpisode: true };
+      }
+
+      return { grouped: false };
+    } finally {
+      // Release mutex
+      if (mutex) {
+        try {
+          logger.debug(
+            `Releasing mutex for grouping key: ${mutexKey} for incident ${incident.id}`,
+          );
+          await Semaphore.release(mutex);
+          logger.debug(
+            `Released mutex for grouping key: ${mutexKey} for incident ${incident.id}`,
+          );
+        } catch (err) {
+          logger.error(
+            `Error releasing mutex for grouping key: ${mutexKey}: ${err}`,
+          );
+        }
+      }
+    }
+  }
+
+  @CaptureSpan()
+  private async buildGroupingKey(
+    incident: Incident,
+    rule: IncidentGroupingRule,
+  ): Promise<string> {
+    const parts: Array<string> = [];
+
+    /*
+     * Group by service - only if explicitly enabled
+     * Must be checked before monitor since service contains multiple monitors
+     */
+    if (rule.groupByService && incident.monitors && incident.monitors.length > 0) {
+      // Use the first monitor's service for grouping
+      const firstMonitor: Monitor | undefined = incident.monitors[0];
+      if (firstMonitor && firstMonitor.id) {
+        const serviceMonitor: ServiceMonitor | null =
+          await ServiceMonitorService.findOneBy({
+            query: {
+              monitorId: firstMonitor.id,
+            },
+            select: {
+              serviceId: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (serviceMonitor?.serviceId) {
+          parts.push(`service:${serviceMonitor.serviceId.toString()}`);
+        }
+      }
+    }
+
+    // Group by monitor - only if explicitly enabled
+    if (rule.groupByMonitor && incident.monitors && incident.monitors.length > 0) {
+      // Use the first monitor for grouping key
+      const firstMonitor: Monitor | undefined = incident.monitors[0];
+      if (firstMonitor && firstMonitor.id) {
+        parts.push(`monitor:${firstMonitor.id.toString()}`);
+      }
+    }
+
+    // Group by severity - only if explicitly enabled
+    if (rule.groupBySeverity && incident.incidentSeverityId) {
+      parts.push(`severity:${incident.incidentSeverityId.toString()}`);
+    }
+
+    // Group by incident title - only if explicitly enabled
+    if (rule.groupByIncidentTitle && incident.title) {
+      // Normalize title for grouping (remove numbers, etc.)
+      const normalizedTitle: string = incident.title
+        .toLowerCase()
+        .replace(/\d+/g, "X");
+      parts.push(`title:${normalizedTitle}`);
+    }
+
+    // If no group by options are enabled, all matching incidents go into a single episode
+    return parts.join("|") || "default";
+  }
+
+  @CaptureSpan()
+  private async findMatchingActiveEpisode(
+    projectId: ObjectID,
+    ruleId: ObjectID,
+    groupingKey: string,
+    timeWindowCutoff: Date | null,
+  ): Promise<IncidentEpisode | null> {
+    /*
+     * Find active episode with matching rule and grouping key
+     * Active episodes have resolvedAt = null (not yet resolved)
+     * If time window is enabled, also filter by lastIncidentAddedAt
+     * If time window is disabled (timeWindowCutoff is null), find any matching active episode
+     */
+    interface EpisodeQueryType {
+      projectId: ObjectID;
+      incidentGroupingRuleId: ObjectID;
+      groupingKey: string;
+      resolvedAt: null;
+      lastIncidentAddedAt?: ReturnType<typeof QueryHelper.greaterThanEqualTo>;
+    }
+
+    const query: EpisodeQueryType = {
+      projectId: projectId,
+      incidentGroupingRuleId: ruleId,
+      groupingKey: groupingKey,
+      resolvedAt: null, // Only find active (non-resolved) episodes
+    };
+
+    // Only add time window filter if enabled
+    if (timeWindowCutoff) {
+      query.lastIncidentAddedAt =
+        QueryHelper.greaterThanEqualTo(timeWindowCutoff);
+    }
+
+    const episode: IncidentEpisode | null =
+      await IncidentEpisodeService.findOneBy({
+        query: query as any,
+        sort: {
+          lastIncidentAddedAt: SortOrder.Descending,
+        },
+        select: {
+          _id: true,
+          lastIncidentAddedAt: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return episode;
+  }
+
+  @CaptureSpan()
+  private async findRecentlyResolvedEpisode(
+    projectId: ObjectID,
+    ruleId: ObjectID,
+    groupingKey: string,
+    reopenCutoff: Date,
+  ): Promise<IncidentEpisode | null> {
+    // Find recently resolved episode with matching rule and grouping key
+    const episode: IncidentEpisode | null =
+      await IncidentEpisodeService.findOneBy({
+        query: {
+          projectId: projectId,
+          incidentGroupingRuleId: ruleId,
+          groupingKey: groupingKey,
+          resolvedAt: QueryHelper.greaterThanEqualTo(reopenCutoff),
+        },
+        sort: {
+          resolvedAt: SortOrder.Descending,
+        },
+        select: {
+          _id: true,
+          resolvedAt: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return episode;
+  }
+
+  @CaptureSpan()
+  private async createNewEpisode(
+    incident: Incident,
+    rule: IncidentGroupingRule,
+    groupingKey: string,
+  ): Promise<IncidentEpisode | null> {
+    // Generate episode title from template (with initial incidentCount of 1)
+    const title: string = this.generateEpisodeTitle(
+      incident,
+      rule.episodeTitleTemplate,
+      1, // Initial incident count
+    );
+
+    // Generate episode description from template (with initial incidentCount of 1)
+    const description: string | undefined = this.generateEpisodeDescription(
+      incident,
+      rule.episodeDescriptionTemplate,
+      1, // Initial incident count
+    );
+
+    const newEpisode: IncidentEpisode = new IncidentEpisode();
+    newEpisode.projectId = incident.projectId!;
+    newEpisode.title = title;
+    if (description) {
+      newEpisode.description = description;
+    }
+    /*
+     * Store preprocessed templates for dynamic variable updates
+     * Static variables are replaced, dynamic ones (like {{incidentCount}}) remain as placeholders
+     */
+    if (rule.episodeTitleTemplate) {
+      newEpisode.titleTemplate = this.preprocessTemplate(
+        incident,
+        rule.episodeTitleTemplate,
+      );
+    }
+    if (rule.episodeDescriptionTemplate) {
+      newEpisode.descriptionTemplate = this.preprocessTemplate(
+        incident,
+        rule.episodeDescriptionTemplate,
+      );
+    }
+    newEpisode.incidentGroupingRuleId = rule.id!;
+    newEpisode.groupingKey = groupingKey;
+    newEpisode.isManuallyCreated = false;
+
+    // Set severity from incident
+    if (incident.incidentSeverityId) {
+      newEpisode.incidentSeverityId = incident.incidentSeverityId;
+    }
+
+    // Set default ownership from rule
+    if (rule.defaultAssignToUserId) {
+      newEpisode.assignedToUserId = rule.defaultAssignToUserId;
+    }
+
+    if (rule.defaultAssignToTeamId) {
+      newEpisode.assignedToTeamId = rule.defaultAssignToTeamId;
+    }
+
+    // Copy on-call policies from rule
+    if (rule.onCallDutyPolicies && rule.onCallDutyPolicies.length > 0) {
+      newEpisode.onCallDutyPolicies = rule.onCallDutyPolicies;
+    }
+
+    try {
+      const createdEpisode: IncidentEpisode =
+        await IncidentEpisodeService.create({
+          data: newEpisode,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      // Add episode feed entry for episode creation
+      if (createdEpisode.id) {
+        const groupByParts: Array<string> = [];
+
+        if (rule.groupByMonitor) {
+          groupByParts.push("Monitor");
+        }
+        if (rule.groupBySeverity) {
+          groupByParts.push("Severity");
+        }
+        if (rule.groupByIncidentTitle) {
+          groupByParts.push("Incident Title");
+        }
+        if (rule.groupByService) {
+          groupByParts.push("Service");
+        }
+
+        const groupByDescription: string =
+          groupByParts.length > 0
+            ? `Grouping by: ${groupByParts.join(", ")}`
+            : "Grouping all matching incidents together";
+
+        let moreInfo: string = `**Rule:** ${rule.name || "Unnamed Rule"}\n\n`;
+        moreInfo += `**Grouping Key:** \`${groupingKey}\`\n\n`;
+        moreInfo += `**${groupByDescription}**`;
+
+        if (rule.enableTimeWindow && rule.timeWindowMinutes) {
+          moreInfo += `\n\n**Time Window:** ${rule.timeWindowMinutes} minutes`;
+        }
+
+        try {
+          await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
+            incidentEpisodeId: createdEpisode.id,
+            projectId: incident.projectId!,
+            incidentEpisodeFeedEventType:
+              IncidentEpisodeFeedEventType.EpisodeCreated,
+            displayColor: Green500,
+            feedInfoInMarkdown: `**Episode Created** by grouping rule **${rule.name || "Unnamed Rule"}**`,
+            moreInformationInMarkdown: moreInfo,
+          });
+        } catch (feedError) {
+          logger.error(
+            `Error creating episode feed for episode creation: ${feedError}`,
+          );
+        }
+      }
+
+      return createdEpisode;
+    } catch (error) {
+      logger.error(`Error creating new episode: ${error}`);
+      return null;
+    }
+  }
+
+  private generateEpisodeTitle(
+    incident: Incident,
+    template: string | undefined,
+    incidentCount: number = 1,
+  ): string {
+    if (!template) {
+      // Default title based on incident
+      if (incident.monitors && incident.monitors.length > 0 && incident.monitors[0]?.name) {
+        return `Incident Episode: ${incident.monitors[0].name}`;
+      }
+      if (incident.title) {
+        return `Incident Episode: ${incident.title.substring(0, 50)}`;
+      }
+      return "Incident Episode";
+    }
+
+    return (
+      this.replaceTemplatePlaceholders(incident, template, incidentCount) ||
+      "Incident Episode"
+    );
+  }
+
+  private generateEpisodeDescription(
+    incident: Incident,
+    template: string | undefined,
+    incidentCount: number = 1,
+  ): string | undefined {
+    if (!template) {
+      return undefined;
+    }
+
+    return (
+      this.replaceTemplatePlaceholders(incident, template, incidentCount) ||
+      undefined
+    );
+  }
+
+  private replaceTemplatePlaceholders(
+    incident: Incident,
+    template: string,
+    incidentCount: number = 1,
+  ): string {
+    let result: string = template;
+
+    /*
+     * Static variables (from first incident)
+     * {{incidentTitle}}
+     */
+    if (incident.title) {
+      result = result.replace(/\{\{incidentTitle\}\}/g, incident.title);
+    }
+
+    // {{incidentDescription}}
+    if (incident.description) {
+      result = result.replace(
+        /\{\{incidentDescription\}\}/g,
+        incident.description,
+      );
+    }
+
+    // {{monitorName}} - use first monitor's name
+    if (incident.monitors && incident.monitors.length > 0 && incident.monitors[0]?.name) {
+      result = result.replace(/\{\{monitorName\}\}/g, incident.monitors[0].name);
+    }
+
+    // {{incidentSeverity}}
+    if (incident.incidentSeverity?.name) {
+      result = result.replace(
+        /\{\{incidentSeverity\}\}/g,
+        incident.incidentSeverity.name,
+      );
+    }
+
+    /*
+     * Dynamic variables (updated when incidents are added/removed)
+     * {{incidentCount}}
+     */
+    result = result.replace(/\{\{incidentCount\}\}/g, incidentCount.toString());
+
+    // Clean up any remaining unknown placeholders
+    result = result.replace(/\{\{[^}]+\}\}/g, "");
+
+    return result;
+  }
+
+  /*
+   * Preprocess template: replace static variables but keep dynamic ones as placeholders
+   * This is stored on the episode so we can re-render with updated dynamic values later
+   */
+  private preprocessTemplate(incident: Incident, template: string): string {
+    let result: string = template;
+
+    /*
+     * Replace static variables (from first incident)
+     * {{incidentTitle}}
+     */
+    if (incident.title) {
+      result = result.replace(/\{\{incidentTitle\}\}/g, incident.title);
+    }
+
+    // {{incidentDescription}}
+    if (incident.description) {
+      result = result.replace(
+        /\{\{incidentDescription\}\}/g,
+        incident.description,
+      );
+    }
+
+    // {{monitorName}} - use first monitor's name
+    if (incident.monitors && incident.monitors.length > 0 && incident.monitors[0]?.name) {
+      result = result.replace(/\{\{monitorName\}\}/g, incident.monitors[0].name);
+    }
+
+    // {{incidentSeverity}}
+    if (incident.incidentSeverity?.name) {
+      result = result.replace(
+        /\{\{incidentSeverity\}\}/g,
+        incident.incidentSeverity.name,
+      );
+    }
+
+    /*
+     * Keep dynamic variables as placeholders (e.g., {{incidentCount}})
+     * They will be replaced when title/description is re-rendered
+     */
+
+    return result;
+  }
+
+  @CaptureSpan()
+  private async addIncidentToEpisode(
+    incident: Incident,
+    episodeId: ObjectID,
+    addedBy: IncidentEpisodeMemberAddedBy,
+    ruleId?: ObjectID,
+  ): Promise<void> {
+    const member: IncidentEpisodeMember = new IncidentEpisodeMember();
+    member.projectId = incident.projectId!;
+    member.incidentEpisodeId = episodeId;
+    member.incidentId = incident.id!;
+    member.addedBy = addedBy;
+
+    if (ruleId) {
+      member.matchedRuleId = ruleId;
+    }
+
+    try {
+      await IncidentEpisodeMemberService.create({
+        data: member,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // Feed entries are created by IncidentEpisodeMemberService.onCreateSuccess
+    } catch (error) {
+      // Check if it's a duplicate error (incident already in episode)
+      if (
+        error instanceof Error &&
+        error.message.includes("already a member")
+      ) {
+        logger.debug(
+          `Incident ${incident.id} is already in episode ${episodeId}`,
+        );
+        return;
+      }
+      throw error;
+    }
+  }
+
+  @CaptureSpan()
+  public async addIncidentToEpisodeManually(
+    incident: Incident,
+    episodeId: ObjectID,
+    addedByUserId?: ObjectID,
+  ): Promise<void> {
+    const member: IncidentEpisodeMember = new IncidentEpisodeMember();
+    member.projectId = incident.projectId!;
+    member.incidentEpisodeId = episodeId;
+    member.incidentId = incident.id!;
+    member.addedBy = IncidentEpisodeMemberAddedBy.Manual;
+
+    if (addedByUserId) {
+      member.addedByUserId = addedByUserId;
+    }
+
+    await IncidentEpisodeMemberService.create({
+      data: member,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Feed entries are created by IncidentEpisodeMemberService.onCreateSuccess
+
+    // Update episode severity if needed
+    if (incident.incidentSeverityId) {
+      await IncidentEpisodeService.updateEpisodeSeverity(
+        episodeId,
+        incident.incidentSeverityId,
+        true, // onlyIfHigher
+      );
+    }
+  }
+}
+
+export default new IncidentGroupingEngineServiceClass();
diff --git a/Common/Server/Services/IncidentGroupingRuleService.ts b/Common/Server/Services/IncidentGroupingRuleService.ts
new file mode 100644
index 0000000000..793eac6e76
--- /dev/null
+++ b/Common/Server/Services/IncidentGroupingRuleService.ts
@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/IncidentGroupingRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+}
+
+export default new Service();
diff --git a/Common/Server/Services/IncidentService.ts b/Common/Server/Services/IncidentService.ts
index 529ad4893b..28c7914c29 100644
--- a/Common/Server/Services/IncidentService.ts
+++ b/Common/Server/Services/IncidentService.ts
@@ -49,6 +49,7 @@ import Semaphore, {
 } from "../../Server/Infrastructure/Semaphore";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
+import IncidentGroupingEngineService from "./IncidentGroupingEngineService";
 import { Blue500, Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
@@ -841,6 +842,16 @@ export class Service extends DatabaseService<Model> {
           return Promise.resolve();
         }
       })
+      .then(async () => {
+        // Process incident for grouping into episodes
+        try {
+          await IncidentGroupingEngineService.processIncident(createdItem);
+        } catch (error) {
+          logger.error(
+            `Incident grouping failed in IncidentService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in IncidentService sequential operations: ${error}`,
diff --git a/Common/Types/Permission.ts b/Common/Types/Permission.ts
index a5eb28b62f..75bc04c806 100644
--- a/Common/Types/Permission.ts
+++ b/Common/Types/Permission.ts
@@ -789,6 +789,12 @@ enum Permission {
   CreateIncidentEpisodeFeed = "CreateIncidentEpisodeFeed",
   EditIncidentEpisodeFeed = "EditIncidentEpisodeFeed",
   ReadIncidentEpisodeFeed = "ReadIncidentEpisodeFeed",
+
+  // Incident Grouping Rule Permissions
+  CreateIncidentGroupingRule = "CreateIncidentGroupingRule",
+  DeleteIncidentGroupingRule = "DeleteIncidentGroupingRule",
+  EditIncidentGroupingRule = "EditIncidentGroupingRule",
+  ReadIncidentGroupingRule = "ReadIncidentGroupingRule",
 }
 
 export class PermissionHelper {
@@ -5597,6 +5603,40 @@ export class PermissionHelper {
         isAssignableToTenant: true,
         isAccessControlPermission: false,
       },
+
+      // Incident Grouping Rule Permissions
+      {
+        permission: Permission.CreateIncidentGroupingRule,
+        title: "Create Incident Grouping Rule",
+        description:
+          "This permission can create Incident Grouping Rules in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.DeleteIncidentGroupingRule,
+        title: "Delete Incident Grouping Rule",
+        description:
+          "This permission can delete Incident Grouping Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.EditIncidentGroupingRule,
+        title: "Edit Incident Grouping Rule",
+        description:
+          "This permission can edit Incident Grouping Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.ReadIncidentGroupingRule,
+        title: "Read Incident Grouping Rule",
+        description:
+          "This permission can read Incident Grouping Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
     ];
 
     return permissions;
diff --git a/Dashboard/src/Pages/Incidents/Settings/IncidentGroupingRules.tsx b/Dashboard/src/Pages/Incidents/Settings/IncidentGroupingRules.tsx
new file mode 100644
index 0000000000..45923f2d5a
--- /dev/null
+++ b/Dashboard/src/Pages/Incidents/Settings/IncidentGroupingRules.tsx
@@ -0,0 +1,713 @@
+import PageComponentProps from "../../PageComponentProps";
+import SortOrder from "Common/Types/BaseDatabase/SortOrder";
+import FormFieldSchemaType from "Common/UI/Components/Forms/Types/FormFieldSchemaType";
+import FormValues from "Common/UI/Components/Forms/Types/FormValues";
+import ModelTable from "Common/UI/Components/ModelTable/ModelTable";
+import Pill from "Common/UI/Components/Pill/Pill";
+import FieldType from "Common/UI/Components/Types/FieldType";
+import Navigation from "Common/UI/Utils/Navigation";
+import IncidentGroupingRule from "Common/Models/DatabaseModels/IncidentGroupingRule";
+import React, { Fragment, FunctionComponent, ReactElement } from "react";
+import { Green, Red } from "Common/Types/BrandColors";
+import OnCallDutyPolicy from "Common/Models/DatabaseModels/OnCallDutyPolicy";
+import Team from "Common/Models/DatabaseModels/Team";
+import ProjectUser from "../../../Utils/ProjectUser";
+import ProjectUtil from "Common/UI/Utils/Project";
+import Monitor from "Common/Models/DatabaseModels/Monitor";
+import IncidentSeverity from "Common/Models/DatabaseModels/IncidentSeverity";
+import Label from "Common/Models/DatabaseModels/Label";
+
+const documentationMarkdown: string = `
+### How Incident Grouping Works
+
+Incident grouping automatically combines related incidents into logical containers called **Episodes**. This reduces incident fatigue by showing one episode with 50 incidents instead of 50 individual notifications.
+
+\`\`\`mermaid
+flowchart TD
+    A[New Incident Created] --> B{Match Against Rules}
+    B -->|Rule Matches| C{Find Existing Episode}
+    B -->|No Match| D[Incident Stays Ungrouped]
+    C -->|Episode Found| E[Add Incident to Episode]
+    C -->|No Episode| F[Create New Episode]
+    E --> G[Update Episode Count]
+    F --> H[Execute On-Call Policy]
+\`\`\`
+
+---
+
+### Match Criteria vs Group By
+
+These two concepts work together but serve different purposes:
+
+| Aspect | Match Criteria | Group By |
+|--------|---------------|----------|
+| **Purpose** | Filter which incidents this rule applies to | Partition matching incidents into separate episodes |
+| **Question** | "Does this incident qualify for this rule?" | "Which episode does this incident go into?" |
+| **Example** | Only Critical incidents from production monitors | Separate episode per monitor |
+
+#### Match Criteria (Filtering)
+
+Match criteria acts as a **filter** that determines which incidents are eligible for this grouping rule. An incident must pass ALL specified criteria to be processed by the rule.
+
+- **Monitors**: Only incidents from these specific monitors
+- **Severities**: Only incidents with these severity levels
+- **Labels**: Only incidents with at least one of these labels
+- **Title/Description Patterns**: Regex patterns to match incident content
+
+#### Group By (Partitioning)
+
+Group By determines **how matching incidents are subdivided** into separate episodes. This creates the "grouping key" that identifies which episode an incident belongs to.
+
+\`\`\`mermaid
+flowchart LR
+    subgraph "Match Criteria: Severity = Critical"
+        A1[Incident: CPU High<br/>Monitor A]
+        A2[Incident: Memory Low<br/>Monitor A]
+        A3[Incident: CPU High<br/>Monitor B]
+        A4[Incident: Disk Full<br/>Monitor B]
+    end
+
+    subgraph "Group By: Monitor"
+        E1[Episode 1<br/>Monitor A<br/>2 incidents]
+        E2[Episode 2<br/>Monitor B<br/>2 incidents]
+    end
+
+    A1 --> E1
+    A2 --> E1
+    A3 --> E2
+    A4 --> E2
+\`\`\`
+
+---
+
+### Group By Options Explained
+
+| Option | When Enabled | When Disabled |
+|--------|-------------|---------------|
+| **Group By Service** | Incidents from monitors in different services → separate episodes | Incidents can be grouped regardless of service |
+| **Group By Monitor** | Incidents from different monitors → separate episodes | Incidents from any monitor can be grouped together |
+| **Group By Severity** | Incidents with different severities → separate episodes | Incidents of any severity can be grouped together |
+| **Group By Incident Title** | Incidents with different titles → separate episodes | Incidents with any title can be grouped together |
+
+> **Note:** Monitors can be attached to Services. A Service can have multiple monitors. Group By Service is useful when you want to group all incidents from a service together regardless of which specific monitor triggered them.
+
+#### Default Behavior
+
+**If NO Group By options are enabled**, all matching incidents go into **ONE single episode**. This is useful when you want to group all related incidents regardless of their source.
+
+\`\`\`mermaid
+flowchart TD
+    subgraph "No Group By Enabled"
+        direction TB
+        A1[Incident 1] --> E[Single Episode<br/>All Matching Incidents]
+        A2[Incident 2] --> E
+        A3[Incident 3] --> E
+        A4[Incident 4] --> E
+    end
+\`\`\`
+
+---
+
+### Examples
+
+#### Example 1: Group all Critical incidents by Monitor
+
+**Configuration:**
+- Match Criteria: Severity = Critical
+- Group By: Monitor
+
+**Result:** Each monitor gets its own episode for critical incidents.
+
+#### Example 2: Single episode for all database incidents
+
+**Configuration:**
+- Match Criteria: Monitor Labels = "database"
+- Group By: (none enabled)
+
+**Result:** ALL database incidents go into one episode, regardless of which specific database monitor they come from.
+
+#### Example 3: Fine-grained grouping
+
+**Configuration:**
+- Match Criteria: (none - matches all incidents)
+- Group By: Monitor, Severity, Incident Title
+
+**Result:** Very specific episodes - one per unique combination of monitor + severity + title.
+`;
+
+const IncidentGroupingRulesPage: FunctionComponent<
+  PageComponentProps
+> = (): ReactElement => {
+  return (
+    <Fragment>
+      <ModelTable<IncidentGroupingRule>
+        modelType={IncidentGroupingRule}
+        id="incident-grouping-rules-table"
+        name="Settings > Incident Grouping Rules"
+        userPreferencesKey="incident-grouping-rules-table"
+        isDeleteable={true}
+        isEditable={true}
+        isCreateable={true}
+        cardProps={{
+          title: "Incident Grouping Rules",
+          description:
+            "Define rules to automatically group related incidents into episodes. Rules are evaluated in priority order - lower priority numbers are evaluated first.",
+        }}
+        helpContent={{
+          title: "How Incident Grouping Rules Work",
+          description:
+            "Understanding Match Criteria, Group By, and how incidents are organized into episodes",
+          markdown: documentationMarkdown,
+        }}
+        sortBy="priority"
+        sortOrder={SortOrder.Ascending}
+        selectMoreFields={{
+          priority: true,
+          isEnabled: true,
+        }}
+        filters={[
+          {
+            field: {
+              name: true,
+            },
+            title: "Name",
+            type: FieldType.Text,
+          },
+          {
+            field: {
+              isEnabled: true,
+            },
+            title: "Enabled",
+            type: FieldType.Boolean,
+          },
+        ]}
+        columns={[
+          {
+            field: {
+              name: true,
+            },
+            title: "Name",
+            type: FieldType.Text,
+          },
+          {
+            field: {
+              description: true,
+            },
+            title: "Description",
+            type: FieldType.Text,
+          },
+          {
+            field: {
+              priority: true,
+            },
+            title: "Priority",
+            type: FieldType.Number,
+          },
+          {
+            field: {
+              isEnabled: true,
+            },
+            title: "Status",
+            type: FieldType.Boolean,
+            getElement: (item: IncidentGroupingRule): ReactElement => {
+              if (item.isEnabled) {
+                return <Pill color={Green} text="Enabled" />;
+              }
+              return <Pill color={Red} text="Disabled" />;
+            },
+          },
+          {
+            field: {
+              timeWindowMinutes: true,
+            },
+            title: "Time Window (min)",
+            type: FieldType.Number,
+          },
+          {
+            field: {
+              inactivityTimeoutMinutes: true,
+            },
+            title: "Inactivity Timeout (min)",
+            type: FieldType.Number,
+          },
+        ]}
+        viewPageRoute={Navigation.getCurrentRoute()}
+        formSteps={[
+          {
+            title: "Basic Info",
+            id: "basic-info",
+          },
+          {
+            title: "Match Criteria",
+            id: "match-criteria",
+          },
+          {
+            title: "Group By",
+            id: "group-by",
+          },
+          {
+            title: "Time Settings",
+            id: "time-settings",
+          },
+          {
+            title: "Episode Template",
+            id: "episode-template",
+          },
+          {
+            title: "On-Call & Ownership",
+            id: "on-call-ownership",
+          },
+        ]}
+        formFields={[
+          {
+            field: {
+              name: true,
+            },
+            title: "Name",
+            stepId: "basic-info",
+            fieldType: FormFieldSchemaType.Text,
+            required: true,
+            placeholder: "Critical Service Incidents",
+            validation: {
+              minLength: 2,
+            },
+          },
+          {
+            field: {
+              description: true,
+            },
+            title: "Description",
+            stepId: "basic-info",
+            fieldType: FormFieldSchemaType.LongText,
+            required: false,
+            placeholder: "Groups all critical incidents from production services",
+          },
+          {
+            field: {
+              priority: true,
+            },
+            title: "Priority",
+            stepId: "basic-info",
+            fieldType: FormFieldSchemaType.Number,
+            required: true,
+            placeholder: "1",
+            description:
+              "Lower numbers have higher priority. Rules are evaluated in order.",
+          },
+          {
+            field: {
+              isEnabled: true,
+            },
+            title: "Enabled",
+            stepId: "basic-info",
+            fieldType: FormFieldSchemaType.Toggle,
+            required: false,
+            description: "Enable or disable this grouping rule.",
+          },
+          // Match Criteria Fields
+          {
+            field: {
+              monitors: true,
+            },
+            title: "Monitors",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.MultiSelectDropdown,
+            dropdownModal: {
+              type: Monitor,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "Only group incidents from these monitors. Leave empty to match incidents from any monitor.",
+            placeholder: "Select Monitors (optional)",
+          },
+          {
+            field: {
+              incidentSeverities: true,
+            },
+            title: "Incident Severities",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.MultiSelectDropdown,
+            dropdownModal: {
+              type: IncidentSeverity,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "Only group incidents with these severities. Leave empty to match incidents of any severity.",
+            placeholder: "Select Severities (optional)",
+          },
+          {
+            field: {
+              incidentLabels: true,
+            },
+            title: "Incident Labels",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.MultiSelectDropdown,
+            dropdownModal: {
+              type: Label,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "Only group incidents that have at least one of these labels attached to them. Leave empty to match incidents regardless of incident labels.",
+            placeholder: "Select Incident Labels (optional)",
+          },
+          {
+            field: {
+              monitorLabels: true,
+            },
+            title: "Monitor Labels",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.MultiSelectDropdown,
+            dropdownModal: {
+              type: Label,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "Only group incidents from monitors that have at least one of these labels. Leave empty to match incidents regardless of monitor labels.",
+            placeholder: "Select Monitor Labels (optional)",
+          },
+          {
+            field: {
+              incidentTitlePattern: true,
+            },
+            title: "Incident Title Pattern",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.Text,
+            required: false,
+            placeholder: "CPU.*high",
+            description:
+              "Regular expression pattern to match incident titles. Leave empty to match any title. Example: 'CPU.*high' matches titles containing 'CPU' followed by 'high'.",
+          },
+          {
+            field: {
+              incidentDescriptionPattern: true,
+            },
+            title: "Incident Description Pattern",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.Text,
+            required: false,
+            placeholder: "timeout|connection refused",
+            description:
+              "Regular expression pattern to match incident descriptions. Leave empty to match any description. Example: 'timeout|connection refused' matches descriptions containing either phrase.",
+          },
+          {
+            field: {
+              monitorNamePattern: true,
+            },
+            title: "Monitor Name Pattern",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.Text,
+            required: false,
+            placeholder: "prod-.*|api-server-.*",
+            description:
+              "Regular expression pattern to match monitor names. Leave empty to match any monitor. Example: 'prod-.*' matches monitors starting with 'prod-'.",
+          },
+          {
+            field: {
+              monitorDescriptionPattern: true,
+            },
+            title: "Monitor Description Pattern",
+            stepId: "match-criteria",
+            fieldType: FormFieldSchemaType.Text,
+            required: false,
+            placeholder: "production|critical",
+            description:
+              "Regular expression pattern to match monitor descriptions. Leave empty to match any description.",
+          },
+          // Group By Fields
+          {
+            field: {
+              groupByService: true,
+            },
+            title: "Group By Service",
+            stepId: "group-by",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "When enabled, incidents from monitors belonging to different services will be grouped into separate episodes. Monitors can be attached to services, and a service can have multiple monitors.",
+          },
+          {
+            field: {
+              groupByMonitor: true,
+            },
+            title: "Group By Monitor",
+            stepId: "group-by",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "When enabled, incidents from different monitors will be grouped into separate episodes. When disabled, incidents from any monitor can be grouped together.",
+          },
+          {
+            field: {
+              groupBySeverity: true,
+            },
+            title: "Group By Incident Severity",
+            stepId: "group-by",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "When enabled, incidents with different severities will be grouped into separate episodes. When disabled, incidents of any severity can be grouped together.",
+          },
+          {
+            field: {
+              groupByIncidentTitle: true,
+            },
+            title: "Group By Incident Title",
+            stepId: "group-by",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "When enabled, incidents with different titles will be grouped into separate episodes. When disabled, incidents with any title can be grouped together.",
+          },
+          // Time Settings Fields
+          {
+            field: {
+              enableTimeWindow: true,
+            },
+            title: "Enable Time Window",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "Enable time-based grouping to limit how long an episode stays open for new incidents. When disabled, all incidents matching the grouping criteria (severity, title, monitor, etc.) will be grouped into a single ongoing episode regardless of when they occur. When enabled, incidents are only grouped if they arrive within the specified time window of the last incident.",
+          },
+          {
+            field: {
+              timeWindowMinutes: true,
+            },
+            title: "Time Window (minutes)",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Number,
+            required: false,
+            placeholder: "60",
+            showIf: (model: FormValues<IncidentGroupingRule>): boolean => {
+              return model.enableTimeWindow === true;
+            },
+            description:
+              "Rolling window that determines how long an episode stays open for new incidents. Incidents arriving within this time gap of the last incident will be grouped into the same episode. For example, if set to 60 minutes, incidents will keep grouping as long as each new incident arrives within 60 minutes of the previous one.",
+          },
+          {
+            field: {
+              enableResolveDelay: true,
+            },
+            title: "Enable Resolve Delay",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "Enable this to add a grace period before auto-resolving an episode after all its incidents are resolved. This helps prevent unnecessary state changes during incident flapping - when incidents rapidly toggle between triggered and resolved states. Without this, the episode would resolve immediately when incidents resolve, then potentially reopen moments later if the issue recurs.",
+          },
+          {
+            field: {
+              resolveDelayMinutes: true,
+            },
+            title: "Resolve Delay (minutes)",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Number,
+            required: false,
+            placeholder: "5",
+            showIf: (model: FormValues<IncidentGroupingRule>): boolean => {
+              return model.enableResolveDelay === true;
+            },
+            description:
+              "Number of minutes to wait after all incidents in the episode are resolved before automatically resolving the episode itself.",
+          },
+          {
+            field: {
+              enableReopenWindow: true,
+            },
+            title: "Enable Reopen Window",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "Enable this to reopen recently resolved episodes instead of creating new ones when matching incidents arrive. This is useful for recurring issues - if a problem returns shortly after being resolved, it makes more sense to continue tracking it in the same episode rather than fragmenting the incident history across multiple episodes.",
+          },
+          {
+            field: {
+              reopenWindowMinutes: true,
+            },
+            title: "Reopen Window (minutes)",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Number,
+            required: false,
+            placeholder: "30",
+            showIf: (model: FormValues<IncidentGroupingRule>): boolean => {
+              return model.enableReopenWindow === true;
+            },
+            description:
+              "Time window after an episode is resolved during which a new matching incident will reopen that episode instead of creating a new one.",
+          },
+          {
+            field: {
+              enableInactivityTimeout: true,
+            },
+            title: "Enable Inactivity Timeout",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Checkbox,
+            required: false,
+            description:
+              "Enable this to automatically resolve episodes after a period of inactivity. This helps clean up stale episodes that are no longer receiving incidents, ensuring your active episode list stays current and relevant. Without this, episodes would remain open indefinitely until manually resolved.",
+          },
+          {
+            field: {
+              inactivityTimeoutMinutes: true,
+            },
+            title: "Inactivity Timeout (minutes)",
+            stepId: "time-settings",
+            fieldType: FormFieldSchemaType.Number,
+            required: false,
+            placeholder: "60",
+            showIf: (model: FormValues<IncidentGroupingRule>): boolean => {
+              return model.enableInactivityTimeout === true;
+            },
+            description:
+              "Number of minutes of inactivity (no new incidents added) after which the episode will be automatically resolved.",
+          },
+          {
+            field: {
+              episodeTitleTemplate: true,
+            },
+            title: "Episode Title Template",
+            stepId: "episode-template",
+            fieldType: FormFieldSchemaType.Text,
+            required: false,
+            placeholder: "{{incidentSeverity}} Incident Episode on {{monitorName}}",
+            description:
+              "Template for auto-generated episode titles. Uses the first incident's data to generate the title.",
+          },
+          {
+            field: {
+              episodeDescriptionTemplate: true,
+            },
+            title: "Episode Description Template",
+            stepId: "episode-template",
+            fieldType: FormFieldSchemaType.LongText,
+            required: false,
+            placeholder:
+              "Episode created from {{incidentSeverity}} incident: {{incidentTitle}} on monitor {{monitorName}}",
+            description:
+              "Template for auto-generated episode descriptions. Uses the first incident's data to generate the description.",
+            footerElement: (
+              <div className="mt-4 p-4 bg-gray-50 rounded-md border border-gray-200 text-sm">
+                <p className="font-medium mb-3">
+                  Supported Template Variables:
+                </p>
+                <div className="mb-3">
+                  <p className="text-xs font-medium text-gray-500 mb-1">
+                    Static Variables (from first incident):
+                  </p>
+                  <ul className="list-disc list-inside space-y-1 text-gray-700">
+                    <li>
+                      <code className="bg-gray-200 px-1 rounded">
+                        {"{{incidentTitle}}"}
+                      </code>{" "}
+                      - Title of the incident
+                    </li>
+                    <li>
+                      <code className="bg-gray-200 px-1 rounded">
+                        {"{{incidentDescription}}"}
+                      </code>{" "}
+                      - Description of the incident
+                    </li>
+                    <li>
+                      <code className="bg-gray-200 px-1 rounded">
+                        {"{{incidentSeverity}}"}
+                      </code>{" "}
+                      - Severity level (e.g., Critical, Warning)
+                    </li>
+                    <li>
+                      <code className="bg-gray-200 px-1 rounded">
+                        {"{{monitorName}}"}
+                      </code>{" "}
+                      - Name of the monitor that triggered the incident
+                    </li>
+                  </ul>
+                </div>
+                <div>
+                  <p className="text-xs font-medium text-gray-500 mb-1">
+                    Dynamic Variables (updated as incidents join):
+                  </p>
+                  <ul className="list-disc list-inside space-y-1 text-gray-700">
+                    <li>
+                      <code className="bg-gray-200 px-1 rounded">
+                        {"{{incidentCount}}"}
+                      </code>{" "}
+                      - Number of incidents in the episode
+                    </li>
+                  </ul>
+                </div>
+                <p className="mt-3 text-gray-500 text-xs">
+                  Static variables use data from the first incident. Dynamic
+                  variables update automatically when incidents are added or
+                  removed.
+                </p>
+              </div>
+            ),
+          },
+          {
+            field: {
+              onCallDutyPolicies: true,
+            },
+            title: "On-Call Duty Policies",
+            stepId: "on-call-ownership",
+            fieldType: FormFieldSchemaType.MultiSelectDropdown,
+            dropdownModal: {
+              type: OnCallDutyPolicy,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "On-call policies to execute when an episode is created with this rule.",
+            placeholder: "Select On-Call Policies",
+          },
+          {
+            field: {
+              defaultAssignToTeam: true,
+            },
+            title: "Default Assign To Team",
+            stepId: "on-call-ownership",
+            fieldType: FormFieldSchemaType.Dropdown,
+            dropdownModal: {
+              type: Team,
+              labelField: "name",
+              valueField: "_id",
+            },
+            required: false,
+            description:
+              "Default team to assign episodes created by this rule.",
+            placeholder: "Select Team",
+          },
+          {
+            field: {
+              defaultAssignToUser: true,
+            },
+            title: "Default Assign To User",
+            stepId: "on-call-ownership",
+            fieldType: FormFieldSchemaType.Dropdown,
+            fetchDropdownOptions: async () => {
+              return await ProjectUser.fetchProjectUsersAsDropdownOptions(
+                ProjectUtil.getCurrentProjectId()!,
+              );
+            },
+            required: false,
+            description:
+              "Default user to assign episodes created by this rule.",
+            placeholder: "Select User",
+          },
+        ]}
+        showRefreshButton={true}
+      />
+    </Fragment>
+  );
+};
+
+export default IncidentGroupingRulesPage;
diff --git a/Dashboard/src/Pages/Incidents/SideMenu.tsx b/Dashboard/src/Pages/Incidents/SideMenu.tsx
index 44af051bf1..5b249ad8c0 100644
--- a/Dashboard/src/Pages/Incidents/SideMenu.tsx
+++ b/Dashboard/src/Pages/Incidents/SideMenu.tsx
@@ -173,6 +173,15 @@ const DashboardSideMenu: FunctionComponent<ComponentProps> = (
           },
           icon: IconProp.TableCells,
         },
+        {
+          link: {
+            title: "Grouping Rules",
+            to: RouteUtil.populateRouteParams(
+              RouteMap[PageMap.INCIDENTS_SETTINGS_GROUPING_RULES] as Route,
+            ),
+          },
+          icon: IconProp.Layers,
+        },
       ],
     },
   ];
diff --git a/Dashboard/src/Routes/IncidentsRoutes.tsx b/Dashboard/src/Routes/IncidentsRoutes.tsx
index fc5ded01e5..f6764a62ed 100644
--- a/Dashboard/src/Routes/IncidentsRoutes.tsx
+++ b/Dashboard/src/Routes/IncidentsRoutes.tsx
@@ -184,6 +184,12 @@ const IncidentSettingsCustomFields: LazyExoticComponent<
   return import("../Pages/Incidents/Settings/IncidentCustomFields");
 });
 
+const IncidentSettingsGroupingRules: LazyExoticComponent<
+  FunctionComponent<ComponentProps>
+> = lazy(() => {
+  return import("../Pages/Incidents/Settings/IncidentGroupingRules");
+});
+
 // Incident Episode Pages
 const IncidentEpisodes: LazyExoticComponent<FunctionComponent<ComponentProps>> =
   lazy(() => {
@@ -513,6 +519,22 @@ const IncidentsRoutes: FunctionComponent<ComponentProps> = (
           }
         />
 
+        <PageRoute
+          path={
+            IncidentsRoutePath[PageMap.INCIDENTS_SETTINGS_GROUPING_RULES] || ""
+          }
+          element={
+            <Suspense fallback={Loader}>
+              <IncidentSettingsGroupingRules
+                {...props}
+                pageRoute={
+                  RouteMap[PageMap.INCIDENTS_SETTINGS_GROUPING_RULES] as Route
+                }
+              />
+            </Suspense>
+          }
+        />
+
         {/* Incident Episode Routes */}
         <PageRoute
           path={IncidentsRoutePath[PageMap.INCIDENT_EPISODES] || ""}
diff --git a/Dashboard/src/Utils/PageMap.ts b/Dashboard/src/Utils/PageMap.ts
index deacb608e8..0a3f6dacf5 100644
--- a/Dashboard/src/Utils/PageMap.ts
+++ b/Dashboard/src/Utils/PageMap.ts
@@ -78,6 +78,7 @@ enum PageMap {
   INCIDENTS_SETTINGS_POSTMORTEM_TEMPLATES = "INCIDENTS_SETTINGS_POSTMORTEM_TEMPLATES",
   INCIDENTS_SETTINGS_POSTMORTEM_TEMPLATES_VIEW = "INCIDENTS_SETTINGS_POSTMORTEM_TEMPLATES_VIEW",
   INCIDENTS_SETTINGS_CUSTOM_FIELDS = "INCIDENTS_SETTINGS_CUSTOM_FIELDS",
+  INCIDENTS_SETTINGS_GROUPING_RULES = "INCIDENTS_SETTINGS_GROUPING_RULES",
 
   ALERTS_ROOT = "ALERTS_ROOT",
   ALERTS = "ALERTS",
diff --git a/Dashboard/src/Utils/RouteMap.ts b/Dashboard/src/Utils/RouteMap.ts
index 84aed83b38..095c23ea5f 100644
--- a/Dashboard/src/Utils/RouteMap.ts
+++ b/Dashboard/src/Utils/RouteMap.ts
@@ -189,6 +189,7 @@ export const IncidentsRoutePath: Dictionary<string> = {
     "settings/postmortem-templates",
   [PageMap.INCIDENTS_SETTINGS_POSTMORTEM_TEMPLATES_VIEW]: `settings/postmortem-templates/${RouteParams.ModelID}`,
   [PageMap.INCIDENTS_SETTINGS_CUSTOM_FIELDS]: "settings/custom-fields",
+  [PageMap.INCIDENTS_SETTINGS_GROUPING_RULES]: "settings/grouping-rules",
 
   [PageMap.INCIDENT_VIEW]: `${RouteParams.ModelID}`,
   [PageMap.INCIDENT_VIEW_STATE_TIMELINE]: `${RouteParams.ModelID}/state-timeline`,
@@ -1061,6 +1062,12 @@ const RouteMap: Dictionary<Route> = {
     }`,
   ),
 
+  [PageMap.INCIDENTS_SETTINGS_GROUPING_RULES]: new Route(
+    `/dashboard/${RouteParams.ProjectID}/incidents/${
+      IncidentsRoutePath[PageMap.INCIDENTS_SETTINGS_GROUPING_RULES]
+    }`,
+  ),
+
   [PageMap.SCHEDULED_MAINTENANCE_EVENTS_ROOT]: new Route(
     `/dashboard/${RouteParams.ProjectID}/scheduled-maintenance-events/*`,
   ),