diff --git a/src/Orbit.Api/Controllers/ProfileController.cs b/src/Orbit.Api/Controllers/ProfileController.cs
index 16c3049d..f5b1e1f4 100644
--- a/src/Orbit.Api/Controllers/ProfileController.cs
+++ b/src/Orbit.Api/Controllers/ProfileController.cs
@@ -36,6 +36,13 @@ public record UpdatePublicProfileRequest(
         bool ShowTopHabits,
         bool Regenerate);
 
+    public record ApplyOnboardingRequest(
+        IReadOnlyList<ApplyHabitInput>? Habits,
+        ApplyLogInput? FirstLog,
+        ApplyGoalInput? Goal,
+        int? WeekStartDay,
+        string? ColorScheme);
+
     private static readonly JsonSerializerOptions ExportJsonOptions = new(JsonSerializerDefaults.Web)
     {
         WriteIndented = true
@@ -216,6 +223,36 @@ public async Task<IActionResult> CompleteOnboarding(CancellationToken cancellati
         return result.ToPayGateAwareResult(() => NoContent());
     }
 
+    [HttpPost("onboarding/apply")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> ApplyOnboarding(
+        [FromBody] ApplyOnboardingRequest request,
+        CancellationToken cancellationToken)
+    {
+        var command = new ApplyOnboardingCommand(
+            HttpContext.GetUserId(),
+            request.Habits ?? [],
+            request.FirstLog,
+            request.Goal,
+            request.WeekStartDay,
+            request.ColorScheme);
+        var result = await mediator.Send(command, cancellationToken);
+        return result.ToPayGateAwareResult(value => Ok(value));
+    }
+
+    [HttpPut("import-prompt/dismiss")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    public async Task<IActionResult> DismissImportPrompt(CancellationToken cancellationToken)
+    {
+        var command = new DismissImportPromptCommand(HttpContext.GetUserId());
+        var result = await mediator.Send(command, cancellationToken);
+        return result.ToPayGateAwareResult(() => NoContent());
+    }
+
     [HttpPut("tour")]
     [ProducesResponseType(StatusCodes.Status204NoContent)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
diff --git a/src/Orbit.Application/Profile/Commands/ApplyOnboardingCommand.cs b/src/Orbit.Application/Profile/Commands/ApplyOnboardingCommand.cs
new file mode 100644
index 00000000..1bd355e1
--- /dev/null
+++ b/src/Orbit.Application/Profile/Commands/ApplyOnboardingCommand.cs
@@ -0,0 +1,252 @@
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+using Orbit.Application.Behaviors;
+using Orbit.Application.Common;
+using Orbit.Domain.Common;
+using Orbit.Domain.Entities;
+using Orbit.Domain.Enums;
+using Orbit.Domain.Interfaces;
+using Orbit.Domain.ValueObjects;
+
+namespace Orbit.Application.Profile.Commands;
+
+public record ApplyHabitInput(
+    string Title,
+    string? Description,
+    string? Emoji,
+    FrequencyUnit? FrequencyUnit,
+    int? FrequencyQuantity,
+    IReadOnlyList<DayOfWeek>? Days = null,
+    bool IsBadHabit = false,
+    bool IsGeneral = false,
+    bool IsFlexible = false,
+    DateOnly? DueDate = null,
+    TimeOnly? DueTime = null,
+    bool ReminderEnabled = false,
+    IReadOnlyList<int>? ReminderTimes = null,
+    IReadOnlyList<ChecklistItem>? ChecklistItems = null);
+
+public record ApplyLogInput(int HabitIndex, DateOnly Date);
+
+public record ApplyGoalInput(
+    string Title,
+    string? Description,
+    decimal TargetValue,
+    string Unit,
+    DateOnly? Deadline = null,
+    GoalType Type = GoalType.Standard);
+
+public record ApplyOnboardingResponse(
+    bool Applied,
+    int CreatedHabitCount,
+    bool CreatedGoal,
+    bool LoggedFirstHabit);
+
+public record ApplyOnboardingCommand(
+    Guid UserId,
+    IReadOnlyList<ApplyHabitInput> Habits,
+    ApplyLogInput? FirstLog,
+    ApplyGoalInput? Goal,
+    int? WeekStartDay,
+    string? ColorScheme) : IRequest<Result<ApplyOnboardingResponse>>, IConcurrencyRetryable;
+
+/// <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
+/// 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>
+public class ApplyOnboardingCommandHandler(
+    IGenericRepository<User> userRepository,
+    IGenericRepository<Habit> habitRepository,
+    IGenericRepository<Goal> goalRepository,
+    IPayGateService payGate,
+    IUserDateService userDateService,
+    IAppConfigService appConfig,
+    IUnitOfWork unitOfWork,
+    IMemoryCache cache) : IRequestHandler<ApplyOnboardingCommand, Result<ApplyOnboardingResponse>>
+{
+    public async Task<Result<ApplyOnboardingResponse>> Handle(
+        ApplyOnboardingCommand request, CancellationToken cancellationToken)
+    {
+        Result<ApplyOnboardingResponse>? failure = null;
+        ApplyOnboardingResponse? response = null;
+
+        await unitOfWork.ExecuteInTransactionAsync(async ct =>
+        {
+            await unitOfWork.AcquireAdvisoryLockAsync($"onboarding-apply:{request.UserId}", ct);
+
+            var user = await userRepository.FindOneTrackedAsync(
+                u => u.Id == request.UserId, cancellationToken: ct);
+
+            if (user is null)
+            {
+                failure = Result.Failure<ApplyOnboardingResponse>(ErrorMessages.UserNotFound);
+                return;
+            }
+
+            if (user.HasCompletedOnboarding)
+            {
+                response = new ApplyOnboardingResponse(false, 0, false, false);
+                return;
+            }
+
+            var today = await userDateService.GetUserTodayAsync(request.UserId, ct);
+
+            var habitsToCreate = await TrimToAllowanceAsync(user, request.Habits, ct);
+
+            var createResult = await CreateHabitsAsync(request.UserId, habitsToCreate, today, ct);
+            if (createResult.IsFailure)
+            {
+                failure = createResult.PropagateError<ApplyOnboardingResponse>();
+                return;
+            }
+
+            var createdHabits = createResult.Value;
+
+            var loggedFirstHabit = false;
+            if (request.FirstLog is { } firstLog
+                && firstLog.HabitIndex >= 0
+                && firstLog.HabitIndex < createdHabits.Count)
+            {
+                var logResult = createdHabits[firstLog.HabitIndex].Log(firstLog.Date);
+                if (logResult.IsFailure)
+                {
+                    failure = logResult.PropagateError<ApplyOnboardingResponse>();
+                    return;
+                }
+                loggedFirstHabit = true;
+            }
+
+            var goalResult = await CreateGoalIfAllowedAsync(request.UserId, request.Goal, today, ct);
+            if (goalResult.IsFailure)
+            {
+                failure = goalResult.PropagateError<ApplyOnboardingResponse>();
+                return;
+            }
+            var createdGoal = goalResult.Value;
+
+            var prefsResult = ApplyPreferences(user, request.WeekStartDay, request.ColorScheme);
+            if (prefsResult.IsFailure)
+            {
+                failure = prefsResult.PropagateError<ApplyOnboardingResponse>();
+                return;
+            }
+
+            user.CompleteOnboarding();
+
+            await unitOfWork.SaveChangesAsync(ct);
+
+            response = new ApplyOnboardingResponse(true, createdHabits.Count, createdGoal, loggedFirstHabit);
+        }, cancellationToken);
+
+        if (failure is not null)
+            return failure;
+
+        if (response!.Applied)
+            CacheInvalidationHelper.InvalidateUserAiCaches(cache, request.UserId);
+
+        return Result.Success(response);
+    }
+
+    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 habitRepository.CountAsync(
+            h => h.UserId == user.Id && h.ParentHabitId == null, cancellationToken);
+        var allowance = Math.Max(0, maxHabits - existingRoots);
+
+        return allowance >= habits.Count ? habits : habits.Take(allowance).ToList();
+    }
+
+    private async Task<Result<List<Habit>>> CreateHabitsAsync(
+        Guid userId, IReadOnlyList<ApplyHabitInput> habits, DateOnly today, CancellationToken cancellationToken)
+    {
+        var createdHabits = new List<Habit>();
+        var position = 0;
+
+        foreach (var item in habits)
+        {
+            var habitResult = Habit.Create(new HabitCreateParams(
+                userId,
+                item.Title,
+                item.FrequencyUnit,
+                item.FrequencyQuantity,
+                item.Description,
+                Emoji: item.Emoji,
+                Days: item.Days,
+                IsBadHabit: item.IsBadHabit,
+                DueDate: item.DueDate ?? today,
+                DueTime: item.DueTime,
+                ReminderEnabled: item.ReminderEnabled,
+                ReminderTimes: item.ReminderTimes,
+                ChecklistItems: item.ChecklistItems,
+                IsGeneral: item.IsGeneral,
+                IsFlexible: item.IsFlexible,
+                Position: position++));
+
+            if (habitResult.IsFailure)
+                return habitResult.PropagateError<List<Habit>>();
+
+            await habitRepository.AddAsync(habitResult.Value, cancellationToken);
+            createdHabits.Add(habitResult.Value);
+        }
+
+        return Result.Success(createdHabits);
+    }
+
+    private async Task<Result<bool>> CreateGoalIfAllowedAsync(
+        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);
+
+        var goalResult = Goal.Create(new Goal.CreateGoalParams(
+            userId,
+            goalInput.Title,
+            goalInput.TargetValue,
+            goalInput.Unit,
+            goalInput.Description,
+            goalInput.Deadline,
+            0,
+            goalInput.Type));
+
+        if (goalResult.IsFailure)
+            return goalResult.PropagateError<bool>();
+
+        await goalRepository.AddAsync(goalResult.Value, cancellationToken);
+        return Result.Success(true);
+    }
+
+    private static Result ApplyPreferences(User user, int? weekStartDay, string? colorScheme)
+    {
+        if (weekStartDay is { } day)
+        {
+            var weekStartResult = user.SetWeekStartDay(day);
+            if (weekStartResult.IsFailure)
+                return weekStartResult;
+        }
+
+        if (colorScheme is not null)
+        {
+            var colorResult = user.SetColorScheme(colorScheme);
+            if (colorResult.IsFailure)
+                return colorResult;
+        }
+
+        return Result.Success();
+    }
+}
diff --git a/src/Orbit.Application/Profile/Commands/DismissImportPromptCommand.cs b/src/Orbit.Application/Profile/Commands/DismissImportPromptCommand.cs
new file mode 100644
index 00000000..fdf2bb45
--- /dev/null
+++ b/src/Orbit.Application/Profile/Commands/DismissImportPromptCommand.cs
@@ -0,0 +1,36 @@
+using MediatR;
+using Orbit.Application.Behaviors;
+using Orbit.Application.Common;
+using Orbit.Domain.Common;
+using Orbit.Domain.Entities;
+using Orbit.Domain.Interfaces;
+
+namespace Orbit.Application.Profile.Commands;
+
+public record DismissImportPromptCommand(Guid UserId) : IRequest<Result>, IConcurrencyRetryable;
+
+/// <summary>
+/// Marks the one-time "import from another app?" prompt as seen for the user. Not pay-gated: the
+/// prompt is shown to every account exactly once, so every account must be able to dismiss it
+/// permanently regardless of plan.
+/// </summary>
+public class DismissImportPromptCommandHandler(
+    IGenericRepository<User> userRepository,
+    IUnitOfWork unitOfWork) : IRequestHandler<DismissImportPromptCommand, Result>
+{
+    public async Task<Result> Handle(DismissImportPromptCommand request, CancellationToken cancellationToken)
+    {
+        var user = await userRepository.FindOneTrackedAsync(
+            u => u.Id == request.UserId,
+            cancellationToken: cancellationToken);
+
+        if (user is null)
+            return Result.Failure(ErrorMessages.UserNotFound);
+
+        user.MarkImportPromptSeen();
+
+        await unitOfWork.SaveChangesAsync(cancellationToken);
+
+        return Result.Success();
+    }
+}
diff --git a/src/Orbit.Application/Profile/Queries/GetProfileQuery.cs b/src/Orbit.Application/Profile/Queries/GetProfileQuery.cs
index c57aa9a1..a80b04b7 100644
--- a/src/Orbit.Application/Profile/Queries/GetProfileQuery.cs
+++ b/src/Orbit.Application/Profile/Queries/GetProfileQuery.cs
@@ -31,6 +31,7 @@ public record ProfileResponse(
     int AiMessagesUsed,
     int AiMessagesLimit,
     bool HasImportedCalendar,
+    bool HasSeenImportPrompt,
     bool HasGoogleConnection,
     string? SubscriptionInterval,
     string? SubscriptionSource,
@@ -117,6 +118,7 @@ public async Task<Result<ProfileResponse>> Handle(GetProfileQuery request, Cance
             user.AiMessagesUsedThisMonth,
             aiMessageLimit,
             user.HasImportedCalendar,
+            user.HasSeenImportPrompt,
             user.GoogleAccessToken is not null,
             user.SubscriptionInterval?.ToString().ToLowerInvariant(),
             user.SubscriptionSource.ToApiValue(),
diff --git a/src/Orbit.Application/Profile/Validators/ApplyOnboardingCommandValidator.cs b/src/Orbit.Application/Profile/Validators/ApplyOnboardingCommandValidator.cs
new file mode 100644
index 00000000..7005a780
--- /dev/null
+++ b/src/Orbit.Application/Profile/Validators/ApplyOnboardingCommandValidator.cs
@@ -0,0 +1,60 @@
+using FluentValidation;
+using Orbit.Application.Common;
+using Orbit.Application.Habits.Validators;
+using Orbit.Application.Profile.Commands;
+
+namespace Orbit.Application.Profile.Validators;
+
+public class ApplyHabitInputValidator : AbstractValidator<ApplyHabitInput>
+{
+    public ApplyHabitInputValidator()
+    {
+        SharedHabitRules.AddTitleRules(RuleFor(x => x.Title));
+        SharedHabitRules.AddDescriptionRules(RuleFor(x => x.Description));
+        SharedHabitRules.AddEmojiRules(RuleFor(x => x.Emoji));
+        SharedHabitRules.AddChecklistItemRules(RuleFor(x => x.ChecklistItems));
+
+        RuleFor(x => x.FrequencyQuantity)
+            .GreaterThan(0)
+            .When(x => x.FrequencyQuantity is not null);
+
+        RuleFor(x => x.FrequencyQuantity)
+            .NotNull()
+            .WithMessage("Frequency quantity is required when frequency unit is set")
+            .When(x => x.FrequencyUnit is not null);
+
+        SharedHabitRules.AddReminderTimesRules(RuleFor(x => x.ReminderTimes));
+        SharedHabitRules.AddDaysRules(this, x => x.Days, x => x.FrequencyQuantity, x => x.FrequencyUnit, x => x.IsFlexible);
+        SharedHabitRules.AddGeneralHabitRules(this, x => x.IsGeneral, x => x.FrequencyUnit, x => x.FrequencyQuantity, x => x.Days);
+    }
+}
+
+public class ApplyGoalInputValidator : AbstractValidator<ApplyGoalInput>
+{
+    public ApplyGoalInputValidator()
+    {
+        RuleFor(x => x.Title).NotEmpty().MaximumLength(200);
+        RuleFor(x => x.Description).MaximumLength(AppConstants.MaxGoalDescriptionLength);
+        RuleFor(x => x.TargetValue).GreaterThan(0);
+        RuleFor(x => x.Unit).NotEmpty().MaximumLength(50);
+        RuleFor(x => x.Type).IsInEnum();
+    }
+}
+
+public class ApplyOnboardingCommandValidator : AbstractValidator<ApplyOnboardingCommand>
+{
+    public ApplyOnboardingCommandValidator()
+    {
+        RuleFor(x => x.Habits).NotNull();
+        RuleFor(x => x.Habits.Count).LessThanOrEqualTo(AppConstants.MaxBulkOperationSize)
+            .When(x => x.Habits is not null);
+        RuleForEach(x => x.Habits).SetValidator(new ApplyHabitInputValidator());
+
+        When(x => x.Goal is not null, () =>
+            RuleFor(x => x.Goal!).SetValidator(new ApplyGoalInputValidator()));
+
+        When(x => x.WeekStartDay is not null, () =>
+            RuleFor(x => x.WeekStartDay!.Value).Must(day => day is 0 or 1)
+                .WithMessage("Week start day must be 0 (Sunday) or 1 (Monday)."));
+    }
+}
diff --git a/src/Orbit.Domain/Entities/User.cs b/src/Orbit.Domain/Entities/User.cs
index 7283d22b..d04d9782 100644
--- a/src/Orbit.Domain/Entities/User.cs
+++ b/src/Orbit.Domain/Entities/User.cs
@@ -39,6 +39,7 @@ public partial class User : Entity
     public string? PlayPurchaseToken { get; private set; }
     public DateTime CreatedAtUtc { get; private set; }
     public bool HasImportedCalendar { get; private set; } = false;
+    public bool HasSeenImportPrompt { get; private set; } = false;
     public string? GoogleAccessToken { get; private set; }
     public string? GoogleRefreshToken { get; private set; }
     public bool GoogleCalendarAutoSyncEnabled { get; private set; }
@@ -307,6 +308,8 @@ public void SetGoogleTokens(string accessToken, string? refreshToken)
 
     public void MarkCalendarImported() => HasImportedCalendar = true;
 
+    public void MarkImportPromptSeen() => HasSeenImportPrompt = true;
+
     public Result EnableCalendarAutoSync()
     {
         if (!HasProAccess)
diff --git a/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.Designer.cs b/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.Designer.cs
new file mode 100644
index 00000000..5b9669c2
--- /dev/null
+++ b/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.Designer.cs
@@ -0,0 +1,2497 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Orbit.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace Orbit.Infrastructure.Migrations
+{
+    [DbContext(typeof(OrbitDbContext))]
+    [Migration("20260705031342_AddHasSeenImportPrompt")]
+    partial class AddHasSeenImportPrompt
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.9")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("HabitGoals", b =>
+                {
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("GoalId", "HabitId");
+
+                    b.HasIndex("HabitId");
+
+                    b.ToTable("HabitGoals");
+                });
+
+            modelBuilder.Entity("HabitTags", b =>
+                {
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("HabitId", "TagId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("HabitTags");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityCheckIn", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<Guid>("PairId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PairId", "CreatedAtUtc");
+
+                    b.HasIndex("PairId", "UserId", "Date")
+                        .IsUnique();
+
+                    b.ToTable("AccountabilityCheckIns");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityPair", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("AcceptedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("AddresseeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Cadence")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("EndedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("RequesterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AddresseeId");
+
+                    b.HasIndex("RequesterId");
+
+                    b.ToTable("AccountabilityPairs");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityPairHabit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("PairId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HabitId");
+
+                    b.HasIndex("PairId", "UserId", "HabitId")
+                        .IsUnique();
+
+                    b.ToTable("AccountabilityPairHabits");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AgentAuditLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AuthMethod")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("CapabilityId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Error")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("OutcomeStatus")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("PolicyDecision")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("RedactedArguments")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("RiskClass")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ShadowPolicyDecision")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ShadowReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("SourceName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Summary")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Surface")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("TargetName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CapabilityId", "CreatedAtUtc");
+
+                    b.HasIndex("UserId", "CreatedAtUtc");
+
+                    b.ToTable("AgentAuditLogs");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AgentStepUpChallengeState", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CodeHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("PendingOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("VerifiedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "PendingOperationId", "CreatedAtUtc");
+
+                    b.ToTable("AgentStepUpChallenges");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AiFactExtractionBatch", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BatchId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("CompletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InputFileId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("OutputFileId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BatchId")
+                        .IsUnique();
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AiFactExtractionBatches");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AiUsageDaily", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("CachedTokens")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("Calls")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CompletionTokens")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("CostUsd")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Model")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<long>("PromptTokens")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Purpose")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<long>("TotalTokens")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date", "Model", "Purpose")
+                        .IsUnique();
+
+                    b.ToTable("AiUsageDaily");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ApiKey", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsReadOnly")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsRevoked")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("KeyHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("KeyPrefix")
+                        .IsRequired()
+                        .HasMaxLength(12)
+                        .HasColumnType("character varying(12)");
+
+                    b.Property<DateTime?>("LastUsedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Scopes")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'[]'::jsonb");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("KeyPrefix");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ApiKeys");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AppConfig", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("AppConfigs");
+
+                    b.HasData(
+                        new
+                        {
+                            Key = "MaxUserFacts",
+                            Description = "Maximum number of facts the AI can remember per user",
+                            Value = "50"
+                        },
+                        new
+                        {
+                            Key = "MaxHabitDepth",
+                            Description = "Maximum nesting depth for sub-habits",
+                            Value = "5"
+                        },
+                        new
+                        {
+                            Key = "MaxTagsPerHabit",
+                            Description = "Maximum number of tags per habit",
+                            Value = "5"
+                        },
+                        new
+                        {
+                            Key = "ReferralRewardDays",
+                            Description = "Days of Pro added per successful referral",
+                            Value = "10"
+                        },
+                        new
+                        {
+                            Key = "MaxReferrals",
+                            Description = "Maximum successful referrals per user",
+                            Value = "10"
+                        },
+                        new
+                        {
+                            Key = "MinSupportedVersion",
+                            Description = "Minimum supported client app version; clients below this receive HTTP 426",
+                            Value = "0.0.0"
+                        });
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AppFeatureFlag", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PlanRequirement")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("AppFeatureFlags");
+
+                    b.HasData(
+                        new
+                        {
+                            Key = "offline_mode",
+                            Description = "Enable offline mode with background sync",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "ai_chat",
+                            Description = "AI chat assistant",
+                            Enabled = true,
+                            PlanRequirement = "Free",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "ai_summary",
+                            Description = "AI daily summary",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "ai_retrospective",
+                            Description = "AI retrospective analysis",
+                            Enabled = true,
+                            PlanRequirement = "YearlyPro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "sub_habits",
+                            Description = "Sub-habit nesting",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "goal_tracking",
+                            Description = "Goal tracking with progress",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "push_notifications",
+                            Description = "Push notification reminders",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "scheduled_reminders",
+                            Description = "Custom scheduled reminders",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "slip_alerts",
+                            Description = "Slip detection alerts",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "checklist_templates",
+                            Description = "Reusable checklist templates",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "habit_duplication",
+                            Description = "Duplicate habits",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "bulk_operations",
+                            Description = "Bulk create/delete/log habits",
+                            Enabled = true,
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "calendar_integration",
+                            Description = "Google Calendar integration",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        },
+                        new
+                        {
+                            Key = "api_keys",
+                            Description = "Personal API keys",
+                            Enabled = true,
+                            PlanRequirement = "Pro",
+                            UpdatedAtUtc = new DateTime(2026, 4, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        });
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.BlockedUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("BlockedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("BlockerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedId");
+
+                    b.HasIndex("BlockerId", "BlockedId")
+                        .IsUnique();
+
+                    b.ToTable("BlockedUsers");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Challenge", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("CompletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("JoinCode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateOnly?>("PeriodEndUtc")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly>("PeriodStartUtc")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int?>("TargetCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatorId");
+
+                    b.HasIndex("JoinCode")
+                        .IsUnique();
+
+                    b.ToTable("Challenges");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChallengeParticipant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChallengeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("JoinedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LeftAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("ChallengeId", "UserId")
+                        .IsUnique()
+                        .HasFilter("\"LeftAtUtc\" IS NULL");
+
+                    b.ToTable("ChallengeParticipants");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChallengeParticipantHabit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChallengeParticipantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HabitId");
+
+                    b.HasIndex("ChallengeParticipantId", "HabitId")
+                        .IsUnique();
+
+                    b.ToTable("ChallengeParticipantHabits");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChecklistTemplate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Items")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'[]'::jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.ToTable("ChecklistTemplates");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Cheer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<Guid>("RecipientId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("SenderId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HabitId");
+
+                    b.HasIndex("RecipientId");
+
+                    b.HasIndex("SenderId", "CreatedAtUtc");
+
+                    b.ToTable("Cheers");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ContentBlock", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Locale")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key", "Locale")
+                        .IsUnique();
+
+                    b.ToTable("ContentBlocks");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.DistributedRateLimitBucket", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PartitionKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PolicyName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("WindowEndsAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("WindowStartUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PolicyName", "PartitionKey", "WindowStartUtc")
+                        .IsUnique();
+
+                    b.ToTable("DistributedRateLimitBuckets");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.FriendFeedEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AchievementId")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<Guid>("ActorUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int?>("Value")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActorUserId", "AchievementId")
+                        .IsUnique()
+                        .HasFilter("\"AchievementId\" IS NOT NULL");
+
+                    b.HasIndex("ActorUserId", "CreatedAtUtc", "Id")
+                        .IsDescending(false, true, true);
+
+                    b.HasIndex("ActorUserId", "Type", "Value")
+                        .IsUnique()
+                        .HasFilter("\"AchievementId\" IS NULL");
+
+                    b.ToTable("FriendFeedEvents");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Friendship", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AddresseeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("RequesterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("RespondedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AddresseeId");
+
+                    b.HasIndex("RequesterId");
+
+                    b.ToTable("Friendships");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Goal", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("CompletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("CurrentValue")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateOnly?>("Deadline")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("StreakSyncedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("TargetValue")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<uint>("xmin")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.ToTable("Goals");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.GoalProgressLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("GoalId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("PreviousValue")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GoalId");
+
+                    b.HasIndex("GoalId", "IsDeleted");
+
+                    b.ToTable("GoalProgressLogs");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.GoogleCalendarSyncSuggestion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DiscoveredAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DismissedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("GoogleEventId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("ImportedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("ImportedHabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RawEventJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartDateUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "GoogleEventId")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "DismissedAtUtc", "ImportedAtUtc");
+
+                    b.ToTable("GoogleCalendarSyncSuggestions");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Habit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChecklistItems")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'[]'::jsonb");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string[]>("Days")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<TimeOnly?>("DueEndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<TimeOnly?>("DueTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<string>("Emoji")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("EndDate")
+                        .HasColumnType("date");
+
+                    b.Property<int?>("FrequencyQuantity")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("FrequencyUnit")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("GoogleEventId")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("IsBadHabit")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsFlexible")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsGeneral")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("OriginalDayOfMonth")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ParentHabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("ReminderEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReminderTimes")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'[15]'::jsonb");
+
+                    b.Property<string>("ScheduledReminders")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("jsonb")
+                        .HasDefaultValueSql("'[]'::jsonb");
+
+                    b.Property<bool>("SlipAlertEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentHabitId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "GoogleEventId")
+                        .IsUnique()
+                        .HasFilter("\"GoogleEventId\" IS NOT NULL AND \"IsDeleted\" = FALSE");
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.ToTable("Habits");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.HabitLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex(new[] { "HabitId", "Date" }, "IX_HabitLogs_HabitId_Date");
+
+                    b.HasIndex(new[] { "HabitId", "Date" }, "IX_HabitLogs_HabitId_Date_Completed")
+                        .IsUnique()
+                        .HasFilter("\"Value\" > 0 AND NOT \"IsDeleted\"");
+
+                    b.ToTable("HabitLogs");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Notification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsRead")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Url")
+                        .HasFilter("\"Url\" IS NOT NULL");
+
+                    b.HasIndex("UserId", "CreatedAtUtc")
+                        .IsDescending(false, true);
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.HasIndex("UserId", "IsRead");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.PendingAgentOperationState", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ArgumentsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("CapabilityId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("ConfirmationRequirement")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ConfirmationTokenHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime?>("ConfirmedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ConsumedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("OperationFingerprint")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("OperationId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RiskClass")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTime?>("StepUpSatisfiedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Summary")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Surface")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "CapabilityId");
+
+                    b.HasIndex("UserId", "OperationFingerprint");
+
+                    b.ToTable("PendingAgentOperations");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.PendingClarification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MissingArgumentKey")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PartialArgumentsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Question")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("QuickActionsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("ResolvedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ToolName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpiresAtUtc");
+
+                    b.HasIndex("UserId", "CreatedAtUtc");
+
+                    b.ToTable("PendingClarifications");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ProcessedPlayNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("MessageId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("ProcessedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MessageId")
+                        .IsUnique();
+
+                    b.ToTable("ProcessedPlayNotifications");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ProcessedStripeEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime>("ProcessedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EventId")
+                        .IsUnique();
+
+                    b.ToTable("ProcessedStripeEvents");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.PushSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Auth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("P256dh")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Endpoint")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("PushSubscriptions");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Referral", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("CompletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ReferredUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ReferrerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("RewardGrantedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<uint>("xmin")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReferredUserId")
+                        .IsUnique();
+
+                    b.HasIndex("ReferrerId");
+
+                    b.ToTable("Referrals");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Report", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("CheerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Details")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("ReportedUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ReporterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("ReviewedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CheerId");
+
+                    b.HasIndex("ReportedUserId");
+
+                    b.HasIndex("ReporterId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.SentProactiveCheckin", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("SentAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Date")
+                        .IsUnique();
+
+                    b.ToTable("SentProactiveCheckins");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.SentReminder", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MinutesBefore")
+                        .HasColumnType("integer");
+
+                    b.Property<TimeOnly?>("ReminderTimeUtc")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<DateTime>("SentAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("When")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HabitId", "Date", "MinutesBefore", "ReminderTimeUtc", "When")
+                        .IsUnique();
+
+                    NpgsqlIndexBuilderExtensions.AreNullsDistinct(b.HasIndex("HabitId", "Date", "MinutesBefore", "ReminderTimeUtc", "When"), false);
+
+                    b.ToTable("SentReminders");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.SentSlipAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("HabitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("SentAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly>("WeekStart")
+                        .HasColumnType("date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HabitId", "WeekStart")
+                        .IsUnique();
+
+                    b.ToTable("SentSlipAlerts");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.SentStreakFreezeAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("FrozenDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime>("SentAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "FrozenDate")
+                        .IsUnique();
+
+                    b.ToTable("SentStreakFreezeAlerts");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.StreakFreeze", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly>("UsedOnDate")
+                        .HasColumnType("date");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "UsedOnDate")
+                        .IsUnique();
+
+                    b.ToTable("StreakFreezes");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Color")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.HasIndex("UserId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AdRewardBonusMessages")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AdRewardsClaimedToday")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AiMemoryEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("AiMessagesResetAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("AiMessagesUsedThisMonth")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AiSummaryEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ColorScheme")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CurrentStreak")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("DeactivatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GoogleAccessToken")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("GoogleCalendarAutoSyncEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("GoogleCalendarAutoSyncStatus")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("GoogleCalendarLastSyncError")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTime?>("GoogleCalendarLastSyncedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("GoogleCalendarSelectedIds")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("GoogleCalendarSyncReconciledAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("GoogleRefreshToken")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Handle")
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<bool>("HasCompletedOnboarding")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasCompletedOnboardingChecklist")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasCompletedTour")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasCreatedFirstHabit")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasImportedCalendar")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasLoggedFirstHabit")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasSeenImportPrompt")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("HasTriedAstra")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeactivated")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsLifetimePro")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("LastActiveDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime?>("LastAdRewardAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly?>("LastAdRewardLocalDate")
+                        .HasColumnType("date");
+
+                    b.Property<int>("LastFreezeAwardStreak")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LongestStreak")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Plan")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("PlanExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PlayPurchaseToken")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ProactiveAstraEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("PublicProfileShowAchievements")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("PublicProfileShowLevel")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("PublicProfileShowStreak")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("PublicProfileShowTopHabits")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PublicProfileSlug")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReferralCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReferralCouponId")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ReferredByUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("ScheduledDeletionAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("SocialOptIn")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("StreakFreezesAccumulated")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("StripeCustomerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StripeSubscriptionId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("SubscriptionInterval")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SubscriptionSource")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ThemePreference")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalXp")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("TrialEndsAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WeekStartDay")
+                        .HasColumnType("integer");
+
+                    b.Property<uint>("xmin")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("xid")
+                        .HasColumnName("xmin");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.HasIndex("PlayPurchaseToken")
+                        .IsUnique()
+                        .HasFilter("\"PlayPurchaseToken\" IS NOT NULL");
+
+                    b.HasIndex("PublicProfileSlug")
+                        .IsUnique()
+                        .HasFilter("\"PublicProfileSlug\" IS NOT NULL");
+
+                    b.HasIndex("ReferralCode")
+                        .IsUnique()
+                        .HasFilter("\"ReferralCode\" IS NOT NULL");
+
+                    b.HasIndex("GoogleCalendarAutoSyncEnabled", "GoogleCalendarLastSyncedAt")
+                        .HasFilter("\"GoogleCalendarAutoSyncEnabled\" = TRUE");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.UserAchievement", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AchievementId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("EarnedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId", "AchievementId")
+                        .IsUnique();
+
+                    b.ToTable("UserAchievements");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.UserFact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Category")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("DeletedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExtractedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FactText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "IsDeleted");
+
+                    b.ToTable("UserFacts");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.UserSession", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("LastUsedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("RevokedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserSessions");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.XpAwardLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Amount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("AwardedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid?>("SourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "AwardedAtUtc");
+
+                    b.ToTable("XpAwardLogs");
+                });
+
+            modelBuilder.Entity("HabitGoals", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Goal", null)
+                        .WithMany()
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany()
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("HabitTags", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany()
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityCheckIn", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.AccountabilityPair", null)
+                        .WithMany()
+                        .HasForeignKey("PairId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityPair", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("AddresseeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("RequesterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AccountabilityPairHabit", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany()
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.AccountabilityPair", null)
+                        .WithMany()
+                        .HasForeignKey("PairId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.AiFactExtractionBatch", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ApiKey", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.BlockedUser", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("BlockerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Challenge", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("CreatorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChallengeParticipant", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Challenge", null)
+                        .WithMany("Participants")
+                        .HasForeignKey("ChallengeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChallengeParticipantHabit", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.ChallengeParticipant", null)
+                        .WithMany("LinkedHabits")
+                        .HasForeignKey("ChallengeParticipantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany()
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChecklistTemplate", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Cheer", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany()
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("RecipientId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("SenderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.FriendFeedEvent", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("ActorUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Friendship", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("AddresseeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("RequesterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.GoalProgressLog", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Goal", null)
+                        .WithMany("ProgressLogs")
+                        .HasForeignKey("GoalId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.GoogleCalendarSyncSuggestion", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Habit", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany("Children")
+                        .HasForeignKey("ParentHabitId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.HabitLog", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Habit", null)
+                        .WithMany("Logs")
+                        .HasForeignKey("HabitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.PendingClarification", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.PushSubscription", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Report", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.Cheer", null)
+                        .WithMany()
+                        .HasForeignKey("CheerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("ReportedUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("ReporterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.SentStreakFreezeAlert", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.StreakFreeze", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.UserSession", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.XpAwardLog", b =>
+                {
+                    b.HasOne("Orbit.Domain.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Challenge", b =>
+                {
+                    b.Navigation("Participants");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.ChallengeParticipant", b =>
+                {
+                    b.Navigation("LinkedHabits");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Goal", b =>
+                {
+                    b.Navigation("ProgressLogs");
+                });
+
+            modelBuilder.Entity("Orbit.Domain.Entities.Habit", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Logs");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.cs b/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.cs
new file mode 100644
index 00000000..95066d82
--- /dev/null
+++ b/src/Orbit.Infrastructure/Migrations/20260705031342_AddHasSeenImportPrompt.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Orbit.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddHasSeenImportPrompt : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "HasSeenImportPrompt",
+                table: "Users",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "HasSeenImportPrompt",
+                table: "Users");
+        }
+    }
+}
diff --git a/src/Orbit.Infrastructure/Migrations/OrbitDbContextModelSnapshot.cs b/src/Orbit.Infrastructure/Migrations/OrbitDbContextModelSnapshot.cs
index da97ab9d..8252f61a 100644
--- a/src/Orbit.Infrastructure/Migrations/OrbitDbContextModelSnapshot.cs
+++ b/src/Orbit.Infrastructure/Migrations/OrbitDbContextModelSnapshot.cs
@@ -1894,6 +1894,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<bool>("HasLoggedFirstHabit")
                         .HasColumnType("boolean");
 
+                    b.Property<bool>("HasSeenImportPrompt")
+                        .HasColumnType("boolean");
+
                     b.Property<bool>("HasTriedAstra")
                         .HasColumnType("boolean");
 
diff --git a/src/Orbit.Infrastructure/Services/AgentCatalogService.Capabilities.cs b/src/Orbit.Infrastructure/Services/AgentCatalogService.Capabilities.cs
index 4721307e..08ed6489 100644
--- a/src/Orbit.Infrastructure/Services/AgentCatalogService.Capabilities.cs
+++ b/src/Orbit.Infrastructure/Services/AgentCatalogService.Capabilities.cs
@@ -462,6 +462,8 @@ private static AgentCapability[] ProfileCapabilities()
                     "ProfileController.SetWeekStartDay",
                     "ProfileController.SetThemePreference",
                     "ProfileController.CompleteOnboarding",
+                    "ProfileController.ApplyOnboarding",
+                    "ProfileController.DismissImportPrompt",
                     "ProfileController.CompleteTour",
                     "ProfileController.ResetTour"
                 ]),
diff --git a/tests/Orbit.Application.Tests/Commands/Profile/ApplyOnboardingCommandHandlerTests.cs b/tests/Orbit.Application.Tests/Commands/Profile/ApplyOnboardingCommandHandlerTests.cs
new file mode 100644
index 00000000..84cfc80c
--- /dev/null
+++ b/tests/Orbit.Application.Tests/Commands/Profile/ApplyOnboardingCommandHandlerTests.cs
@@ -0,0 +1,248 @@
+using FluentAssertions;
+using Microsoft.Extensions.Caching.Memory;
+using NSubstitute;
+using Orbit.Application.Common;
+using Orbit.Application.Profile.Commands;
+using Orbit.Domain.Common;
+using Orbit.Domain.Entities;
+using Orbit.Domain.Enums;
+using Orbit.Domain.Interfaces;
+using System.Linq.Expressions;
+
+namespace Orbit.Application.Tests.Commands.Profile;
+
+public class ApplyOnboardingCommandHandlerTests
+{
+    private readonly IGenericRepository<User> _userRepo = Substitute.For<IGenericRepository<User>>();
+    private readonly IGenericRepository<Habit> _habitRepo = Substitute.For<IGenericRepository<Habit>>();
+    private readonly IGenericRepository<Goal> _goalRepo = Substitute.For<IGenericRepository<Goal>>();
+    private readonly IPayGateService _payGate = Substitute.For<IPayGateService>();
+    private readonly IUserDateService _userDateService = Substitute.For<IUserDateService>();
+    private readonly IAppConfigService _appConfig = Substitute.For<IAppConfigService>();
+    private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
+    private readonly IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
+
+    private static readonly Guid UserId = Guid.NewGuid();
+    private static readonly DateOnly Today = new(2026, 7, 5);
+
+    public ApplyOnboardingCommandHandlerTests()
+    {
+        _userDateService.GetUserTodayAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>()).Returns(Today);
+        _payGate.CanAccessGoals(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(Result.Success()));
+        _appConfig.GetAsync(Arg.Any<string>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns(AppConstants.DefaultFreeMaxHabits);
+        _unitOfWork.ExecuteInTransactionAsync(
+                Arg.Any<Func<CancellationToken, Task>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(call =>
+            {
+                var operation = call.ArgAt<Func<CancellationToken, Task>>(0);
+                var ct = call.ArgAt<CancellationToken>(1);
+                return operation(ct);
+            });
+    }
+
+    private ApplyOnboardingCommandHandler CreateHandler() => new(
+        _userRepo, _habitRepo, _goalRepo, _payGate, _userDateService, _appConfig, _unitOfWork, _cache);
+
+    private void SetupUser(User user)
+    {
+        _userRepo.FindOneTrackedAsync(
+            Arg.Any<Expression<Func<User, bool>>>(),
+            Arg.Any<Func<IQueryable<User>, IQueryable<User>>?>(),
+            Arg.Any<CancellationToken>())
+            .Returns(user);
+    }
+
+    private static User CreateProUser()
+    {
+        return User.Create("Test User", "test@example.com").Value;
+    }
+
+    private static User CreateFreeUser()
+    {
+        var user = User.Create("Free User", "free@example.com").Value;
+        user.StartTrial(DateTime.UtcNow.AddDays(-1));
+        return user;
+    }
+
+    private static ApplyHabitInput Habit(string title) =>
+        new(title, null, null, FrequencyUnit.Day, 1);
+
+    [Fact]
+    public async Task Apply_HappyPath_CreatesEverythingAndCompletesOnboarding()
+    {
+        var user = CreateProUser();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId,
+            [Habit("Drink water"), Habit("Read")],
+            new ApplyLogInput(0, Today),
+            new ApplyGoalInput("Run 100km", null, 100, "km"),
+            WeekStartDay: 0,
+            ColorScheme: "blue");
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeTrue();
+        result.Value.CreatedHabitCount.Should().Be(2);
+        result.Value.CreatedGoal.Should().BeTrue();
+        result.Value.LoggedFirstHabit.Should().BeTrue();
+        user.HasCompletedOnboarding.Should().BeTrue();
+        user.WeekStartDay.Should().Be(0);
+        user.ColorScheme.Should().Be("blue");
+        await _habitRepo.Received(2).AddAsync(Arg.Any<Habit>(), Arg.Any<CancellationToken>());
+        await _goalRepo.Received(1).AddAsync(Arg.Any<Goal>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Apply_AlreadyOnboarded_IsNoOp()
+    {
+        var user = CreateProUser();
+        user.CompleteOnboarding();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], null, null, null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeFalse();
+        result.Value.CreatedHabitCount.Should().Be(0);
+        await _habitRepo.DidNotReceive().AddAsync(Arg.Any<Habit>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.DidNotReceive().SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Apply_UserNotFound_ReturnsFailure()
+    {
+        _userRepo.FindOneTrackedAsync(
+            Arg.Any<Expression<Func<User, bool>>>(),
+            Arg.Any<Func<IQueryable<User>, IQueryable<User>>?>(),
+            Arg.Any<CancellationToken>())
+            .Returns((User?)null);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], null, null, null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsFailure.Should().BeTrue();
+        result.Error.Should().Be("User not found.");
+        await _unitOfWork.DidNotReceive().SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Apply_HabitCreationFails_RollsBackWithoutSaving()
+    {
+        var user = CreateProUser();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Valid"), Habit("   ")], null, null, null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsFailure.Should().BeTrue();
+        user.HasCompletedOnboarding.Should().BeFalse();
+        await _unitOfWork.DidNotReceive().SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Apply_FreeUserOverCap_TrimsToAllowance()
+    {
+        var user = CreateFreeUser();
+        SetupUser(user);
+        _habitRepo.CountAsync(Arg.Any<Expression<Func<Habit, bool>>>(), Arg.Any<CancellationToken>())
+            .Returns(AppConstants.DefaultFreeMaxHabits - 1);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("One"), Habit("Two"), Habit("Three")], null, null, null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeTrue();
+        result.Value.CreatedHabitCount.Should().Be(1);
+        await _habitRepo.Received(1).AddAsync(Arg.Any<Habit>(), Arg.Any<CancellationToken>());
+        user.HasCompletedOnboarding.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Apply_GoalGateFails_SkipsGoalButStillApplies()
+    {
+        var user = CreateFreeUser();
+        SetupUser(user);
+        _payGate.CanAccessGoals(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(Result.PayGateFailure("Goals are a Pro feature. Upgrade to unlock!")));
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], null,
+            new ApplyGoalInput("Run 100km", null, 100, "km"), null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeTrue();
+        result.Value.CreatedGoal.Should().BeFalse();
+        result.Value.CreatedHabitCount.Should().Be(1);
+        await _goalRepo.DidNotReceive().AddAsync(Arg.Any<Goal>(), Arg.Any<CancellationToken>());
+        user.HasCompletedOnboarding.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Apply_GoalDeadlineInPast_ReturnsFailureWithoutSaving()
+    {
+        var user = CreateProUser();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], null,
+            new ApplyGoalInput("Run 100km", null, 100, "km", Today.AddDays(-1)), null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsFailure.Should().BeTrue();
+        result.Error.Should().Be("Deadline cannot be in the past.");
+        user.HasCompletedOnboarding.Should().BeFalse();
+        await _unitOfWork.DidNotReceive().SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Apply_FirstLogIndexOutOfRange_AppliesWithoutLogging()
+    {
+        var user = CreateProUser();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], new ApplyLogInput(5, Today), null, null, null);
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeTrue();
+        result.Value.LoggedFirstHabit.Should().BeFalse();
+        user.HasCompletedOnboarding.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Apply_InvalidColorScheme_ReturnsFailureWithoutSaving()
+    {
+        var user = CreateProUser();
+        SetupUser(user);
+
+        var command = new ApplyOnboardingCommand(
+            UserId, [Habit("Drink water")], null, null, WeekStartDay: null, ColorScheme: "magenta");
+
+        var result = await CreateHandler().Handle(command, CancellationToken.None);
+
+        result.IsFailure.Should().BeTrue();
+        user.HasCompletedOnboarding.Should().BeFalse();
+        await _unitOfWork.DidNotReceive().SaveChangesAsync(Arg.Any<CancellationToken>());
+    }
+}
diff --git a/tests/Orbit.Infrastructure.Tests/Controllers/ProfileControllerTests.cs b/tests/Orbit.Infrastructure.Tests/Controllers/ProfileControllerTests.cs
index c9d19dae..41b19a52 100644
--- a/tests/Orbit.Infrastructure.Tests/Controllers/ProfileControllerTests.cs
+++ b/tests/Orbit.Infrastructure.Tests/Controllers/ProfileControllerTests.cs
@@ -244,6 +244,54 @@ public async Task CompleteOnboarding_Failure_ReturnsBadRequest()
         result.Should().BeAssignableTo<ObjectResult>().Which.StatusCode.Should().Be(400);
     }
 
+    [Fact]
+    public async Task ApplyOnboarding_Success_ReturnsOkWithResponse()
+    {
+        var response = new ApplyOnboardingResponse(true, 2, false, true);
+        _mediator.Send(Arg.Any<ApplyOnboardingCommand>(), Arg.Any<CancellationToken>())
+            .Returns(Result.Success(response));
+
+        var request = new ProfileController.ApplyOnboardingRequest(
+            [new ApplyHabitInput("Drink water", null, null, null, null)], null, null, 1, "purple");
+        var result = await _controller.ApplyOnboarding(request, CancellationToken.None);
+
+        result.Should().BeOfType<OkObjectResult>().Which.Value.Should().Be(response);
+    }
+
+    [Fact]
+    public async Task ApplyOnboarding_Failure_ReturnsBadRequest()
+    {
+        _mediator.Send(Arg.Any<ApplyOnboardingCommand>(), Arg.Any<CancellationToken>())
+            .Returns(Result.Failure<ApplyOnboardingResponse>("Error"));
+
+        var request = new ProfileController.ApplyOnboardingRequest(null, null, null, null, null);
+        var result = await _controller.ApplyOnboarding(request, CancellationToken.None);
+
+        result.Should().BeAssignableTo<ObjectResult>().Which.StatusCode.Should().Be(400);
+    }
+
+    [Fact]
+    public async Task DismissImportPrompt_Success_ReturnsNoContent()
+    {
+        _mediator.Send(Arg.Any<DismissImportPromptCommand>(), Arg.Any<CancellationToken>())
+            .Returns(Result.Success());
+
+        var result = await _controller.DismissImportPrompt(CancellationToken.None);
+
+        result.Should().BeOfType<NoContentResult>();
+    }
+
+    [Fact]
+    public async Task DismissImportPrompt_Failure_ReturnsBadRequest()
+    {
+        _mediator.Send(Arg.Any<DismissImportPromptCommand>(), Arg.Any<CancellationToken>())
+            .Returns(Result.Failure("Error"));
+
+        var result = await _controller.DismissImportPrompt(CancellationToken.None);
+
+        result.Should().BeAssignableTo<ObjectResult>().Which.StatusCode.Should().Be(400);
+    }
+
     [Fact]
     public async Task ResetAccount_Success_ReturnsOk()
     {
diff --git a/tests/Orbit.Infrastructure.Tests/Mcp/ProfileToolsTests.cs b/tests/Orbit.Infrastructure.Tests/Mcp/ProfileToolsTests.cs
index b713efa6..25dd940e 100644
--- a/tests/Orbit.Infrastructure.Tests/Mcp/ProfileToolsTests.cs
+++ b/tests/Orbit.Infrastructure.Tests/Mcp/ProfileToolsTests.cs
@@ -52,7 +52,7 @@ public async Task GetProfile_Success_ReturnsFormattedProfile()
         var profile = new ProfileResponse(
             "Thomas", "thomas@example.com", "America/Sao_Paulo",
             true, true, true, true, true, true, true, true, "pt-BR", "Pro", true, false, null, null,
-            5, 100, false, false, null, null, false, 1, 500, 5, "Achiever",
+            5, 100, false, false, false, null, null, false, 1, 500, 5, "Achiever",
             0, 10, 12, 2, null, null,
             false, GoogleCalendarAutoSyncStatus.Idle, null, true, null, false);
 
diff --git a/tests/Orbit.Infrastructure.Tests/Persistence/ApplyOnboardingConcurrencyTests.cs b/tests/Orbit.Infrastructure.Tests/Persistence/ApplyOnboardingConcurrencyTests.cs
new file mode 100644
index 00000000..18ea86e9
--- /dev/null
+++ b/tests/Orbit.Infrastructure.Tests/Persistence/ApplyOnboardingConcurrencyTests.cs
@@ -0,0 +1,98 @@
+using FluentAssertions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Caching.Memory;
+using NSubstitute;
+using Orbit.Application.Behaviors;
+using Orbit.Application.Common;
+using Orbit.Application.Profile.Commands;
+using Orbit.Domain.Common;
+using Orbit.Domain.Entities;
+using Orbit.Domain.Enums;
+using Orbit.Domain.Interfaces;
+using Orbit.Infrastructure.Persistence;
+
+namespace Orbit.Infrastructure.Tests.Persistence;
+
+/// <summary>
+/// Verifies that <see cref="ApplyOnboardingCommand"/> applies exactly once when the first save hits a
+/// simulated stale-token conflict and the concurrency-retry pipeline re-runs the whole handler. The
+/// in-memory provider does not enforce xmin, so the conflict is injected with a save interceptor.
+/// </summary>
+public class ApplyOnboardingConcurrencyTests
+{
+    [Fact]
+    public async Task Apply_ConflictOnFirstSave_RetriesAndAppliesExactlyOnce()
+    {
+        var dbName = $"ApplyOnboardingConcurrency_{Guid.NewGuid()}";
+        Guid userId;
+
+        await using (var seed = CreateContext(dbName))
+        {
+            var user = User.Create("Tester", $"{Guid.NewGuid():N}@example.com").Value;
+            seed.Users.Add(user);
+            await seed.SaveChangesAsync();
+            userId = user.Id;
+        }
+
+        var interceptor = new ConflictOnceInterceptor();
+        await using var context = CreateContext(dbName, interceptor);
+        var unitOfWork = new UnitOfWork(context);
+        var handler = new ApplyOnboardingCommandHandler(
+            new GenericRepository<User>(context),
+            new GenericRepository<Habit>(context),
+            new GenericRepository<Goal>(context),
+            Substitute.For<IPayGateService>(),
+            StubToday(new DateOnly(2026, 7, 5)),
+            Substitute.For<IAppConfigService>(),
+            unitOfWork,
+            new MemoryCache(new MemoryCacheOptions()));
+
+        var command = new ApplyOnboardingCommand(
+            userId,
+            [new ApplyHabitInput("Drink water", null, null, FrequencyUnit.Day, 1)],
+            null, null, null, null);
+
+        var behavior = new ConcurrencyRetryBehavior<ApplyOnboardingCommand, Result<ApplyOnboardingResponse>>(unitOfWork);
+        var result = await behavior.Handle(command, ct => handler.Handle(command, ct), CancellationToken.None);
+
+        interceptor.SaveAttempts.Should().Be(2);
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Applied.Should().BeTrue();
+        result.Value.CreatedHabitCount.Should().Be(1);
+
+        await using var verify = CreateContext(dbName);
+        verify.Users.Single(u => u.Id == userId).HasCompletedOnboarding.Should().BeTrue();
+        verify.Habits.Count(h => h.UserId == userId).Should().Be(1);
+    }
+
+    private static OrbitDbContext CreateContext(string dbName, ISaveChangesInterceptor? interceptor = null)
+    {
+        var builder = new DbContextOptionsBuilder<OrbitDbContext>().UseInMemoryDatabase(dbName);
+        if (interceptor is not null)
+            builder.AddInterceptors(interceptor);
+        return new OrbitDbContext(builder.Options);
+    }
+
+    private static IUserDateService StubToday(DateOnly today)
+    {
+        var service = Substitute.For<IUserDateService>();
+        service.GetUserTodayAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>()).Returns(today);
+        return service;
+    }
+
+    private sealed class ConflictOnceInterceptor : SaveChangesInterceptor
+    {
+        public int SaveAttempts { get; private set; }
+
+        public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
+            DbContextEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
+        {
+            SaveAttempts++;
+            if (SaveAttempts == 1)
+                throw new DbUpdateConcurrencyException("simulated stale token");
+            return base.SavingChangesAsync(eventData, result, cancellationToken);
+        }
+    }
+}