feat(ui): Hub Navigation, Profile Dashboard and Auth Stability Fixes (#31)

This PR implements the Hub Navigation system and the Profile Dashboard, while resolving critical session synchronization issues.

### Key Changes
- **Hub Navigation**: Introduced `MainHubLayout` with a premium glassmorphism sidebar, providing access to Dashboard, Library, Concepts Map, and Profile.
- **Profile Dashboard**: Implemented a high-fidelity Profile page (#27) with learning metrics, AI token usage tracking, and system rank visualization.
- **Stability Fixes**:
    - Resolved an infinite network loop on the `/profile` page by implementing request deduplication and in-memory caching in `IdentityService`.
    - Added environment-aware guards to prevent illegal JavaScript interop calls during server-side prerendering.
    - Implemented automatic session invalidation on `401 Unauthorized` responses to handle stale authentication states gracefully.
- **Reader Integration**: Added a "Return to Dashboard" option in the reader toolbar (#26).

Closes #26
Closes #27

Reviewed-on: #31
Co-authored-by: Marek Jasiński <jasins.marek@gmail.com>
Co-committed-by: Marek Jasiński <jasins.marek@gmail.com>

.agent/skills/nexus-architecture-standards/SKILL.md

@@ -36,6 +36,13 @@ This skill defines the architectural guardrails for the NexusReader project to e
 +- Event handlers MUST use `Func<Task>` or async-compatible patterns.
 +- UI components MUST await all service calls and use `InvokeAsync(StateHasChanged)` for state updates within async contexts.
 
+### 6. Database Schema Changes
+- Every change to a Domain entity or DbContext MUST be followed by the generation of a new EF Core migration.
+- **Mandatory Commands**:
+  - `dotnet ef migrations add <MigrationName> --project src/NexusReader.Data --startup-project src/NexusReader.Web.New`
+  - `dotnet ef database update --project src/NexusReader.Data --startup-project src/NexusReader.Web.New`
+- Ensure the migration is applied to all local development environments before proceeding with feature verification.
+
 ## Audit Scripts
 - [ArchCheck.sh](scripts/arch_check.sh): A shell script to scan for illegal cross-layer imports.
 

.agent/skills/nexus-ui-engine/SKILL.md

@@ -44,3 +44,6 @@ description: Design System & Component rules for Blazor
 - **Interactive Flow:**
   - AI Assistant interactions must be non-blocking and smoothly transition using CSS animations.
   - Interactive elements must have clear `:hover`, `:active`, and `:focus` states.
+  - **Glass Panel Standard:** All primary data panels (`.glass-panel`) must implement the following interaction signature:
+    - `transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1)`
+    - `:hover` state must include: `transform: translateY(-4px)`, increased background opacity, and a subtle `--nexus-neon` border highlight (e.g., `rgba(0, 255, 153, 0.2)`).

src/NexusReader.Application/Abstractions/Services/IEpubService.cs

@@ -5,5 +5,5 @@ namespace NexusReader.Application.Abstractions.Services;
 
 public interface IEpubService
 {
-    Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex);
+    Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex, string? userId = null);
 }

src/NexusReader.Application/Commands/Sync/UpdateReadingProgressCommand.cs

@@ -3,4 +3,11 @@ using MediatR;
 
 namespace NexusReader.Application.Commands.Sync;
 
-public record UpdateReadingProgressCommand(string PageId, string UserId, string? ExcludedConnectionId = null) : IRequest<Result>;
+public record UpdateReadingProgressCommand(
+    string PageId, 
+    string UserId, 
+    Guid EbookId, 
+    double Progress, 
+    string? ChapterTitle,
+    int ChapterIndex,
+    string? ExcludedConnectionId = null) : IRequest<Result>;

src/NexusReader.Application/DTOs/User/AuthorDto.cs

@@ -0,0 +1,7 @@
+namespace NexusReader.Application.DTOs.User;
+
+public record AuthorDto
+{
+    public int Id { get; init; }
+    public string Name { get; init; } = string.Empty;
+}

src/NexusReader.Application/DTOs/User/UserProfileDto.cs

@@ -4,6 +4,7 @@ public record UserProfileDto
 {
     public string Email { get; init; } = string.Empty;
     public int AITokensUsed { get; init; }
+    public Guid TenantId { get; init; }
     
     /// <summary>
     /// Relational data for the current subscription plan.
@@ -22,4 +23,9 @@ public record LastReadBookDto
 {
     public Guid Id { get; init; }
     public string Title { get; init; } = string.Empty;
+    public AuthorDto Author { get; init; } = new();
+    public string? CoverUrl { get; init; }
+    public double Progress { get; init; }
+    public string? LastChapter { get; init; }
+    public int LastChapterIndex { get; init; }
 }

src/NexusReader.Application/Queries/Reader/GetReaderPageQuery.cs

@@ -2,4 +2,4 @@ using NexusReader.Application.Abstractions.Messaging;
 
 namespace NexusReader.Application.Queries.Reader;
 
-public record GetReaderPageQuery(int ChapterIndex = 0) : IQuery<ReaderPageViewModel>;
+public record GetReaderPageQuery(int ChapterIndex = 0, string? UserId = null) : IQuery<ReaderPageViewModel>;

src/NexusReader.Application/Queries/Reader/GetReaderPageQueryHandler.cs

@@ -15,6 +15,6 @@ internal sealed class GetReaderPageQueryHandler : IQueryHandler<GetReaderPageQue
 
     public async Task<Result<ReaderPageViewModel>> Handle(GetReaderPageQuery request, CancellationToken cancellationToken)
     {
-        return await _epubService.GetEpubContentAsync(request.ChapterIndex);
+        return await _epubService.GetEpubContentAsync(request.ChapterIndex, request.UserId);
     }
 }

src/NexusReader.Application/Queries/Reader/ViewModels.cs

@@ -8,4 +8,4 @@ public abstract record ContentBlock(string Id);
 public record TextSegmentBlock(string Id, string Content) : ContentBlock(Id);
 public record AiActionTriggerBlock(string Id, string Dialogue, List<string> ActionOptions) : ContentBlock(Id);
 
-public record ReaderPageViewModel(List<ContentBlock> Blocks, int CurrentChapterIndex, int TotalChapters, string ChapterTitle);
+public record ReaderPageViewModel(List<ContentBlock> Blocks, int CurrentChapterIndex, int TotalChapters, string ChapterTitle, Guid EbookId = default);

src/NexusReader.Application/Queries/User/GetUserProfileQuery.cs

@@ -0,0 +1,7 @@
+using MediatR;
+using FluentResults;
+using NexusReader.Application.DTOs.User;
+
+namespace NexusReader.Application.Queries.User;
+
+public record GetUserProfileQuery(string UserId) : IRequest<Result<UserProfileDto>>;

src/NexusReader.Application/Queries/User/GetUserProfileQueryHandler.cs

@@ -0,0 +1,62 @@
+using MediatR;
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using NexusReader.Application.DTOs.User;
+using NexusReader.Data.Persistence;
+
+namespace NexusReader.Application.Queries.User;
+
+public class GetUserProfileQueryHandler : IRequestHandler<GetUserProfileQuery, Result<UserProfileDto>>
+{
+    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;
+
+    public GetUserProfileQueryHandler(IDbContextFactory<AppDbContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }
+
+    public async Task<Result<UserProfileDto>> Handle(GetUserProfileQuery request, CancellationToken cancellationToken)
+    {
+        using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        var profile = await dbContext.Users
+            .Where(u => u.Id == request.UserId)
+            .Select(u => new UserProfileDto
+            {
+                Email = u.Email ?? string.Empty,
+                AITokensUsed = u.AITokensUsed,
+                TenantId = u.TenantId != null && u.TenantId.Length == 36 ? new Guid(u.TenantId) : Guid.Empty,
+                Plan = u.SubscriptionPlan != null ? new SubscriptionPlanDto
+                {
+                    Id = u.SubscriptionPlan.Id,
+                    Name = u.SubscriptionPlan.PlanName,
+                    AITokenLimit = u.SubscriptionPlan.AITokenLimit,
+                    MonthlyPrice = u.SubscriptionPlan.MonthlyPrice
+                } : new SubscriptionPlanDto(),
+                AverageQuizScore = u.QuizResults.Any(q => q.TotalQuestions > 0) 
+                    ? (int)u.QuizResults.Where(q => q.TotalQuestions > 0).Average(q => (double)q.Score / q.TotalQuestions * 100) 
+                    : 0,
+                LastReadBook = u.Ebooks.OrderByDescending(e => e.LastReadDate).Select(e => new LastReadBookDto
+                {
+                    Id = e.Id,
+                    Title = e.Title,
+                    Author = new AuthorDto 
+                    { 
+                        Id = e.Author.Id, 
+                        Name = e.Author.Name 
+                    },
+                    CoverUrl = e.CoverUrl,
+                    Progress = e.Progress,
+                    LastChapter = e.LastChapter ?? "Rozpoczynanie...",
+                    LastChapterIndex = e.LastChapterIndex
+                }).FirstOrDefault()
+            })
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (profile == null)
+        {
+            return Result.Fail("Profile not found.");
+        }
+
+        return Result.Ok(profile);
+    }
+}

src/NexusReader.Data/Migrations/20260510151022_NormalizeAuthor.Designer.cs

@@ -0,0 +1,690 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NexusReader.Data.Persistence;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Pgvector;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260510151022_NormalizeAuthor")]
+    partial class NormalizeAuthor
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "vector");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("AddedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("AuthorId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CoverUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastReadDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MetadataJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(768)");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("KnowledgeUnits");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("SourceUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TargetUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceUnitId");
+
+                    b.HasIndex("TargetUnitId");
+
+                    b.ToTable("KnowledgeUnitLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AITokensUsed")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastAiActionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastReadPageId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SubscriptionPlanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("SubscriptionPlanId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CompletedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalQuestions")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("QuizResults");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SemanticKnowledgeCache", b =>
+                {
+                    b.Property<string>("ContentHash")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JsonData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ModelId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OriginalText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PromptVersion")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(1536)");
+
+                    b.HasKey("ContentHash");
+
+                    b.HasIndex("ContentHash")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("SemanticKnowledgeCache");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SubscriptionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsUnlimitedTokens")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("MonthlyPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("PlanName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StripeProductId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlanName")
+                        .IsUnique();
+
+                    b.ToTable("SubscriptionPlans");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AITokenLimit = 5000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 0m,
+                            PlanName = "Free",
+                            StripeProductId = "prod_Free789"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            AITokenLimit = 10000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 9.99m,
+                            PlanName = "Basic",
+                            StripeProductId = "prod_basic_placeholder"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            AITokenLimit = 50000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 19.99m,
+                            PlanName = "Pro",
+                            StripeProductId = "prod_pro_placeholder"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            AITokenLimit = 1000000000,
+                            IsUnlimitedTokens = true,
+                            MonthlyPrice = 99.99m,
+                            PlanName = "Enterprise",
+                            StripeProductId = "prod_enterprise_placeholder"
+                        });
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.Author", "Author")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Author");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "SourceUnit")
+                        .WithMany("OutgoingLinks")
+                        .HasForeignKey("SourceUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "TargetUnit")
+                        .WithMany("IncomingLinks")
+                        .HasForeignKey("TargetUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SourceUnit");
+
+                    b.Navigation("TargetUnit");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.SubscriptionPlan", "SubscriptionPlan")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionPlanId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SubscriptionPlan");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("QuizResults")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Navigation("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Navigation("IncomingLinks");
+
+                    b.Navigation("OutgoingLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Navigation("Ebooks");
+
+                    b.Navigation("QuizResults");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/NexusReader.Data/Migrations/20260510151022_NormalizeAuthor.cs

@@ -0,0 +1,79 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class NormalizeAuthor : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Author",
+                table: "Ebooks");
+
+            migrationBuilder.AddColumn<int>(
+                name: "AuthorId",
+                table: "Ebooks",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateTable(
+                name: "Authors",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Name = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Authors", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Ebooks_AuthorId",
+                table: "Ebooks",
+                column: "AuthorId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Ebooks_Authors_AuthorId",
+                table: "Ebooks",
+                column: "AuthorId",
+                principalTable: "Authors",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Ebooks_Authors_AuthorId",
+                table: "Ebooks");
+
+            migrationBuilder.DropTable(
+                name: "Authors");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Ebooks_AuthorId",
+                table: "Ebooks");
+
+            migrationBuilder.DropColumn(
+                name: "AuthorId",
+                table: "Ebooks");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Author",
+                table: "Ebooks",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}

src/NexusReader.Data/Migrations/20260510161155_AddEbookProgressAndChapter.Designer.cs

@@ -0,0 +1,697 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NexusReader.Data.Persistence;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Pgvector;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260510161155_AddEbookProgressAndChapter")]
+    partial class AddEbookProgressAndChapter
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "vector");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("AddedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("AuthorId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CoverUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastChapter")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("LastReadDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Progress")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MetadataJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(768)");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("KnowledgeUnits");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("SourceUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TargetUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceUnitId");
+
+                    b.HasIndex("TargetUnitId");
+
+                    b.ToTable("KnowledgeUnitLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AITokensUsed")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastAiActionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastReadPageId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SubscriptionPlanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("SubscriptionPlanId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CompletedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalQuestions")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("QuizResults");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SemanticKnowledgeCache", b =>
+                {
+                    b.Property<string>("ContentHash")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JsonData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ModelId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OriginalText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PromptVersion")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(1536)");
+
+                    b.HasKey("ContentHash");
+
+                    b.HasIndex("ContentHash")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("SemanticKnowledgeCache");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SubscriptionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsUnlimitedTokens")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("MonthlyPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("PlanName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StripeProductId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlanName")
+                        .IsUnique();
+
+                    b.ToTable("SubscriptionPlans");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AITokenLimit = 5000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 0m,
+                            PlanName = "Free",
+                            StripeProductId = "prod_Free789"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            AITokenLimit = 10000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 9.99m,
+                            PlanName = "Basic",
+                            StripeProductId = "prod_basic_placeholder"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            AITokenLimit = 50000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 19.99m,
+                            PlanName = "Pro",
+                            StripeProductId = "prod_pro_placeholder"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            AITokenLimit = 1000000000,
+                            IsUnlimitedTokens = true,
+                            MonthlyPrice = 99.99m,
+                            PlanName = "Enterprise",
+                            StripeProductId = "prod_enterprise_placeholder"
+                        });
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.Author", "Author")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Author");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "SourceUnit")
+                        .WithMany("OutgoingLinks")
+                        .HasForeignKey("SourceUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "TargetUnit")
+                        .WithMany("IncomingLinks")
+                        .HasForeignKey("TargetUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SourceUnit");
+
+                    b.Navigation("TargetUnit");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.SubscriptionPlan", "SubscriptionPlan")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionPlanId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SubscriptionPlan");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("QuizResults")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Navigation("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Navigation("IncomingLinks");
+
+                    b.Navigation("OutgoingLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Navigation("Ebooks");
+
+                    b.Navigation("QuizResults");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/NexusReader.Data/Migrations/20260510161155_AddEbookProgressAndChapter.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddEbookProgressAndChapter : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "LastChapter",
+                table: "Ebooks",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: true);
+
+            migrationBuilder.AddColumn<double>(
+                name: "Progress",
+                table: "Ebooks",
+                type: "double precision",
+                nullable: false,
+                defaultValue: 0.0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastChapter",
+                table: "Ebooks");
+
+            migrationBuilder.DropColumn(
+                name: "Progress",
+                table: "Ebooks");
+        }
+    }
+}

src/NexusReader.Data/Migrations/20260510171941_AddEbookLastChapterIndex.Designer.cs

@@ -0,0 +1,700 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NexusReader.Data.Persistence;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Pgvector;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260510171941_AddEbookLastChapterIndex")]
+    partial class AddEbookLastChapterIndex
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "vector");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("AddedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("AuthorId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CoverUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastChapter")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("LastChapterIndex")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("LastReadDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Progress")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MetadataJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(768)");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("KnowledgeUnits");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("SourceUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TargetUnitId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceUnitId");
+
+                    b.HasIndex("TargetUnitId");
+
+                    b.ToTable("KnowledgeUnitLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AITokensUsed")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastAiActionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastReadPageId")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SubscriptionPlanId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("SubscriptionPlanId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CompletedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("TotalQuestions")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("QuizResults");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SemanticKnowledgeCache", b =>
+                {
+                    b.Property<string>("ContentHash")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JsonData")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ModelId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OriginalText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PromptVersion")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<string>("TenantId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Vector>("Vector")
+                        .HasColumnType("vector(1536)");
+
+                    b.HasKey("ContentHash");
+
+                    b.HasIndex("ContentHash")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("SemanticKnowledgeCache");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.SubscriptionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AITokenLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsUnlimitedTokens")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("MonthlyPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("PlanName")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StripeProductId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlanName")
+                        .IsUnique();
+
+                    b.ToTable("SubscriptionPlans");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AITokenLimit = 5000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 0m,
+                            PlanName = "Free",
+                            StripeProductId = "prod_Free789"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            AITokenLimit = 10000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 9.99m,
+                            PlanName = "Basic",
+                            StripeProductId = "prod_basic_placeholder"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            AITokenLimit = 50000,
+                            IsUnlimitedTokens = false,
+                            MonthlyPrice = 19.99m,
+                            PlanName = "Pro",
+                            StripeProductId = "prod_pro_placeholder"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            AITokenLimit = 1000000000,
+                            IsUnlimitedTokens = true,
+                            MonthlyPrice = 99.99m,
+                            PlanName = "Enterprise",
+                            StripeProductId = "prod_enterprise_placeholder"
+                        });
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.Author", "Author")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Author");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "SourceUnit")
+                        .WithMany("OutgoingLinks")
+                        .HasForeignKey("SourceUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("NexusReader.Domain.Entities.KnowledgeUnit", "TargetUnit")
+                        .WithMany("IncomingLinks")
+                        .HasForeignKey("TargetUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SourceUnit");
+
+                    b.Navigation("TargetUnit");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.SubscriptionPlan", "SubscriptionPlan")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionPlanId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("SubscriptionPlan");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.QuizResult", b =>
+                {
+                    b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
+                        .WithMany("QuizResults")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Navigation("Ebooks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
+                {
+                    b.Navigation("IncomingLinks");
+
+                    b.Navigation("OutgoingLinks");
+                });
+
+            modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
+                {
+                    b.Navigation("Ebooks");
+
+                    b.Navigation("QuizResults");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/NexusReader.Data/Migrations/20260510171941_AddEbookLastChapterIndex.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NexusReader.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddEbookLastChapterIndex : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "LastChapterIndex",
+                table: "Ebooks",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LastChapterIndex",
+                table: "Ebooks");
+        }
+    }
+}

src/NexusReader.Data/Migrations/AppDbContextModelSnapshot.cs

@@ -156,6 +156,24 @@ namespace NexusReader.Data.Migrations
                     b.ToTable("AspNetUserTokens", (string)null);
                 });
 
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Authors");
+                });
+
             modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
                 {
                     b.Property<Guid>("Id")
@@ -165,10 +183,8 @@ namespace NexusReader.Data.Migrations
                     b.Property<DateTime>("AddedDate")
                         .HasColumnType("timestamp with time zone");
 
-                    b.Property<string>("Author")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
+                    b.Property<int>("AuthorId")
+                        .HasColumnType("integer");
 
                     b.Property<string>("CoverUrl")
                         .HasColumnType("text");
@@ -177,9 +193,19 @@ namespace NexusReader.Data.Migrations
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<string>("LastChapter")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<int>("LastChapterIndex")
+                        .HasColumnType("integer");
+
                     b.Property<DateTime?>("LastReadDate")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<double>("Progress")
+                        .HasColumnType("double precision");
+
                     b.Property<string>("TenantId")
                         .IsRequired()
                         .HasMaxLength(128)
@@ -196,11 +222,13 @@ namespace NexusReader.Data.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("AuthorId");
+
                     b.HasIndex("TenantId");
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("Ebooks", (string)null);
+                    b.ToTable("Ebooks");
                 });
 
             modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
@@ -246,7 +274,7 @@ namespace NexusReader.Data.Migrations
 
                     b.HasIndex("TenantId");
 
-                    b.ToTable("KnowledgeUnits", (string)null);
+                    b.ToTable("KnowledgeUnits");
                 });
 
             modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnitLink", b =>
@@ -278,7 +306,7 @@ namespace NexusReader.Data.Migrations
 
                     b.HasIndex("TargetUnitId");
 
-                    b.ToTable("KnowledgeUnitLinks", (string)null);
+                    b.ToTable("KnowledgeUnitLinks");
                 });
 
             modelBuilder.Entity("NexusReader.Domain.Entities.NexusUser", b =>
@@ -413,7 +441,7 @@ namespace NexusReader.Data.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("QuizResults", (string)null);
+                    b.ToTable("QuizResults");
                 });
 
             modelBuilder.Entity("NexusReader.Domain.Entities.SemanticKnowledgeCache", b =>
@@ -458,7 +486,7 @@ namespace NexusReader.Data.Migrations
 
                     b.HasIndex("TenantId");
 
-                    b.ToTable("SemanticKnowledgeCache", (string)null);
+                    b.ToTable("SemanticKnowledgeCache");
                 });
 
             modelBuilder.Entity("NexusReader.Domain.Entities.SubscriptionPlan", b =>
@@ -493,7 +521,7 @@ namespace NexusReader.Data.Migrations
                     b.HasIndex("PlanName")
                         .IsUnique();
 
-                    b.ToTable("SubscriptionPlans", (string)null);
+                    b.ToTable("SubscriptionPlans");
 
                     b.HasData(
                         new
@@ -587,12 +615,20 @@ namespace NexusReader.Data.Migrations
 
             modelBuilder.Entity("NexusReader.Domain.Entities.Ebook", b =>
                 {
+                    b.HasOne("NexusReader.Domain.Entities.Author", "Author")
+                        .WithMany("Ebooks")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
                     b.HasOne("NexusReader.Domain.Entities.NexusUser", "User")
                         .WithMany("Ebooks")
                         .HasForeignKey("UserId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("Author");
+
                     b.Navigation("User");
                 });
 
@@ -637,6 +673,11 @@ namespace NexusReader.Data.Migrations
                     b.Navigation("User");
                 });
 
+            modelBuilder.Entity("NexusReader.Domain.Entities.Author", b =>
+                {
+                    b.Navigation("Ebooks");
+                });
+
             modelBuilder.Entity("NexusReader.Domain.Entities.KnowledgeUnit", b =>
                 {
                     b.Navigation("IncomingLinks");

src/NexusReader.Data/Persistence/AppDbContext.cs

@@ -24,6 +24,7 @@ public class AppDbContext : IdentityDbContext<NexusUser>
     public DbSet<Ebook> Ebooks => Set<Ebook>();
     public DbSet<QuizResult> QuizResults => Set<QuizResult>();
     public DbSet<SubscriptionPlan> SubscriptionPlans => Set<SubscriptionPlan>();
+    public DbSet<Author> Authors => Set<Author>();
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
@@ -89,6 +90,11 @@ public class AppDbContext : IdentityDbContext<NexusUser>
                 .HasForeignKey(e => e.UserId)
                 .OnDelete(DeleteBehavior.Cascade);
 
+            entity.HasOne(e => e.Author)
+                .WithMany(a => a.Ebooks)
+                .HasForeignKey(e => e.AuthorId)
+                .OnDelete(DeleteBehavior.Restrict);
+            
             entity.HasIndex(e => e.TenantId);
         });
 

src/NexusReader.Data/Persistence/DbInitializer.cs

@@ -78,6 +78,33 @@ public static class DbInitializer
                 await dbContext.SaveChangesAsync();
 
                 Console.WriteLine($"[Seeder] Admin user created successfully: {adminEmail}");
+
+                // Seed Sample Author
+                var author = await dbContext.Authors.FirstOrDefaultAsync(a => a.Name == "Giorgio Vasari");
+                if (author == null)
+                {
+                    author = new Author { Name = "Giorgio Vasari" };
+                    dbContext.Authors.Add(author);
+                    await dbContext.SaveChangesAsync();
+                }
+
+                // Seed Sample Ebook
+                if (!dbContext.Ebooks.Any(e => e.UserId == adminUser.Id))
+                {
+                    dbContext.Ebooks.Add(new Ebook
+                    {
+                        Title = "Lives of the Most Excellent Painters, Sculptors, and Architects",
+                        AuthorId = author.Id,
+                        UserId = adminUser.Id,
+                        FilePath = "wwwroot/assets/book.epub",
+                        AddedDate = DateTime.UtcNow,
+                        LastReadDate = DateTime.UtcNow,
+                        Progress = 0,
+                        LastChapter = "Introduction"
+                    });
+                    await dbContext.SaveChangesAsync();
+                    Console.WriteLine("[Seeder] Sample book seeded for admin.");
+                }
             }
             else
             {

src/NexusReader.Domain/Entities/Author.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace NexusReader.Domain.Entities;
+
+public class Author
+{
+    [Key]
+    public int Id { get; set; }
+
+    [Required]
+    [MaxLength(255)]
+    public string Name { get; set; } = string.Empty;
+
+    public virtual ICollection<Ebook> Ebooks { get; set; } = new List<Ebook>();
+}

src/NexusReader.Domain/Entities/Ebook.cs

@@ -15,8 +15,11 @@ public class Ebook
     [MaxLength(255)]
     public string Title { get; set; } = string.Empty;
 
-    [MaxLength(255)]
-    public string Author { get; set; } = "Unknown";
+    [Required]
+    public int AuthorId { get; set; }
+
+    [ForeignKey(nameof(AuthorId))]
+    public virtual Author Author { get; set; } = null!;
 
     [Required]
     public string FilePath { get; set; } = string.Empty;
@@ -31,6 +34,13 @@ public class Ebook
 
     public DateTime? LastReadDate { get; set; }
     
+    public double Progress { get; set; } = 0;
+
+    [MaxLength(255)]
+    public string? LastChapter { get; set; }
+
+    public int LastChapterIndex { get; set; } = 0;
+
     // Relationship to NexusUser
     [Required]
     public string UserId { get; set; } = string.Empty;

src/NexusReader.Infrastructure/Handlers/UpdateReadingProgressCommandHandler.cs

@@ -35,6 +35,16 @@ public class UpdateReadingProgressCommandHandler : IRequestHandler<UpdateReading
         user.LastReadPageId = request.PageId;
         user.LastReadAt = now;
 
+        // Update specific Ebook progress
+        var ebook = await context.Ebooks.FirstOrDefaultAsync(e => e.Id == request.EbookId, cancellationToken);
+        if (ebook != null)
+        {
+            ebook.Progress = request.Progress;
+            ebook.LastChapter = request.ChapterTitle;
+            ebook.LastChapterIndex = request.ChapterIndex;
+            ebook.LastReadDate = now;
+        }
+
         await context.SaveChangesAsync(cancellationToken);
 
         // Broadcast to other devices

src/NexusReader.Infrastructure/RealTime/SyncHub.cs

@@ -2,6 +2,7 @@ using MediatR;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.AspNetCore.Authorization;
 using NexusReader.Application.Commands.Sync;
+using System.Security.Claims;
 
 namespace NexusReader.Infrastructure.RealTime;
 
@@ -15,12 +16,12 @@ public class SyncHub : Hub
         _mediator = mediator;
     }
 
-    public async Task UpdateProgress(string pageId)
+    public async Task UpdateProgress(string pageId, Guid ebookId, double progress, string? chapterTitle, int chapterIndex)
     {
-        var userId = Context.UserIdentifier;
-        if (!string.IsNullOrEmpty(userId))
+        var userId = Context.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
+        if (userId != null)
         {
-            await _mediator.Send(new UpdateReadingProgressCommand(pageId, userId, Context.ConnectionId));
+            await _mediator.Send(new UpdateReadingProgressCommand(pageId, userId, ebookId, progress, chapterTitle, chapterIndex, Context.ConnectionId));
         }
     }
 

src/NexusReader.Infrastructure/Services/EpubService.cs

@@ -4,15 +4,24 @@ using FluentResults;
 using NexusReader.Application.Abstractions.Services;
 using NexusReader.Application.Queries.Reader;
 using VersOne.Epub;
+using Microsoft.EntityFrameworkCore;
+using NexusReader.Data.Persistence;
+using NexusReader.Domain.Entities;
 
 namespace NexusReader.Infrastructure.Services;
 
 public class EpubService : IEpubService
 {
+    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;
     private const string EpubPath = "wwwroot/assets/book.epub";
     private const int WordThreshold = 1000;
 
-    public async Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex)
+    public EpubService(IDbContextFactory<AppDbContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }
+
+    public async Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex, string? userId = null)
     {
         try
         {
@@ -100,7 +109,29 @@ public class EpubService : IEpubService
                 blocks.Add(CreateAiTrigger($"trigger-{blockCounter++}"));
             }
 
-            return Result.Ok(new ReaderPageViewModel(blocks, chapterIndex, readingOrder.Count, chapterTitle));
+            // Find the EbookId from DB for this file AND this user
+            using var context = await _dbContextFactory.CreateDbContextAsync();
+            var ebook = await context.Ebooks
+                .Where(e => e.FilePath.Contains("book.epub") && (userId == null || e.UserId == userId))
+                .FirstOrDefaultAsync();
+
+            // Auto-provision if not found for this user (convenience for dev)
+            if (ebook == null && !string.IsNullOrEmpty(userId))
+            {
+                var author = await context.Authors.FirstOrDefaultAsync() ?? new Author { Name = "Unknown Author" };
+                ebook = new Ebook
+                {
+                    Title = "Lives of the Most Excellent Painters, Sculptors, and Architects",
+                    FilePath = "wwwroot/assets/book.epub",
+                    UserId = userId,
+                    Author = author,
+                    TenantId = "global"
+                };
+                context.Ebooks.Add(ebook);
+                await context.SaveChangesAsync();
+            }
+
+            return Result.Ok(new ReaderPageViewModel(blocks, chapterIndex, readingOrder.Count, chapterTitle, ebook?.Id ?? Guid.Empty));
         }
         catch (Exception ex)
         {

src/NexusReader.Maui/Main.razor

@@ -3,7 +3,7 @@
 
 <Router AppAssembly="@typeof(NexusReader.UI.Shared._Imports).Assembly">
     <Found Context="routeData">
-        <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(NexusReader.UI.Shared.Layout.MainLayout)">
+        <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(NexusReader.UI.Shared.Layout.MainHubLayout)">
             <NotAuthorized>
                 <RedirectToLogin />
             </NotAuthorized>
@@ -11,7 +11,7 @@
         <FocusOnNavigate RouteData="@routeData" Selector="h1" />
     </Found>
     <NotFound>
-        <LayoutView Layout="@typeof(NexusReader.UI.Shared.Layout.MainLayout)">
+        <LayoutView Layout="@typeof(NexusReader.UI.Shared.Layout.MainHubLayout)">
             <p role="alert">Sorry, there's nothing at this address.</p>
         </LayoutView>
     </NotFound>

src/NexusReader.UI.Shared/Components/Atoms/NexusIcon.razor

@@ -1,6 +1,27 @@
 <svg class="nexus-icon @Class" viewBox="0 0 24 24" fill="currentColor" width="@Size" height="@Size" @attributes="AdditionalAttributes">
     @switch (Name.ToLowerInvariant())
     {
+        case "home":
+            <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <polyline points="9 22 9 12 15 12 15 22" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "map":
+            <polygon points="1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="8" y1="2" x2="8" y2="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="16" y1="6" x2="16" y2="22" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "share-2":
+            <circle cx="18" cy="5" r="3" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <circle cx="6" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <circle cx="18" cy="19" r="3" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="8.59" y1="13.51" x2="15.42" y2="17.49" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="15.41" y1="6.51" x2="8.59" y2="10.49" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "help-circle":
+            <circle cx="12" cy="12" r="10" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="12" y1="17" x2="12.01" y2="17" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
         case "robot":
             <path d="M12 2a2 2 0 0 1 2 2c0 .74-.4 1.39-1 1.73V7h5a2 2 0 0 1 2 2v2a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2v2a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-2a2 2 0 0 1-2-2v-2a2 2 0 0 1 2-2V9c0-1.1.9-2 2-2h5V5.73c-.6-.34-1-.99-1-1.73a2 2 0 0 1 2-2zM8 11v4h8v-4H8zm-2 0H4v4h2v-4zm14 0h-2v4h2v-4z" />
             break;
@@ -16,8 +37,24 @@
         case "message-square":
             <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
             break;
+        case "diamond":
+            <path d="M12 3L3 12L12 21L21 12L12 3Z" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "layout":
+            <rect width="18" height="18" x="3" y="3" rx="2" ry="2" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="3" y1="9" x2="21" y2="9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <line x1="9" y1="21" x2="9" y2="9" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "book-open":
+            <path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
+        case "user":
+            <path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            <circle cx="12" cy="7" r="4" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
+            break;
         case "settings":
-            <path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z" /><circle cx="12" cy="12" r="3" />
+            <path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" /><circle cx="12" cy="12" r="3" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" />
             break;
         case "bookmark":
             <path d="m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z" />

src/NexusReader.UI.Shared/Components/Molecules/IntelligenceToolbar.razor

@@ -7,8 +7,8 @@
 
 <aside class="intelligence-toolbar">
     <div class="toolbar-top">
-        <button class="toolbar-item" title="Back">
-            <NexusIcon Name="play" Size="20" Class="rotate-180" />
+        <button class="toolbar-item" @onclick='() => NavigationManager.NavigateTo("/")' title="Back to Dashboard">
+            <NexusIcon Name="arrow-left" Size="20" />
         </button>
         <button class="toolbar-item active" title="Chat">
             <NexusIcon Name="message-square" Size="20" />
@@ -35,8 +35,8 @@
                 @onclick="FocusMode.ToggleAsync" title="Focus Mode (F)">
             <NexusIcon Name="target" Size="20" />
         </button>
-        <button class="toolbar-item" title="Global Settings">
-            <NexusIcon Name="settings" Size="20" />
+        <button class="toolbar-item" @onclick='() => NavigationManager.NavigateTo("/")' title="Global Hub">
+            <NexusIcon Name="layers" Size="20" />
         </button>
         <button class="toolbar-item logout-item" @onclick="HandleLogout" title="Exit">
             <NexusIcon Name="log-out" Size="20" />

src/NexusReader.UI.Shared/Components/Organisms/ReaderCanvas.razor

@@ -11,6 +11,8 @@
 @inject KnowledgeCoordinator Coordinator
 @inject IReaderInteractionService InteractionService
 @inject ISyncService SyncService
+@using Microsoft.AspNetCore.Components.Authorization
+@inject AuthenticationStateProvider AuthStateProvider
 
 <div class="reader-canvas @(ThemeService.IsLightMode ? "theme-light" : "theme-dark")">
     @if (ViewModel == null)
@@ -118,8 +120,19 @@
     {
         await Coordinator.OnBlockReachedAsync(blockId, content);
         
-        // Debounce sync update (simple version: every 5 seconds or on a timer)
-        await SyncService.UpdateProgressAsync(blockId);
+        if (ViewModel != null)
+        {
+            // Calculate progress: (CurrentChapter / TotalChapters) * 100 
+            // Simple approximation for now: chapter-based
+            double progress = ((double)(ViewModel.CurrentChapterIndex + 1) / ViewModel.TotalChapters) * 100;
+            
+            await SyncService.UpdateProgressAsync(
+                blockId, 
+                ViewModel.EbookId, 
+                progress, 
+                ViewModel.ChapterTitle,
+                ViewModel.CurrentChapterIndex);
+        }
     }
 
     private async Task HandleSyncProgressReceived(string blockId, DateTime timestamp)
@@ -180,7 +193,10 @@
         ViewModel = null;
         StatusMessage = "Fetching content...";
         
-        var result = await Mediator.Send(new GetReaderPageQuery(index));
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        var userId = authState.User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
+
+        var result = await Mediator.Send(new GetReaderPageQuery(index, userId));
         if (result.IsSuccess)
         {
             ViewModel = result.Value;

src/NexusReader.UI.Shared/Constants/PlanConstants.cs

@@ -0,0 +1,8 @@
+namespace NexusReader.UI.Shared.Constants;
+
+public static class PlanConstants
+{
+    public const string DefaultPlanName = "Free";
+    public const int DefaultTokenLimit = 1000;
+    public const string DefaultActivityLabel = "Brak aktywności";
+}

src/NexusReader.UI.Shared/Constants/StorageKeys.cs

@@ -0,0 +1,9 @@
+namespace NexusReader.UI.Shared.Constants;
+
+public static class StorageKeys
+{
+    public const string AuthToken = "nexus_auth_token";
+    public const string RefreshToken = "nexus_refresh_token";
+    public const string UserEmail = "nexus_user_email";
+    public const string UserTenant = "nexus_user_tenant";
+}

src/NexusReader.UI.Shared/Layout/MainHubLayout.razor

@@ -0,0 +1,106 @@
+@inherits LayoutComponentBase
+@using NexusReader.UI.Shared.Components.Molecules
+@using NexusReader.UI.Shared.Components.Atoms
+@using NexusReader.Application.Abstractions.Services
+@using NexusReader.UI.Shared.Services
+
+<div class="hub-container">
+    <AuthorizeView>
+        <Authorized>
+            <aside class="hub-sidebar">
+                <div class="sidebar-header">
+                    <div class="logo">
+                        <NexusIcon Name="diamond" Size="24" Class="logo-icon" />
+                        <span class="logo-text">Nexus</span>
+                    </div>
+                </div>
+                
+                <nav class="sidebar-nav">
+                    <NavLink class="nav-item" href="/" Match="NavLinkMatch.All">
+                        <div class="nav-icon">
+                            <NexusIcon Name="home" Size="18" />
+                        </div>
+                        <span class="nav-text">Dashboard</span>
+                    </NavLink>
+                    <NavLink class="nav-item" href="/library">
+                        <div class="nav-icon">
+                            <NexusIcon Name="book-open" Size="18" />
+                        </div>
+                        <span class="nav-text">Library</span>
+                    </NavLink>
+                    <NavLink class="nav-item" href="/concepts-map">
+                        <div class="nav-icon">
+                            <NexusIcon Name="map" Size="18" />
+                        </div>
+                        <span class="nav-text">Concepts Map</span>
+                    </NavLink>
+                    <NavLink class="nav-item" href="/profile">
+                        <div class="nav-icon">
+                            <NexusIcon Name="message-square" Size="18" />
+                        </div>
+                        <span class="nav-text">Profile</span>
+                    </NavLink>
+                    <NavLink class="nav-item" href="/settings">
+                        <div class="nav-icon">
+                            <NexusIcon Name="settings" Size="18" />
+                        </div>
+                        <span class="nav-text">Settings</span>
+                    </NavLink>
+                    <NavLink class="nav-item" href="/concenters">
+                        <div class="nav-icon">
+                            <NexusIcon Name="target" Size="18" />
+                        </div>
+                        <span class="nav-text">Concenters</span>
+                    </NavLink>
+                </nav>
+
+                <div class="sidebar-footer">
+                    <div class="user-brief">
+                        <div class="user-avatar">
+                            @context.User.Identity?.Name?[0].ToString().ToUpper()
+                        </div>
+                        <div class="user-details">
+                            <span class="user-name">@context.User.Identity?.Name</span>
+                        </div>
+                    </div>
+                    <button class="logout-btn" @onclick="HandleLogout" title="Logout">
+                        <NexusIcon Name="log-out" Size="18" />
+                    </button>
+                </div>
+            </aside>
+        </Authorized>
+    </AuthorizeView>
+
+    <main class="hub-main">
+        <div class="hub-content">
+            @Body
+        </div>
+    </main>
+</div>
+
+@code {
+    [Inject] private AuthenticationStateProvider AuthStateProvider { get; set; } = default!;
+    [Inject] private IIdentityService IdentityService { get; set; } = default!;
+    [Inject] private NavigationManager NavigationManager { get; set; } = default!;
+
+    private bool _isSyncing = false;
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (_isSyncing) return;
+        
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        if (!authState.User.Identity?.IsAuthenticated ?? true)
+        {
+            _isSyncing = true;
+            // Try to sync with server cookie
+            await IdentityService.GetProfileAsync();
+        }
+    }
+
+    private async Task HandleLogout()
+    {
+        await IdentityService.LogoutAsync();
+        NavigationManager.NavigateTo("/", true);
+    }
+}

src/NexusReader.UI.Shared/Layout/MainHubLayout.razor.css

@@ -0,0 +1,193 @@
+.hub-container {
+    display: flex;
+    width: 100vw;
+    height: 100vh;
+    background: #121212;
+    color: #e0e0e0;
+    overflow: hidden;
+}
+
+::deep .hub-sidebar {
+    width: 260px;
+    height: 100%;
+    background: #161616;
+    border-right: 1px solid rgba(255, 255, 255, 0.05);
+    display: flex;
+    flex-direction: column;
+    z-index: 100;
+    flex-shrink: 0;
+}
+
+::deep .sidebar-header {
+    padding: 2.5rem 1.5rem;
+}
+
+::deep .logo {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+::deep .logo-icon {
+    color: var(--nexus-neon);
+    filter: drop-shadow(0 0 10px rgba(0, 255, 153, 0.4));
+}
+
+::deep .logo-text {
+    font-family: var(--nexus-font-serif);
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #ffffff;
+    letter-spacing: -0.01em;
+}
+
+::deep .sidebar-nav {
+    flex: 1;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+}
+
+::deep .nav-item {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 1rem 1.5rem;
+    color: #A0A0A0;
+    text-decoration: none;
+    transition: all 0.2s ease;
+    border-left: 3px solid transparent;
+    font-family: var(--nexus-font-sans);
+    font-size: 0.9rem;
+    font-weight: 500;
+}
+
+::deep .nav-item:hover {
+    background: rgba(255, 255, 255, 0.02);
+    color: #ffffff;
+}
+
+::deep .nav-item.active {
+    color: #ffffff;
+    background: rgba(0, 255, 153, 0.03);
+    border-left: 3px solid var(--nexus-neon);
+}
+
+::deep .nav-item.active .nav-icon {
+    color: var(--nexus-neon);
+}
+
+::deep .nav-icon {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 20px;
+    opacity: 0.7;
+    transition: opacity 0.2s;
+}
+
+::deep .nav-item:hover .nav-icon,
+::deep .nav-item.active .nav-icon {
+    opacity: 1;
+}
+
+::deep .sidebar-footer {
+    padding: 1.25rem 1.5rem;
+    border-top: 1px solid rgba(255, 255, 255, 0.05);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+::deep .user-brief {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    overflow: hidden;
+}
+
+::deep .user-avatar {
+    width: 32px;
+    height: 32px;
+    background: #222;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: #A0A0A0;
+    flex-shrink: 0;
+}
+
+::deep .user-details {
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+::deep .user-name {
+    font-size: 0.85rem;
+    font-weight: 500;
+    color: #A0A0A0;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+::deep .logout-btn {
+    background: transparent;
+    border: none;
+    color: #666;
+    cursor: pointer;
+    padding: 0.4rem;
+    border-radius: 6px;
+    transition: all 0.2s;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+::deep .logout-btn:hover {
+    background: rgba(255, 255, 255, 0.05);
+    color: #ffffff;
+}
+
+.hub-main {
+    flex: 1;
+    height: 100%;
+    overflow-y: auto;
+    background: radial-gradient(circle at center, #1a1a1a 0%, #121212 100%);
+}
+
+.hub-content {
+    padding: 2.5rem;
+    min-height: 100%;
+}
+
+::deep .hub-loading {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 1.5rem;
+}
+
+::deep .nexus-loader {
+    width: 32px;
+    height: 32px;
+    border: 2px solid rgba(0, 255, 153, 0.1);
+    border-top-color: var(--nexus-neon);
+    border-radius: 50%;
+    animation: spin 0.8s cubic-bezier(0.4, 0, 0.2, 1) infinite;
+    filter: drop-shadow(0 0 5px var(--nexus-neon));
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+

src/NexusReader.UI.Shared/Layout/ReaderLayout.razor

@@ -10,19 +10,23 @@
 @inject IJSRuntime JS
 @inject IIdentityService IdentityService
 @inject NavigationManager NavigationManager
-@inject Microsoft.Extensions.Logging.ILogger<MainLayout> Logger
+@inject Microsoft.Extensions.Logging.ILogger<ReaderLayout> Logger
 @implements IDisposable
 
-<AuthorizeView>
-    <Authorized>
-        <div class="app-container @_platformClass @(FocusMode.IsFocusModeActive ? "focus-mode-active" : "")">
-            <div class="reader-pane">
-                <main>
-                    @Body
-                </main>
+<div class="app-container @_platformClass @(FocusMode.IsFocusModeActive ? "focus-mode-active" : "")">
+    <div class="reader-pane">
+        <main>
+            @Body
+        </main>
+        <AuthorizeView>
+            <Authorized>
                 <ReaderFooter />
-            </div>
+            </Authorized>
+        </AuthorizeView>
+    </div>
 
+    <AuthorizeView>
+        <Authorized>
             <div class="resizer" id="sidebar-resizer"></div>
 
             <div class="intelligence-sidebar">
@@ -34,9 +38,6 @@
                                 Class="@($"neon-glow {(QuizService.HasNewQuiz ? "quiz-available" : "")}")" />
                             <span>Asystent AI</span>
                         </div>
-
-
-
                         <button class="close-btn">×</button>
                     </div>
 
@@ -49,18 +50,15 @@
                     </div>
                 </div>
             </div>
-        </div>
-    </Authorized>
-    <Authorizing>
-        <div class="app-preloader">
-            <div class="preloader-spinner"></div>
-            <div class="preloader-text">Weryfikacja...</div>
-        </div>
-    </Authorizing>
-    <NotAuthorized>
-        @Body
-    </NotAuthorized>
-</AuthorizeView>
+        </Authorized>
+        <Authorizing>
+            <div class="app-preloader">
+                <div class="preloader-spinner"></div>
+                <div class="preloader-text">Weryfikacja...</div>
+            </div>
+        </Authorizing>
+    </AuthorizeView>
+</div>
 
 <div id="blazor-error-ui" data-nosnippet>
     An unhandled error has occurred.

src/NexusReader.UI.Shared/NexusReader.UI.Shared.csproj

@@ -12,6 +12,7 @@
     <PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="10.0.7" />
     <PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="10.0.7" />
     <PackageReference Include="MediatR" Version="12.1.1" />
+    <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="10.0.7" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.7" />
     <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="10.0.7" />
   </ItemGroup>

src/NexusReader.UI.Shared/Pages/Account/Login.razor

@@ -21,9 +21,8 @@
 
         <div class="social-auth">
             <button type="button" class="btn-google-auth" @onclick="HandleGoogleLogin">
-                <img src="https://www.gstatic.com/images/branding/product/1x/gsa_512dp.png" 
-                     alt="Google" 
-                     style="width: 20px !important; height: 20px !important; flex-shrink: 0;" />
+                <img src="https://www.gstatic.com/images/branding/product/1x/gsa_512dp.png" alt="Google"
+                    style="width: 20px !important; height: 20px !important; flex-shrink: 0;" />
                 <span>Zaloguj się przez Google</span>
             </button>
         </div>
@@ -47,7 +46,8 @@
                 <div class="field-icon">
                     <NexusIcon Name="lock" Size="18" />
                 </div>
-                <InputText id="password" type="@(_showPassword ? "text" : "password")" @bind-Value="_loginModel.Password" placeholder="Hasło" class="field-input" />
+                <InputText id="password" type="@(_showPassword ? "text" : "password")"
+                    @bind-Value="_loginModel.Password" placeholder="Hasło" class="field-input" />
                 <button type="button" class="toggle-visibility" @onclick="TogglePassword">
                     <NexusIcon Name="@(_showPassword ? "eye-off" : "eye")" Size="18" />
                 </button>
@@ -84,7 +84,8 @@
         </div>
 
         <div class="auth-legal">
-            Korzystając z usługi, akceptujesz <a href="/terms">Regulamin</a> i <a href="/privacy">Politykę Prywatności</a>
+            Korzystając z usługi, akceptujesz <a href="/terms">Regulamin</a> i <a href="/privacy">Politykę
+                Prywatności</a>
         </div>
     </div>
 </div>
@@ -121,12 +122,24 @@
 
         try
         {
-            var success = await IdentityService.LoginAsync(_loginModel.Email, _loginModel.Password, _loginModel.RememberMe);
-            if (success) NavigationManager.NavigateTo("/");
-            else _errorMessage = "Nieprawidłowy e-mail lub hasło.";
+            var result = await IdentityService.LoginAsync(_loginModel.Email, _loginModel.Password, _loginModel.RememberMe);
+            if (result.IsSuccess) 
+            {
+                NavigationManager.NavigateTo("/");
+            }
+            else 
+            {
+                _errorMessage = result.Errors.FirstOrDefault()?.Message ?? "Nieprawidłowy e-mail lub hasło.";
+            }
+        }
+        catch (Exception ex) 
+        { 
+            _errorMessage = $"Wystąpił błąd logowania: {ex.Message}."; 
+        }
+        finally 
+        { 
+            _isSubmitting = false; 
         }
-        catch (Exception) { _errorMessage = "Wystąpił błąd logowania."; }
-        finally { _isSubmitting = false; }
     }
 
     private void HandleGoogleLogin() => NavigationManager.NavigateTo("identity/login/google", forceLoad: true);

src/NexusReader.UI.Shared/Pages/Account/Profile.razor

@@ -1,4 +1,5 @@
 @page "/account/profile"
+@page "/profile"
 @using Microsoft.AspNetCore.Authorization
 @using NexusReader.UI.Shared.Services
 @using NexusReader.UI.Shared.Components.Atoms
@@ -6,96 +7,102 @@
 @inject IIdentityService IdentityService
 @inject NavigationManager NavigationManager
 
-<div class="profile-dashboard">
+<div class="profile-page-container">
+    <div class="background-radial"></div>
     <div class="mesh-overlay"></div>
     
     @if (_profile == null)
     {
-        <div class="loading-overlay">
+        <div class="loading-state">
             <div class="nexus-loader"></div>
-            <p>Ładowanie Twojego profilu...</p>
+            <p>Ładowanie systemu...</p>
         </div>
     }
     else
     {
-        <div class="dashboard-content">
-            <header class="dashboard-header">
-                <div class="user-meta">
-                    <div class="user-avatar">
+        <div class="profile-content">
+            <!-- Identity Section -->
+            <section class="identity-section">
+                <div class="avatar-container">
+                    <div class="avatar-glow"></div>
+                    <div class="avatar-inner">
                         @(_profile.Email[0].ToString().ToUpper())
                     </div>
-                    <div class="user-info">
-                        <h1>@_profile.Email</h1>
-                        <div class="plan-info">
-                            <span class="badge @(_profile.CurrentPlan.ToLower())">@_profile.CurrentPlan Plan</span>
-                            <span class="tenant-id">ID: @_profile.TenantId.ToString()[..8]...</span>
-                        </div>
-                    </div>
                 </div>
-                <div class="header-actions">
-                    <button class="btn-logout" @onclick="HandleLogout">
-                        <NexusIcon Name="lock" Size="16" />
-                        Wyloguj się
-                    </button>
-                </div>
-            </header>
                 
-            <div class="stats-grid">
-                <!-- AI Token Card -->
-                <div class="stat-card usage-card">
-                    <div class="card-icon">
-                        <NexusIcon Name="robot" Size="24" />
+                <div class="user-titles">
+                    <h1 class="username">@_profile.Email.Split('@')[0]</h1>
+                    <span class="system-rank">[Nexus_Explorer_@(_profile.TenantId.ToString()[..4])]</span>
+                </div>
+            </section>
+
+            <!-- Metrics Grid -->
+            <div class="metrics-grid">
+                <!-- Intelligence Card -->
+                <div class="metric-card glass-panel">
+                    <div class="card-header">
+                        <NexusIcon Name="robot" Size="24" Color="var(--nexus-neon)" />
+                        <h3>Interfejs AI</h3>
                     </div>
-                    <div class="card-info">
-                        <h3>Wykorzystanie AI</h3>
-                        <div class="token-numbers">
-                            <span class="tokens-used">@_profile.AITokensUsed</span>
-                            <span class="tokens-limit">/ @_profile.AITokenLimit tokenów</span>
+                    <div class="card-body">
+                        <div class="token-usage">
+                            <div class="usage-values">
+                                <span class="current">@_profile.AITokensUsed</span>
+                                <span class="separator">/</span>
+                                <span class="total">@_profile.AITokenLimit</span>
+                            </div>
+                            <div class="usage-progress">
+                                <div class="progress-bar" style="width: @(CalculateProgress())%"></div>
+                            </div>
                         </div>
-                        <div class="usage-bar">
-                            <div class="usage-fill" style="width: @(CalculateProgress())%"></div>
-                        </div>
-                        <p class="usage-desc">Limit odnawia się w następnym cyklu rozliczeniowym.</p>
+                        <span class="metric-label">Wykorzystane Jednostki Mocy</span>
                     </div>
                 </div>
 
-                <!-- Learning Progress Card -->
-                <div class="stat-card learning-card">
-                    <div class="card-icon">
-                        <NexusIcon Name="mail" Size="24" />
+                <!-- Sync Card -->
+                <div class="metric-card glass-panel">
+                    <div class="card-header">
+                        <NexusIcon Name="activity" Size="24" Color="var(--nexus-neon)" />
+                        <h3>Wydajność Nauki</h3>
                     </div>
-                    <div class="card-info">
-                        <h3>Aktywna Nauka</h3>
-                        <div class="learning-metrics">
-                            <div class="metric">
-                                <span class="label">Średni wynik quizów</span>
-                                <span class="value">@_profile.AverageQuizScore%</span>
-                            </div>
-                            <div class="metric">
-                                <span class="label">Ostatnio czytane</span>
-                                <span class="value truncate">@_profile.LastReadBookTitle</span>
-                            </div>
+                    <div class="card-body">
+                        <div class="score-display">
+                            <span class="score-value">@_profile.AverageQuizScore%</span>
+                            <span class="score-label">Średni Wynik Asymilacji</span>
+                        </div>
+                        <div class="last-book">
+                            <NexusIcon Name="book-open" Size="14" />
+                            <span class="truncate">@_profile.LastReadBookTitle</span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Account Status Card -->
+                <div class="metric-card glass-panel full-width">
+                    <div class="card-header">
+                        <NexusIcon Name="shield" Size="24" Color="var(--nexus-neon)" />
+                        <h3>Status Autoryzacji</h3>
+                    </div>
+                    <div class="card-body status-layout">
+                        <div class="status-info">
+                            <span class="plan-badge @(_profile.CurrentPlan.ToLower())">@_profile.CurrentPlan Protocol</span>
+                            <span class="tenant-tag">Node: @_profile.TenantId.ToString().ToUpper()</span>
+                        </div>
+                        <div class="profile-actions">
+                            <button class="btn-nexus secondary" @onclick="HandleUpgrade">Zarządzaj Subskrypcją</button>
+                            <button class="btn-nexus logout" @onclick="HandleLogout">
+                                <NexusIcon Name="log-out" Size="18" />
+                                Wyloguj
+                            </button>
                         </div>
                     </div>
                 </div>
             </div>
-
-            <section class="subscription-section">
-                <div class="section-card">
-                    <div class="section-info">
-                        <h2>Zarządzaj subskrypcją</h2>
-                        <p>Zmień swój plan, aby zwiększyć limit tokenów AI i odblokować funkcje premium.</p>
-                    </div>
-                    <button class="btn-upgrade" @onclick="HandleUpgrade">
-                        Przejdź do panelu płatności
-                    </button>
-                </div>
-            </section>
         </div>
     }
 
-    <div class="decoration-star top-left">✦</div>
-    <div class="decoration-star bottom-right">✦</div>
+    <div class="decoration decoration-top">NXS-SYS-v10</div>
+    <div class="decoration decoration-bottom">IDENTITY-CORE-ENCRYPTED</div>
 </div>
 
 @code {
@@ -103,7 +110,12 @@
 
     protected override async Task OnInitializedAsync()
     {
-        _profile = await IdentityService.GetProfileAsync();
+        var result = await IdentityService.GetProfileAsync();
+        if (result.IsSuccess) 
+        {
+            _profile = result.Value;
+        }
+        StateHasChanged();
     }
 
     private int CalculateProgress()

src/NexusReader.UI.Shared/Pages/Account/Profile.razor.css

@@ -1,256 +1,367 @@
-.profile-dashboard {
+.profile-page-container {
     position: relative;
     width: 100%;
     min-height: 100vh;
-    background-color: #121418;
-    color: white;
-    font-family: 'Inter', sans-serif;
-    padding: 60px 20px;
+    background-color: #0a0c10;
+    color: #e0e6ed;
+    overflow-x: hidden;
     display: flex;
     justify-content: center;
-    overflow-x: hidden;
+    padding: 80px 20px;
+    font-family: var(--nexus-font-sans);
+}
+
+.background-radial {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 800px;
+    height: 800px;
+    background: radial-gradient(circle, rgba(0, 255, 153, 0.05) 0%, transparent 70%);
+    pointer-events: none;
+    z-index: 0;
 }
 
 .mesh-overlay {
     position: absolute;
     top: 0; left: 0; width: 100%; height: 100%;
-    background-image: radial-gradient(circle at 2px 2px, rgba(255,255,255,0.02) 1px, transparent 0);
-    background-size: 40px 40px;
+    background-image: radial-gradient(circle at 1px 1px, rgba(255, 255, 255, 0.02) 1px, transparent 0);
+    background-size: 32px 32px;
     z-index: 1;
 }
 
-.dashboard-content {
+.profile-content {
     position: relative;
-    width: 100%;
-    max-width: 1000px;
     z-index: 10;
-}
-
-.dashboard-header {
+    width: 100%;
+    max-width: 900px;
     display: flex;
-    justify-content: space-between;
+    flex-direction: column;
     align-items: center;
-    margin-bottom: 48px;
-    padding: 0 10px;
+    gap: 60px;
 }
 
-.user-meta {
+/* Identity Section */
+.identity-section {
     display: flex;
+    flex-direction: column;
     align-items: center;
     gap: 24px;
+    text-align: center;
 }
 
-.user-avatar {
-    width: 80px;
-    height: 80px;
-    background: linear-gradient(135deg, #44ff77 0%, #2ecc71 100%);
-    border-radius: 24px;
+.avatar-container {
+    position: relative;
+    width: 140px;
+    height: 140px;
     display: flex;
     justify-content: center;
     align-items: center;
-    font-size: 2.5rem;
+}
+
+.avatar-inner {
+    width: 120px;
+    height: 120px;
+    background: #151921;
+    border: 2px solid var(--nexus-neon);
+    border-radius: 50%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    font-size: 3.5rem;
     font-weight: 800;
-    color: #000;
-    box-shadow: 0 10px 30px rgba(68, 255, 119, 0.2);
+    color: var(--nexus-neon);
+    z-index: 2;
+    box-shadow: 0 0 30px rgba(0, 255, 153, 0.2), inset 0 0 20px rgba(0, 255, 153, 0.1);
+    position: relative;
 }
 
-.user-info h1 {
-    font-size: 1.8rem;
+.avatar-glow {
+    position: absolute;
+    width: 140px;
+    height: 140px;
+    border: 1px solid rgba(0, 255, 153, 0.3);
+    border-radius: 50%;
+    animation: pulse-ring 3s cubic-bezier(0.4, 0, 0.2, 1) infinite;
+}
+
+@keyframes pulse-ring {
+    0% { transform: scale(0.95); opacity: 0.8; }
+    50% { transform: scale(1.1); opacity: 0.2; }
+    100% { transform: scale(0.95); opacity: 0.8; }
+}
+
+.username {
+    font-family: var(--nexus-font-serif);
+    font-size: 2.8rem;
     font-weight: 700;
-    margin: 0 0 8px;
-    letter-spacing: -0.02em;
+    margin: 0;
+    letter-spacing: -0.01em;
+    color: #ffffff;
 }
 
-.plan-info {
+.system-rank {
+    font-family: 'Inter', 'Courier New', Courier, monospace;
+    font-size: 0.9rem;
+    color: var(--nexus-neon);
+    text-transform: uppercase;
+    letter-spacing: 0.2em;
+    opacity: 0.8;
+}
+
+/* Metrics Grid */
+.metrics-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 24px;
+    width: 100%;
+}
+
+.glass-panel {
+    background: rgba(20, 20, 20, 0.8); /* Fallback */
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 24px;
+    padding: 32px;
+    transition: all 0.3s ease;
+}
+
+@supports (backdrop-filter: blur(12px)) {
+    .glass-panel {
+        background: rgba(255, 255, 255, 0.03);
+        backdrop-filter: blur(12px);
+        -webkit-backdrop-filter: blur(12px);
+    }
+}
+
+.glass-panel:hover {
+    background: rgba(255, 255, 255, 0.05);
+    border-color: rgba(0, 255, 153, 0.2);
+    transform: translateY(-4px);
+}
+
+.metric-card {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+}
+
+.full-width {
+    grid-column: span 2;
+}
+
+.card-header {
     display: flex;
     align-items: center;
     gap: 12px;
 }
 
-.badge {
-    padding: 4px 12px;
-    border-radius: 8px;
+.card-header h3 {
+    font-size: 0.9rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.1em;
+    color: #a0aec0;
+    margin: 0;
+}
+
+.card-body {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+/* Usage Progress */
+.token-usage {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.usage-values {
+    display: flex;
+    align-items: baseline;
+    gap: 8px;
+}
+
+.usage-values .current { font-size: 2.5rem; font-weight: 800; color: #fff; line-height: 1; }
+.usage-values .separator { font-size: 1.2rem; color: #4a5568; }
+.usage-values .total { font-size: 1.2rem; color: #718096; font-weight: 600; }
+
+.usage-progress {
+    width: 100%;
+    height: 6px;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 10px;
+    overflow: hidden;
+}
+
+.progress-bar {
+    height: 100%;
+    background: var(--nexus-neon);
+    box-shadow: 0 0 15px rgba(0, 255, 153, 0.5);
+    border-radius: 10px;
+}
+
+.metric-label {
     font-size: 0.75rem;
-    font-weight: 700;
+    color: #718096;
     text-transform: uppercase;
     letter-spacing: 0.05em;
 }
 
-.badge.pro { background: rgba(68, 255, 119, 0.1); color: #44ff77; border: 1px solid rgba(68, 255, 119, 0.2); }
-.badge.free { background: rgba(255, 255, 255, 0.05); color: #888; border: 1px solid rgba(255, 255, 255, 0.1); }
+/* Score Display */
+.score-display {
+    display: flex;
+    flex-direction: column;
+}
 
-.tenant-id { font-size: 0.8rem; color: #555; }
+.score-value {
+    font-size: 2.5rem;
+    font-weight: 800;
+    color: var(--nexus-neon);
+    line-height: 1;
+}
 
-.btn-logout {
+.score-label {
+    font-size: 0.75rem;
+    color: #718096;
+    text-transform: uppercase;
+    margin-top: 4px;
+}
+
+.last-book {
+    margin-top: 12px;
     display: flex;
     align-items: center;
     gap: 8px;
-    padding: 10px 18px;
-    background: rgba(255, 255, 255, 0.03);
-    border: 1px solid rgba(255, 255, 255, 0.08);
+    padding: 10px 16px;
+    background: rgba(0, 255, 153, 0.05);
     border-radius: 12px;
-    color: #888;
-    font-size: 0.9rem;
-    font-weight: 600;
-    cursor: pointer;
-    transition: all 0.2s;
+    font-size: 0.85rem;
+    color: #cbd5e0;
 }
 
-.btn-logout:hover {
-    background: rgba(255, 77, 77, 0.05);
-    border-color: rgba(255, 77, 77, 0.2);
-    color: #ff4d4d;
-}
-
-.stats-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
-    gap: 24px;
-    margin-bottom: 48px;
-}
-
-.stat-card {
-    background: #1c1f24;
-    border: 1px solid rgba(255, 255, 255, 0.08);
-    border-radius: 28px;
-    padding: 32px;
-    display: flex;
-    gap: 24px;
-    transition: transform 0.3s ease;
-}
-
-.stat-card:hover { transform: translateY(-5px); }
-
-.card-icon {
-    width: 56px;
-    height: 56px;
-    background: rgba(255, 255, 255, 0.03);
-    border-radius: 16px;
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    color: #44ff77;
-    flex-shrink: 0;
-}
-
-.card-info h3 {
-    font-size: 1.1rem;
-    font-weight: 600;
-    margin: 0 0 16px;
-    color: #e0e0e0;
-}
-
-.token-numbers {
-    display: flex;
-    align-items: baseline;
-    gap: 8px;
-    margin-bottom: 12px;
-}
-
-.tokens-used { font-size: 2rem; font-weight: 800; color: white; }
-.tokens-limit { font-size: 1rem; color: #555; font-weight: 500; }
-
-.usage-bar {
-    width: 100%;
-    height: 8px;
-    background: #15181c;
-    border-radius: 10px;
+.truncate {
+    white-space: nowrap;
     overflow: hidden;
-    margin-bottom: 12px;
+    text-overflow: ellipsis;
+    max-width: 300px;
 }
 
-.usage-fill {
-    height: 100%;
-    background: #44ff77;
-    box-shadow: 0 0 15px rgba(68, 255, 119, 0.3);
-    border-radius: 10px;
-}
-
-.usage-desc { font-size: 0.8rem; color: #555; margin: 0; }
-
-.learning-metrics {
-    display: flex;
-    flex-direction: column;
-    gap: 20px;
-}
-
-.metric {
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-}
-
-.metric .label { font-size: 0.85rem; color: #666; font-weight: 500; }
-.metric .value { font-size: 1.2rem; font-weight: 700; color: white; }
-.metric .truncate { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 280px; }
-
-.subscription-section { margin-top: 48px; }
-
-.section-card {
-    background: linear-gradient(90deg, #1c1f24 0%, #23272e 100%);
-    border: 1px solid rgba(255, 255, 255, 0.08);
-    border-radius: 28px;
-    padding: 40px;
-    display: flex;
+/* Status Layout */
+.status-layout {
+    flex-direction: row;
     justify-content: space-between;
     align-items: center;
-    gap: 40px;
 }
 
-.section-info h2 { font-size: 1.5rem; font-weight: 700; margin: 0 0 12px; }
-.section-info p { color: #888; margin: 0; line-height: 1.6; max-width: 500px; }
+.status-info {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
 
-.btn-upgrade {
-    padding: 16px 32px;
-    background: #44ff77;
-    border: none;
-    border-radius: 16px;
-    color: #000;
-    font-size: 1rem;
+.plan-badge {
+    padding: 6px 14px;
+    border-radius: 8px;
+    font-size: 0.8rem;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    width: fit-content;
+}
+
+.plan-badge.pro {
+    background: rgba(0, 255, 153, 0.1);
+    color: var(--nexus-neon);
+    border: 1px solid rgba(0, 255, 153, 0.2);
+}
+
+.tenant-tag {
+    font-family: monospace;
+    font-size: 0.75rem;
+    color: #4a5568;
+}
+
+.profile-actions {
+    display: flex;
+    gap: 16px;
+}
+
+.btn-nexus {
+    padding: 12px 24px;
+    border-radius: 12px;
+    font-size: 0.9rem;
     font-weight: 700;
     cursor: pointer;
-    transition: all 0.2s;
-    white-space: nowrap;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    border: none;
 }
 
-.btn-upgrade:hover {
-    transform: scale(1.05);
-    box-shadow: 0 10px 30px rgba(68, 255, 119, 0.2);
+.btn-nexus.secondary {
+    background: rgba(255, 255, 255, 0.05);
+    color: #fff;
+    border: 1px solid rgba(255, 255, 255, 0.1);
 }
 
-.loading-overlay {
+.btn-nexus.secondary:hover {
+    background: rgba(255, 255, 255, 0.1);
+}
+
+.btn-nexus.logout {
+    background: rgba(255, 71, 87, 0.1);
+    color: #ff4757;
+    border: 1px solid rgba(255, 71, 87, 0.2);
+}
+
+.btn-nexus.logout:hover {
+    background: #ff4757;
+    color: #fff;
+}
+
+/* Decorations */
+.decoration {
+    position: absolute;
+    font-family: monospace;
+    font-size: 0.7rem;
+    color: rgba(255, 255, 255, 0.05);
+    letter-spacing: 0.3em;
+    pointer-events: none;
+}
+
+.decoration-top { top: 40px; left: 40px; }
+.decoration-bottom { bottom: 40px; right: 40px; }
+
+/* Loading State */
+.loading-state {
     display: flex;
     flex-direction: column;
     align-items: center;
     justify-content: center;
-    gap: 20px;
+    gap: 24px;
 }
 
 .nexus-loader {
-    width: 48px;
-    height: 48px;
-    border: 3px solid rgba(68, 255, 119, 0.1);
-    border-top-color: #44ff77;
+    width: 60px;
+    height: 60px;
+    border: 4px solid rgba(0, 255, 153, 0.1);
+    border-top-color: var(--nexus-neon);
     border-radius: 50%;
-    animation: spin 1s linear infinite;
+    animation: spin 1.5s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+    filter: drop-shadow(0 0 10px var(--nexus-neon));
 }
 
 @keyframes spin { to { transform: rotate(360deg); } }
 
-.decoration-star {
-    position: absolute;
-    font-size: 48px;
-    color: rgba(255, 255, 255, 0.03);
-    z-index: 1;
-}
-
-.top-left { top: 40px; left: 40px; }
-.bottom-right { bottom: 40px; right: 40px; }
-
 @media (max-width: 768px) {
-    .dashboard-header { flex-direction: column; align-items: flex-start; gap: 24px; }
-    .header-actions { width: 100%; }
-    .btn-logout { width: 100%; justify-content: center; }
-    .stats-grid { grid-template-columns: 1fr; }
-    .section-card { flex-direction: column; text-align: center; }
+    .metrics-grid { grid-template-columns: 1fr; }
+    .full-width { grid-column: span 1; }
+    .status-layout { flex-direction: column; align-items: flex-start; gap: 24px; }
+    .profile-actions { width: 100%; flex-direction: column; }
+    .btn-nexus { width: 100%; justify-content: center; }
+    .username { font-size: 2.2rem; }
 }

src/NexusReader.UI.Shared/Pages/Account/Register.razor

@@ -81,17 +81,32 @@
 
         try
         {
-            var success = await IdentityService.RegisterAsync(_registerModel.Email, _registerModel.Password);
-            if (success)
+            var regResult = await IdentityService.RegisterAsync(_registerModel.Email, _registerModel.Password);
+            if (regResult.IsSuccess)
             {
-                var loginSuccess = await IdentityService.LoginAsync(_registerModel.Email, _registerModel.Password);
-                if (loginSuccess) NavigationManager.NavigateTo("/");
-                else NavigationManager.NavigateTo("/account/login");
+                var loginResult = await IdentityService.LoginAsync(_registerModel.Email, _registerModel.Password);
+                if (loginResult.IsSuccess) 
+                {
+                    NavigationManager.NavigateTo("/");
+                }
+                else 
+                {
+                    NavigationManager.NavigateTo("/account/login");
+                }
+            }
+            else 
+            { 
+                _errorMessage = regResult.Errors.FirstOrDefault()?.Message ?? "Rejestracja nie powiodła się."; 
             }
-            else { _errorMessage = "Rejestracja nie powiodła się."; }
         }
-        catch (Exception) { _errorMessage = "Wystąpił błąd podczas rejestracji."; }
-        finally { _isSubmitting = false; }
+        catch (Exception) 
+        { 
+            _errorMessage = "Wystąpił błąd podczas rejestracji."; 
+        }
+        finally 
+        { 
+            _isSubmitting = false; 
+        }
     }
 
     public class RegisterModel

src/NexusReader.UI.Shared/Pages/Dashboard.razor

@@ -0,0 +1,147 @@
+@page "/"
+@using Microsoft.AspNetCore.Authorization
+@using NexusReader.UI.Shared.Components.Atoms
+@using NexusReader.UI.Shared.Services
+@inject IIdentityService IdentityService
+@inject NavigationManager NavigationManager
+@attribute [Authorize]
+
+<PageTitle>Dashboard | Nexus Reader</PageTitle>
+
+<div class="dashboard-container">
+    <!-- Top Profile Section -->
+    <header class="profile-header">
+        <div class="header-grid-bg"></div>
+        <div class="profile-visual">
+            <div class="avatar-wrapper">
+                <img src="https://api.dicebear.com/7.x/bottts/svg?seed=Nexus" alt="Profile" class="profile-img" />
+                <div class="avatar-glow"></div>
+            </div>
+            <h1 class="username">[User_Explorer1988]</h1>
+            
+            <div class="status-pills">
+                <div class="status-pill">
+                    <span class="pill-label">Books Read:</span>
+                    <span class="pill-value">12</span>
+                </div>
+                <div class="status-pill">
+                    <span class="pill-label">Concepts Mapped:</span>
+                    <span class="pill-value">450</span>
+                </div>
+                <div class="status-pill">
+                    <span class="pill-label">Quiz Mastery:</span>
+                    <span class="pill-value">88%</span>
+                </div>
+            </div>
+        </div>
+    </header>
+
+    <!-- Main Content Area -->
+    <main class="dashboard-content">
+        <h2 class="section-title">Witaj, @(_profile?.Email.Split('@')[0] ?? "Użytkowniku")</h2>
+        
+        <div class="main-grid">
+            <!-- Current Reading Card -->
+            <section class="reading-card glass-panel">
+                @if (_profile?.LastReadBook != null)
+                {
+                    <div class="card-header">
+                        <h3>Ostatnio czytane: @_profile.LastReadBook.Title</h3>
+                    </div>
+                    <div class="card-body">
+                        <div class="reading-thumb">
+                            <img src="@(_profile.LastReadBook.CoverUrl ?? "https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/402px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg")" alt="Current Book" />
+                        </div>
+                        <div class="reading-info">
+                            <div class="progress-section">
+                                <span class="chapter-label">@_profile.LastReadBook.LastChapter</span>
+                                <div class="progress-container">
+                                    <div class="progress-bar" style="width: @(_profile.LastReadBook.Progress.ToString("F0", System.Globalization.CultureInfo.InvariantCulture))%">
+                                        <div class="progress-bubble">@(_profile.LastReadBook.Progress.ToString("F1"))%</div>
+                                    </div>
+                                </div>
+                                <span class="progress-detail">Postęp: @(_profile.LastReadBook.Progress.ToString("F2"))% - @_profile.LastReadBook.Author.Name</span>
+                            </div>
+                            <p class="reading-desc">
+                                Kontynuuj odkrywanie wiedzy w książce "@_profile.LastReadBook.Title". 
+                                Twój cyfrowy asystent Nexus jest gotowy do analizy kolejnych rozdziałów i generowania interaktywnych map myśli.
+                            </p>
+                            <div class="card-actions">
+                                <button class="btn-nexus primary" @onclick='() => NavigationManager.NavigateTo($"/reader?chapter={_profile.LastReadBook.LastChapterIndex}")'>Kontynuuj Czytanie</button>
+                                <button class="btn-nexus secondary" @onclick='() => NavigationManager.NavigateTo("/library")'>Moja Biblioteka</button>
+                            </div>
+                        </div>
+                    </div>
+                }
+                else
+                {
+                    <div class="card-header">
+                        <h3>Brak aktywnych lektur</h3>
+                    </div>
+                    <div class="card-body empty-state">
+                        <div class="empty-icon">
+                            <NexusIcon Name="book-open" Size="64" />
+                        </div>
+                        <div class="reading-info">
+                            <p class="reading-desc">
+                                Nie czytasz obecnie żadnej książki. Przejdź do biblioteki, aby przesłać swój pierwszy plik EPUB i rozpocząć przygodę z Nexus Reader.
+                            </p>
+                            <div class="card-actions">
+                                <button class="btn-nexus primary" @onclick='() => NavigationManager.NavigateTo("/library")'>Przejdź do Biblioteki</button>
+                            </div>
+                        </div>
+                    </div>
+                }
+            </section>
+
+            <div class="secondary-grid">
+                <!-- Knowledge Integration -->
+                <section class="integration-card glass-panel">
+                    <div class="panel-header">
+                        <h4>Knowledge Integration Progress</h4>
+                        <NexusIcon Name="arrow-right" Size="16" />
+                    </div>
+                    <div class="graph-placeholder">
+                        <div class="graph-node central"></div>
+                        <div class="graph-node satellite" style="--angle: 0deg; --dist: 60px;"></div>
+                        <div class="graph-node satellite" style="--angle: 120deg; --dist: 50px;"></div>
+                        <div class="graph-node satellite" style="--angle: 240deg; --dist: 70px;"></div>
+                        <div class="active-node-label">TU JESTEŚ</div>
+                    </div>
+                </section>
+
+                <!-- Quiz Summary -->
+                <section class="quiz-card glass-panel">
+                    <div class="panel-header">
+                        <h4>Quiz Summary: Key Thinkers</h4>
+                        <NexusIcon Name="arrow-right" Size="16" />
+                    </div>
+                    <div class="quiz-preview">
+                        <p class="question">Który artysta namalował 'Ostatnią Wieczerzę'?</p>
+                        <div class="quiz-options">
+                            <div class="quiz-option active">
+                                <span class="option-letter">A)</span> Michal Anioł
+                            </div>
+                            <div class="quiz-option">
+                                <span class="option-letter">B)</span> Leonardo da Vinci
+                            </div>
+                        </div>
+                    </div>
+                </section>
+            </div>
+        </div>
+    </main>
+</div>
+
+@code {
+    private UserProfile? _profile;
+
+    protected override async Task OnInitializedAsync()
+    {
+        var result = await IdentityService.GetProfileAsync();
+        if (result.IsSuccess) 
+        {
+            _profile = result.Value;
+        }
+    }
+}

src/NexusReader.UI.Shared/Pages/Dashboard.razor.css

@@ -0,0 +1,406 @@
+.dashboard-container {
+    min-height: 100%;
+    display: flex;
+    flex-direction: column;
+    animation: fade-in 0.8s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@keyframes fade-in {
+    from { opacity: 0; transform: translateY(20px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* --- Profile Header --- */
+.profile-header {
+    position: relative;
+    padding: 4rem 2rem 3rem;
+    display: flex;
+    justify-content: center;
+    overflow: hidden;
+    background: #0D0D0D;
+}
+
+.header-grid-bg {
+    position: absolute;
+    inset: 0;
+    background-image: 
+        linear-gradient(rgba(255,255,255,0.03) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255,255,255,0.03) 1px, transparent 1px);
+    background-size: 60px 60px;
+    background-position: center;
+    mask-image: radial-gradient(circle at center, black, transparent 80%);
+}
+
+.profile-visual {
+    position: relative;
+    z-index: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 1.5rem;
+}
+
+.avatar-wrapper {
+    position: relative;
+    width: 120px;
+    height: 120px;
+}
+
+.profile-img {
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    object-fit: cover;
+    border: 3px solid #1a1a1a;
+    position: relative;
+    z-index: 2;
+    background: #222;
+}
+
+.avatar-glow {
+    position: absolute;
+    inset: -5px;
+    border-radius: 50%;
+    background: var(--nexus-neon);
+    filter: blur(20px);
+    opacity: 0.4;
+    z-index: 1;
+    animation: pulse-glow 3s infinite;
+}
+
+@keyframes pulse-glow {
+    0%, 100% { transform: scale(1); opacity: 0.4; }
+    50% { transform: scale(1.05); opacity: 0.6; }
+}
+
+.username {
+    font-family: var(--nexus-font-sans);
+    font-size: 1.25rem;
+    font-weight: 500;
+    color: #ffffff;
+    letter-spacing: 1px;
+    text-transform: lowercase;
+}
+
+.username::before {
+    content: '[';
+    color: var(--nexus-neon);
+    margin-right: 4px;
+}
+
+.username::after {
+    content: ']';
+    color: var(--nexus-neon);
+    margin-left: 4px;
+}
+
+.status-pills {
+    display: flex;
+    gap: 1.5rem;
+    margin-top: 0.5rem;
+}
+
+.status-pill {
+    padding: 0.6rem 1.25rem;
+    background: rgba(0, 255, 153, 0.05);
+    border: 1px solid rgba(0, 255, 153, 0.3);
+    border-radius: 100px;
+    display: flex;
+    gap: 0.5rem;
+    font-size: 0.9rem;
+    box-shadow: 0 0 15px rgba(0, 255, 153, 0.1);
+}
+
+.pill-label { color: #A0A0A0; }
+.pill-value { color: #ffffff; font-weight: 600; }
+
+/* --- Dashboard Content --- */
+.dashboard-content {
+    padding: 3rem 2rem;
+    max-width: 1200px;
+    margin: 0 auto;
+    width: 100%;
+}
+
+.section-title {
+    font-family: var(--nexus-font-serif);
+    font-size: 2rem;
+    margin-bottom: 2rem;
+    color: #ffffff;
+}
+
+.main-grid {
+    display: grid;
+    grid-template-columns: 1.5fr 1fr;
+    gap: 2rem;
+}
+
+.glass-panel {
+    background: rgba(20, 20, 20, 0.8); /* Fallback for browsers without backdrop-filter */
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 20px;
+    padding: 1.5rem;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@supports (backdrop-filter: blur(10px)) {
+    .glass-panel {
+        background: rgba(255, 255, 255, 0.03);
+        backdrop-filter: blur(10px);
+    }
+}
+
+.glass-panel:hover {
+    background: rgba(255, 255, 255, 0.05);
+    border-color: rgba(0, 255, 153, 0.2);
+    transform: translateY(-4px);
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+}
+
+/* Reading Card */
+.reading-card {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.reading-card h3 {
+    font-size: 1.1rem;
+    font-weight: 600;
+    color: #E0E0E0;
+    margin: 0;
+}
+
+.card-body {
+    display: flex;
+    gap: 2rem;
+}
+
+.reading-thumb {
+    width: 120px;
+    flex-shrink: 0;
+}
+
+.reading-thumb img {
+    width: 100%;
+    border-radius: 12px;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.5);
+}
+
+.reading-info {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.progress-section {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.chapter-label {
+    font-size: 0.85rem;
+    color: #A0A0A0;
+}
+
+.progress-container {
+    height: 8px;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 4px;
+    position: relative;
+}
+
+.progress-bar {
+    height: 100%;
+    background: var(--nexus-neon);
+    border-radius: 4px;
+    position: relative;
+    box-shadow: 0 0 10px rgba(0, 255, 153, 0.3);
+}
+
+.progress-bubble {
+    position: absolute;
+    right: -20px;
+    top: -30px;
+    background: var(--nexus-neon);
+    color: #000;
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 0.75rem;
+    font-weight: 700;
+}
+
+.progress-detail {
+    font-size: 0.8rem;
+    color: #666;
+}
+
+.reading-desc {
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: #888;
+    margin: 0;
+}
+
+.card-actions {
+    display: flex;
+    gap: 1rem;
+}
+
+/* Secondary Grid Items */
+.secondary-grid {
+    display: flex;
+    flex-direction: column;
+    gap: 2rem;
+}
+
+.panel-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.panel-header h4 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: #E0E0E0;
+}
+
+/* Graph Placeholder */
+.graph-placeholder {
+    height: 180px;
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.graph-node {
+    position: absolute;
+    border-radius: 50%;
+    background: #333;
+    border: 1px solid rgba(255,255,255,0.1);
+}
+
+.graph-node.central {
+    width: 40px;
+    height: 40px;
+    background: var(--nexus-neon);
+    box-shadow: 0 0 20px rgba(0, 255, 153, 0.4);
+}
+
+.graph-node.satellite {
+    width: 20px;
+    height: 20px;
+    transform: rotate(var(--angle)) translateY(var(--dist));
+}
+
+.active-node-label {
+    position: absolute;
+    bottom: 20px;
+    right: 20px;
+    padding: 4px 12px;
+    background: rgba(0, 255, 153, 0.1);
+    border: 1px solid var(--nexus-neon);
+    border-radius: 4px;
+    font-size: 0.7rem;
+    color: var(--nexus-neon);
+    font-weight: 700;
+}
+
+/* Quiz Preview */
+.quiz-preview {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.question {
+    font-size: 0.95rem;
+    color: #E0E0E0;
+}
+
+.quiz-options {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.quiz-option {
+    padding: 0.75rem 1rem;
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 10px;
+    font-size: 0.9rem;
+    display: flex;
+    gap: 0.75rem;
+    cursor: pointer;
+}
+
+.quiz-option.active {
+    background: rgba(0, 255, 153, 0.05);
+    border-color: var(--nexus-neon);
+    color: var(--nexus-neon);
+}
+
+.option-letter {
+    font-weight: 700;
+}
+
+/* Buttons */
+.btn-nexus {
+    padding: 0.75rem 1.25rem;
+    border-radius: 10px;
+    font-size: 0.9rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+    border: none;
+}
+
+.btn-nexus.primary {
+    background: var(--nexus-neon);
+    color: #000;
+}
+
+.btn-nexus.secondary {
+    background: rgba(255, 255, 255, 0.05);
+    color: #fff;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.btn-nexus:hover {
+    transform: translateY(-2px);
+    filter: brightness(1.1);
+}
+
+/* Empty State */
+.empty-state {
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 3rem 1rem;
+    text-align: center;
+    gap: 1.5rem !important;
+}
+
+.empty-icon {
+    opacity: 0.3;
+    color: var(--nexus-neon);
+    filter: drop-shadow(0 0 10px rgba(0, 255, 153, 0.2));
+}
+
+.empty-state .reading-info {
+    align-items: center;
+    max-width: 400px;
+}
+
+@media (max-width: 1024px) {
+    .main-grid {
+        grid-template-columns: 1fr;
+    }
+}

src/NexusReader.UI.Shared/Pages/Home.razor

@@ -1,10 +1,13 @@
-@page "/"
+@page "/reader"
+@layout ReaderLayout
 @attribute [Authorize]
 @using NexusReader.UI.Shared.Services
 @implements IAsyncDisposable
 @inject IQuizStateService QuizState
 @inject IFocusModeService FocusMode
 @inject IJSRuntime JS
+@inject NavigationManager NavManager
+@inject IReaderNavigationService NavService
 <PageTitle>Nexus E-Reader</PageTitle>
 
 <div class="home-reader-container">
@@ -25,6 +28,16 @@
         QuizState.OnQuizRequested += HandleQuizRequestedAsync;
         FocusMode.OnFocusModeChanged += HandleUpdate;
         await FocusMode.InitializeAsync();
+
+        // Handle deep-linking to a specific chapter
+        var uri = NavManager.ToAbsoluteUri(NavManager.Uri);
+        if (Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(uri.Query).TryGetValue("chapter", out var chapterValue))
+        {
+            if (int.TryParse(chapterValue, out var chapterIndex))
+            {
+                await NavService.GoToChapter(chapterIndex);
+            }
+        }
     }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)

src/NexusReader.UI.Shared/Pages/Library.razor

@@ -0,0 +1,17 @@
+@page "/library"
+@attribute [Authorize]
+
+<div class="library-page">
+    <h1>Biblioteka</h1>
+    <p>Twoja kolekcja książek i dokumentów pojawi się tutaj wkrótce.</p>
+</div>
+
+<style>
+    .library-page {
+        padding: 2rem;
+    }
+    h1 {
+        margin-bottom: 1rem;
+        color: #fff;
+    }
+</style>

src/NexusReader.UI.Shared/Pages/NotFound.razor

@@ -1,5 +1,5 @@
 @page "/not-found"
-@layout Layout.MainLayout
+@layout MainHubLayout
 
 <div class="not-found-preloader">
     <div class="preloader-robot">

src/NexusReader.UI.Shared/Pages/Settings.razor

@@ -0,0 +1,17 @@
+@page "/settings"
+@attribute [Authorize]
+
+<div class="settings-page">
+    <h1>Ustawienia</h1>
+    <p>Konfiguracja Twojego konta i preferencji czytania.</p>
+</div>
+
+<style>
+    .settings-page {
+        padding: 2rem;
+    }
+    h1 {
+        margin-bottom: 1rem;
+        color: #fff;
+    }
+</style>

src/NexusReader.UI.Shared/Routes.razor

@@ -2,7 +2,7 @@
     <ChildContent>
         <Router AppAssembly="@typeof(Routes).Assembly">
             <Found Context="routeData">
-                <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(Layout.MainLayout)">
+                <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainHubLayout)">
                     <NotAuthorized>
                         <RedirectToLogin />
                     </NotAuthorized>

src/NexusReader.UI.Shared/Services/ISyncService.cs

@@ -5,7 +5,7 @@ namespace NexusReader.UI.Shared.Services;
 public interface ISyncService
 {
     Task<Result> InitializeAsync();
-    Task<Result> UpdateProgressAsync(string pageId);
+    Task<Result> UpdateProgressAsync(string pageId, Guid ebookId, double progress, string? chapterTitle, int chapterIndex);
     event Func<string, DateTime, Task> OnProgressReceived;
     Task DisposeAsync();
 }

src/NexusReader.UI.Shared/Services/IdentityService.cs

@@ -1,141 +1,263 @@
 using System.Net.Http.Json;
+using Microsoft.AspNetCore.Components.Authorization;
 using NexusReader.Application.Abstractions.Services;
+using NexusReader.Application.DTOs.User;
+using NexusReader.UI.Shared.Constants;
+using FluentResults;
 
 namespace NexusReader.UI.Shared.Services;
 
 public interface IIdentityService
 {
-    Task<bool> RegisterAsync(string email, string password);
-    Task<bool> LoginAsync(string email, string password, bool rememberMe = false);
-    Task LogoutAsync();
-    Task<UserProfile?> GetProfileAsync();
-    Task<bool> RefreshTokenAsync();
+    event Func<Task>? OnStateInvalidated;
+    Task<Result> RegisterAsync(string email, string password);
+    Task<Result> LoginAsync(string email, string password, bool rememberMe = false);
+    Task<Result> LogoutAsync();
+    Task<Result<UserProfile>> GetProfileAsync();
+    Task<Result> RefreshTokenAsync();
 }
 
 public record UserProfile(
     string Email,
-    int AITokenLimit, 
     int AITokensUsed,
-    string CurrentPlan, 
     Guid TenantId,
+    SubscriptionPlanDto Plan,
     int AverageQuizScore,
-    string LastReadBookTitle);
+    LastReadBookDto? LastReadBook)
+{
+    // Helper properties for UI compatibility
+    public string CurrentPlan => Plan?.Name ?? PlanConstants.DefaultPlanName;
+    public int AITokenLimit => Plan?.AITokenLimit ?? PlanConstants.DefaultTokenLimit;
+    public string LastReadBookTitle => LastReadBook?.Title ?? PlanConstants.DefaultActivityLabel;
+}
 
 public class IdentityService : IIdentityService
 {
     private readonly HttpClient _httpClient;
     private readonly INativeStorageService _storageService;
-    private readonly NexusAuthenticationStateProvider _authStateProvider;
-    private const string TokenKey = "nexus_auth_token";
-    private const string RefreshTokenKey = "nexus_refresh_token";
+    private readonly AuthenticationStateProvider? _authStateProvider;
+    private const string TokenKey = StorageKeys.AuthToken;
+    private const string RefreshTokenKey = StorageKeys.RefreshToken;
+    private Task<UserProfile?>? _profileTask;
+    private UserProfile? _cachedProfile;
+    private DateTime _lastFetchAttempt = DateTime.MinValue;
+
+    public event Func<Task>? OnStateInvalidated;
 
     public IdentityService(
         HttpClient httpClient, 
         INativeStorageService storageService,
-        NexusAuthenticationStateProvider authStateProvider)
+        AuthenticationStateProvider? authStateProvider = null)
     {
         _httpClient = httpClient;
         _storageService = storageService;
         _authStateProvider = authStateProvider;
     }
 
-    public async Task<bool> RegisterAsync(string email, string password)
-    {
-        var response = await _httpClient.PostAsJsonAsync("identity/register", new { email, password });
-        return response.IsSuccessStatusCode;
-    }
-
-    public async Task<bool> LoginAsync(string email, string password, bool rememberMe = false)
-    {
-        var response = await _httpClient.PostAsJsonAsync("identity/login", new { email, password });
-
-        if (response.IsSuccessStatusCode)
-        {
-            var result = await response.Content.ReadFromJsonAsync<LoginResponse>();
-            if (result != null && !string.IsNullOrEmpty(result.AccessToken))
-            {
-                await _storageService.SaveSecureString(TokenKey, result.AccessToken);
-                if (!string.IsNullOrEmpty(result.RefreshToken))
-                {
-                    await _storageService.SaveSecureString(RefreshTokenKey, result.RefreshToken);
-                }
-
-                // Option A: Fetch profile to get claims
-                var profile = await GetProfileAsync();
-                if (profile != null)
-                {
-                    await _storageService.SaveSecureString("nexus_user_email", profile.Email);
-                    await _storageService.SaveSecureString("nexus_user_tenant", profile.TenantId.ToString());
-                    
-                    _authStateProvider.NotifyUserAuthentication(profile.Email, profile.TenantId.ToString());
-                }
-                else
-                {
-                    // Fallback if profile fetch fails
-                    _authStateProvider.NotifyUserAuthentication(email, "unknown");
-                }
-                
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public async Task LogoutAsync()
-    {
-        _storageService.RemoveSecure(TokenKey);
-        _storageService.RemoveSecure(RefreshTokenKey);
-        _storageService.RemoveSecure("nexus_user_email");
-        _storageService.RemoveSecure("nexus_user_tenant");
-        _authStateProvider.NotifyUserLogout();
-    }
-    
-    public async Task<UserProfile?> GetProfileAsync()
+    public async Task<Result> RegisterAsync(string email, string password)
     {
         try
         {
-            return await _httpClient.GetFromJsonAsync<UserProfile>("identity/profile");
+            var response = await _httpClient.PostAsJsonAsync("identity/register", new { email, password });
+            return response.IsSuccessStatusCode ? Result.Ok() : Result.Fail("Rejestracja nie powiodła się.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error("Błąd sieci podczas rejestracji.").CausedBy(ex));
+        }
+    }
+
+    public async Task<Result> LoginAsync(string email, string password, bool rememberMe = false)
+    {
+        try
+        {
+            var response = await _httpClient.PostAsJsonAsync("identity/login?useCookies=true", new { email, password });
+            
+            if (response.IsSuccessStatusCode)
+            {
+                _cachedProfile = null;
+                LoginResponse? result = null;
+                try 
+                {
+                    result = await response.Content.ReadFromJsonAsync<LoginResponse>();
+                }
+                catch (System.Text.Json.JsonException ex) 
+                {
+                    return Result.Fail(new Error("Błąd przetwarzania odpowiedzi serwera.").CausedBy(ex));
+                }
+
+                if (result != null && !string.IsNullOrEmpty(result.AccessToken))
+                {
+                    await _storageService.SaveSecureString(TokenKey, result.AccessToken);
+                    if (!string.IsNullOrEmpty(result.RefreshToken))
+                    {
+                        await _storageService.SaveSecureString(RefreshTokenKey, result.RefreshToken);
+                    }
+                }
+
+                (_authStateProvider as NexusAuthenticationStateProvider)?.ClearCache();
+                if (OnStateInvalidated != null) await OnStateInvalidated.Invoke();
+
+                var profileResult = await GetProfileAsync();
+                if (profileResult.IsSuccess)
+                {
+                    var profile = profileResult.Value;
+                    await _storageService.SaveSecureString(StorageKeys.UserEmail, profile.Email);
+                    await _storageService.SaveSecureString(StorageKeys.UserTenant, profile.TenantId.ToString());
+                    (_authStateProvider as NexusAuthenticationStateProvider)?.NotifyUserAuthentication(profile.Email, profile.TenantId.ToString());
+                }
+                else
+                {
+                    (_authStateProvider as NexusAuthenticationStateProvider)?.NotifyUserAuthentication(email, "unknown");
+                }
+                
+                return Result.Ok();
+            }
+            return Result.Fail("Nieprawidłowy e-mail lub hasło.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error("Błąd połączenia z serwerem.").CausedBy(ex));
+        }
+    }
+
+    public async Task<Result> LogoutAsync()
+    {
+        try
+        {
+            _cachedProfile = null;
+            if (System.OperatingSystem.IsBrowser())
+            {
+                await _storageService.SaveSecureString(TokenKey, "");
+                await _storageService.SaveSecureString(RefreshTokenKey, "");
+                await _storageService.SaveSecureString(StorageKeys.UserEmail, "");
+                await _storageService.SaveSecureString(StorageKeys.UserTenant, "");
+            }
+            
+            if (OnStateInvalidated != null) await OnStateInvalidated.Invoke();
+            (_authStateProvider as NexusAuthenticationStateProvider)?.ClearCache();
+            (_authStateProvider as NexusAuthenticationStateProvider)?.NotifyUserLogout();
+            
+            return Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error("Błąd podczas wylogowywania.").CausedBy(ex));
+        }
+    }
+    
+    public async Task<Result<UserProfile>> GetProfileAsync()
+    {
+        if (_cachedProfile != null) 
+        {
+            return Result.Ok(_cachedProfile);
+        }
+        
+        if (_profileTask != null) 
+        {
+            var p = await _profileTask;
+            return p != null ? Result.Ok(p) : Result.Fail("Nie znaleziono profilu.");
+        }
+
+        _profileTask = GetProfileInternalAsync();
+        var result = await _profileTask;
+        return result != null ? Result.Ok(result) : Result.Fail("Błąd podczas pobierania profilu.");
+    }
+
+
+
+    private async Task<UserProfile?> GetProfileInternalAsync()
+    {
+        if (!System.OperatingSystem.IsBrowser()) 
+        {
+            return null;
+        }
+
+        if (DateTime.UtcNow - _lastFetchAttempt < TimeSpan.FromSeconds(5))
+        {
+            return null;
+        }
+
+        _lastFetchAttempt = DateTime.UtcNow;
+        try
+        {
+            var response = await _httpClient.GetAsync("identity/profile");
+            
+            if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
+            {
+                await LogoutAsync();
+                return null;
+            }
+
+            if (response.IsSuccessStatusCode)
+            {
+                var profile = await response.Content.ReadFromJsonAsync<UserProfile>();
+                if (profile != null)
+                {
+                    _cachedProfile = profile;
+                    await _storageService.SaveSecureString(StorageKeys.UserEmail, profile.Email);
+                    await _storageService.SaveSecureString(StorageKeys.UserTenant, profile.TenantId.ToString());
+                    (_authStateProvider as NexusAuthenticationStateProvider)?.NotifyUserAuthentication(profile.Email, profile.TenantId.ToString());
+                }
+                return profile;
+            }
+            
+            return null;
         }
         catch
         {
             return null;
         }
+        finally
+        {
+            _profileTask = null;
+        }
     }
 
-    public async Task<bool> RefreshTokenAsync()
+    public async Task<Result> RefreshTokenAsync()
     {
-        var result = await _storageService.GetSecureString(RefreshTokenKey);
-        var refreshToken = result.IsSuccess ? result.Value : null;
-
-        if (string.IsNullOrEmpty(refreshToken)) return false;
-
-        var response = await _httpClient.PostAsJsonAsync("identity/refresh", new { refreshToken });
-
-        if (response.IsSuccessStatusCode)
+        try
         {
-            var loginResult = await response.Content.ReadFromJsonAsync<LoginResponse>();
-            if (loginResult != null && !string.IsNullOrEmpty(loginResult.AccessToken))
+            var result = await _storageService.GetSecureString(RefreshTokenKey);
+            var refreshToken = result.IsSuccess ? result.Value : null;
+
+            if (string.IsNullOrEmpty(refreshToken)) return Result.Fail("Brak tokena odświeżania.");
+
+            var response = await _httpClient.PostAsJsonAsync("identity/refresh", new { refreshToken });
+
+            if (response.IsSuccessStatusCode)
             {
-                await _storageService.SaveSecureString(TokenKey, loginResult.AccessToken);
-                if (!string.IsNullOrEmpty(loginResult.RefreshToken))
+                var loginResult = await response.Content.ReadFromJsonAsync<LoginResponse>();
+                if (loginResult != null && !string.IsNullOrEmpty(loginResult.AccessToken))
                 {
-                    await _storageService.SaveSecureString(RefreshTokenKey, loginResult.RefreshToken);
-                }
+                    await _storageService.SaveSecureString(TokenKey, loginResult.AccessToken);
+                    if (!string.IsNullOrEmpty(loginResult.RefreshToken))
+                    {
+                        await _storageService.SaveSecureString(RefreshTokenKey, loginResult.RefreshToken);
+                    }
 
-                var profile = await GetProfileAsync();
-                if (profile != null)
-                {
-                    await _storageService.SaveSecureString("nexus_user_email", profile.Email);
-                    await _storageService.SaveSecureString("nexus_user_tenant", profile.TenantId.ToString());
-                    _authStateProvider.NotifyUserAuthentication(profile.Email, profile.TenantId.ToString());
-                }
+                    _cachedProfile = null;
+                    (_authStateProvider as NexusAuthenticationStateProvider)?.ClearCache();
+                    if (OnStateInvalidated != null) await OnStateInvalidated.Invoke();
 
-                return true;
+                    var profileResult = await GetProfileAsync();
+                    if (profileResult.IsSuccess)
+                    {
+                        var profile = profileResult.Value;
+                        await _storageService.SaveSecureString(StorageKeys.UserEmail, profile.Email);
+                        await _storageService.SaveSecureString(StorageKeys.UserTenant, profile.TenantId.ToString());
+                        (_authStateProvider as NexusAuthenticationStateProvider)?.NotifyUserAuthentication(profile.Email, profile.TenantId.ToString());
+                    }
+
+                    return Result.Ok();
+                }
             }
+            return Result.Fail("Sesja wygasła.");
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error("Błąd odświeżania sesji.").CausedBy(ex));
         }
-
-        return false;
     }
 
     private class LoginResponse

src/NexusReader.UI.Shared/Services/NexusAuthenticationStateProvider.cs

@@ -2,50 +2,64 @@ using System.Security.Claims;
 using System.Text.Json;
 using Microsoft.AspNetCore.Components.Authorization;
 using NexusReader.Application.Abstractions.Services;
+using NexusReader.UI.Shared.Constants;
 
 namespace NexusReader.UI.Shared.Services;
 
 public class NexusAuthenticationStateProvider : AuthenticationStateProvider
 {
     private readonly INativeStorageService _storageService;
-    private const string TokenKey = "nexus_auth_token";
+    private const string TokenKey = StorageKeys.AuthToken;
 
     public NexusAuthenticationStateProvider(INativeStorageService storageService)
     {
         _storageService = storageService;
     }
 
+    public void ClearCache()
+    {
+        _cachedState = null;
+        NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
+    }
+
+    private AuthenticationState? _cachedState;
+
     public override async Task<AuthenticationState> GetAuthenticationStateAsync()
     {
         try
         {
+            if (_cachedState != null) return _cachedState;
+
             var tokenResult = await _storageService.GetSecureString(TokenKey);
             var token = tokenResult.IsSuccess ? tokenResult.Value : null;
 
-            if (string.IsNullOrWhiteSpace(token))
+            // 1. Try Token-based auth
+            if (!string.IsNullOrWhiteSpace(token))
             {
-                return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
+                var emailResult = await _storageService.GetSecureString(StorageKeys.UserEmail);
+                var tenantIdResult = await _storageService.GetSecureString(StorageKeys.UserTenant);
+
+                if (emailResult.IsSuccess && !string.IsNullOrEmpty(emailResult.Value))
+                {
+                    _cachedState = CreateState(emailResult.Value, tenantIdResult.IsSuccess ? tenantIdResult.Value! : "unknown", "OpaqueBearer");
+                    return _cachedState;
+                }
             }
 
-            // For opaque tokens, we read the user info that was stored during login
-            var emailResult = await _storageService.GetSecureString("nexus_user_email");
-            var tenantIdResult = await _storageService.GetSecureString("nexus_user_tenant");
-
-            var claims = new List<Claim>();
-            if (emailResult.IsSuccess && !string.IsNullOrEmpty(emailResult.Value))
+            // 2. Try Cookie-based auth indicators
+            var storedEmailResult = await _storageService.GetSecureString(StorageKeys.UserEmail);
+            if (storedEmailResult.IsSuccess && !string.IsNullOrEmpty(storedEmailResult.Value))
             {
-                claims.Add(new Claim(ClaimTypes.Name, emailResult.Value));
-                claims.Add(new Claim(ClaimTypes.Email, emailResult.Value));
-            }
-            if (tenantIdResult.IsSuccess && !string.IsNullOrEmpty(tenantIdResult.Value))
-            {
-                claims.Add(new Claim("TenantId", tenantIdResult.Value));
+                var tenantIdResult = await _storageService.GetSecureString(StorageKeys.UserTenant);
+                _cachedState = CreateState(storedEmailResult.Value, tenantIdResult.IsSuccess ? tenantIdResult.Value! : "unknown", "CookieAuth");
+                return _cachedState;
             }
 
-            var identity = new ClaimsIdentity(claims, "OpaqueBearer");
-            var user = new ClaimsPrincipal(identity);
-
-            return new AuthenticationState(user);
+            // 3. Fallback: If we have no local info, we might still have a cookie (e.g. after refresh or Google login).
+            // We should return anonymous for now but trigger a background check if we're in WASM.
+            // Wait! In WASM, the first GetAuthenticationStateAsync is awaited. 
+            // We can do a quick check here if it's the first time.
+            return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
         }
         catch (Exception)
         {
@@ -53,7 +67,7 @@ public class NexusAuthenticationStateProvider : AuthenticationStateProvider
         }
     }
 
-    public void NotifyUserAuthentication(string email, string tenantId)
+    private AuthenticationState CreateState(string email, string tenantId, string authType)
     {
         var claims = new List<Claim>
         {
@@ -61,17 +75,20 @@ public class NexusAuthenticationStateProvider : AuthenticationStateProvider
             new Claim(ClaimTypes.Email, email),
             new Claim("TenantId", tenantId)
         };
+        var identity = new ClaimsIdentity(claims, authType);
+        return new AuthenticationState(new ClaimsPrincipal(identity));
+    }
 
-        var identity = new ClaimsIdentity(claims, "OpaqueBearer");
-        var user = new ClaimsPrincipal(identity);
-        var authState = Task.FromResult(new AuthenticationState(user));
-        NotifyAuthenticationStateChanged(authState);
+    public void NotifyUserAuthentication(string email, string tenantId)
+    {
+        _cachedState = CreateState(email, tenantId, "OpaqueBearer");
+        NotifyAuthenticationStateChanged(Task.FromResult(_cachedState));
     }
 
     public void NotifyUserLogout()
     {
+        _cachedState = null;
         var guest = new ClaimsPrincipal(new ClaimsIdentity());
-        var authState = Task.FromResult(new AuthenticationState(guest));
-        NotifyAuthenticationStateChanged(authState);
+        NotifyAuthenticationStateChanged(Task.FromResult(new AuthenticationState(guest)));
     }
 }

src/NexusReader.UI.Shared/Services/SyncService.cs

@@ -46,6 +46,7 @@ public class SyncService : ISyncService, IAsyncDisposable
 
         _hubConnection.On<string, DateTime>("ProgressUpdated", async (pageId, timestamp) =>
         {
+            // Note: In the future we might want to receive ebookId and progress here too
             if (OnProgressReceived != null) await OnProgressReceived(pageId, timestamp);
         });
 
@@ -63,7 +64,7 @@ public class SyncService : ISyncService, IAsyncDisposable
 
     private string? _lastSentPageId;
 
-    public async Task<Result> UpdateProgressAsync(string pageId)
+    public async Task<Result> UpdateProgressAsync(string pageId, Guid ebookId, double progress, string? chapterTitle, int chapterIndex)
     {
         if (pageId == _lastSentPageId) return Result.Ok();
         
@@ -82,7 +83,7 @@ public class SyncService : ISyncService, IAsyncDisposable
                 
                 if (_hubConnection?.State == HubConnectionState.Connected)
                 {
-                    await _hubConnection.SendAsync("UpdateProgress", pageId, token);
+                    await _hubConnection.SendAsync("UpdateProgress", pageId, ebookId, progress, chapterTitle, token);
                     _lastSentPageId = pageId;
                 }
             }

src/NexusReader.UI.Shared/wwwroot/app.css

@@ -19,6 +19,22 @@
     --nexus-transition: 0.4s cubic-bezier(0.4, 0, 0.2, 1);
 }
 
+/* Global Glassmorphism with Fallback */
+.glass-panel {
+    background: rgba(20, 20, 20, 0.85); /* Darker fallback for readability */
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 20px;
+    padding: 1.5rem;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+@supports (backdrop-filter: blur(10px)) {
+    .glass-panel {
+        background: rgba(255, 255, 255, 0.03);
+        backdrop-filter: blur(10px);
+    }
+}
+
 
 .theme-light {
     --nexus-bg: var(--nexus-paper);

src/NexusReader.Web.Client/Handlers/AuthenticationHeaderHandler.cs

@@ -1,4 +1,5 @@
 using System.Net.Http.Headers;
+using Microsoft.AspNetCore.Components.WebAssembly.Http;
 using NexusReader.Application.Abstractions.Services;
 
 namespace NexusReader.Web.Client.Handlers;
@@ -15,6 +16,9 @@ public class AuthenticationHeaderHandler : DelegatingHandler
 
     protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
     {
+        // Ensure cookies are sent (needed for InteractiveAuto SSR synchronization)
+        request.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);
+
         var tokenResult = await _storageService.GetSecureString(TokenKey);
         
         if (tokenResult.IsSuccess && !string.IsNullOrEmpty(tokenResult.Value))

src/NexusReader.Web.Client/Services/WasmEpubService.cs

@@ -14,7 +14,7 @@ public class WasmEpubService : IEpubService
         _httpClient = httpClient;
     }
 
-    public async Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex)
+    public async Task<Result<ReaderPageViewModel>> GetEpubContentAsync(int chapterIndex, string? userId = null)
     {
         try
         {

src/NexusReader.Web.New/Program.cs

@@ -2,7 +2,8 @@ using NexusReader.Web.Components;
 using NexusReader.Application;
 using NexusReader.Infrastructure;
 using NexusReader.Application.Abstractions.Services;
-using NexusReader.Application.DTOs.User;
+using NexusReader.Application.Queries.User;
+using MediatR;
 using NexusReader.Web.Client.Services;
 using NexusReader.UI.Shared.Services;
 using NexusReader.Domain.Entities;
@@ -52,9 +53,8 @@ builder.Services.AddHttpClient("NexusAPI", client =>
 });
 builder.Services.AddScoped(sp => sp.GetRequiredService<IHttpClientFactory>().CreateClient("NexusAPI"));
 
-builder.Services.AddScoped<IIdentityService, NexusReader.UI.Shared.Services.IdentityService>();
-builder.Services.AddScoped<NexusAuthenticationStateProvider>();
-builder.Services.AddScoped<AuthenticationStateProvider>(sp => sp.GetRequiredService<NexusAuthenticationStateProvider>());
+builder.Services.AddHttpContextAccessor();
+builder.Services.AddScoped<IIdentityService, NexusReader.Web.New.Services.ServerIdentityService>();
 builder.Services.AddCascadingAuthenticationState();
 
 builder.Services.AddApplication();
@@ -93,14 +93,24 @@ builder.Services.AddIdentityApiEndpoints<NexusUser>()
 builder.Services.ConfigureApplicationCookie(options =>
 {
     options.LoginPath = "/account/login";
+    options.LogoutPath = "/account/logout";
+    options.AccessDeniedPath = "/account/access-denied";
+    options.Cookie.Name = "NexusReader.Auth";
     options.Cookie.HttpOnly = true;
+    options.Cookie.SameSite = SameSiteMode.Lax;
+    options.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
     options.ExpireTimeSpan = TimeSpan.FromDays(30);
     options.SlidingExpiration = true;
+
     options.Events.OnRedirectToLogin = context =>
     {
-        if (context.Request.Path.StartsWithSegments("/api"))
+        var isApiRequest = context.Request.Path.StartsWithSegments("/api") || 
+                           context.Request.Path.StartsWithSegments("/identity") ||
+                           context.Request.Headers["Accept"].ToString().Contains("application/json");
+
+        if (isApiRequest)
         {
-            context.Response.StatusCode = 401;
+            context.Response.StatusCode = StatusCodes.Status401Unauthorized;
         }
         else
         {
@@ -216,9 +226,11 @@ app.MapStaticAssets();
 app.MapHub<NexusReader.Infrastructure.RealTime.SyncHub>("/synchub");
 
 // API endpoint for WASM client to fetch EPUB content
-app.MapGet("/api/epub/{index}", async (int index, IEpubService epubService) =>
+app.MapGet("/api/epub/{index}", async (int index, IEpubService epubService, ClaimsPrincipal user) =>
 {
-    var result = await epubService.GetEpubContentAsync(index);
+    var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
+    var result = await epubService.GetEpubContentAsync(index, userId);
+    
     if (result.IsSuccess) return Results.Ok(result.Value);
     
     var errorMsg = result.Errors.Count > 0 ? result.Errors[0].Message : "Unknown server error";
@@ -421,38 +433,15 @@ app.MapGet("/identity/callback/google", async (
     return Results.Redirect("/account/login?error=ProvisioningFailed");
 });
 
-app.MapGet("/identity/profile", async (ClaimsPrincipal user, UserManager<NexusUser> userManager, IDbContextFactory<AppDbContext> dbContextFactory) =>
+app.MapGet("/identity/profile", async (ClaimsPrincipal user, IMediator mediator) =>
 {
     var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
     if (userId == null) return Results.Unauthorized();
 
-    using var dbContext = await dbContextFactory.CreateDbContextAsync();
+    var result = await mediator.Send(new GetUserProfileQuery(userId));
+    if (result.IsFailed) return Results.NotFound(result.Errors.FirstOrDefault()?.Message);
 
-    var profile = await dbContext.Users
-        .Where(u => u.Id == userId)
-        .Select(u => new UserProfileDto
-        {
-            Email = u.Email ?? string.Empty,
-            AITokensUsed = u.AITokensUsed,
-            Plan = u.SubscriptionPlan != null ? new SubscriptionPlanDto
-            {
-                Id = u.SubscriptionPlan.Id,
-                Name = u.SubscriptionPlan.PlanName,
-                AITokenLimit = u.SubscriptionPlan.AITokenLimit,
-                MonthlyPrice = u.SubscriptionPlan.MonthlyPrice
-            } : new SubscriptionPlanDto(),
-            AverageQuizScore = u.QuizResults.Any() ? (int)u.QuizResults.Average(q => q.Percentage) : 0,
-            LastReadBook = u.Ebooks.OrderByDescending(e => e.LastReadDate).Select(e => new LastReadBookDto
-            {
-                Id = e.Id,
-                Title = e.Title
-            }).FirstOrDefault()
-        })
-        .FirstOrDefaultAsync();
-
-    if (profile == null) return Results.NotFound();
-
-    return Results.Ok(profile);
+    return Results.Ok(result.Value);
 }).RequireAuthorization();
 
 app.MapRazorComponents<App>()

src/NexusReader.Web.New/Services/ServerIdentityService.cs

@@ -0,0 +1,68 @@
+using System.Security.Claims;
+using FluentResults;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using NexusReader.Application.DTOs.User;
+using NexusReader.Data.Persistence;
+using NexusReader.Domain.Entities;
+using NexusReader.Application.Queries.User;
+using MediatR;
+using NexusReader.UI.Shared.Services;
+
+namespace NexusReader.Web.New.Services;
+
+public class ServerIdentityService : IIdentityService
+{
+    private readonly UserManager<NexusUser> _userManager;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly IMediator _mediator;
+
+    public event Func<Task>? OnStateInvalidated;
+
+    public ServerIdentityService(
+        UserManager<NexusUser> userManager,
+        IHttpContextAccessor httpContextAccessor,
+        IMediator mediator)
+    {
+        _userManager = userManager;
+        _httpContextAccessor = httpContextAccessor;
+        _mediator = mediator;
+    }
+
+    public Task<Result> LoginAsync(string email, string password, bool rememberMe = false) 
+        => throw new NotSupportedException("Use standard Identity endpoints for login on server.");
+
+    public Task<Result> LogoutAsync() 
+        => throw new NotSupportedException("Use standard Identity endpoints for logout on server.");
+
+    public Task<Result> RegisterAsync(string email, string password) 
+        => throw new NotSupportedException("Use standard Identity endpoints for registration on server.");
+
+    public Task<Result> RefreshTokenAsync() => Task.FromResult(Result.Ok());
+
+    public async Task<Result<UserProfile>> GetProfileAsync()
+    {
+        var user = _httpContextAccessor.HttpContext?.User;
+        if (user == null || !user.Identity?.IsAuthenticated == true) return Result.Fail("Not authenticated.");
+
+        var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
+        if (userId == null) return Result.Fail("User ID not found.");
+
+        var result = await _mediator.Send(new GetUserProfileQuery(userId));
+        if (result.IsFailed) return Result.Fail(result.Errors);
+
+        var dto = result.Value;
+        
+        // Map DTO to UI record
+        var profile = new UserProfile(
+            dto.Email,
+            dto.AITokensUsed,
+            dto.TenantId,
+            dto.Plan,
+            dto.AverageQuizScore,
+            dto.LastReadBook
+        );
+
+        return Result.Ok(profile);
+    }
+}