Raise habit ceiling to abuse guard

architecture.json

@@ -2720,7 +2720,7 @@
       "Challenges": 15,
       "Chat": 80,
       "ChecklistTemplates": 5,
-      "Common": 35,
+      "Common": 36,
       "Gamification": 31,
       "Goals": 35,
       "Habits": 74,
@@ -2929,7 +2929,7 @@
       "Challenges": 14,
       "Chat": 61,
       "ChecklistTemplates": 9,
-      "Common": 178,
+      "Common": 182,
       "Gamification": 38,
       "Goals": 54,
       "Habits": 86,
@@ -4823,6 +4823,13 @@
         "file": "tests/Orbit.Application.Tests/Common/ErrorCodesAndMessagesTests.cs",
         "references": []
       },
+      {
+        "testClass": "HabitCeilingLockTests",
+        "file": "tests/Orbit.Application.Tests/Common/HabitCeilingLockTests.cs",
+        "references": [
+          "Habit"
+        ]
+      },
       {
         "testClass": "LocaleHelperTests",
         "file": "tests/Orbit.Application.Tests/Common/LocaleHelperTests.cs",

src/Orbit.Application/Chat/Content/FeatureExplanations/paygate.md

@@ -13,11 +13,11 @@ derived_from:
 
 # Free vs Pro
 
-Orbit has a free plan and a Pro plan. The free plan is fully usable for daily habit tracking; Pro raises the limits and unlocks the advanced features.
+Orbit has a free plan and a Pro plan. The free plan is fully usable for daily habit tracking; Pro raises the AI message limit and unlocks advanced features.
 
 ## Limits on the free plan
 
-- **Habits** are capped at **10** top-level habits. Sub-habits, completed habits, and soft-deleted habits don't count toward the cap. Pro removes the cap.
+- **Habits** have an abuse guard of **1000** live top-level habits on both the free and Pro plans. Sub-habits, completed habits, and soft-deleted habits don't count toward the guard.
 - **AI messages** are capped at **20** per month. Pro raises this to **500** per month.
 
 Both plans can also earn a small bonus of extra AI messages from ad rewards, added on top of the plan limit.

src/Orbit.Application/Chat/Tools/Implementations/CreateHabitTool.cs

@@ -1,6 +1,7 @@
 using System.Text.Json;
 using Orbit.Application.Chat.Models;
 using Orbit.Application.Chat.Tools;
+using Orbit.Application.Common;
 using Orbit.Domain.Entities;
 using Orbit.Domain.Enums;
 using Orbit.Domain.Interfaces;
@@ -149,6 +150,19 @@ public async Task<ToolResult> ExecuteAsync(JsonElement args, Guid userId, Cancel
 
         var title = titleEl.GetString() ?? string.Empty;
 
+        return await HabitCeilingLock.ExecuteAsync(
+            unitOfWork,
+            userId,
+            transactionToken => ExecuteLockedAsync(args, userId, title, transactionToken),
+            ct);
+    }
+
+    private async Task<ToolResult> ExecuteLockedAsync(
+        JsonElement args,
+        Guid userId,
+        string title,
+        CancellationToken ct)
+    {
         var habitGate = await payGate.CanCreateHabits(userId, 1, ct);
         if (habitGate.IsFailure)
             return ToolResult.FromFailure(habitGate);

src/Orbit.Application/Common/AppConstants.cs

@@ -17,7 +17,7 @@ public static class AppConstants
     public const int HabitLogsLookbackDays = 365;
     public const int MaxHabitLogsReturned = 1000;
     public const int DefaultReminderMinutes = 15;
-    public const int DefaultFreeMaxHabits = 10;
+    public const int DefaultFreeMaxHabits = 1000;
     public const int DefaultFreeAiMessages = 20;
     public const int DefaultProAiMessages = 500;
     public const int MaxBulkOperationSize = 100;

src/Orbit.Application/Common/HabitCeilingLock.cs

@@ -0,0 +1,25 @@
+using Orbit.Domain.Interfaces;
+
+namespace Orbit.Application.Common;
+
+internal static class HabitCeilingLock
+{
+    public static string ForUser(Guid userId) => $"habit-ceiling:{userId}";
+
+    public static Task AcquireAsync(
+        IUnitOfWork unitOfWork,
+        Guid userId,
+        CancellationToken cancellationToken) =>
+        unitOfWork.AcquireAdvisoryLockAsync(ForUser(userId), cancellationToken);
+
+    public static Task<T> ExecuteAsync<T>(
+        IUnitOfWork unitOfWork,
+        Guid userId,
+        Func<CancellationToken, Task<T>> operation,
+        CancellationToken cancellationToken) =>
+        unitOfWork.ExecuteInTransactionAsync(async transactionToken =>
+        {
+            await AcquireAsync(unitOfWork, userId, transactionToken);
+            return await operation(transactionToken);
+        }, cancellationToken);
+}

src/Orbit.Application/Common/PayGateService.cs

@@ -16,15 +16,12 @@ public async Task<Result> CanCreateHabits(Guid userId, int count = 1, Cancellati
         if (user is null)
             return Result.Failure(ErrorMessages.UserNotFound);
 
-        if (user.HasProAccess)
-            return Result.Success();
-
         var maxHabits = await appConfig.GetAsync(AppConfigKeys.FreeMaxHabits, AppConstants.DefaultFreeMaxHabits, ct);
         var activeHabitCount = await habitRepository.CountAsync(
             h => h.UserId == userId && h.ParentHabitId == null && !h.IsCompleted, ct);
 
         if (activeHabitCount + count > maxHabits)
-            return Result.PayGateFailure($"You've reached the {maxHabits} habit limit on the free plan. Upgrade to Pro for unlimited habits.");
+            return Result.Failure($"You've reached the {maxHabits} habit limit.");
 
         return Result.Success();
     }

src/Orbit.Application/Habits/Commands/BulkCreateHabitsCommand.cs

@@ -66,6 +66,24 @@ public partial class BulkCreateHabitsCommandHandler(
     private const string DefaultTagColor = "#7c3aed";
 
     public async Task<Result<BulkCreateResult>> Handle(BulkCreateHabitsCommand request, CancellationToken cancellationToken)
+    {
+        var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
+        var result = await HabitCeilingLock.ExecuteAsync(
+            unitOfWork,
+            request.UserId,
+            ct => HandleLockedAsync(request, userToday, ct),
+            cancellationToken);
+
+        if (result.IsSuccess)
+            CacheInvalidationHelper.InvalidateUserAiCaches(cache, request.UserId, userToday);
+
+        return result;
+    }
+
+    private async Task<Result<BulkCreateResult>> HandleLockedAsync(
+        BulkCreateHabitsCommand request,
+        DateOnly userToday,
+        CancellationToken cancellationToken)
     {
         var parentCount = request.Habits.Count;
         var habitGate = await payGate.CanCreateHabits(request.UserId, parentCount, cancellationToken);
@@ -80,7 +98,6 @@ public async Task<Result<BulkCreateResult>> Handle(BulkCreateHabitsCommand reque
                 return subGate.PropagateError<BulkCreateResult>();
         }
 
-        var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         var results = new List<BulkCreateItemResult>();
 
         var existingRoots = await repos.Habits.FindAsync(
@@ -92,25 +109,26 @@ public async Task<Result<BulkCreateResult>> Handle(BulkCreateHabitsCommand reque
 
         var tagsByName = await LoadTagCacheAsync(request, cancellationToken);
 
-        await unitOfWork.ExecuteInTransactionAsync(async ct =>
+        for (int i = 0; i < request.Habits.Count; i++)
         {
-            for (int i = 0; i < request.Habits.Count; i++)
-            {
-                var itemResult = await CreateSingleHabit(
-                    request.UserId, request.Habits[i], i, userToday, rootPositionCursor + i, tagsByName, ct);
-                results.Add(itemResult);
-            }
-
-            await unitOfWork.SaveChangesAsync(ct);
+            var itemResult = await CreateSingleHabit(
+                request.UserId,
+                request.Habits[i],
+                i,
+                userToday,
+                rootPositionCursor + i,
+                tagsByName,
+                cancellationToken);
+            results.Add(itemResult);
+        }
 
-            if (request.FromSyncReview)
-            {
-                await MarkSyncSuggestionsImported(request.UserId, results, ct);
-                await unitOfWork.SaveChangesAsync(ct);
-            }
-        }, cancellationToken);
+        await unitOfWork.SaveChangesAsync(cancellationToken);
 
-        CacheInvalidationHelper.InvalidateUserAiCaches(cache, request.UserId, userToday);
+        if (request.FromSyncReview)
+        {
+            await MarkSyncSuggestionsImported(request.UserId, results, cancellationToken);
+            await unitOfWork.SaveChangesAsync(cancellationToken);
+        }
 
         return Result.Success(new BulkCreateResult(results));
     }

src/Orbit.Application/Habits/Commands/CreateHabitCommand.cs

@@ -34,7 +34,7 @@
     IGenericRepository<Tag> TagRepository,
     IGenericRepository<Goal> GoalRepository);
 
 public partial class CreateHabitCommandHandler(
     CreateHabitRepositories repos,
     IUserDateService userDateService,
     IPayGateService payGate,
@@ -44,7 +44,16 @@
     IMemoryCache cache,
     ILogger<CreateHabitCommandHandler> logger) : IRequestHandler<CreateHabitCommand, Result<Guid>>
 {
-    public async Task<Result<Guid>> Handle(CreateHabitCommand request, CancellationToken cancellationToken)
+    public Task<Result<Guid>> Handle(CreateHabitCommand request, CancellationToken cancellationToken) =>
+        HabitCeilingLock.ExecuteAsync(
+            unitOfWork,
+            request.UserId,
+            ct => HandleLockedAsync(request, ct),
+            cancellationToken);
+
+    private async Task<Result<Guid>> HandleLockedAsync(
+        CreateHabitCommand request,
+        CancellationToken cancellationToken)
     {
         var opts = request.Options ?? new HabitCommandOptions();
 

src/Orbit.Application/Habits/Commands/DuplicateHabitCommand.cs

@@ -20,7 +20,16 @@ public class DuplicateHabitCommandHandler(
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<DuplicateHabitCommand, Result<Guid>>
 {
-    public async Task<Result<Guid>> Handle(DuplicateHabitCommand request, CancellationToken cancellationToken)
+    public Task<Result<Guid>> Handle(DuplicateHabitCommand request, CancellationToken cancellationToken) =>
+        HabitCeilingLock.ExecuteAsync(
+            unitOfWork,
+            request.UserId,
+            ct => HandleLockedAsync(request, ct),
+            cancellationToken);
+
+    private async Task<Result<Guid>> HandleLockedAsync(
+        DuplicateHabitCommand request,
+        CancellationToken cancellationToken)
     {
         var allHabits = await habitRepository.FindTrackedAsync(
             h => h.UserId == request.UserId,

src/Orbit.Application/Profile/Commands/ApplyOnboardingCommand.cs

@@ -52,7 +52,7 @@ public record ApplyOnboardingCommand(
 
 /// <summary>
 /// Applies the buffer of answers a user built during pre-auth onboarding in a single transaction:
-/// creates the habits (trimmed to the free-plan allowance), an optional first log, an optional
+/// creates the habits (trimmed to the shared habit allowance), an optional first log, an optional
 /// Pro-gated goal, week-start/color preferences, and flips <c>HasCompletedOnboarding</c>. Idempotent
 /// by construction — an already-onboarded user is a no-op (<c>Applied:false</c>) — so the client can
 /// flush unconditionally after any successful auth and retry safely under the concurrency pipeline.
@@ -89,7 +89,7 @@ public async Task<Result<ApplyOnboardingResponse>> Handle(
     private async Task<Result<ApplyOnboardingResponse>> ApplyOnboardingTransactionAsync(
         ApplyOnboardingCommand request, CancellationToken ct)
     {
-        await unitOfWork.AcquireAdvisoryLockAsync($"onboarding-apply:{request.UserId}", ct);
+        await HabitCeilingLock.AcquireAsync(unitOfWork, request.UserId, ct);
 
         var user = await repos.Users.FindOneTrackedAsync(
             u => u.Id == request.UserId, cancellationToken: ct);
@@ -141,9 +141,6 @@ private async Task<Result<ApplyOnboardingResponse>> ApplyOnboardingTransactionAs
     private async Task<IReadOnlyList<ApplyHabitInput>> TrimToAllowanceAsync(
         User user, IReadOnlyList<ApplyHabitInput> habits, CancellationToken cancellationToken)
     {
-        if (user.HasProAccess)
-            return habits;
-
         var maxHabits = await appConfig.GetAsync(
             AppConfigKeys.FreeMaxHabits, AppConstants.DefaultFreeMaxHabits, cancellationToken);
         var existingRoots = await repos.Habits.CountAsync(

src/Orbit.Domain/Interfaces/IPayGateService.cs

@@ -5,7 +5,7 @@ namespace Orbit.Domain.Interfaces;
 public interface IPayGateService
 {
     /// <summary>
-    /// Checks if the user can create more habits (free plan: max 10 active).
+    /// Checks whether the shared live top-level habit ceiling allows the requested count.
     /// </summary>
     Task<Result> CanCreateHabits(Guid userId, int count = 1, CancellationToken ct = default);