Remove the Pro gate from goals

src/Orbit.Application/Common/AppConfigKeys.cs

@@ -14,7 +14,6 @@ public static class AppConfigKeys
     public const string DailySummaryProOnly = "DailySummaryProOnly";
     public const string SmartRescheduleProOnly = "SmartRescheduleProOnly";
     public const string RetrospectiveProOnly = "RetrospectiveProOnly";
-    public const string GoalsProOnly = "GoalsProOnly";
     public const string MinSupportedVersion = "MinSupportedVersion";
     public const string RequireApiKeyCreationStepUp = "RequireApiKeyCreationStepUp";
 }

src/Orbit.Application/Common/PayGateService.cs

@@ -145,21 +145,8 @@ public async Task<Result> CanUseRetrospective(Guid userId, CancellationToken ct
         return Result.Success();
     }
 
-    public async Task<Result> CanAccessGoals(Guid userId, CancellationToken ct = default)
-    {
-        var user = await userRepository.GetByIdAsync(userId, ct);
-        if (user is null)
-            return Result.Failure(ErrorMessages.UserNotFound);
-
-        var goalsProOnly = await appConfig.GetAsync(AppConfigKeys.GoalsProOnly, true, ct);
-        if (goalsProOnly && !user.HasProAccess)
-            return Result.PayGateFailure("Goals are a Pro feature. Upgrade to unlock!");
-
-        return Result.Success();
-    }
-
-    public Task<Result> CanCreateGoals(Guid userId, CancellationToken ct = default) =>
-        CanAccessGoals(userId, ct);
+    public Task<Result> CanUseGoalReview(Guid userId, CancellationToken ct = default) =>
+        RequireProAccess(userId, "Goal reviews are a Pro feature. Upgrade to unlock!", ct);
 
     public Task<Result> CanAccessCalendar(Guid userId, CancellationToken ct = default) =>
         RequireProAccess(userId, "Calendar integration is a Pro feature. Upgrade to unlock!", ct);
@@ -194,9 +181,6 @@ public Task<Result> CanManageUserFacts(Guid userId, CancellationToken ct = defau
     public Task<Result> CanUseSlipAlerts(Guid userId, CancellationToken ct = default) =>
         RequireProAccess(userId, "Slip alerts are a Pro feature. Upgrade to unlock!", ct);
 
-    public Task<Result> CanLinkGoalsToHabits(Guid userId, CancellationToken ct = default) =>
-        CanAccessGoals(userId, ct);
-
     public async Task<Result> CanCreateApiKeys(Guid userId, CancellationToken ct = default)
     {
         return await CanManageApiKeys(userId, ct);

src/Orbit.Application/Goals/Commands/CreateGoalCommand.cs

@@ -22,10 +22,9 @@
     GoalType Type = GoalType.Standard,
     IReadOnlyList<Guid>? HabitIds = null) : IRequest<Result<Guid>>, IIdempotentCommand;
 
 public partial class CreateGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
     IGenericRepository<Habit> habitRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGamificationService gamificationService,
     IGoalCompletionService goalCompletionService,
@@ -35,10 +34,6 @@
 {
     public async Task<Result<Guid>> Handle(CreateGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<Guid>();
-
         var today = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         if (request.Deadline is { } deadline && deadline < today)
             return Result.Failure<Guid>(ErrorMessages.DeadlineInPast);

src/Orbit.Application/Goals/Commands/DeleteGoalCommand.cs

@@ -14,17 +14,12 @@ public record DeleteGoalCommand(
 
 public class DeleteGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<DeleteGoalCommand, Result>
 {
     public async Task<Result> Handle(DeleteGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goal = await goalRepository.FindOneTrackedAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken: cancellationToken);

src/Orbit.Application/Goals/Commands/LinkHabitsToGoalCommand.cs

@@ -18,17 +18,12 @@ public record LinkHabitsToGoalCommand(
 public class LinkHabitsToGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
     IGenericRepository<Habit> habitRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<LinkHabitsToGoalCommand, Result>
 {
     public async Task<Result> Handle(LinkHabitsToGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         if (request.HabitIds.Count > AppConstants.MaxHabitsPerGoal)
             return Result.Failure(ErrorMessages.MaxHabitsPerGoal.Format(AppConstants.MaxHabitsPerGoal));
 

src/Orbit.Application/Goals/Commands/ReorderGoalsCommand.cs

@@ -16,17 +16,12 @@ public record ReorderGoalsCommand(
 
 public class ReorderGoalsCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<ReorderGoalsCommand, Result>
 {
     public async Task<Result> Handle(ReorderGoalsCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var ids = request.Positions.Select(p => p.GoalId).ToHashSet();
 
         var goals = await goalRepository.FindTrackedAsync(

src/Orbit.Application/Goals/Commands/RestoreGoalCommand.cs

@@ -14,17 +14,12 @@ public record RestoreGoalCommand(
 
 public class RestoreGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<RestoreGoalCommand, Result>
 {
     public async Task<Result> Handle(RestoreGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goals = await goalRepository.FindTrackedIgnoringFiltersAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken);

src/Orbit.Application/Goals/Commands/UpdateGoalCommand.cs

@@ -21,18 +21,13 @@ public record UpdateGoalCommand(
 
 public class UpdateGoalCommandHandler(
     GoalRepositories repos,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IMemoryCache cache) : IRequestHandler<UpdateGoalCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var today = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         if (request.Deadline is { } deadline && deadline < today)
             return Result.Failure(ErrorMessages.DeadlineInPast);

src/Orbit.Application/Goals/Commands/UpdateGoalProgressCommand.cs

@@ -17,18 +17,13 @@ public record UpdateGoalProgressCommand(
 
 public class UpdateGoalProgressCommandHandler(
     GoalRepositories repos,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<UpdateGoalProgressCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalProgressCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var saved = await unitOfWork.ExecuteInTransactionAsync(async transactionToken =>
         {
             var justCompleted = false;

src/Orbit.Application/Goals/Commands/UpdateGoalStatusCommand.cs

@@ -17,18 +17,13 @@ public record UpdateGoalStatusCommand(
 
 public class UpdateGoalStatusCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<UpdateGoalStatusCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalStatusCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goal = await goalRepository.FindOneTrackedAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken: cancellationToken);

src/Orbit.Application/Goals/Queries/GetGoalByIdQuery.cs

@@ -37,15 +37,10 @@ public record GetGoalByIdQuery(
 
 public class GetGoalByIdQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService) : IRequestHandler<GetGoalByIdQuery, Result<GoalDetailDto>>
 {
     public async Task<Result<GoalDetailDto>> Handle(GetGoalByIdQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalDetailDto>();
-
         var loaded = await GoalDetailLoader.BuildGoalDetailAsync(
             goalRepository, userDateService, request.GoalId, request.UserId, cancellationToken);
         if (loaded is null)

src/Orbit.Application/Goals/Queries/GetGoalDetailQuery.cs

@@ -18,15 +18,10 @@ public record GetGoalDetailQuery(
 
 public class GetGoalDetailQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService) : IRequestHandler<GetGoalDetailQuery, Result<GoalDetailWithMetricsResponse>>
 {
     public async Task<Result<GoalDetailWithMetricsResponse>> Handle(GetGoalDetailQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalDetailWithMetricsResponse>();
-
         var loaded = await GoalDetailLoader.BuildGoalDetailAsync(
             goalRepository, userDateService, request.GoalId, request.UserId, cancellationToken);
         if (loaded is null)

src/Orbit.Application/Goals/Queries/GetGoalMetricsQuery.cs

@@ -13,16 +13,11 @@
 
 public class GetGoalMetricsQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalProgressReadSyncer goalProgressReadSyncer) : IRequestHandler<GetGoalMetricsQuery, Result<GoalMetrics>>
 {
     public async Task<Result<GoalMetrics>> Handle(GetGoalMetricsQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalMetrics>();
-
         var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         var freshValues = await goalProgressReadSyncer.ComputeFreshValuesAsync(
             request.UserId,
@@ -32,7 +27,7 @@
 
         var goals = await goalRepository.FindAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             q => q.Include(g => g.ProgressLogs)
                   .Include(g => g.Habits).ThenInclude(h => h.Logs.Where(l => l.Date >= streakWindowStart)),
             cancellationToken);
         var goal = goals.Count > 0 ? goals[0] : null;

src/Orbit.Application/Goals/Queries/GetGoalProgressHistoryQuery.cs

@@ -18,19 +18,14 @@ public record GetGoalProgressHistoryQuery(
 
 /// <summary>
 /// Returns a goal's progress-log entries within a date range as an ascending series, for charting
-/// progress over time. Pro-gated behind goals access; scoped to the requesting user's own goal.
+/// progress over time, scoped to the requesting user's own goal.
 /// </summary>
 public class GetGoalProgressHistoryQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IGenericRepository<GoalProgressLog> progressLogRepository,
-    IPayGateService payGate) : IRequestHandler<GetGoalProgressHistoryQuery, Result<GoalProgressHistoryResponse>>
+    IGenericRepository<GoalProgressLog> progressLogRepository) : IRequestHandler<GetGoalProgressHistoryQuery, Result<GoalProgressHistoryResponse>>
 {
     public async Task<Result<GoalProgressHistoryResponse>> Handle(GetGoalProgressHistoryQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalProgressHistoryResponse>();
-
         var goalExists = await goalRepository.AnyAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken);

src/Orbit.Application/Goals/Queries/GetGoalReviewQuery.cs

@@ -26,7 +26,7 @@
         GetGoalReviewQuery request,
         CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
+        var gateCheck = await payGate.CanUseGoalReview(request.UserId, cancellationToken);
         if (gateCheck.IsFailure)
             return gateCheck.PropagateError<GoalReviewResponse>();
 
@@ -44,7 +44,7 @@
 
         var goals = await goalRepository.FindAsync(
             g => g.UserId == request.UserId && g.Status == GoalStatus.Active,
             q => q.Include(g => g.ProgressLogs)
                   .Include(g => g.Habits).ThenInclude(h => h.Logs.Where(l => l.Date >= streakWindowStart)),
             cancellationToken);
 

src/Orbit.Application/Goals/Queries/GetGoalsQuery.cs

@@ -38,16 +38,11 @@ public record GetGoalsQuery(
 
 public class GetGoalsQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalProgressReadSyncer goalProgressReadSyncer) : IRequestHandler<GetGoalsQuery, Result<PaginatedResponse<GoalDto>>>
 {
     public async Task<Result<PaginatedResponse<GoalDto>>> Handle(GetGoalsQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<PaginatedResponse<GoalDto>>();
-
         var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         var freshProgressValues = await goalProgressReadSyncer.ComputeFreshValuesAsync(request.UserId, userToday, cancellationToken);
 

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,
@@ -140,13 +140,6 @@
                 return subGateCheck;
         }
 
-        if (request.GoalIds is { Count: > 0 })
-        {
-            var goalLinkGate = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-            if (goalLinkGate.IsFailure)
-                return goalLinkGate;
-        }
-
         if (opts.SlipAlertEnabled)
         {
             var slipAlertGate = await payGate.CanUseSlipAlerts(request.UserId, cancellationToken);

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

@@ -16,16 +16,11 @@ public record LinkGoalsToHabitCommand(
 public class LinkGoalsToHabitCommandHandler(
     IGenericRepository<Habit> habitRepository,
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUserDateService userDateService) : IRequestHandler<LinkGoalsToHabitCommand, Result>
 {
     public async Task<Result> Handle(LinkGoalsToHabitCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var habit = await habitRepository.FindOneTrackedAsync(
             h => h.Id == request.HabitId && h.UserId == request.UserId,
             q => q.Include(h => h.Goals),

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

@@ -25,7 +25,7 @@
     IReadOnlyList<Guid>? GoalIds = null,
     string? Emoji = null) : IRequest<Result>;
 
 public class UpdateHabitCommandHandler(
     IGenericRepository<Habit> habitRepository,
     IGenericRepository<SentReminder> sentReminderRepository,
     IGenericRepository<Goal> goalRepository,
@@ -35,15 +35,8 @@
     IUnitOfWork unitOfWork,
     IMemoryCache cache) : IRequestHandler<UpdateHabitCommand, Result>
 {
     public async Task<Result> Handle(UpdateHabitCommand request, CancellationToken cancellationToken)
     {
-        if (request.GoalIds is not null)
-        {
-            var goalLinkGate = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-            if (goalLinkGate.IsFailure)
-                return goalLinkGate;
-        }
-
         if (request.Options?.SlipAlertEnabled is not null)
         {
             var slipAlertGate = await payGate.CanUseSlipAlerts(request.UserId, cancellationToken);

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

@@ -53,7 +53,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
-/// Pro-gated goal, week-start/color preferences, and flips <c>HasCompletedOnboarding</c>. Idempotent
+/// 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.
 /// </summary>
@@ -65,7 +65,6 @@ public record ApplyOnboardingRepositories(
 
 public class ApplyOnboardingCommandHandler(
     ApplyOnboardingRepositories repos,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IAppConfigService appConfig,
     IUnitOfWork unitOfWork,
@@ -121,7 +120,7 @@ private async Task<Result<ApplyOnboardingResponse>> ApplyOnboardingTransactionAs
             loggedFirstHabit = true;
         }
 
-        var goalResult = await CreateGoalIfAllowedAsync(request.UserId, request.Goal, today, ct);
+        var goalResult = await CreateGoalAsync(request.UserId, request.Goal, today, ct);
         if (goalResult.IsFailure)
             return goalResult.PropagateError<ApplyOnboardingResponse>();
         var createdGoal = goalResult.Value;
@@ -189,16 +188,12 @@ private async Task<Result<List<Habit>>> CreateHabitsAsync(
         return Result.Success(createdHabits);
     }
 
-    private async Task<Result<bool>> CreateGoalIfAllowedAsync(
+    private async Task<Result<bool>> CreateGoalAsync(
         Guid userId, ApplyGoalInput? goalInput, DateOnly today, CancellationToken cancellationToken)
     {
         if (goalInput is null)
             return Result.Success(false);
 
-        var goalGate = await payGate.CanAccessGoals(userId, cancellationToken);
-        if (goalGate.IsFailure)
-            return Result.Success(false);
-
         if (goalInput.Deadline is { } deadline && deadline < today)
             return Result.Failure<bool>(ErrorMessages.DeadlineInPast);