From 75e384648fd36e26ade541ea7ae6237c92ac7127 Mon Sep 17 00:00:00 2001
From: Copilot Bot <bot@copilot.com>
Date: Sat, 24 Jan 2026 16:20:58 +0000
Subject: [PATCH 1/2] Update v1.1.0: Added Inviter Hub, Instance/Friend
 Inviter, 18+ Filtering, and Profile Viewer

---
 .github/dependabot.yml                       |  21 +
 .github/workflows/build.yml                  |   2 +
 README.md                                    |  12 +-
 src/App.xaml                                 |   6 +
 src/App.xaml.cs                              |   5 +
 src/Converters/Converters.cs                 |  93 ++-
 src/Data/AppDbContext.cs                     |  10 +
 src/Data/Models/InvitedUser.cs               |  24 +
 src/Services/AuditLogService.cs              |  70 +-
 src/Services/DiscordWebhookService.cs        |  32 +-
 src/Services/InstanceInviterService.cs       | 334 +++++++++
 src/Services/SecurityMonitorService.cs       |  49 ++
 src/Services/SettingsService.cs              |  10 +
 src/Services/VRChatApiService.cs             | 263 +++++++
 src/VRCGroupTools.csproj                     |   7 +-
 src/ViewModels/FriendInviterViewModel.cs     | 315 +++++++++
 src/ViewModels/GroupJoinRequestsViewModel.cs | 516 ++++++++++++++
 src/ViewModels/InstanceInviterViewModel.cs   | 679 +++++++++++++++++++
 src/ViewModels/InviterHubViewModel.cs        |  35 +
 src/ViewModels/MainViewModel.cs              |  26 +
 src/ViewModels/MembersListViewModel.cs       |  42 ++
 src/ViewModels/UserProfileViewModel.cs       | 125 ++++
 src/Views/FriendInviterView.xaml             | 242 +++++++
 src/Views/FriendInviterView.xaml.cs          |  11 +
 src/Views/GroupJoinRequestsView.xaml         | 397 +++++++++++
 src/Views/GroupJoinRequestsView.xaml.cs      |  11 +
 src/Views/InstanceInviterView.xaml           | 282 ++++++++
 src/Views/InstanceInviterView.xaml.cs        |  11 +
 src/Views/InviterHubView.xaml                | 158 +++++
 src/Views/InviterHubView.xaml.cs             |  11 +
 src/Views/MainWindow.xaml                    |  29 +-
 src/Views/MembersListView.xaml               |   8 +
 src/Views/UserProfileWindow.xaml             |  93 +++
 src/Views/UserProfileWindow.xaml.cs          |  13 +
 34 files changed, 3905 insertions(+), 37 deletions(-)
 create mode 100644 .github/dependabot.yml
 create mode 100644 src/Data/Models/InvitedUser.cs
 create mode 100644 src/Services/InstanceInviterService.cs
 create mode 100644 src/ViewModels/FriendInviterViewModel.cs
 create mode 100644 src/ViewModels/GroupJoinRequestsViewModel.cs
 create mode 100644 src/ViewModels/InstanceInviterViewModel.cs
 create mode 100644 src/ViewModels/InviterHubViewModel.cs
 create mode 100644 src/ViewModels/UserProfileViewModel.cs
 create mode 100644 src/Views/FriendInviterView.xaml
 create mode 100644 src/Views/FriendInviterView.xaml.cs
 create mode 100644 src/Views/GroupJoinRequestsView.xaml
 create mode 100644 src/Views/GroupJoinRequestsView.xaml.cs
 create mode 100644 src/Views/InstanceInviterView.xaml
 create mode 100644 src/Views/InstanceInviterView.xaml.cs
 create mode 100644 src/Views/InviterHubView.xaml
 create mode 100644 src/Views/InviterHubView.xaml.cs
 create mode 100644 src/Views/UserProfileWindow.xaml
 create mode 100644 src/Views/UserProfileWindow.xaml.cs

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..61eb96b
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,21 @@
+version: 2
+updates:
+  # Enable version updates for NuGet packages
+  - package-ecosystem: "nuget"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"
+      - "nuget"
+  
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    labels:
+      - "dependencies"
+      - "github-actions"
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index db38931..ce20052 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -16,6 +16,8 @@ env:
 jobs:
   build:
     runs-on: windows-latest
+    permissions:
+      contents: read
     
     steps:
     - name: Checkout repository
diff --git a/README.md b/README.md
index 0796281..ed9cf49 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,17 @@ A powerful desktop toolkit for VRChat group owners and moderators. Fast login, r
 - Quick "Use" button to select user
 - One-click invite sending
 
-### 📅 Calendar Events
+### � Inviter Hub (New!)
+- **Instance Inviter**: Detect users in your current VRChat instance and invite them to your group.
+    - Filter by Trust Level (Visitor, New User, User, Known, Trusted).
+    - **18+ Only Filter**: Only show users with confirmed 18+ age verification.
+    - "Select All" and bulk invite capabilities.
+- **Friend Inviter**: Quickly invite your online friends to your group.
+- **Join Requests**: Monitor and process group join requests.
+    - Filter requests by 18+ status.
+    - Approve or block users directly.
+
+### �📅 Calendar Events
 - Create and manage group events
 - **Event Options:**
   - Title, description, category
diff --git a/src/App.xaml b/src/App.xaml
index 6e430f3..6e10db2 100644
--- a/src/App.xaml
+++ b/src/App.xaml
@@ -38,7 +38,13 @@
             <converters:DaysOfWeekStringConverter x:Key="DaysOfWeekStringConverter"/>
             <converters:BoolToTestButtonConverter x:Key="BoolToTestButtonConverter"/>
             <converters:ActionTypeToColorConverter x:Key="ActionTypeToColorConverter"/>
+            <converters:InitialsConverter x:Key="InitialsConverter"/>
+            <converters:InverseNullToVisibilityConverter x:Key="InverseNullToVisibilityConverter"/>
+            <converters:EqualityToVisibilityConverter x:Key="EqualityToVisibilityConverter"/>
+            <converters:InverseEqualityToVisibilityConverter x:Key="InverseEqualityToVisibilityConverter"/>
+            <converters:EmptyStringToVisibilityConverter x:Key="EmptyStringToVisibilityConverter"/>
             <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>
+            <converters:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter"/>
             
             <!-- Custom Styles -->
             <Style x:Key="CardStyle" TargetType="Border">
diff --git a/src/App.xaml.cs b/src/App.xaml.cs
index cac47bc..d6cda08 100644
--- a/src/App.xaml.cs
+++ b/src/App.xaml.cs
@@ -259,6 +259,11 @@ private void ConfigureServices(IServiceCollection services)
         services.AddTransient<InviteToGroupViewModel>();
         services.AddTransient<KillSwitchViewModel>();
         services.AddTransient<AppSettingsViewModel>();
+        services.AddSingleton<IInstanceInviterService, InstanceInviterService>();
+        services.AddTransient<InstanceInviterViewModel>();
+        services.AddTransient<FriendInviterViewModel>();
+        services.AddTransient<InviterHubViewModel>();
+        services.AddTransient<GroupJoinRequestsViewModel>();
         
         LoggingService.Debug("APP", "All services registered");
     }
diff --git a/src/Converters/Converters.cs b/src/Converters/Converters.cs
index fa0724d..5fc99cc 100644
--- a/src/Converters/Converters.cs
+++ b/src/Converters/Converters.cs
@@ -219,7 +219,12 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
     {
         if (value is int count)
         {
-            return count == 0 ? Visibility.Visible : Visibility.Collapsed;
+            bool isInverse = parameter is string str && str.Equals("Inverse", StringComparison.OrdinalIgnoreCase);
+            
+            if (count == 0)
+                return isInverse ? Visibility.Collapsed : Visibility.Visible;
+            else
+                return isInverse ? Visibility.Visible : Visibility.Collapsed;
         }
         return Visibility.Collapsed;
     }
@@ -436,3 +441,89 @@ public object ConvertBack(object value, Type targetType, object parameter, Cultu
         throw new NotImplementedException();
     }
 }
+
+public class InitialsConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        if (value is string name && !string.IsNullOrWhiteSpace(name))
+        {
+            var parts = name.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length >= 2)
+                return $"{parts[0][0]}{parts[1][0]}".ToUpper();
+            return name.Length >= 2 ? name.Substring(0, 2).ToUpper() : name.ToUpper();
+        }
+        return "??";
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class InverseNullToVisibilityConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        return value == null ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class EqualityToVisibilityConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        if (parameter == null) return Visibility.Collapsed;
+        
+        var paramValue = System.Convert.ToInt32(parameter);
+        var actualValue = value is int i ? i : 0;
+        
+        return actualValue == paramValue ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class InverseEqualityToVisibilityConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        if (parameter == null) return Visibility.Visible;
+        
+        var paramValue = System.Convert.ToInt32(parameter);
+        var actualValue = value is int i ? i : 0;
+        
+        return actualValue != paramValue ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class EmptyStringToVisibilityConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        if (value is string str)
+        {
+            return string.IsNullOrWhiteSpace(str) ? Visibility.Collapsed : Visibility.Visible;
+        }
+        return Visibility.Collapsed;
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/src/Data/AppDbContext.cs b/src/Data/AppDbContext.cs
index dd2d53a..4ca4365 100644
--- a/src/Data/AppDbContext.cs
+++ b/src/Data/AppDbContext.cs
@@ -27,6 +27,7 @@ public AppDbContext()
     public DbSet<SecurityIncidentEntity> SecurityIncidents { get; set; } = null!;
     public DbSet<MemberBackupEntity> MemberBackups { get; set; } = null!;
     public DbSet<ModerationActionEntity> ModerationActions { get; set; } = null!;
+    public DbSet<InvitedUser> InvitedUsers { get; set; } = null!;
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
@@ -138,5 +139,14 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             entity.HasIndex(e => new { e.GroupId, e.TargetUserId, e.ActionType });
             entity.HasIndex(e => new { e.GroupId, e.TargetUserId, e.Reason, e.ActionTime });
         });
+        
+        // InvitedUser configuration
+        modelBuilder.Entity<InvitedUser>(entity =>
+        {
+            entity.HasKey(e => e.Id);
+            entity.HasIndex(e => e.UserId);
+            entity.HasIndex(e => e.InvitedAt);
+            entity.HasIndex(e => new { e.UserId, e.WorldId, e.InstanceId });
+        });
     }
 }
diff --git a/src/Data/Models/InvitedUser.cs b/src/Data/Models/InvitedUser.cs
new file mode 100644
index 0000000..60a9edf
--- /dev/null
+++ b/src/Data/Models/InvitedUser.cs
@@ -0,0 +1,24 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace VRCGroupTools.Data.Models;
+
+public class InvitedUser
+{
+    [Key]
+    public int Id { get; set; }
+    
+    public string UserId { get; set; } = string.Empty;
+    public string DisplayName { get; set; } = string.Empty;
+    public string? ProfilePicUrl { get; set; }
+    
+    public bool IsAgeVerified { get; set; }
+    public string? TrustLevel { get; set; }
+    
+    public DateTime InvitedAt { get; set; } = DateTime.UtcNow;
+    public string? WorldId { get; set; }
+    public string? InstanceId { get; set; }
+    
+    public bool InviteSuccessful { get; set; }
+    public string? ErrorMessage { get; set; }
+}
diff --git a/src/Services/AuditLogService.cs b/src/Services/AuditLogService.cs
index 5232a84..7fab1b2 100644
--- a/src/Services/AuditLogService.cs
+++ b/src/Services/AuditLogService.cs
@@ -3,6 +3,7 @@
 using System.Text.Json;
 using System.Timers;
 using System.Linq;
+using VRCGroupTools.Data.Models;
 using Timer = System.Timers.Timer;
 
 namespace VRCGroupTools.Services;
@@ -35,6 +36,7 @@ public class AuditLogService : IAuditLogService, IDisposable
     private readonly ICacheService _cacheService;
     private readonly IDiscordWebhookService _discordService;
     private readonly ISecurityMonitorService? _securityMonitor;
+    private readonly ISettingsService _settingsService;
     private Timer? _pollingTimer;
     private string? _currentGroupId;
     private bool _isPolling;
@@ -48,11 +50,12 @@ public class AuditLogService : IAuditLogService, IDisposable
     public bool IsPolling => _isPolling;
     public int TotalLogCount => _totalLogCount;
 
-    public AuditLogService(IVRChatApiService apiService, ICacheService cacheService, IDiscordWebhookService discordService, ISecurityMonitorService? securityMonitor = null)
+    public AuditLogService(IVRChatApiService apiService, ICacheService cacheService, IDiscordWebhookService discordService, ISettingsService settingsService, ISecurityMonitorService? securityMonitor = null)
     {
         _apiService = apiService;
         _cacheService = cacheService;
         _discordService = discordService;
+        _settingsService = settingsService;
         _securityMonitor = securityMonitor;
     }
 
@@ -80,15 +83,13 @@ public async Task StartPollingAsync(string groupId)
             StatusChanged?.Invoke(this, "No cached logs. Click 'Fetch History' to download.");
         }
 
-        // Check for unsent Discord logs and send them
-        if (_discordService.IsConfigured)
-        {
-            await SendUnsentDiscordLogsAsync();
-        }
+        // Don't send unsent logs on initial load - only send newly fetched logs going forward
+        // This prevents spamming Discord with old logs when app starts
 
-        // Start polling timer (60 seconds)
+        // Start polling timer with configurable interval
+        var pollingIntervalMs = _settingsService.Settings.AuditLogPollingIntervalSeconds * 1000;
         _pollingTimer?.Dispose();
-        _pollingTimer = new Timer(60000); // 60 seconds
+        _pollingTimer = new Timer(pollingIntervalMs);
         _pollingTimer.Elapsed += async (s, e) => await PollForNewLogsAsync();
         _pollingTimer.AutoReset = true;
         _pollingTimer.Start();
@@ -98,8 +99,8 @@ public async Task StartPollingAsync(string groupId)
         Console.WriteLine("[AUDIT-SVC] Starting initial poll...");
         await PollForNewLogsAsync();
         
-        Console.WriteLine("[AUDIT-SVC] Polling timer started (60 second interval)");
-        StatusChanged?.Invoke(this, $"▶ Polling active - auto-checking every 60s | Total: {_totalLogCount} logs");
+        Console.WriteLine($"[AUDIT-SVC] Polling timer started ({_settingsService.Settings.AuditLogPollingIntervalSeconds} second interval)");
+        StatusChanged?.Invoke(this, $"▶ Polling active - auto-checking every {_settingsService.Settings.AuditLogPollingIntervalSeconds}s | Total: {_totalLogCount} logs");
     }
 
     public void StopPolling()
@@ -156,8 +157,11 @@ private async Task PollForNewLogsAsync()
             
             if (newLogs.Count > 0)
             {
-                // Find truly new logs (not in existing)
-                var trulyNewLogs = newLogs.Where(l => !existingIds.Contains(l.Id)).ToList();
+                // Find truly new logs (not in existing) AND not older than configured max age
+                var maxAgeMinutes = _settingsService.Settings.AuditLogDiscordNotificationMaxAgeMinutes;
+                var cutoffTime = DateTime.UtcNow.AddMinutes(-maxAgeMinutes);
+                var trulyNewLogs = newLogs.Where(l => !existingIds.Contains(l.Id) && l.CreatedAt >= cutoffTime).ToList();
+                Console.WriteLine($"[AUDIT-SVC] Found {trulyNewLogs.Count} new logs within last {maxAgeMinutes} minutes (filtered from {newLogs.Where(l => !existingIds.Contains(l.Id)).Count()} total new logs)");
                 
                 var savedCount = await _cacheService.AppendAuditLogsAsync(_currentGroupId, newLogs);
                 _totalLogCount = await _cacheService.GetAuditLogCountAsync(_currentGroupId);
@@ -497,6 +501,29 @@ private async Task<bool> SendDiscordNotificationAsync(AuditLogEntry log)
         }
     }
 
+    private async Task<bool> SendDiscordNotificationAsync(AuditLogEntity log)
+    {
+        try
+        {
+            if (_discordService is DiscordWebhookService discordSvc)
+            {
+                var success = await discordSvc.SendAuditEventAsync(
+                    log.EventType,
+                    log.ActorName ?? "Unknown",
+                    log.TargetName,
+                    log.Description
+                );
+                return success;
+            }
+            return false;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[AUDIT-SVC] Discord notification failed: {ex.Message}");
+            return false;
+        }
+    }
+
     private async Task SendUnsentDiscordLogsAsync()
     {
         if (string.IsNullOrEmpty(_currentGroupId))
@@ -614,6 +641,25 @@ private static string BuildDiscordDedupKey(AuditLogEntry log)
         });
     }
 
+    private static string BuildDiscordDedupKey(AuditLogEntity log)
+    {
+        if (!string.IsNullOrWhiteSpace(log.RawData))
+        {
+            using var sha = SHA256.Create();
+            var bytes = Encoding.UTF8.GetBytes(log.RawData);
+            return Convert.ToHexString(sha.ComputeHash(bytes));
+        }
+
+        return string.Join("|", new[]
+        {
+            log.EventType,
+            log.ActorId ?? string.Empty,
+            log.TargetId ?? string.Empty,
+            log.Description ?? string.Empty,
+            log.CreatedAt.ToUniversalTime().ToString("o")
+        });
+    }
+
     public void Dispose()
     {
         StopPolling();
diff --git a/src/Services/DiscordWebhookService.cs b/src/Services/DiscordWebhookService.cs
index 316715d..0c6da38 100644
--- a/src/Services/DiscordWebhookService.cs
+++ b/src/Services/DiscordWebhookService.cs
@@ -8,7 +8,7 @@ public interface IDiscordWebhookService
 {
     Task<bool> SendMessageAsync(string title, string description, int color, string? thumbnailUrl = null);
     Task<WebhookTestResult> TestWebhookAsync(string webhookUrl);
-    Task<bool> SendModerationActionAsync(string actionType, string targetName, string actorName, string reason, string? description, DateTime actionTime, DateTime? expiresAt = null, int? infractionCount = null);
+    Task<bool> SendModerationActionAsync(string actionType, string targetUserId, string targetName, string actorName, string reason, string? description, DateTime actionTime, DateTime? expiresAt = null, int? infractionCount = null);
     Task<bool> SendWebhookAsync(string webhookUrl, object payload);
     bool IsConfigured { get; }
 }
@@ -155,16 +155,21 @@ public bool ShouldSendAuditEvent(string eventType)
         var settings = _settingsService.Settings;
         return eventType switch
         {
-            // User Events
-            "group.user.join" => settings.DiscordNotifyUserJoins,
-            "group.user.leave" => settings.DiscordNotifyUserLeaves,
-            "group.user.kick" => settings.DiscordNotifyUserKicked,
-            "group.user.ban" => settings.DiscordNotifyUserBanned,
-            "group.user.unban" => settings.DiscordNotifyUserUnbanned,
-            "group.user.role.add" => settings.DiscordNotifyUserRoleAdd,
-            "group.user.role.remove" => settings.DiscordNotifyUserRoleRemove,
-            "group.user.join_request" => settings.DiscordNotifyJoinRequests,
-            "group.joinRequest" => settings.DiscordNotifyJoinRequests,
+            // Member Events - support both group.user.* and group.member.* formats
+            "group.member.join" or "group.user.join" => settings.DiscordNotifyUserJoins,
+            "group.member.leave" or "group.user.leave" => settings.DiscordNotifyUserLeaves,
+            "group.member.kick" or "group.user.kick" => settings.DiscordNotifyUserKicked,
+            "group.member.ban" or "group.user.ban" => settings.DiscordNotifyUserBanned,
+            "group.member.unban" or "group.user.unban" => settings.DiscordNotifyUserUnbanned,
+            "group.member.role.add" or "group.user.role.add" => settings.DiscordNotifyUserRoleAdd,
+            "group.member.role.remove" or "group.user.role.remove" => settings.DiscordNotifyUserRoleRemove,
+            
+            // Join Request Events (actual VRChat event types)
+            "group.request.create" => settings.DiscordNotifyJoinRequests,
+            "group.request.accept" => settings.DiscordNotifyJoinRequests,
+            "group.request.reject" => settings.DiscordNotifyJoinRequests,
+            "group.request.block" => settings.DiscordNotifyJoinRequests,
+            "group.request.unblock" => settings.DiscordNotifyJoinRequests,
 
             // Role Events
             "group.role.create" => settings.DiscordNotifyRoleCreate,
@@ -292,6 +297,7 @@ public async Task<bool> SendAuditEventAsync(string eventType, string actorName,
     // Helper method to send moderation action notifications with timestamps
     public async Task<bool> SendModerationActionAsync(
         string actionType,
+        string targetUserId,
         string targetName,
         string actorName,
         string reason,
@@ -314,7 +320,9 @@ public async Task<bool> SendModerationActionAsync(
         };
         
         var desc = new StringBuilder();
-        desc.AppendLine($"**Target:** {targetName}");
+        var vrchatUrl = $"https://vrchat.com/home/user/{targetUserId}";
+        desc.AppendLine($"**Target:** [{targetName}]({vrchatUrl})");
+        desc.AppendLine($"**User ID:** `{targetUserId}`");
         desc.AppendLine($"**Moderator:** {actorName}");
         desc.AppendLine($"**Reason:** {reason}");
         
diff --git a/src/Services/InstanceInviterService.cs b/src/Services/InstanceInviterService.cs
new file mode 100644
index 0000000..003cb94
--- /dev/null
+++ b/src/Services/InstanceInviterService.cs
@@ -0,0 +1,334 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace VRCGroupTools.Services;
+
+public interface IInstanceInviterService
+{
+    CurrentInstanceInfo? GetCurrentInstance();
+    Task<bool> InviteToCurrentInstanceAsync(string userId, IVRChatApiService apiService);
+    Task<List<InstanceUser>> GetCurrentInstanceUsersAsync(IVRChatApiService apiService);
+}
+
+public class InstanceInviterService : IInstanceInviterService
+{
+    // More flexible regex to match various instance ID formats
+    private static readonly Regex InstanceLocationRegex = new Regex(
+        @"wrld_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}:[^\s]+",
+        RegexOptions.Compiled);
+
+    private static readonly Regex WorldIdRegex = new Regex(
+        @"wrld_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        RegexOptions.Compiled);
+
+    public CurrentInstanceInfo? GetCurrentInstance()
+    {
+        Console.WriteLine("[INSTANCE-SVC] GetCurrentInstance called");
+        try
+        {
+            // Get VRChat log file path from AppData
+            var appDataLocal = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low";
+            var vrchatLogPath = Path.Combine(appDataLocal, "VRChat", "VRChat");
+            Console.WriteLine($"[INSTANCE-SVC] Checking log path: {vrchatLogPath}");
+
+            if (!Directory.Exists(vrchatLogPath))
+            {
+                Console.WriteLine("[INSTANCE-SVC] VRChat log directory not found");
+                return null;
+            }
+
+            // Get the most recent log file
+            var logFiles = Directory.GetFiles(vrchatLogPath, "output_log_*.txt")
+                .OrderByDescending(f => File.GetLastWriteTime(f))
+                .ToList();
+
+            if (logFiles.Count == 0)
+            {
+                Console.WriteLine("[INSTANCE-INVITER] No VRChat log files found");
+                return null;
+            }
+
+            var latestLog = logFiles[0];
+            Console.WriteLine($"[INSTANCE-INVITER] Reading log: {Path.GetFileName(latestLog)}");
+
+            // Read the entire log file or last 5MB to find current instance
+            using var stream = new FileStream(latestLog, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var bufferSize = Math.Min(5000000, stream.Length); // Read last 5MB or entire file if smaller
+            var buffer = new byte[bufferSize];
+            
+            if (stream.Length > bufferSize)
+            {
+                stream.Seek(-bufferSize, SeekOrigin.End);
+            }
+            stream.Read(buffer, 0, (int)bufferSize);
+            
+            Console.WriteLine($"[INSTANCE-INVITER] File size: {stream.Length:N0} bytes, reading last {bufferSize:N0} bytes");
+            
+            var logContent = System.Text.Encoding.UTF8.GetString(buffer);
+            var lines = logContent.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToList();
+
+            Console.WriteLine($"[INSTANCE-INVITER] Searching through {lines.Count} log lines...");
+            
+            int behaviourCount = 0;
+            int joiningCount = 0;
+
+            // Look for the most recent instance location
+            // World ID is on the same line as "Joining" or "Rejoining local world:"
+            foreach (var line in lines)
+            {
+                // Skip lines that don't have the Behaviour tag and joining keywords
+                if (!line.Contains("[Behaviour]")) continue;
+                behaviourCount++;
+                
+                // Debug: Print first few [Behaviour] lines to see what we're getting
+                if (behaviourCount <= 5)
+                {
+                    Console.WriteLine($"[INSTANCE-INVITER] Behaviour line #{behaviourCount}: {line.Substring(0, Math.Min(120, line.Length))}");
+                }
+                
+                if (!line.Contains("Joining") && !line.Contains("Rejoining local world:")) continue;
+                joiningCount++;
+                
+                // Skip "Joining or Creating Room" lines which are different
+                if (line.Contains("Joining or Creating Room:")) 
+                {
+                    Console.WriteLine($"[INSTANCE-INVITER] Skipping 'Joining or Creating Room' line");
+                    continue;
+                }
+                
+                Console.WriteLine($"[INSTANCE-INVITER] Found Joining/Rejoining line!");
+                Console.WriteLine($"[INSTANCE-INVITER] Line content: {line.Substring(0, Math.Min(150, line.Length))}");
+                
+                var match = InstanceLocationRegex.Match(line);
+                if (match.Success)
+                {
+                    var fullLocation = match.Value;
+                    var worldMatch = WorldIdRegex.Match(fullLocation);
+                    
+                    if (worldMatch.Success)
+                    {
+                        var worldId = worldMatch.Value;
+                        var instanceId = fullLocation.Substring(worldId.Length + 1); // Skip the ':'
+                        
+                        Console.WriteLine($"[INSTANCE-INVITER] ✓ Found instance: {worldId}:{instanceId}");
+                        Console.WriteLine($"[INSTANCE-INVITER] Full location: {fullLocation}");
+                        
+                        return new CurrentInstanceInfo
+                        {
+                            WorldId = worldId,
+                            InstanceId = instanceId,
+                            FullLocation = fullLocation,
+                            DetectedAt = DateTime.Now
+                        };
+                    }
+                }
+            }
+
+            Console.WriteLine($"[INSTANCE-INVITER] Stats: {behaviourCount} [Behaviour] lines, {joiningCount} Joining lines found");
+            Console.WriteLine("[INSTANCE-INVITER] ✗ No recent instance found in logs");
+            Console.WriteLine("[INSTANCE-INVITER] Tip: Make sure VRChat is running and you're in a world");
+            return null;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INSTANCE-INVITER] Error reading VRChat logs: {ex.Message}");
+            return null;
+        }
+    }
+
+    public async Task<bool> InviteToCurrentInstanceAsync(string userId, IVRChatApiService apiService)
+    {
+        var currentInstance = GetCurrentInstance();
+        if (currentInstance == null)
+        {
+            Console.WriteLine("[INSTANCE-INVITER] Cannot invite: No current instance detected");
+            return false;
+        }
+
+        Console.WriteLine($"[INSTANCE-INVITER] Inviting user {userId} to {currentInstance.WorldId}:{currentInstance.InstanceId}");
+        return await apiService.InviteUserToInstanceAsync(userId, currentInstance.WorldId, currentInstance.InstanceId);
+    }
+
+    public async Task<List<InstanceUser>> GetCurrentInstanceUsersAsync(IVRChatApiService apiService)
+    {
+        var users = new List<InstanceUser>();
+        
+        try
+        {
+            var currentInstance = GetCurrentInstance();
+            
+            if (currentInstance == null)
+            {
+                Console.WriteLine("[INSTANCE-USERS] No current instance detected");
+                return users;
+            }
+
+            Console.WriteLine($"[INSTANCE-USERS] Looking for users in instance: {currentInstance.WorldId}:{currentInstance.InstanceId}");
+
+            // Get instance details from API to verify and get user count
+            var instanceDetails = await apiService.GetInstanceAsync(currentInstance.WorldId, currentInstance.InstanceId);
+            if (instanceDetails != null)
+            {
+                Console.WriteLine($"[INSTANCE-USERS] API reports {instanceDetails.UserCount} users in instance");
+            }
+
+            // Parse VRChat logs to find users
+            var appDataLocal = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "Low";
+            var vrchatLogPath = Path.Combine(appDataLocal, "VRChat", "VRChat");
+            var logFiles = Directory.GetFiles(vrchatLogPath, "output_log_*.txt")
+                .OrderByDescending(f => File.GetLastWriteTime(f))
+                .ToList();
+
+            if (logFiles.Count == 0)
+            {
+                Console.WriteLine("[INSTANCE-USERS] No VRChat log files found");
+                return users;
+            }
+
+            var latestLog = logFiles[0];
+            Console.WriteLine($"[INSTANCE-USERS] Reading log: {Path.GetFileName(latestLog)}");
+
+            // Read last 10MB of log to capture player join events
+            using var stream = new FileStream(latestLog, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            
+            var bufferSize = Math.Min(10000000, stream.Length); // 10MB
+            var buffer = new byte[bufferSize];
+            
+            if (stream.Length > bufferSize)
+            {
+                stream.Seek(-bufferSize, SeekOrigin.End);
+            }
+            
+            stream.Read(buffer, 0, (int)bufferSize);
+            var logContent = System.Text.Encoding.UTF8.GetString(buffer);
+            var lines = logContent.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToList();
+
+            Console.WriteLine($"[INSTANCE-USERS] Searching through {lines.Count} log lines");
+
+            // Track when we entered the current instance
+            bool foundInstanceEntry = false;
+            bool inCurrentInstance = false;
+            
+            // Regex patterns for finding user information
+            var userIdPattern = new Regex(@"usr_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}");
+            var onPlayerJoinedPattern = new Regex(@"OnPlayerJoined\s+(.+?)(?:\s*$)", RegexOptions.Compiled);
+            var playerJoinedPattern = new Regex(@"\[Player\]\s+(.+?)\s+joined", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+            
+            // Search from newest to oldest to find current instance boundary
+            foreach (var line in lines)
+            {
+                // Look for when we entered the current instance
+                if (!foundInstanceEntry && (line.Contains($"Joining or Creating Room:") || line.Contains($"Rejoining local world:")) && line.Contains(currentInstance.WorldId))
+                {
+                    Console.WriteLine($"[INSTANCE-USERS] Found instance entry point");
+                    foundInstanceEntry = true;
+                    inCurrentInstance = true;
+                    continue;
+                }
+
+                // If we haven't found the instance entry yet, skip
+                if (!foundInstanceEntry)
+                    continue;
+
+                // If we hit another instance join before this one, stop
+                if (inCurrentInstance && (line.Contains("Joining or Creating Room:") || line.Contains("Rejoining local world:")) && !line.Contains(currentInstance.WorldId))
+                {
+                    Console.WriteLine($"[INSTANCE-USERS] Found previous instance boundary, stopping search");
+                    break;
+                }
+
+                // Look for OnPlayerJoined events
+                if (line.Contains("OnPlayerJoined"))
+                {
+                    var match = onPlayerJoinedPattern.Match(line);
+                    if (match.Success && match.Groups.Count > 1)
+                    {
+                        var displayName = match.Groups[1].Value.Trim();
+                        
+                        // Extract user ID if present
+                        var userIdMatch = userIdPattern.Match(line);
+                        var userId = userIdMatch.Success ? userIdMatch.Value : string.Empty;
+                        
+                        // Only add if not already in list
+                        if (!string.IsNullOrEmpty(displayName) && !users.Any(u => u.DisplayName == displayName))
+                        {
+                            users.Add(new InstanceUser
+                            {
+                                DisplayName = displayName,
+                                UserId = userId
+                            });
+                            Console.WriteLine($"[INSTANCE-USERS] Found user: {displayName} ({userId})");
+                        }
+                    }
+                }
+                
+                // Also look for alternate "[Player] X joined" format
+                if (line.Contains("[Player]") && line.Contains("joined"))
+                {
+                    var match = playerJoinedPattern.Match(line);
+                    if (match.Success && match.Groups.Count > 1)
+                    {
+                        var displayName = match.Groups[1].Value.Trim();
+                        
+                        if (!string.IsNullOrEmpty(displayName) && !users.Any(u => u.DisplayName == displayName))
+                        {
+                            users.Add(new InstanceUser
+                            {
+                                DisplayName = displayName,
+                                UserId = string.Empty // Try to find ID in nearby lines
+                            });
+                            Console.WriteLine($"[INSTANCE-USERS] Found user from [Player] log: {displayName}");
+                        }
+                    }
+                }
+            }
+            
+            Console.WriteLine($"[INSTANCE-USERS] Found {users.Count} users in current instance from logs");
+            
+            // If log parsing found no users but API says there are users, at least show the current user
+            if (users.Count == 0 && instanceDetails != null && instanceDetails.UserCount > 0 && apiService.IsLoggedIn)
+            {
+                Console.WriteLine($"[INSTANCE-USERS] No users found in logs but instance has {instanceDetails.UserCount} users");
+                Console.WriteLine($"[INSTANCE-USERS] Adding current user as fallback");
+                
+                if (!string.IsNullOrEmpty(apiService.CurrentUserDisplayName))
+                {
+                    users.Add(new InstanceUser
+                    {
+                        DisplayName = apiService.CurrentUserDisplayName ?? "You",
+                        UserId = apiService.CurrentUserId ?? string.Empty
+                    });
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INSTANCE-USERS] Error reading instance users: {ex.Message}");
+            Console.WriteLine($"[INSTANCE-USERS] Stack trace: {ex.StackTrace}");
+        }
+        
+        return users;
+    }
+}
+
+public class CurrentInstanceInfo
+{
+    public string WorldId { get; set; } = string.Empty;
+    public string InstanceId { get; set; } = string.Empty;
+    public string FullLocation { get; set; } = string.Empty;
+    public DateTime DetectedAt { get; set; }
+}
+
+public class InstanceUser
+{
+    public string DisplayName { get; set; } = string.Empty;
+    public string UserId { get; set; } = string.Empty;
+    public string ProfilePicUrl { get; set; } = string.Empty;
+    public bool IsAgeVerified { get; set; }
+    public List<string> Tags { get; set; } = new();
+}
diff --git a/src/Services/SecurityMonitorService.cs b/src/Services/SecurityMonitorService.cs
index 1a06466..5986f70 100644
--- a/src/Services/SecurityMonitorService.cs
+++ b/src/Services/SecurityMonitorService.cs
@@ -14,6 +14,8 @@ public interface ISecurityMonitorService
     Task<bool> TrackActionAsync(string groupId, string actorUserId, string actorDisplayName, string actionType, string? targetUserId = null, string? targetDisplayName = null, object? additionalData = null);
     Task<List<SecurityIncidentEntity>> GetRecentIncidentsAsync(string groupId, int daysBack = 7);
     Task<List<SecurityActionEntity>> GetUserActionsAsync(string groupId, string userId, int hoursBack = 24);
+    Task<List<SecurityActionEntity>> GetAllSecurityActionsAsync(string groupId, int daysBack = 7);
+    Task<int> ClearOldSecurityActionsAsync(string groupId, int daysOld = 7);
     Task<bool> ResolveIncidentAsync(string incidentId);
     Task<bool> IsEnabled { get; }
 }
@@ -448,4 +450,51 @@ public async Task<bool> ResolveIncidentAsync(string incidentId)
             return false;
         }
     }
+
+    public async Task<List<SecurityActionEntity>> GetAllSecurityActionsAsync(string groupId, int daysBack = 7)
+    {
+        try
+        {
+            var cutoffTime = DateTime.UtcNow.AddDays(-daysBack);
+            using var context = new AppDbContext();
+            
+            return await context.SecurityActions
+                .Where(a => a.GroupId == groupId && a.ActionTime >= cutoffTime)
+                .OrderByDescending(a => a.ActionTime)
+                .ToListAsync();
+        }
+        catch (Exception ex)
+        {
+            LoggingService.Error("SECURITY", ex, "Failed to get all security actions");
+            return new List<SecurityActionEntity>();
+        }
+    }
+
+    public async Task<int> ClearOldSecurityActionsAsync(string groupId, int daysOld = 7)
+    {
+        try
+        {
+            var cutoffTime = DateTime.UtcNow.AddDays(-daysOld);
+            using var context = new AppDbContext();
+            
+            var oldActions = await context.SecurityActions
+                .Where(a => a.GroupId == groupId && a.ActionTime < cutoffTime)
+                .ToListAsync();
+
+            var count = oldActions.Count;
+            if (count > 0)
+            {
+                context.SecurityActions.RemoveRange(oldActions);
+                await context.SaveChangesAsync();
+                LoggingService.Info("SECURITY", $"Cleared {count} old security actions (older than {daysOld} days)");
+            }
+
+            return count;
+        }
+        catch (Exception ex)
+        {
+            LoggingService.Error("SECURITY", ex, "Failed to clear old security actions");
+            return 0;
+        }
+    }
 }
diff --git a/src/Services/SettingsService.cs b/src/Services/SettingsService.cs
index ec69112..88b6c30 100644
--- a/src/Services/SettingsService.cs
+++ b/src/Services/SettingsService.cs
@@ -218,6 +218,16 @@ public class AppSettings
     public bool DiscordNotifyPostCreate { get; set; } = true;
     public bool DiscordNotifyPostDelete { get; set; } = true;
 
+    // Audit Log Settings
+    public int AuditLogPollingIntervalSeconds { get; set; } = 60; // How often to check for new logs
+    public int AuditLogDiscordNotificationMaxAgeMinutes { get; set; } = 10; // Only send Discord notifications for logs newer than this
+
+    // Instance Inviter Settings
+    public bool InstanceInviterOnly18Plus { get; set; } = false;
+    public bool InstanceInviterShowOfflineFriends { get; set; } = false;
+    public bool InstanceInviterAutoRefresh { get; set; } = true;
+    public int InstanceInviterRefreshIntervalSeconds { get; set; } = 30;
+
     // Calendar settings
     public bool AutoGenerateRecurringEvents { get; set; } = true;
     public int RecurringGenerationDaysAhead { get; set; } = 30;
diff --git a/src/Services/VRChatApiService.cs b/src/Services/VRChatApiService.cs
index ec288d3..d6dcc31 100644
--- a/src/Services/VRChatApiService.cs
+++ b/src/Services/VRChatApiService.cs
@@ -61,6 +61,11 @@ public interface IVRChatApiService
     Task<List<GroupPost>> GetGroupPostsAsync(string groupId, int n = 60, int offset = 0, bool publicOnly = false);
     Task<bool> DeleteGroupPostAsync(string groupId, string postId);
     Task<GroupPost?> UpdateGroupPostAsync(string groupId, string postId, string title, string text, string visibility = "public", bool sendNotification = false);
+    Task<List<FriendInfo>> GetFriendsAsync(bool onlineOnly = false, int n = 100, int offset = 0);
+    Task<InstanceDetails?> GetInstanceAsync(string worldId, string instanceId);
+    Task<bool> InviteUserToInstanceAsync(string userId, string worldId, string instanceId);
+    Task<List<GroupJoinRequest>> GetGroupJoinRequestsAsync(string groupId);
+    Task<bool> RespondToGroupJoinRequestAsync(string groupId, string userId, string action);
     string? GetAuthCookie();
     string? GetTwoFactorCookie();
     void Logout();
@@ -1948,6 +1953,227 @@ public void Logout()
         _twoFactorToken = null;
         _cookieContainer.GetCookies(new Uri(BaseUrl)).Cast<Cookie>().ToList().ForEach(c => c.Expired = true);
     }
+
+    public async Task<List<FriendInfo>> GetFriendsAsync(bool onlineOnly = false, int n = 100, int offset = 0)
+    {
+        var friends = new List<FriendInfo>();
+        try
+        {
+            await RateLimitAsync();
+            
+            var url = onlineOnly
+                ? $"auth/user/friends?apiKey={ApiKey}&offline=false&n={n}&offset={offset}"
+                : $"auth/user/friends?apiKey={ApiKey}&n={n}&offset={offset}";
+            
+            var response = await _httpClient.GetAsync(url);
+            
+            if (!response.IsSuccessStatusCode)
+            {
+                Console.WriteLine($"[FRIENDS-API] Error: {response.StatusCode}");
+                return friends;
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+            var users = JsonConvert.DeserializeObject<List<JObject>>(content) ?? new List<JObject>();
+
+            foreach (var user in users)
+            {
+                var profilePic = user["userIcon"]?.ToString();
+                if (string.IsNullOrEmpty(profilePic))
+                {
+                    profilePic = user["currentAvatarThumbnailImageUrl"]?.ToString();
+                }
+
+                var tags = user["tags"]?.ToObject<List<string>>() ?? new List<string>();
+                var isAgeVerified = tags.Contains("system_age_verified") || tags.Contains("system_age_verification_approved");
+                
+                friends.Add(new FriendInfo
+                {
+                    UserId = user["id"]?.ToString() ?? string.Empty,
+                    DisplayName = user["displayName"]?.ToString() ?? string.Empty,
+                    ProfilePicUrl = profilePic,
+                    StatusDescription = user["statusDescription"]?.ToString(),
+                    Status = user["status"]?.ToString() ?? "offline",
+                    Location = user["location"]?.ToString() ?? string.Empty,
+                    IsAgeVerified = isAgeVerified,
+                    Tags = tags
+                });
+            }
+
+            Console.WriteLine($"[FRIENDS-API] Retrieved {friends.Count} friends");
+            return friends;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[FRIENDS-API] Exception: {ex.Message}");
+            return friends;
+        }
+    }
+
+    public async Task<InstanceDetails?> GetInstanceAsync(string worldId, string instanceId)
+    {
+        try
+        {
+            await RateLimitAsync();
+            
+            var url = $"instances/{worldId}:{instanceId}?apiKey={ApiKey}";
+            var response = await _httpClient.GetAsync(url);
+            
+            if (!response.IsSuccessStatusCode)
+            {
+                Console.WriteLine($"[INSTANCE-API] Error: {response.StatusCode}");
+                return null;
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+            var data = JsonConvert.DeserializeObject<JObject>(content);
+
+            if (data == null)
+                return null;
+
+            return new InstanceDetails
+            {
+                InstanceId = data["id"]?.ToString() ?? string.Empty,
+                WorldId = data["worldId"]?.ToString() ?? string.Empty,
+                Name = data["name"]?.ToString() ?? string.Empty,
+                Region = data["region"]?.ToString() ?? string.Empty,
+                Capacity = data["capacity"]?.Value<int>() ?? 0,
+                UserCount = data["n_users"]?.Value<int>() ?? 0,
+                OwnerId = data["ownerId"]?.ToString(),
+                Tags = data["tags"]?.ToObject<List<string>>() ?? new List<string>()
+            };
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INSTANCE-API] Exception: {ex.Message}");
+            return null;
+        }
+    }
+
+    public async Task<bool> InviteUserToInstanceAsync(string userId, string worldId, string instanceId)
+    {
+        try
+        {
+            await RateLimitAsync();
+
+            var payload = new
+            {
+                instanceId = $"{worldId}:{instanceId}"
+            };
+
+            var request = new HttpRequestMessage(HttpMethod.Post, $"invite/{userId}?apiKey={ApiKey}")
+            {
+                Content = new StringContent(JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json")
+            };
+
+            var response = await _httpClient.SendAsync(request);
+            var content = await response.Content.ReadAsStringAsync();
+            
+            Console.WriteLine($"[INVITE-API] Invite status: {response.StatusCode}");
+            
+            if (!response.IsSuccessStatusCode)
+            {
+                Console.WriteLine($"[INVITE-API] Error: {content}");
+                return false;
+            }
+            
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INVITE-API] Exception: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<List<GroupJoinRequest>> GetGroupJoinRequestsAsync(string groupId)
+    {
+        try
+        {
+            await RateLimitAsync();
+            var url = $"groups/{groupId}/requests?apiKey={ApiKey}";
+            var response = await _httpClient.GetAsync(url);
+            var content = await response.Content.ReadAsStringAsync();
+            
+            LogHttp("GROUP-REQUESTS", url, response, content);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                Console.WriteLine($"[GROUP-REQUESTS] Failed to get join requests: {response.StatusCode}");
+                return new List<GroupJoinRequest>();
+            }
+
+            var json = JsonConvert.DeserializeObject<JArray>(content);
+            if (json == null)
+            {
+                return new List<GroupJoinRequest>();
+            }
+
+            var requests = new List<GroupJoinRequest>();
+            foreach (var item in json)
+            {
+                var userObj = item["user"] as JObject;
+                if (userObj == null) continue;
+
+                var tags = userObj["tags"]?.ToObject<List<string>>() ?? new List<string>();
+                var isAgeVerified = tags.Any(t => t.Contains("system_age_verified") || t.Contains("age_verified"));
+
+                requests.Add(new GroupJoinRequest
+                {
+                    UserId = userObj["id"]?.ToString() ?? "",
+                    DisplayName = userObj["displayName"]?.ToString() ?? "",
+                    ProfilePicUrl = userObj["currentAvatarImageUrl"]?.ToString() ?? userObj["profilePicOverride"]?.ToString(),
+                    CreatedAt = item["createdAt"]?.ToString(),
+                    IsAgeVerified = isAgeVerified,
+                    Tags = tags
+                });
+            }
+
+            return requests;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[GROUP-REQUESTS] Exception: {ex.Message}");
+            return new List<GroupJoinRequest>();
+        }
+    }
+
+    public async Task<bool> RespondToGroupJoinRequestAsync(string groupId, string userId, string action)
+    {
+        try
+        {
+            await RateLimitAsync();
+
+            var payload = new
+            {
+                action = action // "accept" or "reject"
+            };
+
+            var url = $"groups/{groupId}/requests/{userId}?apiKey={ApiKey}";
+            var request = new HttpRequestMessage(HttpMethod.Put, url)
+            {
+                Content = new StringContent(JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json")
+            };
+
+            var response = await _httpClient.SendAsync(request);
+            var content = await response.Content.ReadAsStringAsync();
+            LogHttp("GROUP-REQUEST-RESPOND", url, response, content);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                Console.WriteLine($"[GROUP-REQUEST-RESPOND] Failed to {action} user {userId}: {response.StatusCode}");
+                return false;
+            }
+
+            Console.WriteLine($"[GROUP-REQUEST-RESPOND] Successfully {action}ed user {userId}");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[GROUP-REQUEST-RESPOND] Exception: {ex.Message}");
+            return false;
+        }
+    }
 }
 
 public class LoginResult
@@ -1987,6 +2213,16 @@ public class GroupBanEntry
     public string MembershipDisplay => WasMember ? "Was Member" : "Not Member";
 }
 
+public class GroupJoinRequest
+{
+    public string UserId { get; set; } = string.Empty;
+    public string DisplayName { get; set; } = string.Empty;
+    public string? ProfilePicUrl { get; set; }
+    public string? CreatedAt { get; set; }
+    public bool IsAgeVerified { get; set; }
+    public List<string> Tags { get; set; } = new();
+}
+
 public class GroupRole
 {
     public string RoleId { get; set; } = "";
@@ -2109,3 +2345,30 @@ public class WorldInfo
     [JsonProperty("thumbnailImageUrl")]
     public string? ThumbnailImageUrl { get; set; }
 }
+
+public class FriendInfo
+{
+    public string UserId { get; set; } = string.Empty;
+    public string DisplayName { get; set; } = string.Empty;
+    public string? ProfilePicUrl { get; set; }
+    public string? StatusDescription { get; set; }
+    public string Status { get; set; } = "offline";
+    public string Location { get; set; } = string.Empty;
+    public bool IsAgeVerified { get; set; }
+    public List<string> Tags { get; set; } = new();
+    
+    public bool IsOnline => Status == "active" || Status == "join me" || Status == "ask me";
+    public bool IsInInstance => !string.IsNullOrEmpty(Location) && Location != "offline" && Location != "private";
+}
+
+public class InstanceDetails
+{
+    public string InstanceId { get; set; } = string.Empty;
+    public string WorldId { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public string Region { get; set; } = string.Empty;
+    public int Capacity { get; set; }
+    public int UserCount { get; set; }
+    public string? OwnerId { get; set; }
+    public List<string> Tags { get; set; } = new();
+}
diff --git a/src/VRCGroupTools.csproj b/src/VRCGroupTools.csproj
index 3b68a40..4938944 100644
--- a/src/VRCGroupTools.csproj
+++ b/src/VRCGroupTools.csproj
@@ -6,12 +6,13 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <UseWPF>true</UseWPF>
+    <UseWindowsForms>false</UseWindowsForms>
     <AssemblyName>VRCGroupTools</AssemblyName>
     <DefineConstants>DEBUG</DefineConstants>
     <RootNamespace>VRCGroupTools</RootNamespace>
-    <Version>1.0.7</Version>
-    <AssemblyVersion>1.0.7.0</AssemblyVersion>
-    <FileVersion>1.0.7.0</FileVersion>
+    <Version>1.1.0</Version>
+    <AssemblyVersion>1.1.0.0</AssemblyVersion>
+    <FileVersion>1.1.0.0</FileVersion>
     <Company>0xE69</Company>
     <Product>VRC Group Tools</Product>
     <Authors>0xE69</Authors>
diff --git a/src/ViewModels/FriendInviterViewModel.cs b/src/ViewModels/FriendInviterViewModel.cs
new file mode 100644
index 0000000..8cf719f
--- /dev/null
+++ b/src/ViewModels/FriendInviterViewModel.cs
@@ -0,0 +1,315 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using VRCGroupTools.Services;
+
+namespace VRCGroupTools.ViewModels;
+
+public partial class FriendInviterViewModel : ObservableObject
+{
+    private readonly IVRChatApiService _apiService;
+    private readonly ISettingsService _settingsService;
+
+    [ObservableProperty]
+    private ObservableCollection<FriendInviterItemViewModel> _friends = new();
+
+    [ObservableProperty]
+    private ObservableCollection<FriendInviterItemViewModel> _filteredFriends = new();
+
+    [ObservableProperty]
+    private string _searchQuery = string.Empty;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private bool _only18Plus;
+
+    [ObservableProperty]
+    private bool _onlineOnly = true;
+
+    [ObservableProperty]
+    private bool _showTrustLevels = true;
+
+    [ObservableProperty]
+    private string? _statusMessage;
+
+    [ObservableProperty]
+    private int _selectedCount;
+
+    public FriendInviterViewModel(
+        IVRChatApiService apiService,
+        ISettingsService settingsService)
+    {
+        _apiService = apiService;
+        _settingsService = settingsService;
+        
+        _ = LoadFriendsAsync();
+    }
+
+    private FriendInviterItemViewModel CreateFriendViewModel(FriendInfo friend)
+    {
+        return new FriendInviterItemViewModel(friend, this);
+    }
+
+    partial void OnSearchQueryChanged(string value)
+    {
+        ApplyFilters();
+    }
+
+    partial void OnOnly18PlusChanged(bool value)
+    {
+        ApplyFilters();
+    }
+
+    partial void OnOnlineOnlyChanged(bool value)
+    {
+        _ = LoadFriendsAsync();
+    }
+
+    partial void OnShowTrustLevelsChanged(bool value)
+    {
+        // Refresh the filtered list to update the UI
+        var currentFiltered = FilteredFriends.ToList();
+        FilteredFriends.Clear();
+        foreach (var friend in currentFiltered)
+        {
+            FilteredFriends.Add(friend);
+        }
+    }
+
+    [RelayCommand]
+    private async Task RefreshAsync()
+    {
+        await LoadFriendsAsync();
+    }
+
+    private async Task LoadFriendsAsync()
+    {
+        if (IsLoading)
+            return;
+
+        try
+        {
+            IsLoading = true;
+            StatusMessage = "Loading friends...";
+
+            var friendsList = await _apiService.GetFriendsAsync(OnlineOnly);
+
+            Friends.Clear();
+            foreach (var friend in friendsList)
+            {
+                Friends.Add(CreateFriendViewModel(friend));
+            }
+
+            ApplyFilters();
+            UpdateSelectedCount();
+            StatusMessage = $"Loaded {Friends.Count} friends";
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error loading friends: {ex.Message}";
+            MessageBox.Show($"Failed to load friends: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    private void ApplyFilters()
+    {
+        FilteredFriends.Clear();
+
+        var query = SearchQuery?.ToLowerInvariant() ?? string.Empty;
+
+        var filtered = Friends.Where(f =>
+        {
+            // Apply 18+ filter
+            if (Only18Plus && !f.Friend.IsAgeVerified)
+                return false;
+
+            // Apply search filter
+            if (!string.IsNullOrWhiteSpace(query))
+            {
+                var matchesName = f.Friend.DisplayName.ToLowerInvariant().Contains(query);
+                var matchesStatus = f.Friend.StatusDescription?.ToLowerInvariant().Contains(query) ?? false;
+                if (!matchesName && !matchesStatus)
+                    return false;
+            }
+
+            return true;
+        });
+
+        foreach (var friend in filtered)
+        {
+            FilteredFriends.Add(friend);
+        }
+    }
+
+    [RelayCommand]
+    private void SelectAll()
+    {
+        foreach (var friend in FilteredFriends)
+        {
+            friend.IsSelected = true;
+        }
+        UpdateSelectedCount();
+    }
+
+    [RelayCommand]
+    private void DeselectAll()
+    {
+        foreach (var friend in Friends)
+        {
+            friend.IsSelected = false;
+        }
+        UpdateSelectedCount();
+    }
+
+    public void UpdateSelectedCount()
+    {
+        SelectedCount = Friends.Count(f => f.IsSelected);
+    }
+
+    [RelayCommand]
+    private async Task InviteToGroupAsync()
+    {
+        var selectedFriends = Friends.Where(f => f.IsSelected).ToList();
+        if (selectedFriends.Count == 0)
+        {
+            MessageBox.Show("Please select at least one friend to invite.", "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        // Get the current group ID from settings
+        var groupId = _settingsService.Settings.GroupId;
+        if (string.IsNullOrEmpty(groupId))
+        {
+            MessageBox.Show("No group configured. Please set up a group first.", "No Group", MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+
+        try
+        {
+            IsLoading = true;
+            var successCount = 0;
+            var failCount = 0;
+
+            foreach (var friendVM in selectedFriends)
+            {
+                StatusMessage = $"Inviting {friendVM.Friend.DisplayName} to group...";
+
+                // Invite to group using group ID
+                var success = await _apiService.SendGroupInviteAsync(groupId, friendVM.Friend.UserId);
+
+                if (success)
+                {
+                    successCount++;
+                    friendVM.IsSelected = false;
+                }
+                else
+                {
+                    failCount++;
+                }
+
+                // Small delay to avoid rate limiting
+                await Task.Delay(500);
+            }
+
+            StatusMessage = $"Invites sent: {successCount} succeeded, {failCount} failed";
+            MessageBox.Show($"Sent {successCount} group invites successfully.\n{failCount} failed.", "Invites Sent", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error sending invites: {ex.Message}";
+            MessageBox.Show($"Failed to send invites: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+            UpdateSelectedCount();
+        }
+    }
+}
+
+public partial class FriendInviterItemViewModel : ObservableObject
+{
+    private readonly FriendInviterViewModel? _parent;
+
+    [ObservableProperty]
+    private bool _isSelected;
+
+    public FriendInfo Friend { get; }
+
+    public FriendInviterItemViewModel(FriendInfo friend, FriendInviterViewModel? parent)
+    {
+        Friend = friend;
+        _parent = parent;
+    }
+
+    partial void OnIsSelectedChanged(bool value)
+    {
+        _parent?.UpdateSelectedCount();
+    }
+
+    public string? TrustLevel
+    {
+        get
+        {
+            if (Friend.Tags == null || Friend.Tags.Count == 0)
+                return "Visitor";
+
+            if (Friend.Tags.Contains("system_trust_legend")) return "Trusted User";
+            if (Friend.Tags.Contains("system_trust_veteran")) return "Trusted User";
+            if (Friend.Tags.Contains("system_trust_trusted")) return "Known User";
+            if (Friend.Tags.Contains("system_trust_known")) return "User";
+            if (Friend.Tags.Contains("system_trust_basic")) return "New User";
+
+            var tagsLower = Friend.Tags.Select(t => t.ToLowerInvariant()).ToList();
+            if (tagsLower.Any(t => t.Contains("legend"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("veteran"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("trusted"))) return "Known User";
+            if (tagsLower.Any(t => t.Contains("known"))) return "User";
+            if (tagsLower.Any(t => t.Contains("basic"))) return "New User";
+
+            return "Visitor";
+        }
+    }
+
+    public System.Windows.Media.Brush TrustLevelBrush
+    {
+        get
+        {
+            return TrustLevel switch
+            {
+                "Trusted User" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(138, 43, 226)),
+                "Known User" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(255, 123, 0)),
+                "User" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(46, 204, 113)),
+                "New User" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(52, 152, 219)),
+                "Visitor" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(149, 165, 166)),
+                _ => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Gray)
+            };
+        }
+    }
+
+    public System.Windows.Media.Brush StatusBrush
+    {
+        get
+        {
+            return Friend.Status switch
+            {
+                "active" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(46, 204, 113)),
+                "join me" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(52, 152, 219)),
+                "ask me" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(241, 196, 15)),
+                "busy" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(231, 76, 60)),
+                "offline" => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(149, 165, 166)),
+                _ => new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Gray)
+            };
+        }
+    }
+}
diff --git a/src/ViewModels/GroupJoinRequestsViewModel.cs b/src/ViewModels/GroupJoinRequestsViewModel.cs
new file mode 100644
index 0000000..515a0ad
--- /dev/null
+++ b/src/ViewModels/GroupJoinRequestsViewModel.cs
@@ -0,0 +1,516 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using VRCGroupTools.Services;
+using Timer = System.Timers.Timer;
+
+namespace VRCGroupTools.ViewModels;
+
+public partial class GroupJoinRequestsViewModel : ObservableObject
+{
+    private readonly IVRChatApiService _apiService;
+    private readonly ISettingsService _settingsService;
+    private Timer? _autoAcceptTimer;
+
+    [ObservableProperty]
+    private ObservableCollection<JoinRequestItemViewModel> _joinRequests = new();
+
+    [ObservableProperty]
+    private ObservableCollection<JoinRequestItemViewModel> _filteredJoinRequests = new();
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private bool _only18Plus;
+
+    [ObservableProperty]
+    private bool _autoAcceptEnabled;
+
+    [ObservableProperty]
+    private bool _isMonitoring;
+
+    [ObservableProperty]
+    private string? _statusMessage;
+
+    [ObservableProperty]
+    private int _selectedCount;
+
+    [ObservableProperty]
+    private int _totalRequests;
+
+    [ObservableProperty]
+    private int _autoAcceptIntervalSeconds = 30;
+
+    public GroupJoinRequestsViewModel(
+        IVRChatApiService apiService,
+        ISettingsService settingsService)
+    {
+        _apiService = apiService;
+        _settingsService = settingsService;
+    }
+
+    partial void OnOnly18PlusChanged(bool value)
+    {
+        ApplyFilters();
+    }
+
+    partial void OnIsMonitoringChanged(bool value)
+    {
+        if (value)
+        {
+            StartMonitoring();
+        }
+        else
+        {
+            StopMonitoring();
+        }
+    }
+
+    [RelayCommand]
+    private async Task RefreshAsync()
+    {
+        await LoadJoinRequestsAsync();
+    }
+
+    [RelayCommand]
+    private void ToggleMonitoring()
+    {
+        IsMonitoring = !IsMonitoring;
+    }
+
+    private void StartMonitoring()
+    {
+        StatusMessage = "Monitoring started";
+        
+        // Initial load
+        _ = LoadJoinRequestsAsync();
+
+        // Setup auto-refresh timer
+        _autoAcceptTimer = new Timer(AutoAcceptIntervalSeconds * 1000);
+        _autoAcceptTimer.Elapsed += async (s, e) => await LoadJoinRequestsAsync();
+        _autoAcceptTimer.Start();
+    }
+
+    private void StopMonitoring()
+    {
+        StatusMessage = "Monitoring stopped";
+        
+        _autoAcceptTimer?.Stop();
+        _autoAcceptTimer?.Dispose();
+        _autoAcceptTimer = null;
+    }
+
+    private async Task LoadJoinRequestsAsync()
+    {
+        if (IsLoading)
+            return;
+
+        try
+        {
+            IsLoading = true;
+            StatusMessage = "Loading join requests...";
+
+            var groupId = _settingsService.CurrentGroupId;
+            
+            if (string.IsNullOrEmpty(groupId))
+            {
+                // Try fallback to Settings.GroupId
+                groupId = _settingsService.Settings.GroupId;
+            }
+
+            if (string.IsNullOrEmpty(groupId))
+            {
+                StatusMessage = "No group configured";
+                IsLoading = false;
+                return;
+            }
+
+            var requests = await _apiService.GetGroupJoinRequestsAsync(groupId);
+
+            JoinRequests.Clear();
+            foreach (var request in requests)
+            {
+                JoinRequests.Add(new JoinRequestItemViewModel(request, this));
+            }
+
+            TotalRequests = JoinRequests.Count;
+            ApplyFilters();
+
+            StatusMessage = $"Loaded {TotalRequests} join requests";
+
+            // Trigger enrichment in background
+            _ = EnrichRequestsAsync();
+
+            // Auto-accept if enabled
+            if (AutoAcceptEnabled && IsMonitoring)
+            {
+                await AutoAcceptPendingAsync();
+            }
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error loading join requests: {ex.Message}";
+            MessageBox.Show($"Failed to load join requests: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    private async Task EnrichRequestsAsync()
+    {
+        var requestsToEnrich = JoinRequests.Where(r => !r.IsEnriched).ToList();
+        if (requestsToEnrich.Count == 0) return;
+
+        foreach (var req in requestsToEnrich)
+        {
+            if (!IsMonitoring && !IsLoading) 
+            {
+                // Basic check effectively
+            }
+
+            try 
+            {
+                var user = await _apiService.GetUserAsync(req.Request.UserId);
+                if (user != null)
+                {
+                    req.UpdatedUserDetails(user);
+                    
+                    // Re-apply filters to update the view (e.g. for 18+ items popping in)
+                    Application.Current.Dispatcher.Invoke(ApplyFilters);
+                }
+                
+                // Be gentle with the API
+                await Task.Delay(250); 
+            }
+            catch 
+            {
+                // Ignore errors during enrichment
+            }
+        }
+    }
+
+    private void ApplyFilters()
+    {
+        FilteredJoinRequests.Clear();
+
+        var filtered = JoinRequests.Where(r =>
+        {
+            // Apply 18+ filter
+            if (Only18Plus && !r.Request.IsAgeVerified)
+                return false;
+
+            return true;
+        });
+
+        foreach (var request in filtered)
+        {
+            FilteredJoinRequests.Add(request);
+        }
+    }
+
+    private async Task AutoAcceptPendingAsync()
+    {
+        var requestsToAccept = FilteredJoinRequests.Where(r => !r.IsProcessing).ToList();
+        
+        if (requestsToAccept.Count == 0)
+            return;
+
+        StatusMessage = $"Auto-accepting {requestsToAccept.Count} requests...";
+
+        foreach (var request in requestsToAccept)
+        {
+            await AcceptRequestAsync(request);
+            await Task.Delay(500); // Rate limiting
+        }
+
+        await LoadJoinRequestsAsync();
+    }
+
+    [RelayCommand]
+    private void SelectAll()
+    {
+        foreach (var request in FilteredJoinRequests)
+        {
+            request.IsSelected = true;
+        }
+        UpdateSelectedCount();
+    }
+
+    [RelayCommand]
+    private void DeselectAll()
+    {
+        foreach (var request in JoinRequests)
+        {
+            request.IsSelected = false;
+        }
+        UpdateSelectedCount();
+    }
+
+    public void UpdateSelectedCount()
+    {
+        SelectedCount = JoinRequests.Count(r => r.IsSelected);
+    }
+
+    [RelayCommand]
+    private async Task ApproveSelectedAsync()
+    {
+        var selectedRequests = JoinRequests.Where(r => r.IsSelected).ToList();
+        if (selectedRequests.Count == 0)
+        {
+            MessageBox.Show("Please select at least one request to approve.", "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        try
+        {
+            IsLoading = true;
+            var successCount = 0;
+            var failCount = 0;
+
+            foreach (var requestVM in selectedRequests)
+            {
+                var success = await AcceptRequestAsync(requestVM);
+                if (success)
+                {
+                    successCount++;
+                }
+                else
+                {
+                    failCount++;
+                }
+
+                // Small delay to avoid rate limiting
+                await Task.Delay(500);
+            }
+
+            StatusMessage = $"Approved: {successCount} succeeded, {failCount} failed";
+            MessageBox.Show($"Approved {successCount} requests successfully.\n{failCount} failed.", "Approval Complete", MessageBoxButton.OK, MessageBoxImage.Information);
+
+            // Refresh the list
+            await LoadJoinRequestsAsync();
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error approving requests: {ex.Message}";
+            MessageBox.Show($"Failed to approve requests: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+            UpdateSelectedCount();
+        }
+    }
+
+    [RelayCommand]
+    private async Task RejectSelectedAsync()
+    {
+        var selectedRequests = JoinRequests.Where(r => r.IsSelected).ToList();
+        if (selectedRequests.Count == 0)
+        {
+            MessageBox.Show("Please select at least one request to reject.", "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        var result = MessageBox.Show($"Are you sure you want to reject {selectedRequests.Count} join request(s)?", 
+            "Confirm Rejection", MessageBoxButton.YesNo, MessageBoxImage.Warning);
+        
+        if (result != MessageBoxResult.Yes)
+            return;
+
+        try
+        {
+            IsLoading = true;
+            var successCount = 0;
+            var failCount = 0;
+
+            var groupId = _settingsService.Settings.GroupId;
+            if (string.IsNullOrEmpty(groupId))
+            {
+                MessageBox.Show("No group configured.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                return;
+            }
+
+            foreach (var requestVM in selectedRequests)
+            {
+                StatusMessage = $"Rejecting {requestVM.Request.DisplayName}...";
+                requestVM.IsProcessing = true;
+
+                var success = await _apiService.RespondToGroupJoinRequestAsync(groupId, requestVM.Request.UserId, "reject");
+
+                if (success)
+                {
+                    successCount++;
+                }
+                else
+                {
+                    failCount++;
+                }
+
+                requestVM.IsProcessing = false;
+
+                // Small delay to avoid rate limiting
+                await Task.Delay(500);
+            }
+
+            StatusMessage = $"Rejected: {successCount} succeeded, {failCount} failed";
+            MessageBox.Show($"Rejected {successCount} requests successfully.\n{failCount} failed.", "Rejection Complete", MessageBoxButton.OK, MessageBoxImage.Information);
+
+            // Refresh the list
+            await LoadJoinRequestsAsync();
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error rejecting requests: {ex.Message}";
+            MessageBox.Show($"Failed to reject requests: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+            UpdateSelectedCount();
+        }
+    }
+
+    private async Task<bool> AcceptRequestAsync(JoinRequestItemViewModel requestVM)
+    {
+        var groupId = _settingsService.Settings.GroupId;
+        if (string.IsNullOrEmpty(groupId))
+            return false;
+
+        StatusMessage = $"Accepting {requestVM.Request.DisplayName}...";
+        requestVM.IsProcessing = true;
+
+        var success = await _apiService.RespondToGroupJoinRequestAsync(groupId, requestVM.Request.UserId, "accept");
+        
+        requestVM.IsProcessing = false;
+        return success;
+    }
+
+    [RelayCommand]
+    private void OpenUserProfile(string userId)
+    {
+        if (string.IsNullOrEmpty(userId))
+            return;
+
+        try
+        {
+            var vm = new UserProfileViewModel(userId, _apiService);
+            var window = new VRCGroupTools.Views.UserProfileWindow(vm);
+            window.Show();
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Failed to open profile: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+    }
+}
+
+public partial class JoinRequestItemViewModel : ObservableObject
+{
+    private readonly GroupJoinRequestsViewModel? _parent;
+
+    [ObservableProperty]
+    private bool _isSelected;
+
+    [ObservableProperty]
+    private bool _isProcessing;
+
+    [ObservableProperty]
+    private bool _isEnriched;
+
+    public GroupJoinRequest Request { get; }
+
+    // Cache enriched user details
+    private UserDetails? _cachedUser;
+
+    public JoinRequestItemViewModel(GroupJoinRequest request, GroupJoinRequestsViewModel? parent)
+    {
+        Request = request;
+        _parent = parent;
+        // If we already have tags from somewhere (cached), mark enriched? 
+        // No, assume not enriched unless _cachedUser is set or we explicitly flag it.
+    }
+
+    partial void OnIsSelectedChanged(bool value)
+    {
+        _parent?.UpdateSelectedCount();
+    }
+
+    public void UpdatedUserDetails(UserDetails user)
+    {
+        _cachedUser = user;
+        IsEnriched = true;
+        
+        Request.Tags = user.Tags;
+        Request.IsAgeVerified = user.IsAgeVerified; // Sync
+        
+        OnPropertyChanged(nameof(TrustLevel));
+        OnPropertyChanged(nameof(TrustLevelBrush));
+        OnPropertyChanged(nameof(Is18Plus));
+    }
+
+    public void UpdateTags(List<string> tags)
+    {
+        Request.Tags = tags;
+        OnPropertyChanged(nameof(TrustLevel));
+        OnPropertyChanged(nameof(TrustLevelBrush));
+    }
+
+    public bool Is18Plus
+    {
+        get
+        {
+            if (Request.IsAgeVerified) return true;
+            if (Request.Tags != null && Request.Tags.Contains("system_age_verified_adult")) return true;
+            return false;
+        }
+    }
+
+    public string? TrustLevel
+    {
+        get
+        {
+            if (Request.Tags == null || Request.Tags.Count == 0)
+                return "Visitor";
+
+            if (Request.Tags.Contains("system_trust_legend")) return "Trusted User";
+            if (Request.Tags.Contains("system_trust_veteran")) return "Trusted User";
+            if (Request.Tags.Contains("system_trust_trusted")) return "Known User";
+            if (Request.Tags.Contains("system_trust_known")) return "User";
+            if (Request.Tags.Contains("system_trust_basic")) return "New User";
+
+            var tagsLower = Request.Tags.Select(t => t.ToLowerInvariant()).ToList();
+            if (tagsLower.Any(t => t.Contains("legend"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("veteran"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("trusted"))) return "Known User";
+            if (tagsLower.Any(t => t.Contains("known"))) return "User";
+            if (tagsLower.Any(t => t.Contains("basic"))) return "New User";
+
+            return "Visitor";
+        }
+    }
+
+    public Brush TrustLevelBrush
+    {
+        get
+        {
+            return TrustLevel switch
+            {
+                "Trusted User" => new SolidColorBrush(Color.FromRgb(138, 43, 226)),
+                "Known User" => new SolidColorBrush(Color.FromRgb(255, 123, 0)),
+                "User" => new SolidColorBrush(Color.FromRgb(46, 204, 113)),
+                "New User" => new SolidColorBrush(Color.FromRgb(52, 152, 219)),
+                "Visitor" => new SolidColorBrush(Color.FromRgb(149, 165, 166)),
+                _ => new SolidColorBrush(Colors.Gray)
+            };
+        }
+    }
+}
diff --git a/src/ViewModels/InstanceInviterViewModel.cs b/src/ViewModels/InstanceInviterViewModel.cs
new file mode 100644
index 0000000..ab0a90a
--- /dev/null
+++ b/src/ViewModels/InstanceInviterViewModel.cs
@@ -0,0 +1,679 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.EntityFrameworkCore;
+using VRCGroupTools.Data;
+using VRCGroupTools.Data.Models;
+using VRCGroupTools.Services;
+
+namespace VRCGroupTools.ViewModels;
+
+public partial class InstanceInviterViewModel : ObservableObject
+{
+    private readonly IVRChatApiService _apiService;
+    private readonly ISettingsService _settingsService;
+    private readonly IInstanceInviterService _instanceInviterService;
+    private readonly ICacheService _cacheService;
+
+    [ObservableProperty]
+    private ObservableCollection<FriendItemViewModel> _friends = new();
+
+    [ObservableProperty]
+    private ObservableCollection<FriendItemViewModel> _filteredFriends = new();
+
+    [ObservableProperty]
+    private ObservableCollection<InstanceUserViewModel> _instanceUsers = new();
+
+    [ObservableProperty]
+    private ObservableCollection<InstanceUserViewModel> _filteredInstanceUsers = new();
+
+    [ObservableProperty]
+    private string _searchQuery = string.Empty;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private bool _only18Plus;
+
+    [ObservableProperty]
+    private bool _onlineOnly = true;
+
+    [ObservableProperty]
+    private bool _skipVisitors;
+
+    [ObservableProperty]
+    private bool _skipNewUsers;
+
+    [ObservableProperty]
+    private bool _skipUsers;
+
+    [ObservableProperty]
+    private bool _skipKnown;
+
+    [ObservableProperty]
+    private string? _statusMessage;
+
+    [ObservableProperty]
+    private CurrentInstanceInfo? _currentInstance;
+
+    [ObservableProperty]
+    private string? _currentInstanceDisplay;
+
+    [ObservableProperty]
+    private int _selectedCount;
+
+    [ObservableProperty]
+    private bool _autoInviteEnabled;
+
+    [ObservableProperty]
+    private int _instanceUserSelectedCount;
+
+    public InstanceInviterViewModel(
+        IVRChatApiService apiService, 
+        ISettingsService settingsService,
+        IInstanceInviterService instanceInviterService,
+        ICacheService cacheService)
+    {
+        _apiService = apiService;
+        _settingsService = settingsService;
+        _instanceInviterService = instanceInviterService;
+        _cacheService = cacheService;
+        
+        _currentInstanceDisplay = "Click refresh to detect current instance";
+
+        _only18Plus = _settingsService.Settings.InstanceInviterOnly18Plus;
+        _onlineOnly = !_settingsService.Settings.InstanceInviterShowOfflineFriends;
+    }
+
+    partial void OnSearchQueryChanged(string value)
+    {
+        ApplyFilters();
+    }
+
+    partial void OnOnly18PlusChanged(bool value)
+    {
+        _settingsService.Settings.InstanceInviterOnly18Plus = value;
+        _settingsService.Save();
+        ApplyFilters();
+        ApplyInstanceUserFilters();
+    }
+
+    partial void OnSkipVisitorsChanged(bool value)
+    {
+        ApplyFilters();
+        ApplyInstanceUserFilters();
+    }
+    
+    partial void OnSkipNewUsersChanged(bool value)
+    {
+        ApplyFilters();
+        ApplyInstanceUserFilters();
+    }
+    
+    partial void OnSkipUsersChanged(bool value)
+    {
+        ApplyFilters();
+        ApplyInstanceUserFilters();
+    }
+    
+    partial void OnSkipKnownChanged(bool value)
+    {
+        ApplyFilters();
+        ApplyInstanceUserFilters();
+    }
+
+    [RelayCommand]
+    private async Task LoadAsync()
+    {
+        await LoadFriendsAsync();
+        UpdateCurrentInstance();
+    }
+
+    [RelayCommand]
+    private async Task RefreshAsync()
+    {
+        Console.WriteLine("[INSTANCE-VM] RefreshAsync started");
+        await LoadFriendsAsync();
+        Console.WriteLine("[INSTANCE-VM] Calling UpdateCurrentInstance...");
+        UpdateCurrentInstance();
+        Console.WriteLine("[INSTANCE-VM] RefreshAsync completed");
+    }
+
+    private async Task LoadFriendsAsync()
+    {
+        if (IsLoading)
+        {
+            Console.WriteLine("[INSTANCE-VM] LoadFriendsAsync skipped - already loading");
+            return;
+        }
+
+        try
+        {
+            IsLoading = true;
+            StatusMessage = "Loading friends...";
+            Console.WriteLine("[INSTANCE-VM] Loading friends from API...");
+
+            var friendsList = await _apiService.GetFriendsAsync(OnlineOnly);
+            Console.WriteLine($"[INSTANCE-VM] Friends loaded: {friendsList.Count}");
+
+            Friends.Clear();
+            foreach (var friend in friendsList)
+            {
+                Friends.Add(new FriendItemViewModel(friend, this));
+            }
+
+            ApplyFilters();
+            StatusMessage = $"Loaded {Friends.Count} friends";
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INSTANCE-VM] Error loading friends: {ex}");
+            StatusMessage = $"Error loading friends: {ex.Message}";
+            MessageBox.Show($"Failed to load friends: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    private void UpdateCurrentInstance()
+    {
+        Console.WriteLine("[INSTANCE-VM] UpdateCurrentInstance started");
+        CurrentInstance = _instanceInviterService.GetCurrentInstance();
+        Console.WriteLine($"[INSTANCE-VM] CurrentInstance result: {(CurrentInstance == null ? "null" : CurrentInstance.WorldId)}");
+        
+        if (CurrentInstance != null)
+        {
+            CurrentInstanceDisplay = $"Current Instance: {CurrentInstance.WorldId} (Detected at {CurrentInstance.DetectedAt:HH:mm:ss})";
+            StatusMessage = "Ready to send invites";
+            
+            // Load instance users
+            _ = RefreshInstanceUsersAsync();
+        }
+        else
+        {
+            CurrentInstanceDisplay = "No instance detected. Please join a VRChat world.";
+            StatusMessage = "Not in an instance";
+            InstanceUsers.Clear();
+        }
+    }
+
+    private async Task RefreshInstanceUsersAsync()
+    {
+        try
+        {
+            var users = await _instanceInviterService.GetCurrentInstanceUsersAsync(_apiService);
+            InstanceUsers.Clear();
+            foreach (var user in users)
+            {
+                InstanceUsers.Add(new InstanceUserViewModel(user, this));
+            }
+            
+            // Apply filters to instance users
+            ApplyInstanceUserFilters();
+            
+            // Refresh filters to exclude instance users from friend list
+            ApplyFilters();
+            
+            // Auto-invite if enabled
+            if (AutoInviteEnabled && FilteredInstanceUsers.Count > 0)
+            {
+                _ = InviteInstanceUsersAsync();
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[INSTANCE-INVITER-VM] Error refreshing instance users: {ex.Message}");
+        }
+    }
+
+    private void ApplyInstanceUserFilters()
+    {
+        FilteredInstanceUsers.Clear();
+
+        var filtered = InstanceUsers.Where(u =>
+        {
+            // Apply 18+ filter
+            if (Only18Plus && !u.User.IsAgeVerified)
+                return false;
+
+            // Apply trust level filters
+            if (SkipVisitors && u.TrustLevel == "Visitor")
+                return false;
+            if (SkipNewUsers && u.TrustLevel == "New User")
+                return false;
+            if (SkipUsers && u.TrustLevel == "User")
+                return false;
+            if (SkipKnown && u.TrustLevel == "Known User")
+                return false;
+
+            return true;
+        });
+
+        foreach (var user in filtered)
+        {
+            FilteredInstanceUsers.Add(user);
+        }
+    }
+
+    private void ApplyFilters()
+    {
+        FilteredFriends.Clear();
+
+        var query = SearchQuery?.ToLowerInvariant() ?? string.Empty;
+        
+        // Get list of users already in instance to exclude them
+        var instanceUserNames = InstanceUsers.Select(u => u.User.DisplayName.ToLowerInvariant()).ToHashSet();
+
+        var filtered = Friends.Where(f =>
+        {
+            // Exclude friends already in the instance
+            if (instanceUserNames.Contains(f.Friend.DisplayName.ToLowerInvariant()))
+                return false;
+
+            // Apply 18+ filter
+            if (Only18Plus && !f.Friend.IsAgeVerified)
+                return false;
+
+            // Apply trust level filters
+            if (SkipVisitors && f.TrustLevel == "Visitor")
+                return false;
+            if (SkipNewUsers && f.TrustLevel == "New User")
+                return false;
+            if (SkipUsers && f.TrustLevel == "User")
+                return false;
+            if (SkipKnown && f.TrustLevel == "Known User")
+                return false;
+
+            // Apply search filter
+            if (!string.IsNullOrWhiteSpace(query))
+            {
+                var matchesName = f.Friend.DisplayName.ToLowerInvariant().Contains(query);
+                var matchesStatus = f.Friend.StatusDescription?.ToLowerInvariant().Contains(query) ?? false;
+                if (!matchesName && !matchesStatus)
+                    return false;
+            }
+
+            return true;
+        });
+
+        foreach (var friend in filtered)
+        {
+            FilteredFriends.Add(friend);
+        }
+    }
+
+    [RelayCommand]
+    private async Task InviteSelectedAsync()
+    {
+        if (CurrentInstance == null)
+        {
+            MessageBox.Show("No instance detected. Please join a VRChat world first.", "No Instance", MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+
+        var selectedFriends = Friends.Where(f => f.IsSelected).ToList();
+        if (selectedFriends.Count == 0)
+        {
+            MessageBox.Show("Please select at least one friend to invite.", "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        if (Only18Plus && selectedFriends.Any(f => !f.Friend.IsAgeVerified))
+        {
+            MessageBox.Show("Cannot invite non-18+ users when 18+ filter is enabled.", "Filter Violation", MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+
+        try
+        {
+            IsLoading = true;
+            var successCount = 0;
+            var failCount = 0;
+            var skippedCount = 0;
+
+            using (var db = new AppDbContext())
+            {
+                foreach (var friendVM in selectedFriends)
+                {
+                    // Check if already invited to this instance
+                    var alreadyInvited = await db.InvitedUsers
+                        .AnyAsync(u => u.UserId == friendVM.Friend.UserId 
+                                    && u.WorldId == CurrentInstance.WorldId 
+                                    && u.InstanceId == CurrentInstance.InstanceId);
+
+                    if (alreadyInvited)
+                    {
+                        StatusMessage = $"Skipping {friendVM.Friend.DisplayName} (already invited)...";
+                        skippedCount++;
+                        continue;
+                    }
+
+                    StatusMessage = $"Inviting {friendVM.Friend.DisplayName}...";
+                    
+                    var success = await _instanceInviterService.InviteToCurrentInstanceAsync(friendVM.Friend.UserId, _apiService);
+                    
+                    // Create database record
+                    var inviteRecord = new InvitedUser
+                    {
+                        UserId = friendVM.Friend.UserId,
+                        DisplayName = friendVM.Friend.DisplayName,
+                        ProfilePicUrl = friendVM.Friend.ProfilePicUrl,
+                        IsAgeVerified = friendVM.Friend.IsAgeVerified,
+                        TrustLevel = friendVM.TrustLevel,
+                        InvitedAt = DateTime.UtcNow,
+                        WorldId = CurrentInstance.WorldId,
+                        InstanceId = CurrentInstance.InstanceId,
+                        InviteSuccessful = success
+                    };
+
+                    db.InvitedUsers.Add(inviteRecord);
+                    await db.SaveChangesAsync();
+
+                    // Verify the record was saved
+                    var verified = await db.InvitedUsers
+                        .AnyAsync(u => u.UserId == friendVM.Friend.UserId 
+                                    && u.WorldId == CurrentInstance.WorldId 
+                                    && u.InstanceId == CurrentInstance.InstanceId);
+
+                    if (verified && success)
+                    {
+                        successCount++;
+                        friendVM.IsSelected = false;
+                    }
+                    else if (!success)
+                    {
+                        failCount++;
+                    }
+
+                    // Small delay to avoid rate limiting
+                    await Task.Delay(500);
+                }
+            }
+
+            StatusMessage = $"Invites sent: {successCount} succeeded, {failCount} failed, {skippedCount} skipped";
+            MessageBox.Show($"Sent {successCount} invites successfully.\n{failCount} failed.\n{skippedCount} already invited.", "Invites Sent", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error sending invites: {ex.Message}";
+            MessageBox.Show($"Failed to send invites: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+            UpdateSelectedCount();
+        }
+    }
+
+    [RelayCommand]
+    private void SelectAll()
+    {
+        foreach (var friend in FilteredFriends)
+        {
+            friend.IsSelected = true;
+        }
+        UpdateSelectedCount();
+    }
+
+    [RelayCommand]
+    private void DeselectAll()
+    {
+        foreach (var friend in Friends)
+        {
+            friend.IsSelected = false;
+        }
+        UpdateSelectedCount();
+    }
+
+    public void UpdateSelectedCount()
+    {
+        SelectedCount = Friends.Count(f => f.IsSelected);
+    }
+
+    [RelayCommand]
+    private void SelectAllInstanceUsers()
+    {
+        foreach (var user in FilteredInstanceUsers)
+        {
+            user.IsSelected = true;
+        }
+        UpdateInstanceUserSelectedCount();
+    }
+
+    [RelayCommand]
+    private void DeselectAllInstanceUsers()
+    {
+        foreach (var user in InstanceUsers)
+        {
+            user.IsSelected = false;
+        }
+        UpdateInstanceUserSelectedCount();
+    }
+
+    public void UpdateInstanceUserSelectedCount()
+    {
+        InstanceUserSelectedCount = InstanceUsers.Count(u => u.IsSelected);
+    }
+
+    [RelayCommand]
+    private async Task InviteInstanceUsersAsync()
+    {
+        var selectedUsers = InstanceUsers.Where(u => u.IsSelected).ToList();
+        if (selectedUsers.Count == 0)
+        {
+            MessageBox.Show("Please select at least one user to invite.", "No Selection", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        // Get the current group ID from settings
+        var groupId = _settingsService.Settings.GroupId;
+        if (string.IsNullOrEmpty(groupId))
+        {
+            MessageBox.Show("No group configured. Please set up a group first.", "No Group", MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+
+        try
+        {
+            IsLoading = true;
+            var successCount = 0;
+            var failCount = 0;
+
+            foreach (var userVM in selectedUsers)
+            {
+                StatusMessage = $"Inviting {userVM.User.DisplayName} to group...";
+
+                // Invite to group using group ID
+                var success = await _apiService.SendGroupInviteAsync(groupId, userVM.User.UserId);
+
+                if (success)
+                {
+                    successCount++;
+                    userVM.IsSelected = false;
+                }
+                else
+                {
+                    failCount++;
+                }
+
+                // Small delay to avoid rate limiting
+                await Task.Delay(500);
+            }
+
+            StatusMessage = $"Invites sent: {successCount} succeeded, {failCount} failed";
+            MessageBox.Show($"Sent {successCount} group invites successfully.\n{failCount} failed.", "Invites Sent", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Error sending invites: {ex.Message}";
+            MessageBox.Show($"Failed to send invites: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+        finally
+        {
+            IsLoading = false;
+            UpdateInstanceUserSelectedCount();
+        }
+    }
+}
+
+public partial class FriendItemViewModel : ObservableObject
+{
+    private readonly InstanceInviterViewModel? _parent;
+
+    [ObservableProperty]
+    private bool _isSelected;
+
+    public FriendInfo Friend { get; }
+
+    public FriendItemViewModel(FriendInfo friend, InstanceInviterViewModel? parent)
+    {
+        Friend = friend;
+        _parent = parent;
+    }
+
+    partial void OnIsSelectedChanged(bool value)
+    {
+        _parent?.UpdateSelectedCount();
+    }
+
+    public string AgeVerificationDisplay => Friend.IsAgeVerified ? "✓ 18+" : "";
+    public string OnlineStatusDisplay => Friend.IsOnline ? "🟢 Online" : "⚫ Offline";
+    
+    public string? TrustLevel
+    {
+        get
+        {
+            // Debug: Log all tags
+            Console.WriteLine($"[TRUST-DEBUG] {Friend.DisplayName} ALL tags: {string.Join(", ", Friend.Tags)}");
+            
+            // VRChat trust level tags - check all possible formats
+            // Check for exact system tags first
+            if (Friend.Tags.Contains("system_trust_legend")) return "Trusted User";
+            if (Friend.Tags.Contains("system_trust_veteran")) return "Trusted User";
+            if (Friend.Tags.Contains("system_trust_trusted")) return "Known User";
+            if (Friend.Tags.Contains("system_trust_known")) return "User";
+            if (Friend.Tags.Contains("system_trust_basic")) return "New User";
+            
+            // Check for partial matches
+            var tagsLower = Friend.Tags.Select(t => t.ToLowerInvariant()).ToList();
+            if (tagsLower.Any(t => t.Contains("legend"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("veteran"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("trusted"))) return "Known User";
+            if (tagsLower.Any(t => t.Contains("known"))) return "User";
+            if (tagsLower.Any(t => t.Contains("basic"))) return "New User";
+            
+            // Default for users without trust tags
+            Console.WriteLine($"[TRUST-DEBUG] {Friend.DisplayName} has NO trust tags - defaulting to Visitor");
+            return "Visitor";
+        }
+    }
+    
+    public string TrustLevelDisplay => TrustLevel ?? "";
+    
+    public bool HasTrustLevel => !string.IsNullOrEmpty(TrustLevel);
+    
+    public Brush TrustLevelColor
+    {
+        get
+        {
+            return TrustLevel switch
+            {
+                "Trusted User" => new SolidColorBrush(Color.FromRgb(138, 43, 226)), // Purple
+                "Known User" => new SolidColorBrush(Color.FromRgb(255, 123, 0)), // Orange
+                "User" => new SolidColorBrush(Color.FromRgb(46, 204, 113)), // Green
+                "New User" => new SolidColorBrush(Color.FromRgb(52, 152, 219)), // Blue
+                "Visitor" => new SolidColorBrush(Color.FromRgb(149, 165, 166)), // Gray
+                _ => new SolidColorBrush(Colors.Gray)
+            };
+        }
+    }
+    
+    public Brush TrustLevelBrush => TrustLevelColor;
+    
+    public Brush StatusBrush
+    {
+        get
+        {
+            return Friend.Status switch
+            {
+                "active" => new SolidColorBrush(Color.FromRgb(46, 204, 113)), // Green
+                "join me" => new SolidColorBrush(Color.FromRgb(52, 152, 219)), // Blue
+                "ask me" => new SolidColorBrush(Color.FromRgb(241, 196, 15)), // Yellow
+                "busy" => new SolidColorBrush(Color.FromRgb(231, 76, 60)), // Red
+                "offline" => new SolidColorBrush(Color.FromRgb(149, 165, 166)), // Gray
+                _ => new SolidColorBrush(Colors.Gray)
+            };
+        }
+    }
+}
+
+public partial class InstanceUserViewModel : ObservableObject
+{
+    private readonly InstanceInviterViewModel _parent;
+
+    [ObservableProperty]
+    private bool _isSelected;
+
+    public InstanceUser User { get; }
+
+    public InstanceUserViewModel(InstanceUser user, InstanceInviterViewModel parent)
+    {
+        User = user;
+        _parent = parent;
+    }
+
+    partial void OnIsSelectedChanged(bool value)
+    {
+        _parent.UpdateInstanceUserSelectedCount();
+    }
+
+    public string? TrustLevel
+    {
+        get
+        {
+            if (User.Tags == null || User.Tags.Count == 0)
+                return "Visitor";
+
+            if (User.Tags.Contains("system_trust_legend")) return "Trusted User";
+            if (User.Tags.Contains("system_trust_veteran")) return "Trusted User";
+            if (User.Tags.Contains("system_trust_trusted")) return "Known User";
+            if (User.Tags.Contains("system_trust_known")) return "User";
+            if (User.Tags.Contains("system_trust_basic")) return "New User";
+
+            var tagsLower = User.Tags.Select(t => t.ToLowerInvariant()).ToList();
+            if (tagsLower.Any(t => t.Contains("legend"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("veteran"))) return "Trusted User";
+            if (tagsLower.Any(t => t.Contains("trusted"))) return "Known User";
+            if (tagsLower.Any(t => t.Contains("known"))) return "User";
+            if (tagsLower.Any(t => t.Contains("basic"))) return "New User";
+
+            return "Visitor";
+        }
+    }
+
+    public Brush TrustLevelBrush
+    {
+        get
+        {
+            return TrustLevel switch
+            {
+                "Trusted User" => new SolidColorBrush(Color.FromRgb(138, 43, 226)), // Purple
+                "Known User" => new SolidColorBrush(Color.FromRgb(255, 123, 0)), // Orange
+                "User" => new SolidColorBrush(Color.FromRgb(46, 204, 113)), // Green
+                "New User" => new SolidColorBrush(Color.FromRgb(52, 152, 219)), // Blue
+                "Visitor" => new SolidColorBrush(Color.FromRgb(149, 165, 166)), // Gray
+                _ => new SolidColorBrush(Colors.Gray)
+            };
+        }
+    }
+}
diff --git a/src/ViewModels/InviterHubViewModel.cs b/src/ViewModels/InviterHubViewModel.cs
new file mode 100644
index 0000000..934b509
--- /dev/null
+++ b/src/ViewModels/InviterHubViewModel.cs
@@ -0,0 +1,35 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace VRCGroupTools.ViewModels;
+
+public partial class InviterHubViewModel : ObservableObject
+{
+    [ObservableProperty]
+    private string _selectedMode = "GroupInviter";
+
+    [ObservableProperty]
+    private InviteToGroupViewModel? _inviteToGroupVM;
+
+    [ObservableProperty]
+    private InstanceInviterViewModel? _instanceInviterVM;
+
+    [ObservableProperty]
+    private FriendInviterViewModel? _friendInviterVM;
+
+    public InviterHubViewModel(
+        InviteToGroupViewModel inviteToGroupVM,
+        InstanceInviterViewModel instanceInviterVM,
+        FriendInviterViewModel friendInviterVM)
+    {
+        InviteToGroupVM = inviteToGroupVM;
+        InstanceInviterVM = instanceInviterVM;
+        FriendInviterVM = friendInviterVM;
+    }
+
+    [RelayCommand]
+    private void SelectMode(string mode)
+    {
+        SelectedMode = mode;
+    }
+}
diff --git a/src/ViewModels/MainViewModel.cs b/src/ViewModels/MainViewModel.cs
index 7c4fcc2..b6974cd 100644
--- a/src/ViewModels/MainViewModel.cs
+++ b/src/ViewModels/MainViewModel.cs
@@ -89,6 +89,15 @@ public partial class MainViewModel : ObservableObject
     [ObservableProperty]
     private KillSwitchViewModel? _killSwitchVM;
 
+    [ObservableProperty]
+    private InstanceInviterViewModel? _instanceInviterVM;
+
+    [ObservableProperty]
+    private InviterHubViewModel? _inviterHubVM;
+
+    [ObservableProperty]
+    private GroupJoinRequestsViewModel? _groupJoinRequestsVM;
+
     public string AppVersion => $"v{App.Version}";
 
     public event Action? LogoutRequested;
@@ -136,7 +145,10 @@ public void Initialize()
         BansListVM = App.Services.GetRequiredService<BansListViewModel>();
         MemberBackupVM = App.Services.GetRequiredService<MemberBackupViewModel>();
         KillSwitchVM = App.Services.GetRequiredService<KillSwitchViewModel>();
+        InstanceInviterVM = App.Services.GetRequiredService<InstanceInviterViewModel>();
         AppSettingsVM = App.Services.GetRequiredService<AppSettingsViewModel>();
+        InviterHubVM = App.Services.GetRequiredService<InviterHubViewModel>();
+        GroupJoinRequestsVM = App.Services.GetRequiredService<GroupJoinRequestsViewModel>();
         
         // Sync group ID to badge scanner and API service
         BadgeScannerVM!.GroupId = GroupId;
@@ -161,6 +173,7 @@ partial void OnSelectedGroupChanged(GroupConfiguration? value)
         {
             GroupId = value.GroupId;
             _settingsService.CurrentGroupId = value.GroupId;
+            _settingsService.Settings.GroupId = value.GroupId; // Sync legacy setting
             _settingsService.Save();
             
             // Update API service
@@ -183,6 +196,12 @@ partial void OnSelectedGroupChanged(GroupConfiguration? value)
             {
                 _ = AuditLogVM.InitializeAsync();
             }
+
+            // Refresh join requests
+            if (GroupJoinRequestsVM != null)
+            {
+                _ = GroupJoinRequestsVM.RefreshCommand.ExecuteAsync(null);
+            }
             
             Console.WriteLine($"[DEBUG] Switched to group: {value.GroupName} ({value.GroupId})");
         }
@@ -349,6 +368,13 @@ private void SelectModule(string module)
             Console.WriteLine("[DEBUG] Initializing AuditLogVM...");
             _ = AuditLogVM.InitializeAsync();  // Fire and forget
         }
+
+        // Initialize GroupJoinRequests when switching to it
+        if (module == "GroupJoinRequests" && GroupJoinRequestsVM != null)
+        {
+            Console.WriteLine("[DEBUG] Refreshing GroupJoinRequestsVM...");
+            _ = GroupJoinRequestsVM.RefreshCommand.ExecuteAsync(null);
+        }
     }
 
     [RelayCommand]
diff --git a/src/ViewModels/MembersListViewModel.cs b/src/ViewModels/MembersListViewModel.cs
index 77faa62..1fb0c2b 100644
--- a/src/ViewModels/MembersListViewModel.cs
+++ b/src/ViewModels/MembersListViewModel.cs
@@ -352,8 +352,32 @@ await moderationService.LogModerationActionAsync(
                 Members.Remove(SelectedMember);
                 OnPropertyChanged(nameof(FilteredMembers));
                 ShowMemberPanel = false;
+                var bannedUserName = SelectedMember.DisplayName;
+                var bannedUserId = SelectedMember.UserId;
                 SelectedMember = null;
                 Status = $"Member banned: {request.Reason}";
+                
+                // Send Discord notification
+                try
+                {
+                    var discordService = App.Services.GetService<IDiscordWebhookService>();
+                    if (discordService != null && discordService.IsConfigured)
+                    {
+                        var history = await moderationService.GetInfractionHistoryAsync(groupId, bannedUserId);
+                        await discordService.SendModerationActionAsync(
+                            "ban",
+                            bannedUserId,
+                            bannedUserName,
+                            _apiService.CurrentUserDisplayName ?? "Unknown",
+                            request.Reason,
+                            request.Description,
+                            DateTime.UtcNow,
+                            null,
+                            history.TotalBans
+                        );
+                    }
+                }
+                catch { /* Discord notification failed, but ban was successful */ }
             }
             else
             {
@@ -418,6 +442,7 @@ await moderationService.LogModerationActionAsync(
                         var history = await moderationService.GetInfractionHistoryAsync(groupId, SelectedMember.UserId);
                         await discordService.SendModerationActionAsync(
                             "warning",
+                            SelectedMember.UserId,
                             SelectedMember.DisplayName,
                             _apiService.CurrentUserDisplayName ?? "Unknown",
                             request.Reason,
@@ -454,4 +479,21 @@ partial void OnSelectedRoleChanged(string value)
     {
         OnPropertyChanged(nameof(FilteredMembers));
     }
+
+    [RelayCommand]
+    private void ViewFullProfile()
+    {
+        if (SelectedMember == null) return;
+        
+        try
+        {
+            var vm = new UserProfileViewModel(SelectedMember.UserId, _apiService);
+            var window = new VRCGroupTools.Views.UserProfileWindow(vm);
+            window.Show();
+        }
+        catch (Exception ex)
+        {
+            System.Windows.MessageBox.Show($"Failed to open profile: {ex.Message}");
+        }
+    }
 }
diff --git a/src/ViewModels/UserProfileViewModel.cs b/src/ViewModels/UserProfileViewModel.cs
new file mode 100644
index 0000000..246473a
--- /dev/null
+++ b/src/ViewModels/UserProfileViewModel.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using VRCGroupTools.Services;
+
+namespace VRCGroupTools.ViewModels;
+
+public partial class UserProfileViewModel : ObservableObject
+{
+    private readonly IVRChatApiService? _apiService;
+
+    [ObservableProperty]
+    private string _userId = string.Empty;
+
+    [ObservableProperty]
+    private UserDetails? _user;
+
+    [ObservableProperty]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    private string _trustRank = "Loading...";
+
+    [ObservableProperty]
+    private Brush _trustRankBrush = new SolidColorBrush(Colors.Gray);
+
+    public UserProfileViewModel(UserDetails user)
+    {
+        User = user;
+        UserId = user.UserId;
+        UpdateDisplays();
+    }
+
+    public UserProfileViewModel(string userId, IVRChatApiService apiService)
+    {
+        UserId = userId;
+        _apiService = apiService;
+        _ = LoadUserAsync();
+    }
+
+    private async Task LoadUserAsync()
+    {
+        if (_apiService == null || IsLoading) return;
+        
+        try 
+        {
+            IsLoading = true;
+            TrustRank = "Loading...";
+            
+            var user = await _apiService.GetUserAsync(UserId);
+            if (user != null)
+            {
+                User = user;
+                UpdateDisplays();
+            }
+            else
+            {
+                TrustRank = "Failed to load";
+            }
+        }
+        catch (Exception)
+        {
+            TrustRank = "Error";
+        }
+        finally
+        {
+            IsLoading = false;
+        }
+    }
+
+    private void UpdateDisplays()
+    {
+        if (User == null) return;
+
+        // Calculate Trust Rank
+        CalculateTrustRank();
+    }
+
+    private void CalculateTrustRank()
+    {
+        if (User == null || User.Tags == null)
+        {
+            TrustRank = "Visitor";
+            TrustRankBrush = new SolidColorBrush(Color.FromRgb(149, 165, 166));
+            return;
+        }
+
+        var tags = User.Tags;
+
+        if (tags.Contains("system_trust_legend")) { TrustRank = "Trusted User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(138, 43, 226)); return; }
+        if (tags.Contains("system_trust_veteran")) { TrustRank = "Trusted User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(138, 43, 226)); return; }
+        if (tags.Contains("system_trust_trusted")) { TrustRank = "Known User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(255, 123, 0)); return; }
+        if (tags.Contains("system_trust_known")) { TrustRank = "User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(46, 204, 113)); return; }
+        if (tags.Contains("system_trust_basic")) { TrustRank = "New User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(52, 152, 219)); return; }
+
+        var tagsLower = tags.Select(t => t.ToLowerInvariant()).ToList();
+        if (tagsLower.Any(t => t.Contains("legend") || t.Contains("veteran"))) { TrustRank = "Trusted User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(138, 43, 226)); return; }
+        if (tagsLower.Any(t => t.Contains("trusted"))) { TrustRank = "Known User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(255, 123, 0)); return; }
+        if (tagsLower.Any(t => t.Contains("known"))) { TrustRank = "User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(46, 204, 113)); return; }
+        if (tagsLower.Any(t => t.Contains("basic"))) { TrustRank = "New User"; TrustRankBrush = new SolidColorBrush(Color.FromRgb(52, 152, 219)); return; }
+
+        TrustRank = "Visitor";
+        TrustRankBrush = new SolidColorBrush(Color.FromRgb(149, 165, 166));
+    }
+
+    [RelayCommand]
+    private void OpenWebProfile()
+    {
+        if (string.IsNullOrEmpty(UserId)) return;
+        var url = $"https://vrchat.com/home/user/{UserId}";
+        try
+        {
+            Process.Start(new ProcessStartInfo(url) { UseShellExecute = true });
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Failed to open profile: {ex.Message}");
+        }
+    }
+}
diff --git a/src/Views/FriendInviterView.xaml b/src/Views/FriendInviterView.xaml
new file mode 100644
index 0000000..570bcf8
--- /dev/null
+++ b/src/Views/FriendInviterView.xaml
@@ -0,0 +1,242 @@
+<UserControl x:Class="VRCGroupTools.Views.FriendInviterView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:viewmodels="clr-namespace:VRCGroupTools.ViewModels"
+             d:DataContext="{d:DesignInstance Type=viewmodels:FriendInviterViewModel}"
+             mc:Ignorable="d"
+             Background="Transparent"
+             d:DesignHeight="600" d:DesignWidth="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <StackPanel Grid.Row="0" Margin="0,0,0,20">
+            <TextBlock Text="👥 Friend Manager" 
+                      FontSize="28" 
+                      FontWeight="Bold" 
+                      Foreground="White"/>
+            <TextBlock Text="View your VRChat friends list, manage connections, and see who's online" 
+                      Foreground="#888" 
+                      FontSize="14" 
+                      Margin="0,5,0,0"/>
+        </StackPanel>
+
+        <!-- Search and Filters -->
+        <Border Grid.Row="1" Background="#2D2D30" CornerRadius="8" Padding="20" Margin="0,0,0,15">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+
+                <!-- Search Box -->
+                <Grid Grid.Row="0" Margin="0,0,0,15">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    
+                    <TextBox Grid.Column="0"
+                            Text="{Binding SearchQuery, UpdateSourceTrigger=PropertyChanged}"
+                            materialDesign:HintAssist.Hint="🔍 Search friends by name..."
+                            Foreground="White"
+                            CaretBrush="White"
+                            Style="{StaticResource MaterialDesignOutlinedTextBox}"
+                            Margin="0,0,15,0"/>
+
+                    <Button Grid.Column="1"
+                           Content="🔄 Refresh"
+                           Command="{Binding RefreshCommand}"
+                           Style="{StaticResource MaterialDesignOutlinedButton}"
+                           Width="100"/>
+                </Grid>
+
+                <!-- Filters -->
+                <StackPanel Grid.Row="1" Orientation="Horizontal">
+                    <CheckBox Content="Online Only" 
+                             IsChecked="{Binding OnlineOnly}"
+                             Foreground="White"
+                             Margin="0,0,20,0"/>
+                    <CheckBox Content="18+ Verified" 
+                             IsChecked="{Binding Only18Plus}"
+                             Foreground="White"
+                             Margin="0,0,20,0"/>
+                    <CheckBox Content="Show Trust Levels" 
+                             IsChecked="{Binding ShowTrustLevels}"
+                             Foreground="White"/>
+                </StackPanel>
+            </Grid>
+        </Border>
+
+        <!-- Friends List -->
+        <Border Grid.Row="2" Background="#1E1E1E" CornerRadius="8" Padding="15">
+            <Grid>
+                <!-- Loading Indicator -->
+                <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center"
+                           Visibility="{Binding IsLoading, Converter={StaticResource BooleanToVisibilityConverter}}">
+                    <ProgressBar Style="{StaticResource MaterialDesignCircularProgressBar}"
+                                Value="0"
+                                IsIndeterminate="True"
+                                Width="50" Height="50"
+                                Foreground="#7C4DFF"/>
+                    <TextBlock Text="Loading friends..." 
+                              Foreground="#888" 
+                              Margin="0,15,0,0"
+                              HorizontalAlignment="Center"/>
+                </StackPanel>
+
+                <!-- Empty State -->
+                <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center"
+                           Visibility="{Binding FilteredFriends.Count, Converter={StaticResource ZeroToVisibilityConverter}}">
+                    <TextBlock Text="👥" FontSize="48" HorizontalAlignment="Center" Margin="0,0,0,20"/>
+                    <TextBlock Text="No friends found" 
+                              FontSize="18" 
+                              FontWeight="SemiBold"
+                              Foreground="White"
+                              HorizontalAlignment="Center"
+                              Margin="0,0,0,10"/>
+                    <TextBlock Text="Try adjusting your search filters" 
+                              Foreground="#888" 
+                              FontSize="13" 
+                              HorizontalAlignment="Center"/>
+                </StackPanel>
+
+                <!-- Friends List -->
+                <ScrollViewer VerticalScrollBarVisibility="Auto"
+                             Visibility="{Binding IsLoading, Converter={StaticResource InverseBoolToVisConverter}}">
+                    <ItemsControl ItemsSource="{Binding FilteredFriends}" Padding="5">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Border Background="#2D2D30" 
+                                       CornerRadius="8" 
+                                       Padding="15" 
+                                       Margin="0,0,0,10">
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                        </Grid.ColumnDefinitions>
+
+                                        <!-- Selection Checkbox -->
+                                        <CheckBox Grid.Column="0" 
+                                                 IsChecked="{Binding IsSelected}"
+                                                 VerticalAlignment="Center"
+                                                 Margin="0,0,15,0"/>
+
+                                        <!-- Avatar -->
+                                        <Border Grid.Column="1" 
+                                               Width="50" Height="50" 
+                                               CornerRadius="25" 
+                                               Background="#1E1E1E" 
+                                               ClipToBounds="True" 
+                                               VerticalAlignment="Top">
+                                            <Image Source="{Binding Friend.ProfilePicUrl}" 
+                                                  Stretch="UniformToFill"/>
+                                        </Border>
+
+                                        <!-- Friend Info -->
+                                        <StackPanel Grid.Column="2" 
+                                                   Margin="15,0,15,0" 
+                                                   VerticalAlignment="Center">\n                                            <TextBlock Text="{Binding Friend.DisplayName}" 
+                                                      Foreground="White" 
+                                                      FontWeight="SemiBold" 
+                                                      FontSize="15"/>
+                                            
+                                            <StackPanel Orientation="Horizontal" Margin="0,3,0,0">
+                                                <TextBlock Text="{Binding TrustLevel}" 
+                                                          Foreground="{Binding TrustLevelBrush}"
+                                                          FontSize="11"
+                                                          Margin="0,0,10,0"
+                                                          Visibility="{Binding DataContext.ShowTrustLevels, RelativeSource={RelativeSource AncestorType=UserControl}, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+                                                
+                                                <TextBlock Text="🔞" 
+                                                          FontSize="11"
+                                                          Margin="0,0,10,0"
+                                                          Visibility="{Binding Friend.IsAgeVerified, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+                                                
+                                                <TextBlock Text="{Binding Friend.Status}" 
+                                                          Foreground="{Binding StatusBrush}"
+                                                          FontSize="11"/>
+                                            </StackPanel>
+
+                                            <TextBlock Text="{Binding Friend.StatusDescription}" 
+                                                      Foreground="#888" 
+                                                      FontSize="11" 
+                                                      TextTrimming="CharacterEllipsis"
+                                                      MaxWidth="400"
+                                                      Margin="0,3,0,0"
+                                                      Visibility="{Binding Friend.StatusDescription, Converter={StaticResource EmptyStringToVisibilityConverter}, ConverterParameter=Inverse}"/>
+                                        </StackPanel>
+
+                                        <!-- Status Indicator -->
+                                        <Border Grid.Column="3"
+                                               Width="12" Height="12"
+                                               CornerRadius="6"
+                                               Background="{Binding StatusBrush}"
+                                               VerticalAlignment="Center"
+                                               ToolTip="{Binding Friend.Status}"/>
+                                    </Grid>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </ScrollViewer>
+            </Grid>
+        </Border>
+
+        <!-- Action Bar -->
+        <Border Grid.Row="3" 
+               Background="#252526" 
+               Padding="20,15"
+               Visibility="{Binding FilteredFriends.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+
+                <!-- Selection Controls -->
+                <StackPanel Grid.Column="0" Orientation="Horizontal">
+                    <Button Content="Select All" 
+                           Command="{Binding SelectAllCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"
+                           Margin="0,0,10,0"/>
+                    <Button Content="Deselect All" 
+                           Command="{Binding DeselectAllCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"/>
+                </StackPanel>
+
+                <!-- Selected Count -->
+                <TextBlock Grid.Column="1" 
+                          Text="{Binding SelectedCount, StringFormat='{}{0} selected'}"
+                          Foreground="#888"
+                          VerticalAlignment="Center"
+                          HorizontalAlignment="Center"
+                          FontSize="14"/>
+
+                <!-- Invite Button -->
+                <Button Grid.Column="2" 
+                       Content="📨 Invite Selected to Group" 
+                       Command="{Binding InviteToGroupCommand}"
+                       Style="{StaticResource MaterialDesignRaisedButton}"
+                       Background="#4CAF50"
+                       Height="40"
+                       Padding="20,0"
+                       IsEnabled="{Binding SelectedCount, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}"/>
+            </Grid>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/src/Views/FriendInviterView.xaml.cs b/src/Views/FriendInviterView.xaml.cs
new file mode 100644
index 0000000..3f29c07
--- /dev/null
+++ b/src/Views/FriendInviterView.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace VRCGroupTools.Views;
+
+public partial class FriendInviterView : UserControl
+{
+    public FriendInviterView()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/Views/GroupJoinRequestsView.xaml b/src/Views/GroupJoinRequestsView.xaml
new file mode 100644
index 0000000..e798d5d
--- /dev/null
+++ b/src/Views/GroupJoinRequestsView.xaml
@@ -0,0 +1,397 @@
+<UserControl x:Class="VRCGroupTools.Views.GroupJoinRequestsView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:viewmodels="clr-namespace:VRCGroupTools.ViewModels"
+             d:DataContext="{d:DesignInstance Type=viewmodels:GroupJoinRequestsViewModel}"
+             mc:Ignorable="d"
+             Background="Transparent"
+             d:DesignHeight="600" d:DesignWidth="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <StackPanel Grid.Row="0" Margin="0,0,0,20">
+            <TextBlock Text="📥 Group Join Requests" 
+                      FontSize="28" 
+                      FontWeight="Bold" 
+                      Foreground="White"/>
+            <TextBlock Text="View and manage pending join requests to your group" 
+                      Foreground="#888" 
+                      FontSize="14" 
+                      Margin="0,5,0,0"/>
+        </StackPanel>
+
+        <!-- Control Panel -->
+        <Border Grid.Row="1" Background="#2D2D30" CornerRadius="8" Padding="20" Margin="0,0,0,15">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+
+                <!-- Monitoring Controls -->
+                <Grid Grid.Row="0" Margin="0,0,0,15">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <StackPanel Grid.Column="0" Orientation="Horizontal">
+                        <Button Command="{Binding RefreshCommand}"
+                               Style="{StaticResource MaterialDesignRaisedButton}"
+                               Background="#7C4DFF"
+                               Height="40"
+                               Margin="0,0,10,0"
+                               Padding="15,0">
+                            <StackPanel Orientation="Horizontal">
+                                <TextBlock Text="🔄" FontSize="14" Margin="0,0,8,0"/>
+                                <TextBlock Text="Refresh" FontSize="14"/>
+                            </StackPanel>
+                        </Button>
+
+                        <Button Command="{Binding ToggleMonitoringCommand}"
+                               Height="40"
+                               Padding="15,0">
+                            <Button.Style>
+                                <Style TargetType="Button" BasedOn="{StaticResource MaterialDesignRaisedButton}">
+                                    <Setter Property="Background" Value="#4CAF50"/>
+                                    <Style.Triggers>
+                                        <DataTrigger Binding="{Binding IsMonitoring}" Value="True">
+                                            <Setter Property="Background" Value="#FF5722"/>
+                                        </DataTrigger>
+                                    </Style.Triggers>
+                                </Style>
+                            </Button.Style>
+                            <StackPanel Orientation="Horizontal">
+                                <TextBlock FontSize="14" Margin="0,0,8,0">
+                                    <TextBlock.Style>
+                                        <Style TargetType="TextBlock">
+                                            <Setter Property="Text" Value="▶️"/>
+                                            <Style.Triggers>
+                                                <DataTrigger Binding="{Binding IsMonitoring}" Value="True">
+                                                    <Setter Property="Text" Value="⏹️"/>
+                                                </DataTrigger>
+                                            </Style.Triggers>
+                                        </Style>
+                                    </TextBlock.Style>
+                                </TextBlock>
+                                <TextBlock FontSize="14">
+                                    <TextBlock.Style>
+                                        <Style TargetType="TextBlock">
+                                            <Setter Property="Text" Value="Start Monitoring"/>
+                                            <Style.Triggers>
+                                                <DataTrigger Binding="{Binding IsMonitoring}" Value="True">
+                                                    <Setter Property="Text" Value="Stop Monitoring"/>
+                                                </DataTrigger>
+                                            </Style.Triggers>
+                                        </Style>
+                                    </TextBlock.Style>
+                                </TextBlock>
+                            </StackPanel>
+                        </Button>
+                    </StackPanel>
+
+                    <Border Grid.Column="1" 
+                           Background="#7C4DFF" 
+                           CornerRadius="12" 
+                           Padding="12,6"
+                           Visibility="{Binding TotalRequests, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+                        <TextBlock Text="{Binding TotalRequests, StringFormat='{}{0} pending'}" 
+                                  Foreground="White" 
+                                  FontWeight="Bold" 
+                                  FontSize="14"/>
+                    </Border>
+                </Grid>
+
+                <!-- Filters and Settings -->
+                <Grid Grid.Row="1">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <!-- Filters -->
+                    <StackPanel Grid.Column="0" Orientation="Horizontal">
+                        <CheckBox Content="18+ Only" 
+                                 IsChecked="{Binding Only18Plus}"
+                                 Foreground="White"
+                                 Margin="0,0,20,0"/>
+                        <CheckBox Content="Auto-Accept" 
+                                 IsChecked="{Binding AutoAcceptEnabled}"
+                                 Foreground="White"
+                                 ToolTip="Automatically accept filtered requests"
+                                 IsEnabled="{Binding IsMonitoring}"/>
+                    </StackPanel>
+
+                    <!-- Interval Setting -->
+                    <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
+                        <TextBlock Text="Check every:" 
+                                  Foreground="#AAA"
+                                  VerticalAlignment="Center"
+                                  Margin="0,0,10,0"/>
+                        <TextBox Text="{Binding AutoAcceptIntervalSeconds}"
+                                Width="50"
+                                Style="{StaticResource MaterialDesignOutlinedTextBox}"
+                                VerticalAlignment="Center"
+                                Foreground="White"
+                                Margin="0,0,5,0"/>
+                        <TextBlock Text="seconds" 
+                                  Foreground="#AAA"
+                                  VerticalAlignment="Center"/>
+                    </StackPanel>
+                </Grid>
+            </Grid>
+        </Border>
+
+        <!-- Status Bar -->
+        <Border Grid.Row="2" Background="#252526" Padding="15,10" Margin="0,0,0,15" CornerRadius="8">
+            <Grid>
+                <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
+                    <TextBlock Text="📊 Status: " Foreground="#888" FontSize="13"/>
+                    <TextBlock Text="{Binding StatusMessage}" Foreground="White" FontSize="13"/>
+                </StackPanel>
+
+                <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">
+                    <Border Background="#4CAF50" 
+                           CornerRadius="8" 
+                           Padding="8,4"
+                           Visibility="{Binding IsMonitoring, Converter={StaticResource BooleanToVisibilityConverter}}"
+                           Margin="0,0,10,0">
+                        <TextBlock Text="🟢 Monitoring Active" 
+                                  Foreground="White" 
+                                  FontWeight="SemiBold" 
+                                  FontSize="11"/>
+                    </Border>
+                    
+                    <ProgressBar Style="{StaticResource MaterialDesignCircularProgressBar}"
+                                Value="0"
+                                IsIndeterminate="True"
+                                Width="20" Height="20"
+                                Foreground="#7C4DFF"
+                                Visibility="{Binding IsLoading, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+                </StackPanel>
+            </Grid>
+        </Border>
+
+        <!-- Requests List -->
+        <Border Grid.Row="3" Background="#2D2D30" CornerRadius="8" Padding="20">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="*"/>
+                </Grid.RowDefinitions>
+
+                <!-- Header -->
+                <TextBlock Grid.Row="0" 
+                          Text="Pending Requests" 
+                          FontSize="18" 
+                          FontWeight="SemiBold" 
+                          Foreground="White" 
+                          Margin="0,0,0,15"/>
+
+                <!-- Empty State -->
+                <StackPanel Grid.Row="1" 
+                           VerticalAlignment="Center" 
+                           HorizontalAlignment="Center"
+                           Visibility="{Binding FilteredJoinRequests.Count, Converter={StaticResource ZeroToVisibilityConverter}}">
+                    <TextBlock Text="✅" FontSize="48" HorizontalAlignment="Center" Margin="0,0,0,15"/>
+                    <TextBlock Text="No pending join requests" 
+                              FontSize="16" 
+                              FontWeight="SemiBold" 
+                              Foreground="White" 
+                              HorizontalAlignment="Center"
+                              Margin="0,0,0,10"/>
+                    <TextBlock Text="All caught up!" 
+                              FontSize="13" 
+                              Foreground="#888" 
+                              HorizontalAlignment="Center"/>
+                </StackPanel>
+
+                <!-- Requests List -->
+                <ScrollViewer Grid.Row="1" 
+                             VerticalScrollBarVisibility="Auto"
+                             Visibility="{Binding FilteredJoinRequests.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+                    <ItemsControl ItemsSource="{Binding FilteredJoinRequests}" Padding="5">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Border Background="#1E1E1E" 
+                                       CornerRadius="8" 
+                                       Padding="15" 
+                                       Margin="0,0,0,10">
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                        </Grid.ColumnDefinitions>
+
+                                        <!-- Selection Checkbox -->
+                                        <CheckBox Grid.Column="0" 
+                                                 IsChecked="{Binding IsSelected}"
+                                                 VerticalAlignment="Center"
+                                                 Margin="0,0,15,0"/>
+
+                                        <!-- Avatar (Clickable) -->
+                                        <Border Grid.Column="1" 
+                                               Width="60" Height="60" 
+                                               CornerRadius="30" 
+                                               Background="#2D2D30" 
+                                               ClipToBounds="True" 
+                                               VerticalAlignment="Center"
+                                               Margin="0,0,15,0"
+                                               Cursor="Hand">
+                                            <Border.InputBindings>
+                                                <MouseBinding MouseAction="LeftClick" 
+                                                            Command="{Binding DataContext.OpenUserProfileCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                            CommandParameter="{Binding Request.UserId}"/>
+                                            </Border.InputBindings>
+                                            <Image Source="{Binding Request.ProfilePicUrl}" 
+                                                  Stretch="UniformToFill"/>
+                                        </Border>
+
+                                        <!-- User Info -->
+                                        <StackPanel Grid.Column="2" VerticalAlignment="Center">
+                                            <TextBlock Foreground="White" 
+                                                      FontWeight="SemiBold" 
+                                                      FontSize="15"
+                                                      Cursor="Hand">
+                                                <Hyperlink Command="{Binding DataContext.OpenUserProfileCommand, RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                                          CommandParameter="{Binding Request.UserId}"
+                                                          TextDecorations="None">
+                                                    <Run Text="{Binding Request.DisplayName}" Foreground="White"/>
+                                                </Hyperlink>
+                                            </TextBlock>
+                                            
+                                            <StackPanel Orientation="Horizontal" Margin="0,5,0,0">
+                                                <TextBlock Text="{Binding TrustLevel}" 
+                                                          Foreground="{Binding TrustLevelBrush}"
+                                                          FontSize="11"
+                                                          Margin="0,0,10,0"/>
+                                            </StackPanel>
+                                            
+                                            <TextBlock Text="{Binding Request.UserId}" 
+                                                      Foreground="#666" 
+                                                      FontSize="10" 
+                                                      Margin="0,3,0,0"/>
+                                                      
+                                            <TextBlock Text="{Binding Request.CreatedAt, StringFormat='Requested: {0}'}" 
+                                                      Foreground="#888" 
+                                                      FontSize="10" 
+                                                      Margin="0,2,0,0"/>
+                                        </StackPanel>
+
+                                        <!-- Right Side Actions -->
+                                        <StackPanel Grid.Column="3" Orientation="Horizontal" VerticalAlignment="Center">
+                                            <!-- 18+ Badge -->
+                                            <Border Background="#D32F2F" CornerRadius="4" Padding="8,4" Margin="0,0,15,0"
+                                                    Visibility="{Binding Is18Plus, Converter={StaticResource BooleanToVisibilityConverter}}"
+                                                    ToolTip="User is 18+ Verified">
+                                                <TextBlock Text="18+" Foreground="White" FontWeight="Bold" FontSize="12"/>
+                                            </Border>
+
+                                            <!-- Processing Indicator -->
+                                            <ProgressBar Style="{StaticResource MaterialDesignCircularProgressBar}"
+                                                        Value="0"
+                                                        IsIndeterminate="True"
+                                                        Width="24" Height="24"
+                                                        Visibility="{Binding IsProcessing, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+                                        </StackPanel>
+                                    </Grid>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </ScrollViewer>
+
+                <!-- Loading Overlay -->
+                <Grid Grid.Row="1" 
+                      Background="#CC2D2D30" 
+                      Visibility="{Binding IsLoading, Converter={StaticResource BooleanToVisibilityConverter}}"
+                      Panel.ZIndex="100">
+                    <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
+                        <ProgressBar Style="{StaticResource MaterialDesignCircularProgressBar}"
+                                   Value="0"
+                                   IsIndeterminate="True"
+                                   Width="50" Height="50"
+                                   Foreground="#7C4DFF"
+                                   Margin="0,0,0,20"/>
+                        <TextBlock Text="Loading join requests..." 
+                                  Foreground="White" 
+                                  FontSize="16" 
+                                  FontWeight="SemiBold"
+                                  HorizontalAlignment="Center"/>
+                        <TextBlock Text="{Binding StatusMessage}" 
+                                  Foreground="#AAA" 
+                                  FontSize="13" 
+                                  Margin="0,5,0,0"
+                                  HorizontalAlignment="Center"/>
+                    </StackPanel>
+                </Grid>
+            </Grid>
+        </Border>
+
+        <!-- Action Bar -->
+        <Border Grid.Row="4" 
+               Background="#252526" 
+               Padding="20,15"
+               Visibility="{Binding FilteredJoinRequests.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+
+                <!-- Selection Controls -->
+                <StackPanel Grid.Column="0" Orientation="Horizontal">
+                    <Button Content="Select All" 
+                           Command="{Binding SelectAllCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"
+                           Margin="0,0,10,0"/>
+                    <Button Content="Deselect All" 
+                           Command="{Binding DeselectAllCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"/>
+                </StackPanel>
+
+                <!-- Selected Count -->
+                <TextBlock Grid.Column="1" 
+                          Text="{Binding SelectedCount, StringFormat='{}{0} selected'}"
+                          Foreground="#888"
+                          VerticalAlignment="Center"
+                          HorizontalAlignment="Center"
+                          FontSize="14"/>
+
+                <!-- Action Buttons -->
+                <StackPanel Grid.Column="2" Orientation="Horizontal">
+                    <Button Content="✅ Approve Selected" 
+                           Command="{Binding ApproveSelectedCommand}"
+                           Style="{StaticResource MaterialDesignRaisedButton}"
+                           Background="#4CAF50"
+                           Height="40"
+                           Padding="20,0"
+                           Margin="0,0,10,0"
+                           IsEnabled="{Binding SelectedCount, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}"/>
+                    <Button Content="❌ Reject Selected" 
+                           Command="{Binding RejectSelectedCommand}"
+                           Style="{StaticResource MaterialDesignRaisedButton}"
+                           Background="#F44336"
+                           Height="40"
+                           Padding="20,0"
+                           IsEnabled="{Binding SelectedCount, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}"/>
+                </StackPanel>
+            </Grid>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/src/Views/GroupJoinRequestsView.xaml.cs b/src/Views/GroupJoinRequestsView.xaml.cs
new file mode 100644
index 0000000..9f849ea
--- /dev/null
+++ b/src/Views/GroupJoinRequestsView.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace VRCGroupTools.Views;
+
+public partial class GroupJoinRequestsView : UserControl
+{
+    public GroupJoinRequestsView()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/Views/InstanceInviterView.xaml b/src/Views/InstanceInviterView.xaml
new file mode 100644
index 0000000..5643516
--- /dev/null
+++ b/src/Views/InstanceInviterView.xaml
@@ -0,0 +1,282 @@
+<UserControl x:Class="VRCGroupTools.Views.InstanceInviterView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:viewmodels="clr-namespace:VRCGroupTools.ViewModels"
+             d:DataContext="{d:DesignInstance Type=viewmodels:InstanceInviterViewModel}"
+             mc:Ignorable="d"
+             Background="Transparent"
+             d:DesignHeight="600" d:DesignWidth="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <StackPanel Grid.Row="0" Margin="0,0,0,20">
+            <TextBlock Text="💌 Instance Inviter" 
+                      FontSize="28" 
+                      FontWeight="Bold" 
+                      Foreground="White"/>
+            <TextBlock Text="Invite users from your current VRChat instance to your group" 
+                      Foreground="#888" 
+                      FontSize="14" 
+                      Margin="0,5,0,0"/>
+        </StackPanel>
+
+        <!-- Current Instance Info -->
+        <Border Grid.Row="1" Background="#2D2D30" CornerRadius="8" Padding="20" Margin="0,0,0,15">
+            <StackPanel>
+                <TextBlock Text="📍 Current Instance" 
+                          FontSize="18"
+                          FontWeight="SemiBold"
+                          Foreground="White"
+                          Margin="0,0,0,15"/>
+                
+                <StackPanel Orientation="Horizontal" Margin="0,0,0,15">
+                    <TextBlock Text="🌍 " 
+                              FontSize="16"
+                              VerticalAlignment="Center"/>
+                    <TextBlock Text="{Binding CurrentInstanceDisplay}" 
+                              FontSize="14"
+                              Foreground="White"
+                              VerticalAlignment="Center"/>
+                </StackPanel>
+                
+                <Button Content="🔄 Refresh Instance Detection" 
+                       Command="{Binding RefreshCommand}"
+                       Style="{StaticResource MaterialDesignRaisedButton}"
+                       Background="#7C4DFF"
+                       Width="260"
+                       HorizontalAlignment="Left"/>
+            </StackPanel>
+        </Border>
+
+        <!-- Filters -->
+        <Border Grid.Row="2" Background="#2D2D30" CornerRadius="8" Padding="20" Margin="0,0,0,15">
+            <StackPanel>
+                <TextBlock Text="⚙️ Filters" 
+                          FontSize="16"
+                          FontWeight="SemiBold"
+                          Foreground="White"
+                          Margin="0,0,0,15"/>
+                
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <!-- Filter Checkboxes -->
+                    <WrapPanel Grid.Column="0" Orientation="Horizontal">
+                        <CheckBox Content="18+ Only" 
+                                 IsChecked="{Binding Only18Plus}"
+                                 Foreground="White"
+                                 Margin="0,0,20,10"/>
+                        <CheckBox Content="Skip Visitors" 
+                                 IsChecked="{Binding SkipVisitors}"
+                                 Foreground="White"
+                                 Margin="0,0,20,10"/>
+                        <CheckBox Content="Skip New Users" 
+                                 IsChecked="{Binding SkipNewUsers}"
+                                 Foreground="White"
+                                 Margin="0,0,20,10"/>
+                        <CheckBox Content="Skip Users" 
+                                 IsChecked="{Binding SkipUsers}"
+                                 Foreground="White"
+                                 Margin="0,0,20,10"/>
+                        <CheckBox Content="Skip Known" 
+                                 IsChecked="{Binding SkipKnown}"
+                                 Foreground="White"
+                                 Margin="0,0,20,10"/>
+                    </WrapPanel>
+
+                    <!-- Auto Invite Toggle -->
+                    <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Center">
+                        <TextBlock Text="🤖 Auto Invite:" 
+                                  Foreground="White"
+                                  VerticalAlignment="Center"
+                                  Margin="0,0,10,0"/>
+                        <ToggleButton IsChecked="{Binding AutoInviteEnabled}"
+                                     Style="{StaticResource MaterialDesignSwitchToggleButton}"
+                                     ToolTip="Automatically invite new instance users that pass filters"/>
+                    </StackPanel>
+                </Grid>
+            </StackPanel>
+        </Border>
+
+        <!-- Instance Users List -->
+        <Border Grid.Row="3" Background="#2D2D30" CornerRadius="8" Padding="20">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="*"/>
+                </Grid.RowDefinitions>
+
+                <!-- Header -->
+                <Grid Grid.Row="0" Margin="0,0,0,15">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    
+                    <TextBlock Grid.Column="0" 
+                              Text="👥" 
+                              FontSize="18" 
+                              VerticalAlignment="Center" 
+                              Margin="0,0,10,0"/>
+                    <TextBlock Grid.Column="1" 
+                              Text="Users in Instance" 
+                              FontSize="18" 
+                              FontWeight="SemiBold" 
+                              Foreground="White" 
+                              VerticalAlignment="Center"/>
+                    <Border Grid.Column="2" 
+                           Background="#7C4DFF" 
+                           CornerRadius="12" 
+                           Padding="8,4"
+                           Visibility="{Binding FilteredInstanceUsers.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+                        <TextBlock Text="{Binding FilteredInstanceUsers.Count}" 
+                                  Foreground="White" 
+                                  FontWeight="Bold" 
+                                  FontSize="12"/>
+                    </Border>
+                </Grid>
+
+                <!-- Empty State -->
+                <StackPanel Grid.Row="1" 
+                           VerticalAlignment="Center" 
+                           HorizontalAlignment="Center"
+                           Visibility="{Binding FilteredInstanceUsers.Count, Converter={StaticResource ZeroToVisibilityConverter}}">
+                    <TextBlock Text="⚠️" FontSize="48" HorizontalAlignment="Center" Margin="0,0,0,15"/>
+                    <TextBlock Text="No users detected in this instance" 
+                              FontSize="16" 
+                              FontWeight="SemiBold" 
+                              Foreground="White" 
+                              HorizontalAlignment="Center"
+                              Margin="0,0,0,10"/>
+                    <TextBlock Text="Try refreshing instance detection or adjust your filters" 
+                              FontSize="13" 
+                              Foreground="#888" 
+                              HorizontalAlignment="Center"/>
+                </StackPanel>
+
+                <!-- Users List -->
+                <ScrollViewer Grid.Row="1" 
+                             VerticalScrollBarVisibility="Auto"
+                             Visibility="{Binding FilteredInstanceUsers.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+                    <ItemsControl ItemsSource="{Binding FilteredInstanceUsers}" Padding="5">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Border Background="#1E1E1E" 
+                                       CornerRadius="8" 
+                                       Padding="15" 
+                                       Margin="0,0,0,10">
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="Auto"/>
+                                        </Grid.ColumnDefinitions>
+
+                                        <!-- Selection Checkbox -->
+                                        <CheckBox Grid.Column="0" 
+                                                 IsChecked="{Binding IsSelected}"
+                                                 VerticalAlignment="Center"
+                                                 Margin="0,0,15,0"/>
+
+                                        <!-- Avatar -->
+                                        <Border Grid.Column="1" 
+                                               Width="50" Height="50" 
+                                               CornerRadius="25" 
+                                               Background="#2D2D30" 
+                                               ClipToBounds="True" 
+                                               VerticalAlignment="Center"
+                                               Margin="0,0,15,0">
+                                            <Image Source="{Binding User.ProfilePicUrl}" 
+                                                  Stretch="UniformToFill"/>
+                                        </Border>
+
+                                        <!-- User Info -->
+                                        <StackPanel Grid.Column="2" VerticalAlignment="Center">
+                                            <TextBlock Text="{Binding User.DisplayName}" 
+                                                      Foreground="White" 
+                                                      FontWeight="SemiBold" 
+                                                      FontSize="15"/>
+                                            <StackPanel Orientation="Horizontal" Margin="0,3,0,0">
+                                                <TextBlock Text="{Binding TrustLevel}" 
+                                                          Foreground="{Binding TrustLevelBrush}"
+                                                          FontSize="11"
+                                                          Margin="0,0,10,0"/>
+                                                <TextBlock Text="🔞" 
+                                                          FontSize="11"
+                                                          Visibility="{Binding User.IsAgeVerified, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+                                            </StackPanel>
+                                            <TextBlock Text="{Binding User.UserId}" 
+                                                      Foreground="#666" 
+                                                      FontSize="10" 
+                                                      Margin="0,3,0,0"/>
+                                        </StackPanel>
+                                    </Grid>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </ScrollViewer>
+            </Grid>
+        </Border>
+
+        <!-- Action Bar -->
+        <Border Grid.Row="4" 
+               Background="#252526" 
+               Padding="20,15"
+               Visibility="{Binding FilteredInstanceUsers.Count, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+
+                <!-- Selection Controls -->
+                <StackPanel Grid.Column="0" Orientation="Horizontal">
+                    <Button Content="Select All" 
+                           Command="{Binding SelectAllInstanceUsersCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"
+                           Margin="0,0,10,0"/>
+                    <Button Content="Deselect All" 
+                           Command="{Binding DeselectAllInstanceUsersCommand}"
+                           Style="{StaticResource MaterialDesignFlatButton}"
+                           Foreground="#7C4DFF"/>
+                </StackPanel>
+
+                <!-- Selected Count -->
+                <TextBlock Grid.Column="1" 
+                          Text="{Binding InstanceUserSelectedCount, StringFormat='{}{0} selected'}"
+                          Foreground="#888"
+                          VerticalAlignment="Center"
+                          HorizontalAlignment="Center"
+                          FontSize="14"/>
+
+                <!-- Invite Button -->
+                <Button Grid.Column="2" 
+                       Content="📨 Invite Selected to Group" 
+                       Command="{Binding InviteInstanceUsersCommand}"
+                       Style="{StaticResource MaterialDesignRaisedButton}"
+                       Background="#4CAF50"
+                       Height="40"
+                       Padding="20,0"
+                       IsEnabled="{Binding InstanceUserSelectedCount, Converter={StaticResource ZeroToVisibilityConverter}, ConverterParameter=Inverse}"/>
+            </Grid>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/src/Views/InstanceInviterView.xaml.cs b/src/Views/InstanceInviterView.xaml.cs
new file mode 100644
index 0000000..322bb05
--- /dev/null
+++ b/src/Views/InstanceInviterView.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace VRCGroupTools.Views;
+
+public partial class InstanceInviterView : UserControl
+{
+    public InstanceInviterView()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/Views/InviterHubView.xaml b/src/Views/InviterHubView.xaml
new file mode 100644
index 0000000..dfcf1b7
--- /dev/null
+++ b/src/Views/InviterHubView.xaml
@@ -0,0 +1,158 @@
+<UserControl x:Class="VRCGroupTools.Views.InviterHubView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:viewmodels="clr-namespace:VRCGroupTools.ViewModels"
+             xmlns:views="clr-namespace:VRCGroupTools.Views"
+             d:DataContext="{d:DesignInstance Type=viewmodels:InviterHubViewModel}"
+             mc:Ignorable="d"
+             Background="Transparent"
+             d:DesignHeight="600" d:DesignWidth="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <!-- Header with Mode Selection -->
+        <Border Grid.Row="0" Background="#1E1E1E" CornerRadius="8" Padding="20" Margin="0,0,0,20">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+
+                <!-- Title -->
+                <StackPanel Grid.Row="0" Margin="0,0,0,20">
+                    <TextBlock Text="📬 Inviter Hub" 
+                              FontSize="28" 
+                              FontWeight="Bold" 
+                              Foreground="White"/>
+                    <TextBlock Text="Invite users to groups, instances, or connect with friends" 
+                              Foreground="#888" 
+                              FontSize="14" 
+                              Margin="0,5,0,0"/>
+                </StackPanel>
+
+                <!-- Mode Selection Buttons -->
+                <Grid Grid.Row="1">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="*"/>
+                    </Grid.ColumnDefinitions>
+
+                    <Button Grid.Column="0" 
+                           Command="{Binding SelectModeCommand}"
+                           CommandParameter="GroupInviter"
+                           Margin="0,0,10,0"
+                           Height="60">
+                        <Button.Style>
+                            <Style TargetType="Button" BasedOn="{StaticResource MaterialDesignRaisedButton}">
+                                <Setter Property="Background" Value="#424242"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding SelectedMode}" Value="GroupInviter">
+                                        <Setter Property="Background" Value="#7C4DFF"/>
+                                    </DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </Button.Style>
+                        <StackPanel Orientation="Vertical">
+                            <TextBlock Text="📨" FontSize="20" HorizontalAlignment="Center"/>
+                            <TextBlock Text="Group Inviter" 
+                                      FontSize="13" 
+                                      FontWeight="SemiBold"
+                                      HorizontalAlignment="Center"
+                                      Margin="0,4,0,0"/>
+                        </StackPanel>
+                    </Button>
+
+                    <Button Grid.Column="1" 
+                           Command="{Binding SelectModeCommand}"
+                           CommandParameter="InstanceInviter"
+                           Margin="5,0"
+                           Height="60">
+                        <Button.Style>
+                            <Style TargetType="Button" BasedOn="{StaticResource MaterialDesignRaisedButton}">
+                                <Setter Property="Background" Value="#424242"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding SelectedMode}" Value="InstanceInviter">
+                                        <Setter Property="Background" Value="#7C4DFF"/>
+                                    </DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </Button.Style>
+                        <StackPanel Orientation="Vertical">
+                            <TextBlock Text="💌" FontSize="20" HorizontalAlignment="Center"/>
+                            <TextBlock Text="Instance Inviter" 
+                                      FontSize="13" 
+                                      FontWeight="SemiBold"
+                                      HorizontalAlignment="Center"
+                                      Margin="0,4,0,0"/>
+                        </StackPanel>
+                    </Button>
+
+                    <Button Grid.Column="2" 
+                           Command="{Binding SelectModeCommand}"
+                           CommandParameter="FriendInviter"
+                           Margin="10,0,0,0"
+                           Height="60">
+                        <Button.Style>
+                            <Style TargetType="Button" BasedOn="{StaticResource MaterialDesignRaisedButton}">
+                                <Setter Property="Background" Value="#424242"/>
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding SelectedMode}" Value="FriendInviter">
+                                        <Setter Property="Background" Value="#7C4DFF"/>
+                                    </DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </Button.Style>
+                        <StackPanel Orientation="Vertical">
+                            <TextBlock Text="👥" FontSize="20" HorizontalAlignment="Center"/>
+                            <TextBlock Text="Friend Manager" 
+                                      FontSize="13" 
+                                      FontWeight="SemiBold"
+                                      HorizontalAlignment="Center"
+                                      Margin="0,4,0,0"/>
+                        </StackPanel>
+                    </Button>
+                </Grid>
+            </Grid>
+        </Border>
+
+        <!-- Content Area -->
+        <Border Grid.Row="1" Background="Transparent">
+            <ContentControl>
+                <ContentControl.Resources>
+                    <DataTemplate DataType="{x:Type viewmodels:InviteToGroupViewModel}">
+                        <views:InviteToGroupView/>
+                    </DataTemplate>
+                    <DataTemplate DataType="{x:Type viewmodels:InstanceInviterViewModel}">
+                        <views:InstanceInviterView/>
+                    </DataTemplate>
+                    <DataTemplate DataType="{x:Type viewmodels:FriendInviterViewModel}">
+                        <views:FriendInviterView/>
+                    </DataTemplate>
+                </ContentControl.Resources>
+                <ContentControl.Style>
+                    <Style TargetType="ContentControl">
+                        <Setter Property="Content" Value="{Binding InviteToGroupVM}"/>
+                        <Style.Triggers>
+                            <DataTrigger Binding="{Binding SelectedMode}" Value="GroupInviter">
+                                <Setter Property="Content" Value="{Binding InviteToGroupVM}"/>
+                            </DataTrigger>
+                            <DataTrigger Binding="{Binding SelectedMode}" Value="InstanceInviter">
+                                <Setter Property="Content" Value="{Binding InstanceInviterVM}"/>
+                            </DataTrigger>
+                            <DataTrigger Binding="{Binding SelectedMode}" Value="FriendInviter">
+                                <Setter Property="Content" Value="{Binding FriendInviterVM}"/>
+                            </DataTrigger>
+                        </Style.Triggers>
+                    </Style>
+                </ContentControl.Style>
+            </ContentControl>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/src/Views/InviterHubView.xaml.cs b/src/Views/InviterHubView.xaml.cs
new file mode 100644
index 0000000..cb4c7f9
--- /dev/null
+++ b/src/Views/InviterHubView.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace VRCGroupTools.Views;
+
+public partial class InviterHubView : UserControl
+{
+    public InviterHubView()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/Views/MainWindow.xaml b/src/Views/MainWindow.xaml
index 1fcbd92..097e46f 100644
--- a/src/Views/MainWindow.xaml
+++ b/src/Views/MainWindow.xaml
@@ -170,15 +170,22 @@
                                         Height="40"
                                         Margin="0,0,0,5"
                                         Style="{StaticResource MaterialDesignFlatButton}"
-                                        Foreground="White"/>
-                                    <Button Content="📨  Invite To Group"
+                                        Foreground="White"/>                                    <Button Content="📥  Join Requests"
                                         Command="{Binding SelectModuleCommand}"
-                                        CommandParameter="InviteToGroup"
+                                        CommandParameter="GroupJoinRequests"
                                         HorizontalContentAlignment="Left"
                                         Height="40"
                                         Margin="0,0,0,5"
                                         Style="{StaticResource MaterialDesignFlatButton}"
-                                        Foreground="White"/>
+                                        Foreground="White"/>                                    <Button Content="�  Inviter Hub"
+                                        Command="{Binding SelectModuleCommand}"
+                                        CommandParameter="InviterHub"
+                                        HorizontalContentAlignment="Left"
+                                        Height="40"
+                                        Margin="0,0,0,5"
+                                        Style="{StaticResource MaterialDesignFlatButton}"
+                                        Foreground="#7C4DFF"
+                                        FontWeight="SemiBold"/>
                                     <Button Content="🔍  18+ Badge Scanner"
                                         Command="{Binding SelectModuleCommand}"
                                         CommandParameter="BadgeScanner"
@@ -306,8 +313,11 @@
                             <DataTemplate x:Key="GroupPosts">
                                 <views:GroupPostsView DataContext="{Binding GroupPostsVM}"/>
                             </DataTemplate>
-                            <DataTemplate x:Key="InviteToGroup">
-                                <views:InviteToGroupView DataContext="{Binding InviteToGroupVM}"/>
+                            <DataTemplate x:Key="GroupJoinRequests">
+                                <views:GroupJoinRequestsView DataContext="{Binding GroupJoinRequestsVM}"/>
+                            </DataTemplate>
+                            <DataTemplate x:Key="InviterHub">
+                                <views:InviterHubView DataContext="{Binding InviterHubVM}"/>
                             </DataTemplate>
                             <DataTemplate x:Key="BadgeScanner">
                                 <views:BadgeScannerView DataContext="{Binding BadgeScannerVM}"/>
@@ -357,8 +367,11 @@
                                     <DataTrigger Binding="{Binding CurrentModule}" Value="GroupPosts">
                                         <Setter Property="ContentTemplate" Value="{StaticResource GroupPosts}"/>
                                     </DataTrigger>
-                                    <DataTrigger Binding="{Binding CurrentModule}" Value="InviteToGroup">
-                                        <Setter Property="ContentTemplate" Value="{StaticResource InviteToGroup}"/>
+                                    <DataTrigger Binding="{Binding CurrentModule}" Value="GroupJoinRequests">
+                                        <Setter Property="ContentTemplate" Value="{StaticResource GroupJoinRequests}"/>
+                                    </DataTrigger>
+                                    <DataTrigger Binding="{Binding CurrentModule}" Value="InviterHub">
+                                        <Setter Property="ContentTemplate" Value="{StaticResource InviterHub}"/>
                                     </DataTrigger>
                                     <DataTrigger Binding="{Binding CurrentModule}" Value="BadgeScanner">
                                         <Setter Property="ContentTemplate" Value="{StaticResource BadgeScanner}"/>
diff --git a/src/Views/MembersListView.xaml b/src/Views/MembersListView.xaml
index cfc3d93..7d2feae 100644
--- a/src/Views/MembersListView.xaml
+++ b/src/Views/MembersListView.xaml
@@ -139,6 +139,14 @@
                                        FontSize="10"
                                        HorizontalAlignment="Center"
                                        Margin="0,5,0,0"/>
+
+                            <Button Content="View Full Profile"
+                                    Command="{Binding ViewFullProfileCommand}"
+                                    Style="{StaticResource MaterialDesignOutlinedButton}"
+                                    Height="30"
+                                    Margin="0,10,0,0"
+                                    Foreground="#2196F3"
+                                    BorderBrush="#2196F3"/>
                             
                             <!-- Joined Date -->
                             <Border Background="#1E1E1E" CornerRadius="8" Padding="12" Margin="0,15,0,0">
diff --git a/src/Views/UserProfileWindow.xaml b/src/Views/UserProfileWindow.xaml
new file mode 100644
index 0000000..dd32bfd
--- /dev/null
+++ b/src/Views/UserProfileWindow.xaml
@@ -0,0 +1,93 @@
+<Window x:Class="VRCGroupTools.Views.UserProfileWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:vm="clr-namespace:VRCGroupTools.ViewModels"
+        xmlns:converters="clr-namespace:VRCGroupTools.Converters"
+        mc:Ignorable="d"
+        Title="User Profile" Height="450" Width="400"
+        WindowStartupLocation="CenterScreen"
+        ResizeMode="NoResize"
+        Background="#1E1E1E">
+    
+    <Window.Resources>
+        <converters:BoolToVisibilityConverter x:Key="BoolToVis"/>
+        <converters:InverseBoolToVisConverter x:Key="InverseBoolToVis"/>
+    </Window.Resources>
+
+    <Grid>
+        <!-- Loading State -->
+        <Grid Visibility="{Binding IsLoading, Converter={StaticResource BoolToVis}}" 
+              Panel.ZIndex="10" 
+              Background="#80000000">
+            <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
+                <TextBlock Text="Loading..." Foreground="White" FontSize="16"/>
+            </StackPanel>
+        </Grid>
+
+        <Border Padding="20">
+            <StackPanel>
+                <!-- Header: Profile Pic & Name -->
+                <Grid Margin="0,0,0,20">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="*"/>
+                    </Grid.ColumnDefinitions>
+
+                    <Border Grid.Column="0" Width="80" Height="80" CornerRadius="40" ClipToBounds="True" BorderBrush="White" BorderThickness="2" Margin="0,0,15,0">
+                         <Border.Background>
+                             <ImageBrush ImageSource="{Binding User.ProfilePicUrl}" Stretch="UniformToFill"/>
+                         </Border.Background>
+                    </Border>
+
+                    <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                        <TextBlock Text="{Binding User.DisplayName}" 
+                                   Foreground="White" 
+                                   FontSize="24" 
+                                   FontWeight="Bold"
+                                   TextTrimming="CharacterEllipsis"/>
+                        
+                        <Border Background="{Binding TrustRankBrush}" 
+                                Padding="8,2" 
+                                HorizontalAlignment="Left" 
+                                CornerRadius="4" 
+                                Margin="0,5,0,0">
+                            <TextBlock Text="{Binding TrustRank}" 
+                                       Foreground="White" 
+                                       FontSize="12" 
+                                       FontWeight="Bold"/>
+                        </Border>
+                    </StackPanel>
+                </Grid>
+
+                <!-- 18+ Status -->
+                <Border Background="#2D2D2D" CornerRadius="5" Padding="10" Margin="0,0,0,10">
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock Text="Age Verified:" Foreground="#AAAAAA" Width="100"/>
+                        <TextBlock Text="Yes (18+)" Foreground="#2ECC71" FontWeight="Bold" 
+                                   Visibility="{Binding User.IsAgeVerified, Converter={StaticResource BoolToVis}}"/>
+                         <TextBlock Text="No" Foreground="White" 
+                                   Visibility="{Binding User.IsAgeVerified, Converter={StaticResource InverseBoolToVis}}"/>
+                    </StackPanel>
+                </Border>
+
+                <!-- Bio -->
+                <TextBlock Text="Bio" Foreground="#AAAAAA" Margin="0,0,0,5"/>
+                <Border Background="#2D2D2D" CornerRadius="5" Padding="10" Height="100">
+                    <ScrollViewer>
+                        <TextBlock Text="{Binding User.Bio}" Foreground="White" TextWrapping="Wrap"/>
+                    </ScrollViewer>
+                </Border>
+
+                <!-- Buttons -->
+                <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,20,0,0">
+                    <Button Content="Open Web Profile" 
+                            Command="{Binding OpenWebProfileCommand}"
+                            Background="#34495E" Foreground="White"
+                            Padding="15,8" Margin="0,0,10,0" BorderThickness="0"/>
+                </StackPanel>
+            </StackPanel>
+        </Border>
+    </Grid>
+</Window>
\ No newline at end of file
diff --git a/src/Views/UserProfileWindow.xaml.cs b/src/Views/UserProfileWindow.xaml.cs
new file mode 100644
index 0000000..ea8eaf1
--- /dev/null
+++ b/src/Views/UserProfileWindow.xaml.cs
@@ -0,0 +1,13 @@
+using System.Windows;
+using VRCGroupTools.ViewModels;
+
+namespace VRCGroupTools.Views;
+
+public partial class UserProfileWindow : Window
+{
+    public UserProfileWindow(UserProfileViewModel viewModel)
+    {
+        InitializeComponent();
+        DataContext = viewModel;
+    }
+}

From ff59203f65119cd3d12224337dca121bc964ed6c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 24 Jan 2026 16:21:42 +0000
Subject: [PATCH 2/2] Bump actions/checkout from 4 to 6

Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 6.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v6)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ce20052..0d5cd87 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -21,7 +21,7 @@ jobs:
     
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
@@ -54,7 +54,7 @@ jobs:
     
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup .NET
       uses: actions/setup-dotnet@v4