fix(knowledge-service): resolve semantic cache collision by partitioning content hash by traceType and PromptVersion

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

@@ -0,0 +1,17 @@
+using FluentResults;
+
+namespace NexusReader.Application.Abstractions.Services;
+
+/// <summary>
+/// Service abstraction to extract raw text content from EPUB chapters.
+/// </summary>
+public interface IEpubExtractor
+{
+    /// <summary>
+    /// Extracts the sanitized, plain-text content of each chapter in the EPUB file.
+    /// </summary>
+    /// <param name="relativePath">The relative storage path of the EPUB file.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A list of plain-text chapters, or a failure result.</returns>
+    Task<Result<List<string>>> ExtractChaptersTextAsync(string relativePath, CancellationToken cancellationToken = default);
+}

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

@@ -11,4 +11,5 @@ public interface IIdentityService
     Task<Result> LogoutAsync();
     Task<Result<UserProfileDto>> GetProfileAsync();
     Task<Result> RefreshTokenAsync();
+    void ClearCache();
 }

src/NexusReader.Application/Commands/Library/IngestEbookCommandHandler.cs

@@ -1,5 +1,6 @@
 using FluentResults;
 using MediatR;
+using Microsoft.Extensions.DependencyInjection;
 using NexusReader.Application.Abstractions.Messaging;
 using NexusReader.Application.Abstractions.Persistence;
 using NexusReader.Application.Abstractions.Services;
@@ -11,13 +12,16 @@ public class IngestEbookCommandHandler : IRequestHandler<IngestEbookCommand, Res
 {
     private readonly IEbookRepository _ebookRepository;
     private readonly IBookStorageService _storageService;
+    private readonly IServiceScopeFactory _scopeFactory;
 
     public IngestEbookCommandHandler(
         IEbookRepository ebookRepository,
-        IBookStorageService storageService)
+        IBookStorageService storageService,
+        IServiceScopeFactory scopeFactory)
     {
         _ebookRepository = ebookRepository;
         _storageService = storageService;
+        _scopeFactory = scopeFactory;
     }
 
     public async Task<Result<Guid>> Handle(IngestEbookCommand request, CancellationToken cancellationToken)
@@ -72,6 +76,21 @@ public class IngestEbookCommandHandler : IRequestHandler<IngestEbookCommand, Res
             _ebookRepository.AddEbook(ebook);
             await _ebookRepository.SaveChangesAsync(cancellationToken);
 
+            // 4. Trigger asynchronous background processing and vector indexing
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    using var scope = _scopeFactory.CreateScope();
+                    var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+                    await mediator.Send(new ProcessEbookCommand(ebook.Id, request.UserId, request.TenantId));
+                }
+                catch (Exception)
+                {
+                    // Swallowed to prevent ThreadPool crashes
+                }
+            });
+
             return Result.Ok(ebook.Id);
         }
         catch (Exception ex)

src/NexusReader.Application/Commands/Library/ProcessEbookCommand.cs

@@ -0,0 +1,177 @@
+using System.Text.RegularExpressions;
+using FluentResults;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using NexusReader.Application.Abstractions.Messaging;
+using NexusReader.Application.Abstractions.Services;
+using NexusReader.Data.Persistence;
+
+namespace NexusReader.Application.Commands.Library;
+
+public record ProcessEbookCommand(
+    Guid EbookId,
+    string UserId,
+    string TenantId
+) : ICommand<bool>;
+
+public class ProcessEbookCommandHandler : IRequestHandler<ProcessEbookCommand, Result<bool>>
+{
+    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;
+    private readonly IKnowledgeService _knowledgeService;
+    private readonly IEpubExtractor _epubExtractor;
+    private readonly ISyncBroadcaster _broadcaster;
+    private readonly ILogger<ProcessEbookCommandHandler> _logger;
+
+    public ProcessEbookCommandHandler(
+        IDbContextFactory<AppDbContext> dbContextFactory,
+        IKnowledgeService knowledgeService,
+        IEpubExtractor epubExtractor,
+        ISyncBroadcaster broadcaster,
+        ILogger<ProcessEbookCommandHandler> logger)
+    {
+        _dbContextFactory = dbContextFactory;
+        _knowledgeService = knowledgeService;
+        _epubExtractor = epubExtractor;
+        _broadcaster = broadcaster;
+        _logger = logger;
+    }
+
+    public async Task<Result<bool>> Handle(ProcessEbookCommand request, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("[ProcessEbook] Starting background processing for Ebook: {EbookId}", request.EbookId);
+        
+        try
+        {
+            await _broadcaster.BroadcastIngestionProgressAsync(request.UserId, "Wyszukiwanie e-booka w bazie danych...", 0.05, cancellationToken);
+
+            using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            var ebook = await dbContext.Ebooks.FindAsync(new object[] { request.EbookId }, cancellationToken);
+            if (ebook == null)
+            {
+                _logger.LogError("[ProcessEbook] Ebook not found in database: {EbookId}", request.EbookId);
+                return Result.Fail<bool>($"Ebook nie znaleziony w bazie danych: {request.EbookId}");
+            }
+
+            _logger.LogInformation("[ProcessEbook] Extracting chapters text for Ebook: {Title} ({FilePath})", ebook.Title, ebook.FilePath);
+            await _broadcaster.BroadcastIngestionProgressAsync(request.UserId, "Otwieranie i parsowanie pliku EPUB...", 0.1, cancellationToken);
+            
+            var extractionResult = await _epubExtractor.ExtractChaptersTextAsync(ebook.FilePath, cancellationToken);
+            if (extractionResult.IsFailed)
+            {
+                var errorMsg = extractionResult.Errors.FirstOrDefault()?.Message ?? "Failed to extract text chapters.";
+                _logger.LogError("[ProcessEbook] Extraction failed: {Error}", errorMsg);
+                return Result.Fail<bool>(extractionResult.Errors);
+            }
+
+            var chapters = extractionResult.Value;
+            if (chapters == null || !chapters.Any())
+            {
+                _logger.LogWarning("[ProcessEbook] EPUB has no readable content files: {EbookId}", request.EbookId);
+                return Result.Fail<bool>("EPUB nie zawiera czytelnych rozdziałów.");
+            }
+
+            int totalChapters = chapters.Count;
+            _logger.LogInformation("[ProcessEbook] Processing {Count} chapters for Ebook: {Title}", totalChapters, ebook.Title);
+            
+            await _broadcaster.BroadcastIngestionProgressAsync(request.UserId, $"Analizowanie struktury ({totalChapters} rozdziałów)...", 0.15, cancellationToken);
+
+            int processedChapters = 0;
+
+            for (int i = 0; i < totalChapters; i++)
+            {
+                var cleanText = chapters[i];
+
+                if (cleanText.Length < 100)
+                {
+                    _logger.LogInformation("[ProcessEbook] Skipping chapter {Index} (text too short: {Length} chars)", i, cleanText.Length);
+                    processedChapters++;
+                    continue;
+                }
+
+                // Chunk the text to maintain granular Knowledge Units
+                var chunks = ChunkText(cleanText, 3000);
+                _logger.LogInformation("[ProcessEbook] Chapter {Index} split into {ChunkCount} chunk(s)", i, chunks.Count);
+
+                foreach (var chunk in chunks)
+                {
+                    try
+                    {
+                        // Invoke GetKnowledgeMapAsync to extract, embed, and upsert knowledge units
+                        var result = await _knowledgeService.GetKnowledgeMapAsync(chunk, request.TenantId, request.EbookId, cancellationToken);
+                        if (result.IsFailed)
+                        {
+                            _logger.LogWarning("[ProcessEbook] Failed to generate knowledge map for a chunk of chapter {Index}: {Error}", i, result.Errors.FirstOrDefault()?.Message);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "[ProcessEbook] Exception during AI vectorization of chapter {Index} chunk", i);
+                    }
+                }
+
+                processedChapters++;
+                double progress = 0.15 + (0.75 * processedChapters / totalChapters);
+                await _broadcaster.BroadcastIngestionProgressAsync(
+                    request.UserId, 
+                    $"Przetwarzanie rozdziału {processedChapters} z {totalChapters} przez AI...", 
+                    progress, 
+                    cancellationToken);
+            }
+
+            // Mark the ebook as ready
+            ebook.IsReadyForReading = true;
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            _logger.LogInformation("[ProcessEbook] Ingestion and vector indexing completed for: {Title}", ebook.Title);
+            
+            await _broadcaster.BroadcastIngestionProgressAsync(
+                request.UserId, 
+                "Indeksowanie wektorowe e-booka przez Nexus AI zakończone pomyślnie!", 
+                1.0, 
+                cancellationToken);
+
+            return Result.Ok(true);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "[ProcessEbook] Critical error during background EPUB vectorization of ebook {EbookId}", request.EbookId);
+            await _broadcaster.BroadcastIngestionProgressAsync(
+                request.UserId, 
+                $"Błąd indeksowania: {ex.Message}", 
+                1.0, 
+                cancellationToken);
+            return Result.Fail<bool>(new Error("Wystąpił błąd podczas indeksowania e-booka przez AI").CausedBy(ex));
+        }
+    }
+
+    private static List<string> ChunkText(string text, int maxWords = 3000)
+    {
+        var words = text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+        var chunks = new List<string>();
+        if (words.Length <= maxWords)
+        {
+            chunks.Add(text);
+            return chunks;
+        }
+        var currentChunk = new List<string>();
+        int count = 0;
+        foreach (var word in words)
+        {
+            currentChunk.Add(word);
+            count++;
+            if (count >= maxWords)
+            {
+                chunks.Add(string.Join(" ", currentChunk));
+                currentChunk.Clear();
+                count = 0;
+            }
+        }
+        if (currentChunk.Any())
+        {
+            chunks.Add(string.Join(" ", currentChunk));
+        }
+        return chunks;
+    }
+}

src/NexusReader.Application/Commands/Quiz/SubmitQuizResultCommand.cs

@@ -0,0 +1,10 @@
+using FluentResults;
+using NexusReader.Application.Abstractions.Messaging;
+
+namespace NexusReader.Application.Commands.Quiz;
+
+public record SubmitQuizResultCommand(
+    string UserId,
+    string Topic,
+    int Score,
+    int TotalQuestions) : ICommand;

src/NexusReader.Application/Commands/Quiz/SubmitQuizResultCommandHandler.cs

@@ -0,0 +1,44 @@
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using NexusReader.Application.Abstractions.Messaging;
+using NexusReader.Data.Persistence;
+using NexusReader.Domain.Entities;
+
+namespace NexusReader.Application.Commands.Quiz;
+
+public sealed class SubmitQuizResultCommandHandler : ICommandHandler<SubmitQuizResultCommand>
+{
+    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;
+
+    public SubmitQuizResultCommandHandler(IDbContextFactory<AppDbContext> dbContextFactory)
+    {
+        _dbContextFactory = dbContextFactory;
+    }
+
+    public async Task<Result> Handle(SubmitQuizResultCommand request, CancellationToken cancellationToken)
+    {
+        using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        var user = await context.Users.FirstOrDefaultAsync(u => u.Id == request.UserId, cancellationToken);
+        if (user == null)
+        {
+            return Result.Fail("User not found.");
+        }
+
+        var quizResult = new QuizResult
+        {
+            Id = Guid.NewGuid(),
+            UserId = request.UserId,
+            TenantId = string.IsNullOrEmpty(user.TenantId) ? "global" : user.TenantId,
+            Topic = request.Topic,
+            Score = request.Score,
+            TotalQuestions = request.TotalQuestions,
+            CompletedDate = DateTime.UtcNow
+        };
+
+        context.QuizResults.Add(quizResult);
+        await context.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok();
+    }
+}

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

@@ -5,6 +5,7 @@ namespace NexusReader.Application.DTOs.User;
 public record UserProfileDto
 {
     public string Email { get; init; } = string.Empty;
+    public string UserId { get; init; } = string.Empty;
     public int AITokensUsed { get; init; }
     public Guid TenantId { get; init; }
     
@@ -15,11 +16,11 @@ public record UserProfileDto
 
     public int AverageQuizScore { get; init; }
     
-    /// <summary>
-    /// Summary of the last read book.
-    /// </summary>
+    public string? DisplayName { get; init; }
+    public int BooksReadCount { get; init; }
+    public int ConceptsMappedCount { get; init; }
     public LastReadBookDto? LastReadBook { get; init; }
-
+    public IReadOnlyList<QuizResultDto> RecentQuizzes { get; init; } = Array.Empty<QuizResultDto>();
     public string[] Roles { get; init; } = Array.Empty<string>();
 
     // Helper properties for UI compatibility
@@ -38,4 +39,15 @@ public record LastReadBookDto
     public string? LastChapter { get; init; }
     public int LastChapterIndex { get; init; }
     public string? Description { get; init; }
+    public bool IsReadyForReading { get; init; }
+}
+
+public record QuizResultDto
+{
+    public Guid Id { get; init; }
+    public string Topic { get; init; } = string.Empty;
+    public int Score { get; init; }
+    public int TotalQuestions { get; init; }
+    public double Percentage { get; init; }
+    public DateTime CompletedDate { get; init; }
 }

src/NexusReader.Application/Queries/Graph/GraphViewModels.cs

@@ -1,9 +1,27 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
 namespace NexusReader.Application.Queries.Graph;
 
-public record GraphNodeDto(string Id, string Label, string Group, string? Type = null);
-public record GraphLinkDto(string Source, string Target, string RelationType, int Value = 1);
+public record GraphNodeDto(
+    [property: JsonPropertyName("id")] string Id,
+    [property: JsonPropertyName("label")] string Label,
+    [property: JsonPropertyName("group")] string Group,
+    [property: JsonPropertyName("description")] string? Description = null,
+    [property: JsonPropertyName("type")] string? Type = null,
+    [property: JsonPropertyName("summary")] string? Summary = null,
+    [property: JsonPropertyName("key_terms")] List<string>? KeyTerms = null
+);
+
+public record GraphLinkDto(
+    [property: JsonPropertyName("source")] string Source,
+    [property: JsonPropertyName("target")] string Target,
+    [property: JsonPropertyName("type")] string RelationType,
+    [property: JsonPropertyName("value")] int Value = 1
+);
+
 public record GraphDataDto
 {
-    public List<GraphNodeDto> Nodes { get; init; } = new();
-    public List<GraphLinkDto> Links { get; init; } = new();
+    [JsonPropertyName("nodes")] public List<GraphNodeDto> Nodes { get; init; } = new();
+    [JsonPropertyName("links")] public List<GraphLinkDto> Links { get; init; } = new();
 }

src/NexusReader.Application/Queries/Library/GetMyEbooksQuery.cs

@@ -37,7 +37,8 @@ public class GetMyEbooksQueryHandler : IRequestHandler<GetMyEbooksQuery, Result<
                 Progress = e.Progress,
                 LastChapter = e.LastChapter ?? "Rozpoczynanie...",
                 LastChapterIndex = e.LastChapterIndex,
-                Description = e.Description
+                Description = e.Description,
+                IsReadyForReading = e.IsReadyForReading
             })
             .ToListAsync(cancellationToken);
 

src/NexusReader.Application/Queries/Library/SearchLibrarySemanticallyQuery.cs

@@ -1,18 +1,7 @@
 using FluentResults;
 using MediatR;
-using Pgvector;
-using Pgvector.EntityFrameworkCore;
 using NexusReader.Application.Abstractions.Services;
 using NexusReader.Application.DTOs.AI;
-using Microsoft.Extensions.AI;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Resilience;
-using Polly;
-using Polly.Registry;
-using Mapster;
-using MapsterMapper;
-
-using NexusReader.Data.Persistence;
 
 namespace NexusReader.Application.Queries.Library;
 
@@ -21,21 +10,11 @@ public record SearchLibrarySemanticallyQuery(string QueryText, string TenantId,
 
 public class SearchLibrarySemanticallyQueryHandler : IRequestHandler<SearchLibrarySemanticallyQuery, Result<List<SemanticSearchResultDto>>>
 {
-    private readonly IEmbeddingGenerator<string, Embedding<float>> _embeddingGenerator;
-    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;
-    private readonly ResiliencePipeline _retryPipeline;
-    private readonly IMapper _mapper;
+    private readonly IKnowledgeService _knowledgeService;
 
-    public SearchLibrarySemanticallyQueryHandler(
-        IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator,
-        IDbContextFactory<AppDbContext> dbContextFactory,
-        ResiliencePipelineProvider<string> pipelineProvider,
-        IMapper mapper)
+    public SearchLibrarySemanticallyQueryHandler(IKnowledgeService knowledgeService)
     {
-        _embeddingGenerator = embeddingGenerator;
-        _dbContextFactory = dbContextFactory;
-        _retryPipeline = pipelineProvider.GetPipeline("ai-retry");
-        _mapper = mapper;
+        _knowledgeService = knowledgeService;
     }
 
     public async Task<Result<List<SemanticSearchResultDto>>> Handle(SearchLibrarySemanticallyQuery request, CancellationToken cancellationToken)
@@ -45,19 +24,10 @@ public class SearchLibrarySemanticallyQueryHandler : IRequestHandler<SearchLibra
             return Result.Fail("Query text cannot be empty.");
         }
 
-        // Generate embedding with retry
-        var embeddingResponse = await _retryPipeline.ExecuteAsync(async ct =>
-            await _embeddingGenerator.GenerateAsync(new[] { request.QueryText }, cancellationToken: ct), cancellationToken);
-        var queryVector = new Vector(embeddingResponse.First().Vector.ToArray());
-
-        await using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        var cacheEntries = await dbContext.SemanticKnowledgeCache
-            .Where(c => c.TenantId == request.TenantId && c.Embedding != null)
-            .OrderBy(c => c.Embedding!.CosineDistance(queryVector))
-            .Take(request.Limit)
-            .ToListAsync(cancellationToken);
-
-        var dtos = _mapper.Map<List<SemanticSearchResultDto>>(cacheEntries);
-        return Result.Ok(dtos);
+        return await _knowledgeService.SearchLibrarySemanticallyAsync(
+            request.QueryText, 
+            request.TenantId, 
+            request.Limit, 
+            cancellationToken);
     }
 }

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

@@ -23,6 +23,7 @@ public class GetUserProfileQueryHandler : IRequestHandler<GetUserProfileQuery, R
             .Select(u => new UserProfileDto
             {
                 Email = u.Email ?? string.Empty,
+                UserId = u.Id,
                 AITokensUsed = u.AITokensUsed,
                 TenantId = u.TenantId != null && u.TenantId.Length == 36 ? new Guid(u.TenantId) : Guid.Empty,
                 Plan = u.SubscriptionPlan != null ? new SubscriptionPlanDto
@@ -35,6 +36,9 @@ public class GetUserProfileQueryHandler : IRequestHandler<GetUserProfileQuery, R
                 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,
+                DisplayName = u.DisplayName,
+                BooksReadCount = u.Ebooks.Count(),
+                ConceptsMappedCount = dbContext.KnowledgeUnits.Count(k => k.TenantId == u.TenantId),
                 LastReadBook = u.Ebooks.OrderByDescending(e => e.LastReadDate).Select(e => new LastReadBookDto
                 {
                     Id = e.Id,
@@ -48,8 +52,18 @@ public class GetUserProfileQueryHandler : IRequestHandler<GetUserProfileQuery, R
                     Progress = e.Progress,
                     LastChapter = e.LastChapter ?? "Rozpoczynanie...",
                     LastChapterIndex = e.LastChapterIndex,
-                    Description = e.Description
+                    Description = e.Description,
+                    IsReadyForReading = e.IsReadyForReading
                 }).FirstOrDefault(),
+                RecentQuizzes = u.QuizResults.OrderByDescending(q => q.CompletedDate).Take(5).Select(q => new QuizResultDto
+                {
+                    Id = q.Id,
+                    Topic = q.Topic,
+                    Score = q.Score,
+                    TotalQuestions = q.TotalQuestions,
+                    Percentage = q.Percentage,
+                    CompletedDate = q.CompletedDate
+                }).ToList(),
                 Roles = dbContext.UserRoles
                     .Where(ur => ur.UserId == u.Id)
                     .Join(dbContext.Roles, ur => ur.RoleId, r => r.Id, (ur, r) => r.Name!)

src/NexusReader.Data/Persistence/AppDbContext.cs

@@ -55,16 +55,7 @@ public class AppDbContext : IdentityDbContext<NexusUser>
             entity.HasKey(e => e.ContentHash);
             entity.HasIndex(e => e.ContentHash).IsUnique();
             entity.HasIndex(e => e.TenantId);
-            if (Database.IsNpgsql())
-            {
-                // Configure vector column (768 dims) and HNSW index for cosine similarity
-                entity.Property(e => e.Embedding).HasColumnType("vector(768)");
-                entity.HasIndex(e => e.Embedding).HasMethod("hnsw").HasOperators("vector_cosine_ops");
-            }
-            else
-            {
             entity.Ignore(e => e.Embedding);
-            }
         });
 
         modelBuilder.Entity<KnowledgeUnit>(entity =>

src/NexusReader.Data/Persistence/AppDbContextFactory.cs

@@ -1,7 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Design;
 using Microsoft.Extensions.Configuration;
-using Pgvector.EntityFrameworkCore;
 
 namespace NexusReader.Data.Persistence;
 
@@ -38,7 +37,7 @@ public class AppDbContextFactory : IDesignTimeDbContextFactory<AppDbContext>
              connectionString = "Host=localhost;Database=nexus_reader;Username=postgres;Password=postgres";
         }
 
-        optionsBuilder.UseNpgsql(connectionString, x => x.UseVector());
+        optionsBuilder.UseNpgsql(connectionString);
 
         return new AppDbContext(optionsBuilder.Options);
     }

src/NexusReader.Infrastructure/DependencyInjection.cs

@@ -112,6 +112,7 @@ public static class DependencyInjection
         services.AddScoped<IKnowledgeService, KnowledgeService>();
         services.AddTransient<IEpubReader, EpubReaderService>();
         services.AddTransient<IEpubMetadataExtractor, EpubMetadataExtractor>();
+        services.AddTransient<IEpubExtractor, EpubExtractor>();
 
         // Fix #4: Scoped instead of Singleton — BookStorageService uses path resolution
         // that is environment-specific and incompatible with Singleton lifetime in MAUI.

src/NexusReader.Infrastructure/Services/EpubExtractor.cs

@@ -0,0 +1,85 @@
+using System.Text.RegularExpressions;
+using FluentResults;
+using Microsoft.Extensions.Logging;
+using NexusReader.Application.Abstractions.Services;
+using VersOne.Epub;
+
+namespace NexusReader.Infrastructure.Services;
+
+public class EpubExtractor : IEpubExtractor
+{
+    private readonly ILogger<EpubExtractor> _logger;
+
+    public EpubExtractor(ILogger<EpubExtractor> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<Result<List<string>>> ExtractChaptersTextAsync(string relativePath, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fullPath = ResolvePath(relativePath);
+            if (string.IsNullOrEmpty(fullPath) || !File.Exists(fullPath))
+            {
+                _logger.LogError("[EpubExtractor] EPUB file not found at path: {FilePath}", relativePath);
+                return Result.Fail<List<string>>($"Plik EPUB nie został znaleziony na dysku: {relativePath}");
+            }
+
+            using var bookRef = await EpubReader.OpenBookAsync(fullPath);
+            var readingOrder = bookRef.GetReadingOrder();
+
+            if (readingOrder == null || !readingOrder.Any())
+            {
+                return Result.Fail<List<string>>("EPUB nie zawiera czytelnych rozdziałów.");
+            }
+
+            var chapters = new List<string>();
+            foreach (var chapterRef in readingOrder)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+
+                var rawContent = await chapterRef.ReadContentAsTextAsync();
+                var cleanText = StripHtml(rawContent);
+                chapters.Add(cleanText);
+            }
+
+            return Result.Ok(chapters);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "[EpubExtractor] Error extracting chapters from EPUB: {FilePath}", relativePath);
+            return Result.Fail<List<string>>(new Error("Failed to parse and extract text from EPUB").CausedBy(ex));
+        }
+    }
+
+    private static string? ResolvePath(string relativePath)
+    {
+        var normalized = relativePath.Replace('/', Path.DirectorySeparatorChar);
+        var currentDir = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
+        while (currentDir != null)
+        {
+            var candidate = Path.Combine(currentDir.FullName, "wwwroot", normalized);
+            if (File.Exists(candidate)) return candidate;
+
+            var devCandidate = Path.Combine(currentDir.FullName, "src", "NexusReader.Web", "wwwroot", normalized);
+            if (File.Exists(devCandidate)) return devCandidate;
+
+            currentDir = currentDir.Parent;
+        }
+        return null;
+    }
+
+    private static string StripHtml(string html)
+    {
+        if (string.IsNullOrEmpty(html)) return string.Empty;
+        var clean = Regex.Replace(html, @"<(style|script)\b[^>]*>.*?</\1>", "", RegexOptions.IgnoreCase | RegexOptions.Singleline);
+        clean = Regex.Replace(clean, @"<[^>]*>", " ");
+        clean = System.Net.WebUtility.HtmlDecode(clean);
+        clean = Regex.Replace(clean, @"\s+", " ").Trim();
+        return clean;
+    }
+}

src/NexusReader.Infrastructure/Services/KnowledgeService.cs

@@ -15,6 +15,7 @@ using Polly.Registry;
 using Microsoft.Extensions.Options;
 using NexusReader.Infrastructure.Configuration;
 using Qdrant.Client;
+using Qdrant.Client.Grpc;
 using Neo4j.Driver;
 
 namespace NexusReader.Infrastructure.Services;
@@ -32,7 +33,7 @@ public class KnowledgeService : IKnowledgeService
     private readonly ILogger<KnowledgeService> _logger;
     private readonly QdrantClient _qdrantClient;
     private readonly IDriver _neo4jDriver;
-    private const string PromptVersion = "1.3";
+    private const string PromptVersion = "1.7";
     private static readonly ConcurrentDictionary<string, Lazy<Task<Result<KnowledgePacket>>>> _activeRequests = new();
 
     public KnowledgeService(
@@ -84,7 +85,8 @@ public class KnowledgeService : IKnowledgeService
 
         using var dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         var normalizedText = text.Trim();
-        var hash = ContentHasher.ComputeHash(normalizedText);
+        var hashInput = $"{normalizedText}:{traceType}:{PromptVersion}";
+        var hash = ContentHasher.ComputeHash(hashInput);
 
         // 1. Check Cache
         var cached = await dbContext.SemanticKnowledgeCache
@@ -285,6 +287,98 @@ public class KnowledgeService : IKnowledgeService
                 _logger.LogWarning("[KnowledgeService] Skipping invalid link {Source} -> {Target}: one or both units are missing.", linkDto.Source, linkDto.Target);
             }
         }
+
+        // Generate and upsert vectors to Qdrant in batch
+        var unitsToEmbed = packet.Units
+            .Where(u => !string.IsNullOrEmpty(u.Content))
+            .ToList();
+
+        if (unitsToEmbed.Any())
+        {
+            try
+            {
+                var contents = unitsToEmbed.Select(u => u.Content).ToList();
+                
+                var embeddingResponse = await _retryPipeline.ExecuteAsync(async ct => 
+                    await _embeddingGenerator.GenerateAsync(
+                        contents, 
+                        new EmbeddingGenerationOptions { Dimensions = 768 }, 
+                        cancellationToken: ct), cancellationToken);
+
+                var embeddings = embeddingResponse.ToList();
+                var points = new List<PointStruct>();
+
+                for (int i = 0; i < unitsToEmbed.Count; i++)
+                {
+                    var unitDto = unitsToEmbed[i];
+                    var vector = embeddings[i].Vector.ToArray();
+
+                    var point = new PointStruct
+                    {
+                        Id = GetDeterministicGuid(unitDto.Id),
+                        Vectors = vector,
+                        Payload =
+                        {
+                            ["content"] = unitDto.Content,
+                            ["type"] = unitDto.Type ?? string.Empty,
+                            ["tenantId"] = tenantId,
+                            ["ebookId"] = ebookId?.ToString() ?? string.Empty,
+                            ["metadataJson"] = JsonSerializer.Serialize(unitDto.Metadata)
+                        }
+                    };
+                    points.Add(point);
+                }
+
+                if (points.Any())
+                {
+                    await EnsureCollectionExistsAsync("knowledge_units", cancellationToken);
+                    await _qdrantClient.UpsertAsync("knowledge_units", points, cancellationToken: cancellationToken);
+                    _logger.LogInformation("[KnowledgeService] Successfully upserted {Count} points to Qdrant collection 'knowledge_units'.", points.Count);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "[KnowledgeService] Failed to generate and upsert embeddings for knowledge units to Qdrant.");
+            }
+        }
+    }
+
+    private async Task EnsureCollectionExistsAsync(string collectionName, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var exists = await _qdrantClient.CollectionExistsAsync(collectionName, cancellationToken);
+            if (!exists)
+            {
+                _logger.LogInformation("[KnowledgeService] Creating Qdrant collection '{CollectionName}'...", collectionName);
+                await _qdrantClient.CreateCollectionAsync(
+                    collectionName: collectionName,
+                    vectorsConfig: new VectorParams
+                    {
+                        Size = 768,
+                        Distance = Distance.Cosine
+                    },
+                    cancellationToken: cancellationToken
+                );
+                _logger.LogInformation("[KnowledgeService] Qdrant collection '{CollectionName}' created successfully.", collectionName);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "[KnowledgeService] Error ensuring Qdrant collection '{CollectionName}' exists.", collectionName);
+        }
+    }
+
+    private static Guid GetDeterministicGuid(string input)
+    {
+        if (Guid.TryParse(input, out var guid))
+        {
+            return guid;
+        }
+
+        using var md5 = System.Security.Cryptography.MD5.Create();
+        byte[] hash = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(input));
+        return new Guid(hash);
     }
 
     public async Task<Result<GroundednessResult>> VerifyGroundednessAsync(string answer, string context, string tenantId, CancellationToken cancellationToken = default)
@@ -354,6 +448,7 @@ public class KnowledgeService : IKnowledgeService
             List<Qdrant.Client.Grpc.ScoredPoint> searchResult;
             try
             {
+                await EnsureCollectionExistsAsync("knowledge_units", cancellationToken);
                 var response = await _qdrantClient.SearchAsync(
                     collectionName: "knowledge_units",
                     vector: queryVector,
@@ -417,6 +512,7 @@ public class KnowledgeService : IKnowledgeService
             List<Qdrant.Client.Grpc.ScoredPoint> searchResult;
             try
             {
+                await EnsureCollectionExistsAsync("knowledge_units", cancellationToken);
                 var response = await _qdrantClient.SearchAsync(
                     collectionName: "knowledge_units",
                     vector: queryVector,
@@ -602,6 +698,7 @@ public class KnowledgeService : IKnowledgeService
             List<Qdrant.Client.Grpc.ScoredPoint> searchResult;
             try
             {
+                await EnsureCollectionExistsAsync("knowledge_units", cancellationToken);
                 var response = await _qdrantClient.SearchAsync(
                     collectionName: "knowledge_units",
                     vector: queryVector,
@@ -790,6 +887,16 @@ Strict Grounding Rules:
             await dbContext.SemanticKnowledgeCache.ExecuteDeleteAsync(cancellationToken);
             await dbContext.KnowledgeUnits.ExecuteDeleteAsync(cancellationToken);
             await dbContext.KnowledgeUnitLinks.ExecuteDeleteAsync(cancellationToken);
+            
+            try
+            {
+                await _qdrantClient.DeleteCollectionAsync("knowledge_units", cancellationToken: cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "[KnowledgeService] Failed to drop Qdrant collection 'knowledge_units' during cache clear.");
+            }
+
             return Result.Ok();
         }
         catch (Exception ex)

src/NexusReader.Infrastructure/Services/PromptRegistry.cs

@@ -4,9 +4,10 @@ public static class PromptRegistry
 {
     public const string KnowledgeExtractionSystemPrompt = 
         "You are an expert educator. Analyze the provided text to extract key concepts, generate relevant quizzes, and construct a knowledge graph. " +
-        "CRITICAL: Restrict 'concept.label' to a maximum of 3 words (e.g., 'Dependency Injection' instead of full sentences). " +
+        "**LANGUAGE CRITICAL**: Detect the language of the provided text. You MUST generate all human-readable fields ('title', 'description', 'question', 'options', 'label') in the EXACT SAME LANGUAGE as the source text. Do NOT translate them to English unless the source text is in English. " +
+        "CRITICAL: Restrict 'concept.label' to a maximum of 3 words (e.g., 'Dependency Injection' or its exact foreign equivalent, never full sentences). " +
         "CRITICAL: Extract a MAXIMUM of 15 key concepts/plot points from the text. " +
-        "CRITICAL: Code blocks (e.g., markdown code snippets) must be excluded from the relationship graph, or summarized as a single node (e.g., 'Code Example'). Do NOT create nodes for variables, functions, namespaces, or individual lines of code. " +
+        "CRITICAL: Code blocks (e.g., markdown code snippets) must be excluded from the relationship graph, or summarized as a single node with the label 'Code Example' translated to the detected language. Do NOT create nodes for variables, functions, namespaces, or individual lines of code. " +
         "CRITICAL: Return ONLY a minified JSON object. Do NOT include markdown formatting like ```json or ```. Do NOT include explanations. " +
         "Schema: { " +
         "\"concepts\": [ { \"title\": \"string\", \"description\": \"string\" } ], " +
@@ -15,26 +16,44 @@ public static class PromptRegistry
         "}.";
 
     public const string GraphExtractionPrompt = 
-        "You are an expert at information architecture. Extract key concepts and paragraph mappings from the text to build a unified knowledge graph. " +
-        "The input text consists of several paragraphs, each starting with its unique block ID in the format '[ID: seg-X]'. " +
-        "Extract two types of nodes: " +
-        "1. Concept Nodes (group: 'concept'): Extract the main technical concepts discussed (e.g., ID: 'dependency-injection', label: 'Dependency Injection'). Max 10 concepts. Labels must be at most 3 words. " +
-        "2. Block Nodes (group: 'current'): For each paragraph in the input, create a node representing that paragraph where 'id' is the exact block ID (e.g., 'seg-1'), and 'label' is a brief summary of that paragraph's content (max 3 words). " +
-        "CRITICAL: If a paragraph is a code block, represent it as a single block node with label 'Code Example' (group: 'current'). Do NOT extract low-level code elements (like variables, classes, methods, or namespaces) as separate concept nodes. " +
-        "CRITICAL: Connect related concept nodes together, and connect each concept node to the block nodes ('seg-X') where it is discussed. " +
-        "Limit connections to a MAXIMUM of 15 most relevant links. " +
-        "Return ONLY minified JSON. Schema: { \"graph\": { \"nodes\": [ { \"id\": \"string\", \"label\": \"string\", \"group\": \"concept|current\" } ], \"links\": [ { \"source\": \"string\", \"target\": \"string\", \"value\": 1 } ] } }";
-
+        "You are a strict Minimalist Information Architect. Your sole job is to build a high-level, sparse linear backbone for a textbook chapter. " +
+        "**LANGUAGE CRITICAL**: Detect the language of the provided text. The 'label', 'summary', and 'key_terms' fields MUST be in the EXACT SAME LANGUAGE as the source text. " +
+        "The input text consists of sections starting with block IDs (e.g., '[ID: seg-4]'). " +
+        "CRITICAL TOPOLOGY RULES (ZERO TOLERANCE FOR CLUTTER): " +
+        "1. HARD NODE LIMIT: You are strictly forbidden from extracting more than 4 to 5 nodes IN TOTAL for the entire text. If there are more sections, select ONLY the 4-5 absolute most critical, high-level structural pillars. " +
+        "2. NO CONCEPT CLOUDS: Do NOT create nodes for individual technologies, files, terms, or phrases (e.g., 'Kestrel', 'appsettings.json', 'DI', 'Blazor Server' must NEVER be nodes). They must ONLY exist as text strings inside the 'key_terms' array of a major node. " +
+        "3. LINEAR SPINE PATTERN: Nodes must form a clear, clean path or simple tree representing the chronological reading journey (e.g., Node 1 -> Node 2 -> Node 3). Do NOT create complex web loops or interconnect every node. Limit total links in the entire JSON to maximum 4 or 5 links. " +
+        "4. NODE DATA STRUCTURE: " +
+        "   - 'id': must be the exact block ID (e.g., 'seg-16'). " +
+        "   - 'label': clear technical title (Max 3 words, e.g., 'Blazor Hosting Models'). " +
+        "   - 'group': strictly either 'bridge' (if it compares legacy vs modern) or 'concept' (for standalone core pillars). " +
+        "   - 'summary': exact 2-sentence distillation for the Contextual Panel. " +
+        "   - 'key_terms': array of max 5 short strings representing the micro-concepts hidden inside this section. " +
+        "System keys configuration: All JSON keys ('nodes', 'links', 'id', 'label', 'group', 'summary', 'key_terms', 'source', 'target', 'type') must remain strictly in English. " +
+        "Return ONLY minified JSON. Schema: " +
+        "{ " +
+        "  \"graph\": { " +
+        "    \"nodes\": [ " +
+        "      { \"id\": \"seg-X\", \"label\": \"string\", \"group\": \"concept|bridge\", \"summary\": \"string\", \"key_terms\": [ \"string\" ] } " +
+        "    ], " +
+        "    \"links\": [ " +
+        "      { \"source\": \"seg-X\", \"target\": \"seg-Y\", \"type\": \"maps_to|contains\" } " +
+        "    ] " +
+        "  } " +
+        "}";
 
     public const string SummaryAndQuizPrompt = 
         "You are an expert educator. Provide a concise summary of the text and generate a challenging quiz (3-5 questions). " +
+        "**LANGUAGE CRITICAL**: Detect the language of the provided text. The generated 'summary', 'question', and 'options' MUST be in the EXACT SAME LANGUAGE as the source text. " +
         "Return ONLY minified JSON. Schema: { \"summary\": \"string\", \"quizzes\": [ { \"question\": \"string\", \"options\": [ \"string\" ], \"correct_index\": 0 } ] }";
 
     public const string KM_ExtractionPrompt = 
         "You are an expert at Knowledge Engineering. Segment the provided text into discrete Knowledge Units. " +
+        "**LANGUAGE CRITICAL**: Detect the language of the provided text. The 'content' field MUST be in the EXACT SAME LANGUAGE as the source text. " +
         "Identify 'units' (sections, tables, definitions, rules) and 'links' (how they relate). " +
         "CRITICAL: Units must be granular. " +
-        "CRITICAL: Code blocks must be summarized under the parent unit or represented as a single 'Code Example' unit. Do NOT segment code blocks into granular low-level code details (e.g., classes, variables, parameters). " +
+        "CRITICAL: Code blocks must be summarized under the parent unit or represented as a single 'Code Example' unit (translate the name to the detected language). Do NOT segment code blocks into granular low-level code details (e.g., classes, variables, parameters). " +
+        "CRITICAL SYSTEM VALUES: The fields 'type' (strictly: 'Section', 'Table', 'Definition', or 'Rule') and 'relation' (strictly: 'Next', 'Defines', 'Contains', or 'References') are system keys and MUST remain in English as specified. " +
         "Schema: { " +
         "\"units\": [ { \"id\": \"string\", \"type\": \"Section|Table|Definition|Rule\", \"content\": \"string\", \"metadata\": { \"page\": 0 } } ], " +
         "\"links\": [ { \"source\": \"string\", \"target\": \"string\", \"relation\": \"Next|Defines|Contains|References\" } ] " +

src/NexusReader.Maui/App.xaml.cs

@@ -8,4 +8,22 @@ public partial class App : Microsoft.Maui.Controls.Application
 
 		MainPage = new MainPage();
 	}
+
+	protected override Window CreateWindow(IActivationState? activationState)
+	{
+		var window = base.CreateWindow(activationState);
+
+		// Hook into native MAUI lifecycle events to cleanly flush and close Serilog buffers
+		window.Stopped += (s, e) => 
+		{
+			Serilog.Log.CloseAndFlush();
+		};
+
+		window.Destroying += (s, e) => 
+		{
+			Serilog.Log.CloseAndFlush();
+		};
+
+		return window;
+	}
 }

src/NexusReader.Maui/Infrastructure/Identity/MobileAuthenticationHeaderHandler.cs

@@ -0,0 +1,144 @@
+using System.Net.Http.Headers;
+using System.Threading;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using NexusReader.Application.Abstractions.Services;
+
+namespace NexusReader.Maui.Infrastructure.Identity;
+
+/// <summary>
+/// A secure HTTP message delegating handler for MAUI that automatically appends JWT tokens
+/// to trusted origin requests and transparently refreshes expired tokens in a thread-safe manner.
+/// </summary>
+public class MobileAuthenticationHeaderHandler : DelegatingHandler
+{
+    private readonly INativeStorageService _storageService;
+    private readonly IServiceProvider _serviceProvider;
+    private const string TokenKey = "nexus_auth_token";
+    private static readonly SemaphoreSlim _refreshSemaphore = new(1, 1);
+
+    public MobileAuthenticationHeaderHandler(INativeStorageService storageService, IServiceProvider serviceProvider)
+    {
+        _storageService = storageService;
+        _serviceProvider = serviceProvider;
+    }
+
+    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+    {
+        var path = request.RequestUri?.AbsolutePath ?? "";
+        bool isAuthEndpoint = path.Contains("identity/login") || 
+                             path.Contains("identity/register") || 
+                             path.Contains("identity/refresh");
+
+        // Resolve configured API host dynamically to avoid hardcoded IP addresses
+        var config = _serviceProvider.GetRequiredService<IConfiguration>();
+        var apiBaseUrlString = config["ApiSettings:BaseUrl"];
+        string? apiHost = null;
+        if (!string.IsNullOrEmpty(apiBaseUrlString) && Uri.TryCreate(apiBaseUrlString, UriKind.Absolute, out var apiUri))
+        {
+            apiHost = apiUri.Host;
+        }
+
+        // In MAUI, since we only call our own local or staging APIs, we trust local IP/localhost/configured API host.
+        // We ensure we don't accidentally leak tokens to third-party endpoints.
+        bool isTrustedHost = request.RequestUri != null && 
+                             (request.RequestUri.Host == "localhost" ||
+                              request.RequestUri.Host == "127.0.0.1" ||
+                              (apiHost != null && request.RequestUri.Host == apiHost) ||
+                              request.RequestUri.Host.EndsWith("nexusreader.com")); // Or staging domains
+
+        string? originalToken = null;
+
+        if (!isAuthEndpoint && isTrustedHost)
+        {
+            var tokenResult = await _storageService.GetSecureString(TokenKey);
+            if (tokenResult.IsSuccess && !string.IsNullOrEmpty(tokenResult.Value))
+            {
+                originalToken = tokenResult.Value;
+                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", originalToken);
+            }
+        }
+
+        var response = await base.SendAsync(request, cancellationToken);
+
+        // Transparent JWT Auto-Refresh on 401 Unauthorized
+        if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized && !isAuthEndpoint)
+        {
+            await _refreshSemaphore.WaitAsync(cancellationToken);
+            try
+            {
+                // Re-read token to verify if another concurrent request already refreshed it
+                var tokenResult = await _storageService.GetSecureString(TokenKey);
+                var currentToken = tokenResult.IsSuccess ? tokenResult.Value : null;
+
+                bool refreshed = false;
+
+                if (!string.IsNullOrEmpty(currentToken) && currentToken != originalToken)
+                {
+                    refreshed = true;
+                }
+                else
+                {
+                    using var scope = _serviceProvider.CreateScope();
+                    var identityService = scope.ServiceProvider.GetRequiredService<IIdentityService>();
+                    var refreshResult = await identityService.RefreshTokenAsync();
+                    if (refreshResult.IsSuccess)
+                    {
+                        var newTokenResult = await _storageService.GetSecureString(TokenKey);
+                        currentToken = newTokenResult.IsSuccess ? newTokenResult.Value : null;
+                        refreshed = !string.IsNullOrEmpty(currentToken);
+                    }
+                    else
+                    {
+                        await identityService.LogoutAsync();
+                    }
+                }
+
+                if (refreshed && !string.IsNullOrEmpty(currentToken))
+                {
+                    var newRequest = await CloneHttpRequestMessageAsync(request);
+                    newRequest.Headers.Authorization = new AuthenticationHeaderValue("Bearer", currentToken);
+                    return await base.SendAsync(newRequest, cancellationToken);
+                }
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Error(ex, "[MobileAuthHandler] Automated token renewal failed");
+            }
+            finally
+            {
+                _refreshSemaphore.Release();
+            }
+        }
+
+        return response;
+    }
+
+    private async Task<HttpRequestMessage> CloneHttpRequestMessageAsync(HttpRequestMessage req)
+    {
+        var clone = new HttpRequestMessage(req.Method, req.RequestUri)
+        {
+            Version = req.Version
+        };
+
+        if (req.Content != null)
+        {
+            var ms = new System.IO.MemoryStream();
+            await req.Content.CopyToAsync(ms);
+            ms.Position = 0;
+            clone.Content = new StreamContent(ms);
+
+            foreach (var h in req.Content.Headers)
+            {
+                clone.Content.Headers.TryAddWithoutValidation(h.Key, h.Value);
+            }
+        }
+
+        foreach (var h in req.Headers)
+        {
+            clone.Headers.TryAddWithoutValidation(h.Key, h.Value);
+        }
+
+        return clone;
+    }
+}

src/NexusReader.Maui/Infrastructure/Logging/BlazorLoggingBridge.cs

@@ -0,0 +1,53 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.JSInterop;
+
+namespace NexusReader.Maui.Infrastructure.Logging;
+
+/// <summary>
+/// Lightweight bridge service that intercepts logs, console outputs, and uncaught exceptions 
+/// from the Blazor WebView/JS side, and routes them directly to Serilog under "BlazorWebView" context.
+/// </summary>
+public sealed class BlazorLoggingBridge
+{
+    private readonly ILogger _logger;
+
+    public BlazorLoggingBridge(ILoggerFactory loggerFactory)
+    {
+        _logger = loggerFactory.CreateLogger("BlazorWebView");
+    }
+
+    [JSInvokable("LogJsMessage")]
+    public void LogJsMessage(string level, string message, string? stackTrace = null)
+    {
+        if (string.IsNullOrWhiteSpace(message))
+        {
+            return;
+        }
+
+        switch (level.ToLowerInvariant())
+        {
+            case "error":
+            case "exception":
+                if (!string.IsNullOrWhiteSpace(stackTrace))
+                {
+                    _logger.LogError("JS Unhandled Exception: {Message}\nStack Trace:\n{StackTrace}", message, stackTrace);
+                }
+                else
+                {
+                    _logger.LogError("JS Error: {Message}", message);
+                }
+                break;
+
+            case "warning":
+            case "warn":
+                _logger.LogWarning("JS Warning: {Message}", message);
+                break;
+
+            case "info":
+            case "log":
+            default:
+                _logger.LogInformation("JS Log: {Message}", message);
+                break;
+        }
+    }
+}

src/NexusReader.Maui/Infrastructure/Logging/SerilogConfiguration.cs

@@ -0,0 +1,106 @@
+using Microsoft.Extensions.Logging;
+using Serilog;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting;
+using Serilog.Formatting.Display;
+
+namespace NexusReader.Maui.Infrastructure.Logging;
+
+public static class SerilogConfiguration
+{
+    private const string OutputTemplate = 
+        "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] [ThreadId: {ThreadId}] [{SourceContext}] {Message:lj}{NewLine}{Exception}";
+
+    public static MauiAppBuilder RegisterLogging(this MauiAppBuilder builder)
+    {
+        // 1. Ensure logs directory exists in secure sandbox
+        var logDir = Path.Combine(Microsoft.Maui.Storage.FileSystem.AppDataDirectory, "logs");
+        if (!Directory.Exists(logDir))
+        {
+            Directory.CreateDirectory(logDir);
+        }
+        var logPath = Path.Combine(logDir, "log-.txt");
+
+        // 2. Inject sandboxed log path dynamically into configuration provider
+        builder.Configuration["Serilog:WriteTo:0:Args:configure:0:Args:path"] = logPath;
+
+        // 3. Configure Serilog Logger Configuration using App Configuration settings
+        var loggerConfig = new LoggerConfiguration()
+            .ReadFrom.Configuration(builder.Configuration)
+            .Enrich.With(new ThreadIdEnricher());
+
+        // 4. Platform-specific and environment-specific sinks
+#if ANDROID
+        // Direct Native Android Logcat Sink (JNI bindings for native diagnostics)
+        loggerConfig.WriteTo.Sink(
+            new AndroidLogcatSink(new MessageTemplateTextFormatter(OutputTemplate, null)),
+            restrictedToMinimumLevel: LogEventLevel.Debug);
+#endif
+
+        // 5. Initialize the static Serilog Log
+        Log.Logger = loggerConfig.CreateLogger();
+
+        // 6. Connect Serilog to Microsoft.Extensions.Logging
+        builder.Logging.ClearProviders();
+        builder.Logging.AddSerilog(dispose: true);
+
+        return builder;
+    }
+}
+
+/// <summary>
+/// A custom self-contained thread enricher to avoid unnecessary NuGet packages.
+/// </summary>
+internal sealed class ThreadIdEnricher : ILogEventEnricher
+{
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("ThreadId", Environment.CurrentManagedThreadId));
+    }
+}
+
+#if ANDROID
+/// <summary>
+/// A high-performance, direct Android Logcat Sink utilizing native Android APIs.
+/// </summary>
+internal sealed class AndroidLogcatSink : ILogEventSink
+{
+    private readonly ITextFormatter _formatter;
+    private const string Tag = "NexusReader";
+
+    public AndroidLogcatSink(ITextFormatter formatter)
+    {
+        _formatter = formatter ?? throw new ArgumentNullException(nameof(formatter));
+    }
+
+    public void Emit(LogEvent logEvent)
+    {
+        using var writer = new StringWriter();
+        _formatter.Format(logEvent, writer);
+        var message = writer.ToString().Trim();
+
+        switch (logEvent.Level)
+        {
+            case LogEventLevel.Verbose:
+                Android.Util.Log.Verbose(Tag, message);
+                break;
+            case LogEventLevel.Debug:
+                Android.Util.Log.Debug(Tag, message);
+                break;
+            case LogEventLevel.Information:
+                Android.Util.Log.Info(Tag, message);
+                break;
+            case LogEventLevel.Warning:
+                Android.Util.Log.Warn(Tag, message);
+                break;
+            case LogEventLevel.Error:
+                Android.Util.Log.Error(Tag, message);
+                break;
+            case LogEventLevel.Fatal:
+                Android.Util.Log.Wtf(Tag, message);
+                break;
+        }
+    }
+}
+#endif

src/NexusReader.Maui/Main.razor

@@ -1,5 +1,8 @@
 @using Microsoft.AspNetCore.Components.Routing
 @using NexusReader.UI.Shared
+@using NexusReader.Maui.Infrastructure.Logging
+@inject IJSRuntime JSRuntime
+@inject BlazorLoggingBridge LoggingBridge
 
 <Router AppAssembly="@typeof(NexusReader.UI.Shared._Imports).Assembly">
     <Found Context="routeData">
@@ -16,3 +19,21 @@
         </LayoutView>
     </NotFound>
 </Router>
+
+@code {
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            try
+            {
+                var dotNetRef = DotNetObjectReference.Create(LoggingBridge);
+                await JSRuntime.InvokeVoidAsync("NexusLogging.initializeBridge", dotNetRef);
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"[SerilogBridge] Failed to initialize Blazor/JS Bridge: {ex}");
+            }
+        }
+    }
+}

src/NexusReader.Maui/MauiProgram.cs

@@ -1,9 +1,13 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using NexusReader.Application.Abstractions.Services;
 using NexusReader.Infrastructure.Mobile.Services;
 using NexusReader.UI.Shared.Services;
 using NexusReader.Application;
 using MediatR;
+using NexusReader.Maui.Infrastructure.Logging;
+using NexusReader.Maui.Infrastructure.Identity;
 
 namespace NexusReader.Maui;
 
@@ -14,16 +18,30 @@ public static class MauiProgram
 		try
 		{
 			var builder = MauiApp.CreateBuilder();
+
+			// Load embedded appsettings.json configuration
+			var assembly = typeof(App).Assembly;
+			using (var stream = assembly.GetManifestResourceStream("NexusReader.Maui.appsettings.json"))
+			{
+				if (stream != null)
+				{
+					((IConfigurationBuilder)builder.Configuration).AddJsonStream(stream);
+				}
+			}
+
 			builder
-				.UseMauiApp<App>();
+				.UseMauiApp<App>()
+				.RegisterLogging();
 
 			builder.Services.AddMauiBlazorWebView();
 
 #if DEBUG
 			builder.Services.AddBlazorWebViewDeveloperTools();
-			builder.Logging.AddDebug();
 #endif
 
+			// Interception bridge for JS/Blazor WebView logs
+			builder.Services.AddSingleton<BlazorLoggingBridge>();
+
 			// Minimal Infrastructure
 			builder.Services.AddSingleton<IPlatformService, MauiPlatformService>();
 			builder.Services.AddSingleton<INativeStorageService, MauiStorageService>();
@@ -34,8 +52,15 @@ public static class MauiProgram
 				sp.GetRequiredService<NexusAuthenticationStateProvider>());
 			builder.Services.AddAuthorizationCore();
 
-			// Basic Network
-			builder.Services.AddScoped(sp => new HttpClient { BaseAddress = new Uri("http://10.0.2.2:5000") });
+			// Basic Network with Secure Token Handler
+			builder.Services.AddTransient<MobileAuthenticationHeaderHandler>();
+			builder.Services.AddHttpClient("NexusAPI", client =>
+			{
+				var apiBaseUrl = builder.Configuration["ApiSettings:BaseUrl"] ?? "http://localhost:5000";
+				client.BaseAddress = new Uri(apiBaseUrl);
+			}).AddHttpMessageHandler<MobileAuthenticationHeaderHandler>();
+
+			builder.Services.AddScoped(sp => sp.GetRequiredService<IHttpClientFactory>().CreateClient("NexusAPI"));
 
 			// UI State
 			builder.Services.AddScoped<IThemeService, ThemeService>();

src/NexusReader.Maui/NexusReader.Maui.csproj

@@ -27,6 +27,14 @@
 		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="10.0.0" />
 		<PackageReference Include="Microsoft.AspNetCore.Components.WebView.Maui" Version="10.0.20" />
 		<PackageReference Include="Microsoft.Maui.Essentials" Version="10.0.20" />
+		<PackageReference Include="Serilog" Version="4.1.0" />
+		<PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
+		<PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+		<PackageReference Include="Serilog.Sinks.Async" Version="2.1.0" />
+		<PackageReference Include="Serilog.Sinks.Debug" Version="3.0.0" />
+		<PackageReference Include="Serilog.Settings.Configuration" Version="8.0.4" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -34,4 +42,8 @@
 		<ProjectReference Include="..\NexusReader.Infrastructure.Mobile\NexusReader.Infrastructure.Mobile.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+		<EmbeddedResource Include="appsettings.json" />
+	</ItemGroup>
+
 </Project>

src/NexusReader.Maui/appsettings.json

@@ -0,0 +1,48 @@
+{
+  "ApiSettings": {
+    "BaseUrl": "https://localhost:5000"
+  },
+  "Serilog": {
+    "Using": [
+      "Serilog.Sinks.File",
+      "Serilog.Sinks.Debug",
+      "Serilog.Sinks.Async"
+    ],
+    "MinimumLevel": {
+      "Default": "Debug",
+      "Override": {
+        "Microsoft": "Warning",
+        "Microsoft.AspNetCore": "Warning",
+        "System": "Warning"
+      }
+    },
+    "WriteTo": [
+      {
+        "Name": "Async",
+        "Args": {
+          "configure": [
+            {
+              "Name": "File",
+              "Args": {
+                "path": "LOG_PATH_PLACEHOLDER",
+                "rollingInterval": "Day",
+                "retainedFileCountLimit": 7,
+                "outputTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] [ThreadId: {ThreadId}] [{SourceContext}] {Message:lj}{NewLine}{Exception}",
+                "shared": true
+              }
+            }
+          ]
+        }
+      },
+      {
+        "Name": "Debug",
+        "Args": {
+          "outputTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] [ThreadId: {ThreadId}] [{SourceContext}] {Message:lj}{NewLine}{Exception}"
+        }
+      }
+    ],
+    "Enrich": [
+      "FromLogContext"
+    ]
+  }
+}

src/NexusReader.Maui/wwwroot/index.html

@@ -26,7 +26,53 @@
 
     <script src="_framework/blazor.webview.js" autostart="false"></script>
     <script src="_content/NexusReader.UI.Shared/js/d3.v7.min.js"></script>
+    <script>
+        window.NexusLogging = {
+            initializeBridge: function (dotNetHelper) {
+                const originalLog = console.log;
+                const originalWarn = console.warn;
+                const originalError = console.error;
 
+                console.log = function (...args) {
+                    originalLog.apply(console, args);
+                    try {
+                        dotNetHelper.invokeMethodAsync('LogJsMessage', 'info', args.map(x => typeof x === 'object' ? JSON.stringify(x) : String(x)).join(' '));
+                    } catch (e) {}
+                };
+
+                console.warn = function (...args) {
+                    originalWarn.apply(console, args);
+                    try {
+                        dotNetHelper.invokeMethodAsync('LogJsMessage', 'warn', args.map(x => typeof x === 'object' ? JSON.stringify(x) : String(x)).join(' '));
+                    } catch (e) {}
+                };
+
+                console.error = function (...args) {
+                    originalError.apply(console, args);
+                    try {
+                        dotNetHelper.invokeMethodAsync('LogJsMessage', 'error', args.map(x => typeof x === 'object' ? JSON.stringify(x) : String(x)).join(' '));
+                    } catch (e) {}
+                };
+
+                window.onerror = function (message, source, lineno, colno, error) {
+                    const stack = error ? error.stack : '';
+                    try {
+                        dotNetHelper.invokeMethodAsync('LogJsMessage', 'error', `${message} at ${source}:${lineno}:${colno}`, stack);
+                    } catch (e) {}
+                    return false;
+                };
+
+                window.addEventListener('unhandledrejection', function (event) {
+                    const reason = event.reason;
+                    const message = reason instanceof Error ? reason.message : String(reason);
+                    const stack = reason instanceof Error ? reason.stack : '';
+                    try {
+                        dotNetHelper.invokeMethodAsync('LogJsMessage', 'error', `Unhandled Promise Rejection: ${message}`, stack);
+                    } catch (e) {}
+                });
+            }
+        };
+    </script>
 </body>
 
 </html>

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

@@ -1,39 +1,334 @@
 @namespace NexusReader.UI.Shared.Components.Atoms
+@using System.Text.RegularExpressions
+@using NexusReader.Application.DTOs.AI
+@inject IKnowledgeService KnowledgeService
+@inject IReaderNavigationService NavService
+@inject IReaderInteractionService InteractionService
+@inject NavigationManager NavManager
+@inject AuthenticationStateProvider AuthStateProvider
+@inject ILogger<NexusSearchBox> Logger
+@implements IDisposable
 
-<div class="nexus-search-container @(IsActive ? "active" : "")">
+<div class="nexus-search-container @(IsFocused ? "focused" : "") @(HasResults ? "has-results" : "")" @onfocusin="HandleFocusIn" @onfocusout="HandleFocusOut">
     <div class="search-wrapper">
-        <i class="nexus-icon @IconClass"></i>
-        <input type="text" 
-               @bind="SearchValue" 
-               @bind:event="oninput"
-               @onkeypress="HandleKeyPress"
-               placeholder="@Placeholder" 
-               class="nexus-search-input" />
-        @if (!string.IsNullOrEmpty(SearchValue))
+        <div class="search-icon-container">
+            @if (_isLoading)
             {
-            <button class="clear-btn" @onclick="ClearSearch">×</button>
+                <div class="neon-spinner"></div>
+            }
+            else
+            {
+                <i class="nexus-icon bi bi-search"></i>
             }
         </div>
+        
+        <input type="text"
+               value="@SearchValue"
+               @oninput="HandleInput"
+               @onkeydown="HandleKeyDown"
+               placeholder="@Placeholder"
+               class="nexus-search-input" />
+               
+        <div class="ai-status-indicator" title="Aktywny silnik AI biblioteki">
+            <span class="ai-pulse-dot"></span>
+        </div>
+
+        @if (!string.IsNullOrEmpty(SearchValue))
+        {
+            <button type="button" class="clear-btn" @onclick="ClearSearch" aria-label="Wyczyść wyszukiwanie">×</button>
+        }
+    </div>
+
+    @if (_isDropdownOpen && (!string.IsNullOrEmpty(SearchValue) || _isLoading || _results.Any() || _searchError != null))
+    {
+        <div class="search-dropdown glass-panel">
+            @if (_isLoading)
+            {
+                <div class="dropdown-state-container">
+                    <div class="neon-spinner-large"></div>
+                    <span class="state-text">Analizowanie biblioteki semantycznej...</span>
+                </div>
+            }
+            else if (_searchError != null)
+            {
+                <div class="dropdown-state-container error">
+                    <i class="bi bi-exclamation-triangle-fill error-icon"></i>
+                    <span class="state-text">@_searchError</span>
+                </div>
+            }
+            else if (_results.Any())
+            {
+                <div class="dropdown-results-list">
+                    @foreach (var result in _results)
+                    {
+                        <div class="result-card" @onclick="() => HandleResultClick(result)">
+                            <div class="result-header">
+                                <span class="relevance-badge">@(Math.Round(result.RelevanceScore * 100))% Trafności</span>
+                                @if (!string.IsNullOrEmpty(result.SourceBookTitle))
+                                {
+                                    <span class="source-title" title="@result.SourceBookTitle">w <strong>@result.SourceBookTitle</strong></span>
+                                }
+                            </div>
+                            <div class="result-snippet">
+                                @((MarkupString)HighlightQueryWords(result.Snippet, SearchValue))
+                            </div>
+                        </div>
+                    }
+                </div>
+            }
+            else if (!string.IsNullOrEmpty(SearchValue))
+            {
+                <div class="dropdown-state-container empty">
+                    <i class="bi bi-search empty-icon"></i>
+                    <span class="state-text">Brak wyników dla zapytania.</span>
+                </div>
+            }
+        </div>
+    }
 </div>
 
 @code {
-    [Parameter] public string Placeholder { get; set; } = "Search your library...";
-    [Parameter] public string IconClass { get; set; } = "bi bi-search";
+    [Parameter] public string Placeholder { get; set; } = "Zapytaj swoją bibliotekę AI...";
     [Parameter] public EventCallback<string> OnSearch { get; set; }
+    [Parameter] public int Limit { get; set; } = 5;
 
     private string SearchValue { get; set; } = string.Empty;
-    private bool IsActive => !string.IsNullOrEmpty(SearchValue);
+    private bool IsFocused { get; set; }
+    private bool HasResults => _results.Any() && _isDropdownOpen;
 
-    private async Task HandleKeyPress(KeyboardEventArgs e)
+    private List<SemanticSearchResultDto> _results = new();
+    private bool _isLoading;
+    private string? _searchError;
+    private bool _isDropdownOpen;
+    
+    private CancellationTokenSource? _searchCts;
+
+    private async Task HandleInput(ChangeEventArgs e)
     {
-        if (e.Key == "Enter")
+        SearchValue = e.Value?.ToString() ?? string.Empty;
+        _searchError = null;
+
+        if (string.IsNullOrWhiteSpace(SearchValue))
         {
+            _results.Clear();
+            _isDropdownOpen = false;
+            return;
+        }
+
+        _isDropdownOpen = true;
+
+        // Cancel previous search in-flight
+        _searchCts?.Cancel();
+        _searchCts?.Dispose();
+        _searchCts = new CancellationTokenSource();
+
+        var token = _searchCts.Token;
+
+        try
+        {
+            // Debounce for 300ms
+            await Task.Delay(300, token);
+            await PerformSearchAsync(token);
+        }
+        catch (TaskCanceledException)
+        {
+            // Typing continued, search cancelled
+        }
+    }
+
+    private async Task PerformSearchAsync(CancellationToken token)
+    {
+        _isLoading = true;
+        _searchError = null;
+        await InvokeAsync(StateHasChanged);
+
+        try
+        {
+            var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+            var tenantId = authState.User.FindFirst("TenantId")?.Value ?? "global";
+
+            var result = await KnowledgeService.SearchLibrarySemanticallyAsync(SearchValue, tenantId, Limit, token);
+            if (token.IsCancellationRequested) return;
+
+            if (result.IsSuccess)
+            {
+                _results = result.Value ?? new List<SemanticSearchResultDto>();
+                _searchError = null;
+            }
+            else
+            {
+                _results.Clear();
+                _searchError = result.Errors.FirstOrDefault()?.Message ?? "Nie udało się wykonać wyszukiwania.";
+                Logger.LogWarning("Semantic search returned errors: {Errors}", string.Join(", ", result.Errors.Select(e => e.Message)));
+            }
+        }
+        catch (Exception ex)
+        {
+            if (!token.IsCancellationRequested)
+            {
+                _results.Clear();
+                _searchError = "Wystąpił nieoczekiwany błąd podczas wyszukiwania.";
+                Logger.LogError(ex, "Unexpected error during semantic search for query: {Query}", SearchValue);
+            }
+        }
+        finally
+        {
+            if (!token.IsCancellationRequested)
+            {
+                _isLoading = false;
+                await InvokeAsync(StateHasChanged);
+            }
+        }
+    }
+
+    private async Task HandleResultClick(SemanticSearchResultDto result)
+    {
+        _isDropdownOpen = false;
+
+        // 1. Resolve Ebook ID
+        Guid? ebookId = null;
+        if (result.Metadata != null)
+        {
+            foreach (var key in new[] { "ebookId", "ebook_id", "EbookId", "Ebook_Id" })
+            {
+                if (result.Metadata.TryGetValue(key, out var val) && val != null)
+                {
+                    if (Guid.TryParse(val.ToString(), out var g))
+                    {
+                        ebookId = g;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (ebookId == null || ebookId == Guid.Empty)
+        {
+            ebookId = NavService.CurrentEbookId;
+        }
+
+        if (ebookId == null || ebookId == Guid.Empty)
+        {
+            Logger.LogWarning("Could not resolve ebook ID from search result metadata.");
+            return;
+        }
+
+        // 2. Resolve Chapter Index
+        int chapterIndex = 0;
+        if (result.Metadata != null)
+        {
+            foreach (var key in new[] { "chapterIndex", "chapter_index", "ChapterIndex", "chapter" })
+            {
+                if (result.Metadata.TryGetValue(key, out var val) && val != null)
+                {
+                    if (int.TryParse(val.ToString(), out var parsedInt))
+                    {
+                        chapterIndex = parsedInt;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // 3. Resolve Block ID
+        string? blockId = null;
+        if (result.Metadata != null)
+        {
+            foreach (var key in new[] { "blockId", "block_id", "BlockId", "nodeId", "node_id", "NodeId", "id" })
+            {
+                if (result.Metadata.TryGetValue(key, out var val) && val != null)
+                {
+                    blockId = val.ToString();
+                    break;
+                }
+            }
+        }
+
+        if (string.IsNullOrEmpty(blockId))
+        {
+            blockId = result.ContentHash;
+        }
+
+        // 4. Set pending scroll and navigate
+        NavService.PendingScrollBlockId = blockId;
+
+        if (NavService.CurrentEbookId == ebookId.Value && NavService.CurrentChapterIndex == chapterIndex)
+        {
+            // Same chapter - scroll and highlight immediately
+            if (!string.IsNullOrEmpty(blockId))
+            {
+                await InteractionService.RequestScrollToBlock(blockId);
+                await InteractionService.RequestHighlightBlock(blockId);
+            }
+        }
+        else
+        {
+            // Different chapter or book - perform routing
+            NavService.SetBook(ebookId.Value, chapterIndex);
+            NavManager.NavigateTo($"/reader/{ebookId.Value}?chapter={chapterIndex}");
+        }
+
+        // Invoke the optional callback for parent components
         await OnSearch.InvokeAsync(SearchValue);
     }
+
+    private void HandleKeyDown(KeyboardEventArgs e)
+    {
+        if (e.Key == "Escape")
+        {
+            _isDropdownOpen = false;
+        }
+    }
+
+    private void HandleFocusIn()
+    {
+        IsFocused = true;
+        _isDropdownOpen = true;
+    }
+
+    private async Task HandleFocusOut()
+    {
+        IsFocused = false;
+        // Delay slightly to allow click handlers on result cards to execute
+        await Task.Delay(200);
+        _isDropdownOpen = false;
+        StateHasChanged();
     }
 
     private void ClearSearch()
     {
         SearchValue = string.Empty;
+        _results.Clear();
+        _searchError = null;
+        _isDropdownOpen = false;
+    }
+
+    private string HighlightQueryWords(string text, string query)
+    {
+        if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(query))
+            return text;
+
+        var words = query.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
+                         .Where(w => w.Length > 2)
+                         .Select(Regex.Escape);
+
+        if (!words.Any())
+            return text;
+
+        var pattern = "(" + string.Join("|", words) + ")";
+        try
+        {
+            return Regex.Replace(text, pattern, "<mark class=\"search-highlight\">$1</mark>", RegexOptions.IgnoreCase);
+        }
+        catch
+        {
+            return text;
+        }
+    }
+
+    public void Dispose()
+    {
+        _searchCts?.Cancel();
+        _searchCts?.Dispose();
     }
 }

src/NexusReader.UI.Shared/Components/Atoms/NexusSearchBox.razor.css

@@ -1,57 +1,309 @@
 .nexus-search-container {
+    position: relative;
     width: 100%;
-    max-width: 500px;
-    margin: 1rem auto;
-    transition: all 0.3s ease;
+    max-width: 600px;
+    margin: 1.5rem auto;
+    font-family: var(--nexus-font-sans), 'Inter', sans-serif;
+    z-index: 1000;
 }
 
 .search-wrapper {
     position: relative;
     display: flex;
     align-items: center;
-    background: var(--nexus-card, #141414);
-    border: 1px solid rgba(255, 255, 255, 0.1);
-    border-radius: 12px;
-    padding: 0.5rem 1rem;
-    transition: border-color 0.3s ease, box-shadow 0.3s ease;
+    background: rgba(255, 255, 255, 0.03);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 14px;
+    padding: 0.65rem 1.1rem;
+    transition: all 0.3s cubic-bezier(0.25, 0.8, 0.25, 1);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
 }
 
-.nexus-search-container.active .search-wrapper,
-.search-wrapper:focus-within {
-    border-color: var(--nexus-neon, #00ff99);
-    box-shadow: 0 0 15px rgba(0, 255, 153, 0.2);
+/* Focused state: glowing neon border matching other dashboard components */
+.nexus-search-container.focused .search-wrapper {
+    background: rgba(255, 255, 255, 0.05);
+    border-color: var(--nexus-neon);
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.5), 0 0 15px rgba(0, 255, 153, 0.25);
+}
+
+.search-icon-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 20px;
+    height: 20px;
+    margin-right: 0.85rem;
 }
 
 .nexus-icon {
-    color: rgba(255, 255, 255, 0.5);
-    margin-right: 0.75rem;
-    font-size: 1.1rem;
+    color: rgba(255, 255, 255, 0.45);
+    font-size: 1.25rem;
+    transition: color 0.3s ease;
+}
+
+.nexus-search-container.focused .nexus-icon {
+    color: var(--nexus-neon);
 }
 
 .nexus-search-input {
     flex: 1;
     background: transparent;
     border: none;
-    color: white;
-    font-family: 'Inter', sans-serif;
-    font-size: 0.95rem;
+    color: #ffffff;
+    font-size: 1rem;
+    font-weight: 400;
     outline: none;
+    padding: 0;
+    width: 100%;
 }
 
 .nexus-search-input::placeholder {
-    color: rgba(255, 255, 255, 0.3);
+    color: rgba(255, 255, 255, 0.35);
+    font-style: italic;
+    transition: color 0.3s ease;
+}
+
+.nexus-search-container.focused .nexus-search-input::placeholder {
+    color: rgba(255, 255, 255, 0.5);
+}
+
+/* Pulsing neon-green AI status indicator */
+.ai-status-indicator {
+    display: flex;
+    align-items: center;
+    margin: 0 0.75rem;
+}
+
+.ai-pulse-dot {
+    width: 8px;
+    height: 8px;
+    background-color: var(--nexus-neon);
+    border-radius: 50%;
+    display: inline-block;
+    position: relative;
+    box-shadow: 0 0 8px var(--nexus-neon);
+}
+
+.ai-pulse-dot::after {
+    content: '';
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    top: 0;
+    left: 0;
+    background-color: var(--nexus-neon);
+    border-radius: 50%;
+    z-index: -1;
+    animation: pulse 2s infinite ease-in-out;
 }
 
 .clear-btn {
     background: transparent;
     border: none;
     color: rgba(255, 255, 255, 0.4);
-    font-size: 1.2rem;
+    font-size: 1.5rem;
+    line-height: 1;
     cursor: pointer;
-    padding: 0 0.5rem;
-    transition: color 0.2s ease;
+    padding: 0 0.25rem;
+    margin-left: 0.5rem;
+    transition: color 0.2s ease, transform 0.2s ease;
 }
 
 .clear-btn:hover {
-    color: var(--nexus-neon, #00ff99);
+    color: #ff3b30;
+    transform: scale(1.1);
+}
+
+/* Frosted glass results container */
+.search-dropdown {
+    position: absolute;
+    top: calc(100% + 8px);
+    left: 0;
+    right: 0;
+    background: rgba(18, 18, 18, 0.9);
+    backdrop-filter: blur(20px) saturate(160%);
+    -webkit-backdrop-filter: blur(20px) saturate(160%);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 14px;
+    box-shadow: 0 12px 36px rgba(0, 0, 0, 0.6), 0 0 20px rgba(0, 255, 153, 0.05);
+    max-height: 420px;
+    overflow-y: auto;
+    overflow-x: hidden;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(255, 255, 255, 0.15) transparent;
+    transition: all 0.3s cubic-bezier(0.25, 0.8, 0.25, 1);
+    animation: slideDown 0.25s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.search-dropdown::-webkit-scrollbar {
+    width: 6px;
+}
+
+.search-dropdown::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.15);
+    border-radius: 3px;
+}
+
+.search-dropdown::-webkit-scrollbar-thumb:hover {
+    background: var(--nexus-neon);
+}
+
+/* In-flight spinners */
+.neon-spinner {
+    width: 16px;
+    height: 16px;
+    border: 2px solid rgba(0, 255, 153, 0.15);
+    border-top: 2px solid var(--nexus-neon);
+    border-radius: 50%;
+    animation: spin 0.75s linear infinite;
+}
+
+.neon-spinner-large {
+    width: 32px;
+    height: 32px;
+    border: 3px solid rgba(255, 255, 255, 0.05);
+    border-top: 3px solid var(--nexus-neon);
+    border-radius: 50%;
+    animation: spin 0.8s cubic-bezier(0.5, 0.1, 0.5, 0.9) infinite;
+    margin-bottom: 1rem;
+}
+
+.dropdown-state-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 2.5rem 1.5rem;
+    text-align: center;
+}
+
+.state-text {
+    font-size: 0.95rem;
+    color: rgba(255, 255, 255, 0.65);
+    font-weight: 300;
+}
+
+.error-icon, .empty-icon {
+    font-size: 2rem;
+    margin-bottom: 0.75rem;
+}
+
+.error-icon {
+    color: #ff3b30;
+    text-shadow: 0 0 10px rgba(255, 59, 48, 0.4);
+}
+
+.empty-icon {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+/* Results Cards list */
+.dropdown-results-list {
+    padding: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.result-card {
+    padding: 0.95rem 1.1rem;
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.04);
+    border-radius: 10px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.result-card:hover {
+    background: rgba(0, 255, 153, 0.05);
+    border-color: rgba(0, 255, 153, 0.2);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+}
+
+.result-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 0.5rem;
+    font-size: 0.8rem;
+}
+
+.relevance-badge {
+    background: rgba(0, 255, 153, 0.1);
+    color: var(--nexus-neon);
+    border: 1px solid rgba(0, 255, 153, 0.25);
+    border-radius: 6px;
+    padding: 0.15rem 0.45rem;
+    font-weight: 600;
+    letter-spacing: 0.02em;
+    text-shadow: 0 0 4px rgba(0, 255, 153, 0.25);
+}
+
+.source-title {
+    color: rgba(255, 255, 255, 0.5);
+    max-width: 60%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.source-title strong {
+    color: rgba(255, 255, 255, 0.85);
+}
+
+.result-snippet {
+    font-size: 0.88rem;
+    line-height: 1.45;
+    color: rgba(255, 255, 255, 0.78);
+    font-weight: 300;
+    display: -webkit-box;
+    -webkit-line-clamp: 3;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+/* Markup highlights */
+::deep mark.search-highlight {
+    background: rgba(0, 255, 153, 0.2);
+    color: var(--nexus-neon);
+    border-bottom: 1px solid var(--nexus-neon);
+    padding: 0.05rem 0.15rem;
+    border-radius: 3px;
+    font-weight: 500;
+}
+
+/* Animations */
+@keyframes pulse {
+    0% {
+        transform: scale(1);
+        box-shadow: 0 0 0 0 rgba(0, 255, 153, 0.7);
+    }
+    70% {
+        transform: scale(1.6);
+        box-shadow: 0 0 0 6px rgba(0, 255, 153, 0);
+    }
+    100% {
+        transform: scale(1);
+        box-shadow: 0 0 0 0 rgba(0, 255, 153, 0);
+    }
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+@keyframes slideDown {
+    from {
+        opacity: 0;
+        transform: translateY(-8px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
 }

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

@@ -2,9 +2,14 @@
 @using NexusReader.Application.Queries.Quiz
 @using NexusReader.Application.Commands.Quiz
 @using NexusReader.Application.Abstractions.Services
+@using NexusReader.UI.Shared.Components.Atoms
+@using NexusReader.UI.Shared.Services
 @inject IMediator Mediator
 @inject IPlatformService PlatformService
 @inject IQuizStateService QuizService
+@inject IIdentityService IdentityService
+@inject IKnowledgeGraphService GraphService
+@inject KnowledgeCoordinator Coordinator
 
 <div class="knowledge-check">
     <div class="quiz-header">
@@ -12,10 +17,33 @@
         <button class="expand-btn">⌵</button>
     </div>
 
-    @if (QuizService.IsHydrating)
+    @if (QuizService.IsHydrating || _isGenerating)
     {
         <div class="loading-state shimmer">Skanowanie wiedzy przez AI...</div>
     }
+    else if (_isSubmitted)
+    {
+        <div class="submitted-container">
+            <div class="success-icon-wrapper">
+                <NexusIcon Name="check" Size="48" Class="success-glow" />
+            </div>
+            <h3 class="submitted-title">Gratulacje!</h3>
+            <p class="submitted-text">Sprawdzian zakończony pomyślnie. Twój wynik został zapisany w bazie danych.</p>
+            
+            <div class="score-card">
+                <div class="score-main">
+                    <span class="score-num">@_score</span>
+                    <span class="score-divider">/</span>
+                    <span class="score-total">@_totalQuestions</span>
+                </div>
+                <div class="score-percent">@((int)_percentage)% poprawnych odpowiedzi</div>
+            </div>
+
+            <button class="reset-quiz-btn" @onclick="CloseQuiz">
+                <span>ZAKOŃCZ</span>
+            </button>
+        </div>
+    }
     else if (QuizService.CurrentQuiz != null)
     {
         <div class="quiz-body">
@@ -41,17 +69,45 @@
             }
             
             <div class="quiz-footer">
-                <button class="submit-btn" disabled="@(!AllQuestionsAnswered())">Wyślij</button>
+                <button class="submit-btn" disabled="@(!AllQuestionsAnswered() || _isSubmitting)" @onclick="SubmitQuizAsync">
+                    @if (_isSubmitting)
+                    {
+                        <span>Zapisywanie...</span>
+                    }
+                    else
+                    {
+                        <span>Wyślij</span>
+                    }
+                </button>
             </div>
         </div>
     }
-</div>
+    else
+    {
+        <div class="empty-quiz-state">
+            <div class="empty-icon-wrapper">
+                <NexusIcon Name="robot" Size="48" Class="neon-glow" />
+            </div>
+            <h3 class="empty-title">Brak Aktywnego Quizu</h3>
+            <p class="empty-text">Generuj spersonalizowany sprawdzian wiedzy na podstawie bieżącego rozdziału książki.</p>
             
+            <button class="generate-quiz-btn" @onclick="GenerateChapterQuizAsync" disabled="@(string.IsNullOrWhiteSpace(Coordinator.CurrentFullPageContent))">
+                <span>GENERUJ QUIZ DLA ROZDZIAŁU</span>
+            </button>
+        </div>
+    }
+</div>
 
 @code {
     [Parameter] public string ContextBlockId { get; set; } = string.Empty;
 
     private Dictionary<QuizQuestionDto, (int SelectedIndex, bool IsCorrect)> _states = new();
+    private bool _isSubmitting = false;
+    private bool _isSubmitted = false;
+    private bool _isGenerating = false;
+    private int _score = 0;
+    private int _totalQuestions = 0;
+    private double _percentage = 0.0;
 
     protected override void OnInitialized()
     {
@@ -65,6 +121,24 @@
         QuizService.OnQuizUpdated -= HandleUpdate;
     }
 
+    private async Task GenerateChapterQuizAsync()
+    {
+        if (_isGenerating || string.IsNullOrWhiteSpace(Coordinator.CurrentFullPageContent)) return;
+
+        _isGenerating = true;
+        StateHasChanged();
+
+        try
+        {
+            await Coordinator.RequestSummaryAndQuizAsync(Coordinator.CurrentFullPageContent);
+        }
+        finally
+        {
+            _isGenerating = false;
+            StateHasChanged();
+        }
+    }
+
     private async Task SelectOptionAsync(QuizQuestionDto question, int index)
     {
         if (_states.ContainsKey(question)) return;
@@ -90,6 +164,67 @@
         return QuizService.CurrentQuiz != null && _states.Count == QuizService.CurrentQuiz.Questions.Count;
     }
 
+    private async Task SubmitQuizAsync()
+    {
+        if (QuizService.CurrentQuiz == null || !AllQuestionsAnswered() || _isSubmitting) return;
+
+        _isSubmitting = true;
+        StateHasChanged();
+
+        try
+        {
+            _score = _states.Values.Count(s => s.IsCorrect);
+            _totalQuestions = QuizService.CurrentQuiz.Questions.Count;
+            _percentage = _totalQuestions > 0 ? ((double)_score / _totalQuestions) * 100 : 0.0;
+
+            string topic = "Quiz wiedzy";
+            var graph = GraphService.CurrentGraphData;
+            if (graph != null && !string.IsNullOrEmpty(QuizService.CurrentQuizBlockId))
+            {
+                var node = graph.Nodes.FirstOrDefault(n => n.Id == QuizService.CurrentQuizBlockId);
+                if (node != null && !string.IsNullOrEmpty(node.Label))
+                {
+                    topic = $"Test: {node.Label}";
+                }
+            }
+
+            var profileResult = await IdentityService.GetProfileAsync();
+            if (profileResult.IsSuccess && profileResult.Value != null)
+            {
+                var userId = profileResult.Value.UserId;
+
+                var cmd = new SubmitQuizResultCommand(userId, topic, _score, _totalQuestions);
+                var result = await Mediator.Send(cmd);
+                
+                if (result.IsSuccess)
+                {
+                    IdentityService.ClearCache();
+                    _isSubmitted = true;
+                    await PlatformService.VibrateSuccessAsync();
+                }
+                else
+                {
+                    await PlatformService.VibrateErrorAsync();
+                }
+            }
+        }
+        catch
+        {
+            await PlatformService.VibrateErrorAsync();
+        }
+        finally
+        {
+            _isSubmitting = false;
+            StateHasChanged();
+        }
+    }
+
+    private void CloseQuiz()
+    {
+        _isSubmitted = false;
+        _states.Clear();
+        QuizService.SetQuiz(null, null);
+    }
 
     private string GetBlockClass(QuizQuestionDto question)
     {

src/NexusReader.UI.Shared/Components/Molecules/KnowledgeCheck.razor.css

@@ -121,3 +121,217 @@
     0% { background-position: -200% 0; }
     100% { background-position: 200% 0; }
 }
+
+.option-revealed-correct {
+    border-color: #00ff99 !important;
+    background: rgba(0, 255, 153, 0.08) !important;
+    box-shadow: 0 0 8px rgba(0, 255, 153, 0.15);
+}
+
+.option-faded {
+    opacity: 0.45;
+}
+
+.submitted-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 2rem 1rem;
+    animation: fadeIn 0.4s ease-out;
+}
+
+.success-icon-wrapper {
+    background: rgba(0, 255, 153, 0.1);
+    border: 1px solid rgba(0, 255, 153, 0.3);
+    border-radius: 50%;
+    width: 80px;
+    height: 80px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-bottom: 1.5rem;
+    box-shadow: 0 0 20px rgba(0, 255, 153, 0.15);
+}
+
+.success-glow {
+    color: var(--nexus-neon, #00ff99);
+    filter: drop-shadow(0 0 8px var(--nexus-neon, #00ff99));
+}
+
+.submitted-title {
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #fff;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.5px;
+}
+
+.submitted-text {
+    font-size: 0.9rem;
+    color: #888;
+    margin-bottom: 2rem;
+    line-height: 1.5;
+}
+
+.score-card {
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 16px;
+    padding: 1.5rem 2.5rem;
+    margin-bottom: 2rem;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    backdrop-filter: blur(10px);
+}
+
+.score-main {
+    display: flex;
+    align-items: baseline;
+    gap: 0.2rem;
+    margin-bottom: 0.5rem;
+}
+
+.score-num {
+    font-size: 3rem;
+    font-weight: 800;
+    color: var(--nexus-neon, #00ff99);
+    line-height: 1;
+    text-shadow: 0 0 15px rgba(0, 255, 153, 0.3);
+}
+
+.score-divider {
+    font-size: 1.8rem;
+    color: #444;
+}
+
+.score-total {
+    font-size: 1.8rem;
+    font-weight: 600;
+    color: #fff;
+}
+
+.score-percent {
+    font-size: 0.85rem;
+    color: #666;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.reset-quiz-btn {
+    padding: 0.8rem 3rem;
+    background: transparent;
+    border: 1px solid rgba(255, 255, 255, 0.15);
+    border-radius: 30px;
+    color: #fff;
+    font-size: 0.9rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    letter-spacing: 0.5px;
+}
+
+.reset-quiz-btn:hover {
+    background: rgba(255, 255, 255, 0.05);
+    border-color: #fff;
+    box-shadow: 0 0 15px rgba(255, 255, 255, 0.1);
+}
+
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.empty-quiz-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 2.5rem 1rem;
+    animation: fadeIn 0.4s ease-out;
+}
+
+.empty-icon-wrapper {
+    background: rgba(0, 255, 153, 0.03);
+    border: 1px solid rgba(0, 255, 153, 0.15);
+    border-radius: 50%;
+    width: 80px;
+    height: 80px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-bottom: 1.5rem;
+    box-shadow: 0 0 30px rgba(0, 255, 153, 0.05);
+    transition: all 0.3s ease;
+}
+
+.empty-quiz-state:hover .empty-icon-wrapper {
+    background: rgba(0, 255, 153, 0.08);
+    border-color: rgba(0, 255, 153, 0.4);
+    box-shadow: 0 0 35px rgba(0, 255, 153, 0.15);
+    transform: scale(1.05);
+}
+
+.neon-glow {
+    color: var(--nexus-neon, #00ff99);
+    filter: drop-shadow(0 0 6px var(--nexus-neon, #00ff99));
+}
+
+.empty-title {
+    font-size: 1.3rem;
+    font-weight: 700;
+    color: #fff;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.3px;
+}
+
+.empty-text {
+    font-size: 0.9rem;
+    color: #888;
+    margin-bottom: 2rem;
+    line-height: 1.5;
+    max-width: 280px;
+}
+
+.generate-quiz-btn {
+    padding: 0.85rem 2rem;
+    background: rgba(0, 255, 153, 0.08);
+    border: 1px solid var(--nexus-neon, #00ff99);
+    border-radius: 30px;
+    color: var(--nexus-neon, #00ff99);
+    font-size: 0.85rem;
+    font-weight: 700;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    letter-spacing: 0.8px;
+    text-shadow: 0 0 10px rgba(0, 255, 153, 0.3);
+    box-shadow: 0 0 15px rgba(0, 255, 153, 0.1);
+}
+
+.generate-quiz-btn:not(:disabled):hover {
+    background: var(--nexus-neon, #00ff99);
+    color: #000;
+    box-shadow: 0 0 25px rgba(0, 255, 153, 0.4);
+    transform: translateY(-2px);
+    text-shadow: none;
+}
+
+.generate-quiz-btn:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+    border-color: rgba(255, 255, 255, 0.15);
+    background: rgba(255, 255, 255, 0.02);
+    color: #666;
+    text-shadow: none;
+    box-shadow: none;
+}
+

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

@@ -2,12 +2,14 @@
 @using NexusReader.Application.Abstractions.Services
 @using NexusReader.Application.Queries.Reader
 @using NexusReader.Application.Commands.Library
+@using NexusReader.UI.Shared.Services
 @using System.Net.Http.Json
 @inject IEpubMetadataExtractor MetadataExtractor
 @inject ILogger<BookIngestionModal> Logger
 @inject HttpClient Http
 @inject IReaderNavigationService ReaderNavigation
 @inject IJSRuntime JSRuntime
+@inject ISyncService SyncService
 @implements IAsyncDisposable
 
 @if (IsOpen)
@@ -16,20 +18,23 @@
         <div class="modal-content glass-panel" @onclick:stopPropagation>
             <div class="modal-header">
                 <h2>Add New Book</h2>
+                @if (!IsIngesting && !IsIndexing)
+                {
                     <button class="close-btn" @onclick="CloseModal">
                         <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
                     </button>
+                }
             </div>
 
             <div class="modal-body">
-                <div class="parsing-state shimmer" style="@(IsParsing ? "display:flex;" : "display:none;")">
+                <div class="parsing-state shimmer" style="@(IsParsing && !IsIndexing ? "display:flex;" : "display:none;")">
                     <div class="shimmer-content">
                         <div class="spinner"></div>
                         <p>Scanning metadata...</p>
                     </div>
                 </div>
                 
-                <div class="verification-state" style="@(IsVerifying && !IsParsing ? "display:flex;" : "display:none;")">
+                <div class="verification-state" style="@(IsVerifying && !IsParsing && !IsIndexing ? "display:flex;" : "display:none;")">
                     @if (Metadata != null)
                     {
                         <div class="verification-layout">
@@ -74,7 +79,7 @@
                 </div>
                 
                 <div class="upload-state @(_isDragging ? "drag-over" : "")" 
-                     style="@(!IsParsing && !IsVerifying ? "display:flex;" : "display:none;")"
+                     style="@(!IsParsing && !IsVerifying && !IsIndexing ? "display:flex;" : "display:none;")"
                      @ondragenter="OnDragEnter" 
                      @ondragleave="OnDragLeave">
                     <div class="drop-zone">
@@ -87,6 +92,18 @@
                     </div>
                 </div>
 
+                <div class="indexing-state" style="@(IsIndexing ? "display:flex;" : "display:none;")">
+                    <div class="indexing-content">
+                        <div class="spinner"></div>
+                        <h3>Nexus AI Indexing</h3>
+                        <p class="status-msg">@IngestionStatusMessage</p>
+                        <div class="progress-bar-container">
+                            <div class="progress-bar-fill" style="width: @((IngestionProgressPercent * 100).ToString("F0"))%"></div>
+                        </div>
+                        <span class="percent">@((IngestionProgressPercent * 100).ToString("F0"))%</span>
+                    </div>
+                </div>
+
                 
                 @if (!string.IsNullOrEmpty(ErrorMessage))
                 {
@@ -118,6 +135,10 @@
     private bool IsParsing { get; set; }
     private bool IsVerifying { get; set; }
     private bool IsIngesting { get; set; }
+    private bool IsIndexing { get; set; }
+    private string IngestionStatusMessage { get; set; } = "Initializing...";
+    private double IngestionProgressPercent { get; set; }
+    private Guid IngestedBookId { get; set; } = Guid.Empty;
     private LocalEpubMetadata? Metadata { get; set; }
     private string? ErrorMessage { get; set; }
     private byte[]? _epubBytes;
@@ -125,8 +146,42 @@
     // Allow up to 50 MB
     private const long MaxFileSize = 50 * 1024 * 1024;
 
+    protected override async Task OnInitializedAsync()
+    {
+        await SyncService.InitializeAsync();
+        SyncService.OnIngestionProgressReceived += HandleIngestionProgress;
+    }
+
+    private async Task HandleIngestionProgress(string message, double progress)
+    {
+        if (!IsIndexing) return;
+
+        IngestionStatusMessage = message;
+        IngestionProgressPercent = progress;
+        
+        await InvokeAsync(StateHasChanged);
+
+        if (progress >= 1.0)
+        {
+            // Give the user a moment to see the completion message
+            await Task.Delay(2500);
+            
+            // Now close the modal and navigate to the book
+            if (IngestedBookId != Guid.Empty)
+            {
+                var bookId = IngestedBookId;
+                await InvokeAsync(async () => {
+                    await CloseModal();
+                    ReaderNavigation.NavigateToBook(bookId);
+                });
+            }
+        }
+    }
+
     private async Task CloseModal()
     {
+        if (IsIngesting || IsIndexing) return;
+
         IsOpen = false;
         Reset();
         await IsOpenChanged.InvokeAsync(false);
@@ -137,6 +192,10 @@
         IsParsing = false;
         IsVerifying = false;
         IsIngesting = false;
+        IsIndexing = false;
+        IngestionStatusMessage = "Initializing...";
+        IngestionProgressPercent = 0.0;
+        IngestedBookId = Guid.Empty;
         Metadata = null;
         ErrorMessage = null;
         _isDragging = false;
@@ -220,33 +279,40 @@
                 var result = await response.Content.ReadFromJsonAsync<IngestResult>();
                 if (result != null)
                 {
-                    await CloseModal();
-                    ReaderNavigation.NavigateToBook(result.Id);
+                    IngestedBookId = result.Id;
+                    IsVerifying = false;
+                    IsIngesting = false;
+                    IsIndexing = true;
+                    IngestionStatusMessage = "Book saved! Starting background indexing...";
+                    IngestionProgressPercent = 0.0;
+                    StateHasChanged();
                 }
             }
             else
             {
                 ErrorMessage = await response.Content.ReadAsStringAsync();
+                IsIngesting = false;
             }
         }
         catch (Exception ex)
         {
             Logger.LogError(ex, "Error during ingestion");
             ErrorMessage = "Failed to save book to library. Please try again.";
+            IsIngesting = false;
         }
         finally
         {
-            IsIngesting = false;
             StateHasChanged();
         }
     }
 
     private record IngestResult(Guid Id);
 
-    public ValueTask DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
+        SyncService.OnIngestionProgressReceived -= HandleIngestionProgress;
         // Clear the large byte array so it is eligible for GC even if the component is cached.
         _epubBytes = null;
-        return ValueTask.CompletedTask;
+        await ValueTask.CompletedTask;
     }
 }

src/NexusReader.UI.Shared/Components/Organisms/BookIngestionModal.razor.css

@@ -377,6 +377,72 @@
     animation: spin 0.8s linear infinite;
 }
 
+/* Indexing State */
+.indexing-state {
+    flex: 1;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    border-radius: 12px;
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    box-shadow: inset 0 0 12px rgba(255, 255, 255, 0.02);
+    position: relative;
+    overflow: hidden;
+    padding: 2rem;
+    animation: fadeIn 0.4s ease-out;
+}
+
+.indexing-content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    text-align: center;
+    width: 100%;
+    gap: 1.25rem;
+}
+
+.indexing-content h3 {
+    margin: 0;
+    font-size: 1.25rem;
+    color: var(--nexus-neon, #00ffaa);
+    text-shadow: 0 0 10px rgba(0, 255, 153, 0.2);
+    letter-spacing: 0.5px;
+}
+
+.status-msg {
+    margin: 0;
+    font-size: 0.9rem;
+    color: var(--nexus-text-muted, #888);
+    min-height: 2.5rem;
+    line-height: 1.4;
+}
+
+.progress-bar-container {
+    width: 100%;
+    height: 8px;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 4px;
+    overflow: hidden;
+    position: relative;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.progress-bar-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--nexus-neon, #00ffaa) 0%, #00b3ff 100%);
+    box-shadow: 0 0 10px rgba(0, 255, 153, 0.4);
+    border-radius: 4px;
+    transition: width 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.percent {
+    font-family: var(--nexus-font-mono, monospace);
+    font-size: 1.1rem;
+    font-weight: 700;
+    color: var(--nexus-text);
+}
+
 @keyframes fadeIn {
     from { opacity: 0; }
     to { opacity: 1; }

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

@@ -211,6 +211,7 @@
 
     private async Task LoadChapterAsync(int index)
     {
+        await Coordinator.ClearAsync();
         _isLoadingChapter = true;
         StatusMessage = "Wczytywanie treści...";
         StateHasChanged();
@@ -247,6 +248,17 @@
 
         _isLoadingChapter = false;
         StateHasChanged();
+
+        if (result.IsSuccess && !string.IsNullOrEmpty(NavigationService.PendingScrollBlockId))
+        {
+            var targetBlockId = NavigationService.PendingScrollBlockId;
+            NavigationService.PendingScrollBlockId = null; // Clear it to prevent multiple scrolls
+
+            // Give the browser slightly more than one frame to render the loaded blocks
+            await Task.Delay(150);
+            await ScrollToNodeAsync(targetBlockId);
+            await InteractionService.RequestHighlightBlock(targetBlockId);
+        }
     }
 
     public async Task ScrollToNodeAsync(string id)

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

@@ -3,10 +3,13 @@
 @using NexusReader.UI.Shared.Services
 @using NexusReader.UI.Shared.Components.Molecules
 @using NexusReader.UI.Shared.Components.Organisms
+@using NexusReader.Application.Queries.Graph
 @using Microsoft.Extensions.Logging
 @inject IPlatformService PlatformService
 @inject IFocusModeService FocusMode
 @inject IQuizStateService QuizService
+@inject IReaderInteractionService InteractionService
+@inject IKnowledgeGraphService GraphService
 @inject IJSRuntime JS
 @inject IIdentityService IdentityService
 @inject NavigationManager NavigationManager
@@ -41,13 +44,92 @@
                         <button class="close-btn">×</button>
                     </div>
 
-                    <div class="intelligence-scroll-area">
+                    @if (_activeTab == SidebarTab.Knowledge)
+                    {
+                        <div class="intelligence-scroll-area stacked-layout">
                             @if (!_isMobile)
                             {
+                                <div class="visual-workspace">
                                     <KnowledgeGraph />
+                                </div>
                             }
+                            
+                            <div class="contextual-intelligence-panel">
+                                <div class="panel-header">
+                                    <NexusIcon Name="brain" Size="18" Class="neon-accent-icon" />
+                                    <span class="panel-title">Contextual Intelligence Panel</span>
+                                </div>
+                                <div class="panel-body">
+                                    @if (_selectedNode != null)
+                                    {
+                                        <div class="node-details">
+                                            <div class="node-header-section">
+                                                <span class="node-group-badge @(_selectedNode.Group.ToLower())">@(_selectedNode.Group.ToUpper())</span>
+                                                <h3 class="node-label">@_selectedNode.Label</h3>
+                                            </div>
+                                            
+                                            @if (!string.IsNullOrEmpty(_selectedNode.Description))
+                                            {
+                                                <div class="detail-section">
+                                                    <p class="node-description">@_selectedNode.Description</p>
+                                                </div>
+                                            }
+
+                                            @if (!string.IsNullOrEmpty(_selectedNode.Summary))
+                                            {
+                                                <div class="detail-section summary-section">
+                                                    <h4 class="section-title neon-sub-header">Podsumowanie</h4>
+                                                    <p class="node-summary">@_selectedNode.Summary</p>
+                                                </div>
+                                            }
+
+                                            @if (_selectedNode.KeyTerms != null && _selectedNode.KeyTerms.Any())
+                                            {
+                                                <div class="detail-section key-terms-section">
+                                                    <h4 class="section-title neon-sub-header">Kluczowe Pojęcia</h4>
+                                                    <ul class="key-terms-list">
+                                                        @foreach (var term in _selectedNode.KeyTerms)
+                                                        {
+                                                            <li class="key-term-item">
+                                                                <span class="term-bullet">•</span>
+                                                                <span class="term-text">@term</span>
+                                                            </li>
+                                                        }
+                                                    </ul>
+                                                </div>
+                                            }
+                                        </div>
+                                    }
+                                    else
+                                    {
+                                        <div class="no-node-selected">
+                                            <div class="placeholder-glow"></div>
+                                            <p class="placeholder-text">Wybierz węzeł na wykresie, aby wyświetlić szczegóły architektoniczne.</p>
+                                        </div>
+                                    }
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="sidebar-footer">
+                            <button class="open-quiz-btn neon-glow-btn @(QuizService.HasNewQuiz ? "quiz-pulse-btn" : "")" @onclick="() => SetActiveTab(SidebarTab.Quiz)">
+                                <NexusIcon Name="quiz" Size="18" />
+                                <span>OPEN KNOWLEDGE QUIZ</span>
+                            </button>
+                        </div>
+                    }
+                    else
+                    {
+                        <div class="intelligence-scroll-area quiz-layout">
+                            <div class="quiz-nav">
+                                <button class="back-to-graph-btn" @onclick="() => SetActiveTab(SidebarTab.Knowledge)">
+                                    <NexusIcon Name="arrow-left" Size="16" />
+                                    <span>← Powrót do wykresu</span>
+                                </button>
+                            </div>
                             <KnowledgeCheck />
                         </div>
+                    }
                 </div>
             </div>
         </Authorized>
@@ -67,6 +149,16 @@
 </div>
 
 @code {
+    private enum SidebarTab
+    {
+        Knowledge,
+        Quiz
+    }
+
+    private SidebarTab _activeTab = SidebarTab.Knowledge;
+    private string? _selectedNodeId;
+    private GraphNodeDto? _selectedNode;
+
     private string _platformClass = "platform-desktop";
     private bool _isMobile = false;
 
@@ -74,6 +166,10 @@
     {
         FocusMode.OnFocusModeChanged += HandleUpdate;
         QuizService.OnQuizUpdated += HandleUpdate;
+        QuizService.OnQuizRequested += HandleQuizRequestedAsync;
+
+        InteractionService.OnNodeSelected += HandleNodeSelectedAsync;
+        GraphService.OnGraphUpdated += HandleGraphUpdatedAsync;
 
         var context = PlatformService.GetDeviceContext();
         if (context.IsSuccess)
@@ -88,7 +184,34 @@
         }
     }
 
+    private void SetActiveTab(SidebarTab tab)
+    {
+        _activeTab = tab;
+        StateHasChanged();
+    }
 
+    private async Task HandleQuizRequestedAsync(string blockId)
+    {
+        _activeTab = SidebarTab.Quiz;
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async Task HandleNodeSelectedAsync(string nodeId)
+    {
+        _selectedNodeId = nodeId;
+        if (GraphService.CurrentGraphData != null)
+        {
+            _selectedNode = GraphService.CurrentGraphData.Nodes.FirstOrDefault(n => n.Id == nodeId);
+        }
+        await InvokeAsync(StateHasChanged);
+    }
+
+    private async Task HandleGraphUpdatedAsync()
+    {
+        _selectedNodeId = null;
+        _selectedNode = null;
+        await InvokeAsync(StateHasChanged);
+    }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
@@ -112,5 +235,8 @@
     {
         FocusMode.OnFocusModeChanged -= HandleUpdate;
         QuizService.OnQuizUpdated -= HandleUpdate;
+        QuizService.OnQuizRequested -= HandleQuizRequestedAsync;
+        InteractionService.OnNodeSelected -= HandleNodeSelectedAsync;
+        GraphService.OnGraphUpdated -= HandleGraphUpdatedAsync;
     }
 }

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

@@ -153,3 +153,318 @@ main {
     50% { filter: drop-shadow(0 0 10px var(--nexus-neon)); transform: scale(1.1); }
     100% { filter: drop-shadow(0 0 2px var(--nexus-neon)); transform: scale(1); }
 }
+
+/* Contextual Intelligence Panel Layout */
+.stacked-layout {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+}
+
+.visual-workspace {
+    flex-shrink: 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.contextual-intelligence-panel {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: rgba(13, 13, 13, 0.6);
+    border-top: 1px solid rgba(255, 255, 255, 0.03);
+    overflow: hidden;
+}
+
+.panel-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.25rem;
+    background: rgba(255, 255, 255, 0.01);
+    border-bottom: 1px solid rgba(255, 255, 255, 0.03);
+}
+
+.neon-accent-icon {
+    color: var(--nexus-neon, #00f0ff);
+    filter: drop-shadow(0 0 5px var(--nexus-neon, #00f0ff));
+}
+
+.panel-title {
+    font-family: var(--nexus-font-sans, "Outfit", sans-serif);
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.1em;
+    color: rgba(255, 255, 255, 0.5);
+    font-weight: 600;
+}
+
+.panel-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1.25rem;
+}
+
+.no-node-selected {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    min-height: 150px;
+    text-align: center;
+    color: rgba(255, 255, 255, 0.35);
+    padding: 2rem;
+}
+
+.placeholder-glow {
+    width: 48px;
+    height: 48px;
+    border-radius: 50%;
+    background: radial-gradient(circle, rgba(0, 240, 255, 0.15) 0%, transparent 70%);
+    animation: glow-pulse 2s infinite ease-in-out;
+    margin-bottom: 1rem;
+}
+
+@keyframes glow-pulse {
+    0% { transform: scale(0.9); opacity: 0.5; }
+    50% { transform: scale(1.1); opacity: 1; }
+    100% { transform: scale(0.9); opacity: 0.5; }
+}
+
+.placeholder-text {
+    font-size: 0.85rem;
+    line-height: 1.4;
+    font-weight: 300;
+}
+
+.node-details {
+    display: flex;
+    flex-direction: column;
+    gap: 1.25rem;
+    animation: fade-in 0.3s ease-out;
+}
+
+@keyframes fade-in {
+    from { opacity: 0; transform: translateY(5px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.node-header-section {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+    padding-bottom: 0.75rem;
+}
+
+.node-group-badge {
+    align-self: flex-start;
+    font-size: 0.65rem;
+    font-weight: 700;
+    padding: 0.15rem 0.5rem;
+    border-radius: 4px;
+    letter-spacing: 0.08em;
+    border: 1px solid transparent;
+}
+
+/* Badge specific styling matching category theme colors */
+.node-group-badge.rule {
+    background: rgba(244, 63, 94, 0.1);
+    color: #f43f5e;
+    border-color: rgba(244, 63, 94, 0.3);
+}
+
+.node-group-badge.definition {
+    background: rgba(234, 179, 8, 0.1);
+    color: #eab308;
+    border-color: rgba(234, 179, 8, 0.3);
+}
+
+.node-group-badge.table {
+    background: rgba(168, 85, 247, 0.1);
+    color: #a855f7;
+    border-color: rgba(168, 85, 247, 0.3);
+}
+
+.node-group-badge.section {
+    background: rgba(59, 130, 246, 0.1);
+    color: #3b82f6;
+    border-color: rgba(59, 130, 246, 0.3);
+}
+
+.node-group-badge.bridge {
+    background: rgba(236, 72, 153, 0.1);
+    color: #ec4899;
+    border-color: rgba(236, 72, 153, 0.3);
+}
+
+.node-group-badge.current {
+    background: rgba(16, 185, 129, 0.1);
+    color: #10b981;
+    border-color: rgba(16, 185, 129, 0.3);
+}
+
+.node-group-badge.concept {
+    background: rgba(0, 240, 255, 0.1);
+    color: #00f0ff;
+    border-color: rgba(0, 240, 255, 0.3);
+}
+
+.node-label {
+    font-family: var(--nexus-font-sans, "Outfit", sans-serif);
+    font-size: 1.15rem;
+    font-weight: 600;
+    color: #ffffff;
+    margin: 0;
+}
+
+.detail-section {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.section-title {
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    margin: 0;
+    color: rgba(255, 255, 255, 0.4);
+}
+
+.neon-sub-header {
+    border-left: 2px solid var(--nexus-neon, #00f0ff);
+    padding-left: 0.5rem;
+    text-shadow: 0 0 10px rgba(0, 240, 255, 0.2);
+}
+
+.node-description {
+    font-size: 0.85rem;
+    line-height: 1.5;
+    color: rgba(255, 255, 255, 0.85);
+    margin: 0;
+}
+
+.node-summary {
+    font-size: 0.82rem;
+    line-height: 1.5;
+    color: rgba(255, 255, 255, 0.75);
+    background: rgba(255, 255, 255, 0.02);
+    border-left: 2px solid rgba(255, 255, 255, 0.1);
+    padding: 0.5rem 0.75rem;
+    border-radius: 0 4px 4px 0;
+    margin: 0;
+}
+
+.key-terms-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.key-term-item {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    font-size: 0.82rem;
+    color: rgba(255, 255, 255, 0.8);
+}
+
+.term-bullet {
+    color: var(--nexus-neon, #00f0ff);
+    filter: drop-shadow(0 0 3px var(--nexus-neon, #00f0ff));
+    font-weight: bold;
+}
+
+.term-text {
+    line-height: 1.4;
+}
+
+/* Sidebar Footer & Open Quiz Button */
+.sidebar-footer {
+    padding: 1rem 1.25rem;
+    background: rgba(13, 13, 13, 0.95);
+    border-top: 1px solid rgba(255, 255, 255, 0.05);
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    z-index: 10;
+}
+
+.open-quiz-btn {
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border-radius: 8px;
+    font-family: var(--nexus-font-sans, "Outfit", sans-serif);
+    font-size: 0.75rem;
+    font-weight: 700;
+    letter-spacing: 0.12em;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.6rem;
+    cursor: pointer;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    background: rgba(0, 240, 255, 0.03);
+    border: 1px solid rgba(0, 240, 255, 0.3);
+    color: var(--nexus-neon, #00f0ff);
+    box-shadow: 0 4px 15px rgba(0, 240, 255, 0.05);
+}
+
+.open-quiz-btn:hover {
+    background: rgba(0, 240, 255, 0.1);
+    border-color: var(--nexus-neon, #00f0ff);
+    color: #ffffff;
+    box-shadow: 0 0 20px rgba(0, 240, 255, 0.25);
+    transform: translateY(-2px);
+}
+
+.open-quiz-btn:active {
+    transform: translateY(0);
+}
+
+.quiz-pulse-btn {
+    animation: quiz-pulse-glow 2s infinite ease-in-out;
+}
+
+@keyframes quiz-pulse-glow {
+    0% { border-color: rgba(0, 240, 255, 0.3); box-shadow: 0 0 5px rgba(0, 240, 255, 0.1); }
+    50% { border-color: var(--nexus-neon, #00f0ff); box-shadow: 0 0 25px rgba(0, 240, 255, 0.3); }
+    100% { border-color: rgba(0, 240, 255, 0.3); box-shadow: 0 0 5px rgba(0, 240, 255, 0.1); }
+}
+
+/* Quiz Navigation Header */
+.quiz-layout {
+    display: flex;
+    flex-direction: column;
+}
+
+.quiz-nav {
+    padding: 0.75rem 1.25rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+    background: rgba(255, 255, 255, 0.01);
+}
+
+.back-to-graph-btn {
+    background: none;
+    border: none;
+    color: rgba(255, 255, 255, 0.5);
+    font-size: 0.8rem;
+    font-weight: 500;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    transition: all 0.2s;
+}
+
+.back-to-graph-btn:hover {
+    color: var(--nexus-neon, #00f0ff);
+    background: rgba(255, 255, 255, 0.02);
+}

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

@@ -6,6 +6,8 @@
 @inject IIdentityService IdentityService
 @inject NavigationManager NavigationManager
 @attribute [Authorize]
+@implements IDisposable
+
 
 <PageTitle>Dashboard | Nexus Reader</PageTitle>
 
@@ -18,20 +20,20 @@
                 <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>
+            <h1 class="username">@(string.IsNullOrEmpty(_profile?.DisplayName) ? (_profile?.Email.Split('@')[0] ?? "Użytkownik") : _profile.DisplayName)</h1>
             
             <div class="status-pills">
                 <div class="status-pill">
-                    <span class="pill-label">Books Read:</span>
-                    <span class="pill-value">12</span>
+                    <span class="pill-label">Książki:</span>
+                    <span class="pill-value">@(_profile?.BooksReadCount ?? 0)</span>
                 </div>
                 <div class="status-pill">
-                    <span class="pill-label">Concepts Mapped:</span>
-                    <span class="pill-value">450</span>
+                    <span class="pill-label">Pojęcia:</span>
+                    <span class="pill-value">@(_profile?.ConceptsMappedCount ?? 0)</span>
                 </div>
                 <div class="status-pill">
-                    <span class="pill-label">Quiz Mastery:</span>
-                    <span class="pill-value">88%</span>
+                    <span class="pill-label">Średni Wynik:</span>
+                    <span class="pill-value">@(_profile?.AverageQuizScore ?? 0)%</span>
                 </div>
             </div>
         </div>
@@ -39,7 +41,7 @@
 
     <!-- Main Content Area -->
     <main class="dashboard-content">
-        <h2 class="section-title">Witaj, @(_profile?.Email.Split('@')[0] ?? "Użytkowniku")</h2>
+        <h2 class="section-title">Witaj, @(string.IsNullOrEmpty(_profile?.DisplayName) ? (_profile?.Email.Split('@')[0] ?? "Użytkowniku") : _profile.DisplayName)</h2>
         
         <div class="main-grid">
             <!-- Current Reading Card -->
@@ -49,7 +51,7 @@
                 <!-- Knowledge Integration -->
                 <section class="integration-card glass-panel">
                     <div class="panel-header">
-                        <h4>Knowledge Integration Progress</h4>
+                        <h4>Integracja Wiedzy</h4>
                         <NexusIcon Name="arrow-right" Size="16" />
                     </div>
                     <div class="graph-placeholder">
@@ -64,19 +66,36 @@
                 <!-- Quiz Summary -->
                 <section class="quiz-card glass-panel">
                     <div class="panel-header">
-                        <h4>Quiz Summary: Key Thinkers</h4>
+                        <h4>Rozwiązane Quizy</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ł
+                        @if (_profile?.RecentQuizzes != null && _profile.RecentQuizzes.Any())
+                        {
+                            <div class="quiz-history-list">
+                                @foreach (var quiz in _profile.RecentQuizzes)
+                                {
+                                    <div class="quiz-history-item">
+                                        <div class="quiz-item-header">
+                                            <span class="quiz-topic">@quiz.Topic</span>
+                                            <span class="quiz-score badge @(quiz.Percentage >= 80 ? "badge-success" : quiz.Percentage >= 50 ? "badge-warning" : "badge-danger")">
+                                                @quiz.Score / @quiz.TotalQuestions (@((int)quiz.Percentage)%)
+                                            </span>
                                         </div>
-                            <div class="quiz-option">
-                                <span class="option-letter">B)</span> Leonardo da Vinci
+                                        <div class="quiz-item-meta">
+                                            <span class="quiz-date">@quiz.CompletedDate.ToString("g")</span>
                                         </div>
                                     </div>
+                                }
+                            </div>
+                        }
+                        else
+                        {
+                            <div class="empty-quiz-state">
+                                <p class="question">Brak rozwiązanych quizów</p>
+                                <p class="sub-text">Rozwiązuj quizy w trakcie czytania książek, aby śledzić swoje postępy.</p>
+                            </div>
+                        }
                     </div>
                 </section>
             </div>
@@ -88,11 +107,36 @@
     private UserProfileDto? _profile;
 
     protected override async Task OnInitializedAsync()
+    {
+        IdentityService.OnStateInvalidated += HandleStateInvalidatedAsync;
+        await LoadProfileAsync();
+    }
+
+    private async Task LoadProfileAsync()
     {
         var result = await IdentityService.GetProfileAsync();
         if (result.IsSuccess) 
         {
             _profile = result.Value;
         }
+        else
+        {
+            _profile = null;
+        }
+        StateHasChanged();
+    }
+
+    private async Task HandleStateInvalidatedAsync()
+    {
+        await InvokeAsync(async () =>
+        {
+            await LoadProfileAsync();
+        });
+    }
+
+    public void Dispose()
+    {
+        IdentityService.OnStateInvalidated -= HandleStateInvalidatedAsync;
     }
 }
+

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

@@ -404,3 +404,79 @@
         grid-template-columns: 1fr;
     }
 }
+
+/* --- Quiz History Styling --- */
+.quiz-history-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.quiz-history-item {
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 12px;
+    padding: 1rem;
+    transition: all 0.2s ease;
+}
+
+.quiz-history-item:hover {
+    background: rgba(255, 255, 255, 0.04);
+    border-color: rgba(255, 255, 255, 0.1);
+}
+
+.quiz-item-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 0.5rem;
+}
+
+.quiz-topic {
+    font-size: 0.95rem;
+    font-weight: 500;
+    color: #ffffff;
+}
+
+.quiz-item-meta {
+    display: flex;
+    font-size: 0.75rem;
+    color: #666666;
+}
+
+.badge {
+    padding: 0.25rem 0.5rem;
+    border-radius: 6px;
+    font-size: 0.75rem;
+    font-weight: 600;
+}
+
+.badge-success {
+    background: rgba(0, 255, 153, 0.1);
+    color: var(--nexus-neon);
+    border: 1px solid rgba(0, 255, 153, 0.3);
+}
+
+.badge-warning {
+    background: rgba(255, 170, 0, 0.1);
+    color: #ffa800;
+    border: 1px solid rgba(255, 170, 0, 0.3);
+}
+
+.badge-danger {
+    background: rgba(255, 50, 50, 0.1);
+    color: #ff3232;
+    border: 1px solid rgba(255, 50, 50, 0.3);
+}
+
+.empty-quiz-state {
+    text-align: center;
+    padding: 2rem 1rem;
+}
+
+.empty-quiz-state .sub-text {
+    font-size: 0.8rem;
+    color: #666666;
+    margin-top: 0.5rem;
+}

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

@@ -6,6 +6,8 @@
 @using System.Net.Http.Json
 @inject HttpClient Http
 @inject IKnowledgeService KnowledgeService
+@inject AuthenticationStateProvider AuthStateProvider
+
 
 <div class="intelligence-page">
     <header class="intelligence-header">
@@ -131,7 +133,7 @@
     }
 
     .header-title-section h1 {
-        font-family: var(--nexus-font-serif, 'Outfit', 'Georgia', serif);
+        font-family: var(--nexus-font-serif);
         font-size: 2.8rem;
         font-weight: 700;
         margin: 0 0 0.5rem 0;
@@ -148,11 +150,13 @@
 
     .intelligence-layout {
         padding: 2.5rem;
-        border-radius: var(--nexus-radius-lg, 16px);
-        background: rgba(15, 23, 42, 0.4);
-        border: 1px solid rgba(255, 255, 255, 0.08);
-        backdrop-filter: blur(20px);
-        box-shadow: 0 20px 50px rgba(0, 0, 0, 0.3);
+        border-radius: 20px;
+        background: rgba(255, 255, 255, 0.03);
+        border: 1px solid rgba(255, 255, 255, 0.05);
+        backdrop-filter: blur(10px);
+        -webkit-backdrop-filter: blur(10px);
+        box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
     }
 
     .search-scope-bar {
@@ -166,16 +170,17 @@
     .search-input-group {
         flex-grow: 1;
         display: flex;
-        background: rgba(15, 23, 42, 0.5);
-        border: 1px solid rgba(255, 255, 255, 0.1);
-        border-radius: 30px;
+        background: rgba(255, 255, 255, 0.02);
+        border: 1px solid rgba(255, 255, 255, 0.05);
+        border-radius: 10px;
         padding: 0.25rem 0.25rem 0.25rem 1.25rem;
-        transition: all 0.3s ease;
+        transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
     }
 
     .search-input-group:focus-within {
-        border-color: var(--nexus-primary, #6366f1);
-        box-shadow: 0 0 10px rgba(99, 102, 241, 0.2);
+        border-color: var(--nexus-neon);
+        background: rgba(0, 255, 153, 0.02);
+        box-shadow: 0 0 15px rgba(0, 255, 153, 0.15);
     }
 
     .nexus-input {
@@ -184,6 +189,7 @@
         border: none;
         color: #ffffff;
         font-size: 1rem;
+        font-family: var(--nexus-font-sans);
         outline: none;
         padding: 0.5rem 0;
     }
@@ -192,8 +198,35 @@
         color: rgba(255, 255, 255, 0.4);
     }
 
+    .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;
+        font-family: var(--nexus-font-sans);
+    }
+
+    .btn-nexus.primary {
+        background: var(--nexus-neon);
+        color: #000000;
+    }
+
+    .btn-nexus:hover:not(:disabled) {
+        transform: translateY(-2px);
+        filter: brightness(1.1);
+        box-shadow: 0 4px 12px rgba(0, 255, 153, 0.3);
+    }
+
+    .btn-nexus:disabled {
+        background: rgba(255, 255, 255, 0.05);
+        color: rgba(255, 255, 255, 0.3);
+        cursor: not-allowed;
+    }
+
     .search-btn {
-        border-radius: 25px !important;
         padding: 0.5rem 1.5rem !important;
         font-size: 0.95rem !important;
         display: flex;
@@ -205,22 +238,33 @@
         display: flex;
         align-items: center;
         gap: 0.75rem;
-        color: rgba(255, 255, 255, 0.7);
+        color: #A0A0A0;
+        font-family: var(--nexus-font-sans);
     }
 
     .nexus-select {
-        background: rgba(15, 23, 42, 0.6);
-        border: 1px solid rgba(255, 255, 255, 0.1);
+        background: rgba(255, 255, 255, 0.02);
+        border: 1px solid rgba(255, 255, 255, 0.05);
         color: #ffffff;
-        padding: 0.5rem 1.5rem 0.5rem 1rem;
-        border-radius: 20px;
+        padding: 0.5rem 2.5rem 0.5rem 1rem;
+        border-radius: 10px;
         outline: none;
         cursor: pointer;
+        font-family: var(--nexus-font-sans);
+        font-size: 0.9rem;
         transition: all 0.3s ease;
+        appearance: none;
+        -webkit-appearance: none;
+        background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='white' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3e%3cpolyline points='6 9 12 15 18 9'%3e%3c/polyline%3e%3c/svg%3e");
+        background-repeat: no-repeat;
+        background-position: right 1rem center;
+        background-size: 1em;
     }
 
     .nexus-select:focus {
-        border-color: var(--nexus-primary, #6366f1);
+        border-color: var(--nexus-neon);
+        background-color: rgba(0, 255, 153, 0.02);
+        box-shadow: 0 0 10px rgba(0, 255, 153, 0.15);
     }
 
     .results-area {
@@ -241,10 +285,11 @@
     .nexus-spinner {
         width: 50px;
         height: 50px;
-        border: 3px solid rgba(99, 102, 241, 0.1);
+        border: 3px solid rgba(0, 255, 153, 0.1);
         border-radius: 50%;
-        border-top-color: var(--nexus-primary, #6366f1);
+        border-top-color: var(--nexus-neon);
         animation: spin 1s linear infinite;
+        filter: drop-shadow(0 0 8px var(--nexus-neon));
     }
 
     .welcome-state, .empty-state {
@@ -297,7 +342,7 @@
         font-size: 1.15rem;
         line-height: 1.7;
         color: #ffffff;
-        background: rgba(255, 255, 255, 0.03);
+        background: rgba(255, 255, 255, 0.02);
         padding: 1.5rem;
         border-radius: 12px;
         border: 1px solid rgba(255, 255, 255, 0.05);
@@ -310,7 +355,7 @@
     }
 
     .citation-card {
-        background: rgba(15, 23, 42, 0.4);
+        background: rgba(255, 255, 255, 0.01);
         border: 1px solid rgba(255, 255, 255, 0.05);
         border-radius: 12px;
         padding: 1.25rem;
@@ -318,8 +363,10 @@
     }
 
     .citation-card:hover {
-        border-color: rgba(99, 102, 241, 0.3);
+        border-color: rgba(0, 255, 153, 0.3);
         transform: translateY(-2px);
+        background: rgba(255, 255, 255, 0.05);
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.2);
     }
 
     .citation-header {
@@ -332,8 +379,9 @@
     .source-badge {
         font-size: 0.8rem;
         font-weight: 600;
-        color: var(--nexus-primary, #6366f1);
-        background: rgba(99, 102, 241, 0.1);
+        color: var(--nexus-neon);
+        background: rgba(0, 255, 153, 0.05);
+        border: 1px solid rgba(0, 255, 153, 0.2);
         padding: 0.25rem 0.75rem;
         border-radius: 20px;
     }
@@ -422,7 +470,10 @@
                 ebookId = parsedId;
             }
 
-            var result = await KnowledgeService.AskQuestionAsync(_question, "tenantId", ebookId);
+            var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+            var tenantId = authState.User.FindFirst("TenantId")?.Value ?? "global";
+
+            var result = await KnowledgeService.AskQuestionAsync(_question, tenantId, ebookId);
             if (result.IsSuccess)
             {
                 _response = result.Value;

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

@@ -0,0 +1,370 @@
+@page "/serilog-demo"
+@inject ILogger<SerilogDemo> Logger
+@inject IJSRuntime JSRuntime
+
+<div class="serilog-demo-container">
+    <div class="header-card">
+        <div class="header-content">
+            <NexusIcon Name="cpu" Size="36" Class="header-icon" />
+            <div class="header-text">
+                <h1>Serilog Logging Infrastructure</h1>
+                <p class="subtitle">Production-grade diagnostic pipeline for unified native & web logs</p>
+            </div>
+        </div>
+        <div class="status-badge">
+            <span class="status-dot green"></span>
+            <span class="status-text">Pipeline Active</span>
+        </div>
+    </div>
+
+    <div class="demo-grid">
+        <!-- Native .NET Logging Panel -->
+        <div class="control-card">
+            <div class="card-header">
+                <NexusIcon Name="terminal" Size="20" Class="card-icon" />
+                <h2>Native .NET Logs (C#)</h2>
+            </div>
+            <p class="card-desc">Trigger structured C# logs using Dependency Injected ILogger.</p>
+            <div class="btn-group">
+                <button class="btn btn-info" @onclick="LogInfo">
+                    <NexusIcon Name="info" Size="16" />
+                    Log Info
+                </button>
+                <button class="btn btn-warning" @onclick="LogWarning">
+                    <NexusIcon Name="alert-triangle" Size="16" />
+                    Log Warning
+                </button>
+                <button class="btn btn-error" @onclick="LogError">
+                    <NexusIcon Name="x-circle" Size="16" />
+                    Log Error Exception
+                </button>
+            </div>
+        </div>
+
+        <!-- Blazor / JS Interop Bridge Panel -->
+        <div class="control-card">
+            <div class="card-header">
+                <NexusIcon Name="globe" Size="20" Class="card-icon js-icon" />
+                <h2>Blazor / JS WebView Logs</h2>
+            </div>
+            <p class="card-desc">Trigger logs from JavaScript to verify the interop error capture bridge.</p>
+            <div class="btn-group">
+                <button class="btn btn-js-info" @onclick="TriggerJsLog">
+                    <NexusIcon Name="message-square" Size="16" />
+                    Trigger console.log()
+                </button>
+                <button class="btn btn-js-error" @onclick="TriggerJsException">
+                    <NexusIcon Name="zap" Size="16" />
+                    Trigger JS Exception
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Active Log Config Panel -->
+    <div class="config-card">
+        <div class="card-header">
+            <NexusIcon Name="settings" Size="20" Class="card-icon" />
+            <h2>Pipeline Diagnostics</h2>
+        </div>
+        <div class="config-grid">
+            <div class="config-item">
+                <span class="label">Rolling Daily File Sandbox Path</span>
+                <span class="value code-value">AppDataDirectory/logs/log-*.txt</span>
+            </div>
+            <div class="config-item">
+                <span class="label">Active Configuration Provider</span>
+                <span class="value">Serilog.Settings.Configuration (appsettings.json)</span>
+            </div>
+            <div class="config-item">
+                <span class="label">Native Apple Console Sink</span>
+                <span class="value">Serilog.Sinks.Debug (conditional compilation)</span>
+            </div>
+            <div class="config-item">
+                <span class="label">Native Android Logcat Sink</span>
+                <span class="value">AndroidLogcatSink (direct JNI bindings)</span>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+.serilog-demo-container {
+    padding: 2rem;
+    max-width: 1200px;
+    margin: 0 auto;
+    color: #e2e8f0;
+    font-family: 'Inter', system-ui, -apple-system, sans-serif;
+}
+
+.header-card {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: linear-gradient(135deg, rgba(30, 41, 59, 0.7) 0%, rgba(15, 23, 42, 0.8) 100%);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: 16px;
+    padding: 2rem;
+    margin-bottom: 2rem;
+    backdrop-filter: blur(12px);
+    box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
+}
+
+.header-content {
+    display: flex;
+    align-items: center;
+    gap: 1.5rem;
+}
+
+.header-icon {
+    color: #6366f1;
+    filter: drop-shadow(0 0 8px rgba(99, 102, 241, 0.5));
+}
+
+.header-text h1 {
+    font-size: 1.8rem;
+    font-weight: 700;
+    margin: 0;
+    background: linear-gradient(to right, #ffffff, #94a3b8);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+
+.subtitle {
+    margin: 0.25rem 0 0 0;
+    color: #94a3b8;
+    font-size: 0.95rem;
+}
+
+.status-badge {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    background: rgba(16, 185, 129, 0.1);
+    border: 1px solid rgba(16, 185, 129, 0.2);
+    padding: 0.5rem 1rem;
+    border-radius: 9999px;
+}
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+}
+
+.status-dot.green {
+    background-color: #10b981;
+    box-shadow: 0 0 8px #10b981;
+}
+
+.status-text {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: #10b981;
+}
+
+.demo-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+@@media (max-width: 768px) {
+    .demo-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+.control-card {
+    background: rgba(30, 41, 59, 0.45);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 16px;
+    padding: 2rem;
+    backdrop-filter: blur(8px);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    margin-bottom: 1rem;
+}
+
+.card-icon {
+    color: #6366f1;
+}
+
+.js-icon {
+    color: #eab308;
+}
+
+.card-header h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    margin: 0;
+}
+
+.card-desc {
+    color: #94a3b8;
+    font-size: 0.9rem;
+    margin-bottom: 1.5rem;
+    line-height: 1.5;
+}
+
+.btn-group {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 1rem;
+}
+
+.btn {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.25rem;
+    border-radius: 8px;
+    font-size: 0.85rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    border: none;
+}
+
+.btn-info {
+    background-color: rgba(99, 102, 241, 0.1);
+    color: #818cf8;
+    border: 1px solid rgba(99, 102, 241, 0.2);
+}
+
+.btn-info:hover {
+    background-color: #6366f1;
+    color: white;
+}
+
+.btn-warning {
+    background-color: rgba(245, 158, 11, 0.1);
+    color: #fbbf24;
+    border: 1px solid rgba(245, 158, 11, 0.2);
+}
+
+.btn-warning:hover {
+    background-color: #f59e0b;
+    color: white;
+}
+
+.btn-error {
+    background-color: rgba(239, 68, 68, 0.1);
+    color: #f87171;
+    border: 1px solid rgba(239, 68, 68, 0.2);
+}
+
+.btn-error:hover {
+    background-color: #ef4444;
+    color: white;
+}
+
+.btn-js-info {
+    background-color: rgba(234, 179, 8, 0.1);
+    color: #fef08a;
+    border: 1px solid rgba(234, 179, 8, 0.2);
+}
+
+.btn-js-info:hover {
+    background-color: #eab308;
+    color: #0f172a;
+}
+
+.btn-js-error {
+    background-color: rgba(236, 72, 153, 0.1);
+    color: #fbcfe8;
+    border: 1px solid rgba(236, 72, 153, 0.2);
+}
+
+.btn-js-error:hover {
+    background-color: #ec4899;
+    color: white;
+}
+
+.config-card {
+    background: rgba(15, 23, 42, 0.5);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    border-radius: 16px;
+    padding: 2rem;
+}
+
+.config-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1.5rem;
+    margin-top: 1.5rem;
+}
+
+@@media (max-width: 768px) {
+    .config-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+.config-item {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.config-item .label {
+    font-size: 0.8rem;
+    color: #64748b;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-weight: 600;
+}
+
+.config-item .value {
+    font-size: 0.95rem;
+    color: #cbd5e1;
+}
+
+.code-value {
+    font-family: 'Fira Code', 'Courier New', Courier, monospace;
+    background: rgba(0, 0, 0, 0.2);
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+    word-break: break-all;
+}
+</style>
+
+@code {
+    private void LogInfo()
+    {
+        Logger.LogInformation("Structured native log triggered by user from SerilogDemo. Button: LogInfo");
+    }
+
+    private void LogWarning()
+    {
+        Logger.LogWarning("Potential warning log triggered from Blazor razor component at {Time}", DateTime.UtcNow);
+    }
+
+    private void LogError()
+    {
+        try
+        {
+            throw new InvalidOperationException("Simulated native C# operation exception triggered in Diagnostic dashboard.");
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "Captured exception successfully in native Serilog pipeline!");
+        }
+    }
+
+    private async Task TriggerJsLog()
+    {
+        await JSRuntime.InvokeVoidAsync("console.log", "Intercepted JS console statement from Blazor WebView interop trigger!");
+    }
+
+    private async Task TriggerJsException()
+    {
+        await JSRuntime.InvokeVoidAsync("eval", "throw new Error('Simulated runtime JS Exception triggered from Blazor UI button click!');");
+    }
+}

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

@@ -2,16 +2,63 @@
 @attribute [Authorize]
 
 <div class="settings-page">
-    <h1>Ustawienia</h1>
-    <p>Konfiguracja Twojego konta i preferencji czytania.</p>
+    <h1>Settings</h1>
+    <p>Configure your account and application preferences.</p>
+
+    <div class="settings-section">
+        <h2>Diagnostics & System Logs</h2>
+        <p>Inspect native logging infrastructure, trigger custom logs, and trace WebView errors.</p>
+        <a class="diag-btn" href="/serilog-demo">
+            <NexusIcon Name="cpu" Size="16" />
+            Open Serilog Diagnostics Dashboard
+        </a>
+    </div>
 </div>
 
 <style>
     .settings-page {
         padding: 2rem;
+        color: #e2e8f0;
+        font-family: 'Inter', sans-serif;
     }
     h1 {
-        margin-bottom: 1rem;
+        margin-bottom: 0.5rem;
         color: #fff;
     }
+    h2 {
+        margin-top: 2rem;
+        font-size: 1.2rem;
+        color: #fff;
+        margin-bottom: 0.5rem;
+    }
+    .settings-section {
+        background: rgba(30, 41, 59, 0.45);
+        border: 1px solid rgba(255, 255, 255, 0.05);
+        padding: 1.5rem;
+        border-radius: 12px;
+        margin-top: 1.5rem;
+    }
+    .settings-section p {
+        color: #94a3b8;
+        font-size: 0.9rem;
+        margin-bottom: 1.25rem;
+    }
+    .diag-btn {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.5rem;
+        background: rgba(99, 102, 241, 0.1);
+        color: #818cf8;
+        border: 1px solid rgba(99, 102, 241, 0.2);
+        padding: 0.75rem 1.25rem;
+        border-radius: 8px;
+        text-decoration: none;
+        font-size: 0.85rem;
+        font-weight: 600;
+        transition: all 0.2s ease;
+    }
+    .diag-btn:hover {
+        background: #6366f1;
+        color: white;
+    }
 </style>

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

@@ -6,6 +6,7 @@ public interface IReaderNavigationService
     int CurrentChapterIndex { get; }
     int TotalChapters { get; }
     string ChapterTitle { get; }
+    string? PendingScrollBlockId { get; set; }
 
     event Func<Task>? OnNavigationChanged;
 

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

@@ -7,5 +7,6 @@ public interface ISyncService
     Task<Result> InitializeAsync();
     Task<Result> UpdateProgressAsync(string pageId, Guid ebookId, double progress, string? chapterTitle, int chapterIndex);
     event Func<string, DateTime, Task> OnProgressReceived;
+    event Func<string, double, Task>? OnIngestionProgressReceived;
     Task DisposeAsync();
 }

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

@@ -249,6 +249,25 @@ public class IdentityService : IIdentityService
         }
     }
 
+    public void ClearCache()
+    {
+        _cachedProfile = null;
+        if (OnStateInvalidated != null)
+        {
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await OnStateInvalidated.Invoke();
+                }
+                catch
+                {
+                    // Ignore exceptions from event handlers
+                }
+            });
+        }
+    }
+
     private class LoginResponse
     {
         public string TokenType { get; set; } = string.Empty;

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

@@ -17,6 +17,8 @@ public sealed partial class KnowledgeCoordinator : IDisposable
     private readonly IReaderInteractionService _interactionService;
     private readonly ILogger<KnowledgeCoordinator> _logger;
     
+    public string CurrentFullPageContent { get; private set; } = string.Empty;
+    
     /// <summary>
     /// Raised when the knowledge graph has been updated with new data.
     /// Subscribers must return a Task to enable proper async handling.
@@ -77,6 +79,7 @@ public sealed partial class KnowledgeCoordinator : IDisposable
     {
         if (string.IsNullOrWhiteSpace(fullContent)) return;
 
+        CurrentFullPageContent = fullContent;
         LogGeneratingGraph(tenantId);
         
         await _graphService.Clear();
@@ -94,11 +97,15 @@ public sealed partial class KnowledgeCoordinator : IDisposable
                     if (OnGraphUpdated != null)
                         await OnGraphUpdated.Invoke(packet.Graph);
                     await _platformService.VibrateSuccessAsync();
+                    return;
                 }
             }
+            
+            await _graphService.SetLoading(false);
         }
         catch (Exception ex)
         {
+            await _graphService.SetLoading(false);
             LogGraphError(ex, tenantId);
         }
     }
@@ -144,6 +151,7 @@ public sealed partial class KnowledgeCoordinator : IDisposable
 
     public async Task ClearAsync()
     {
+        CurrentFullPageContent = string.Empty;
         await _graphService.Clear();
         await _quizService.SetQuiz(null, null);
     }

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

@@ -15,6 +15,7 @@ public class ReaderNavigationService : IReaderNavigationService
     public int CurrentChapterIndex { get; private set; } = 0;
     public int TotalChapters { get; private set; } = 1;
     public string ChapterTitle { get; private set; } = "Loading...";
+    public string? PendingScrollBlockId { get; set; }
 
     public event Func<Task>? OnNavigationChanged;
 

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

@@ -16,6 +16,7 @@ public class SyncService : ISyncService, IAsyncDisposable
     private CancellationTokenSource? _debounceCts;
 
     public event Func<string, DateTime, Task>? OnProgressReceived;
+    public event Func<string, double, Task>? OnIngestionProgressReceived;
 
     public SyncService(
         HttpClient httpClient,
@@ -53,6 +54,11 @@ public class SyncService : ISyncService, IAsyncDisposable
             if (OnProgressReceived != null) await OnProgressReceived(pageId, timestamp);
         });
 
+        _hubConnection.On<string, double>("IngestionProgress", async (message, progress) =>
+        {
+            if (OnIngestionProgressReceived != null) await OnIngestionProgressReceived(message, progress);
+        });
+
         try
         {
             await _hubConnection.StartAsync();

src/NexusReader.UI.Shared/wwwroot/js/knowledgeGraph.js

@@ -3,6 +3,110 @@ import * as d3 from 'https://esm.sh/d3@7';
 const getDisplayLabel = d => d.label.length > 20 ? d.label.substring(0, 17) + "..." : d.label;
 const getPillWidth = d => getDisplayLabel(d).length * 8 + 30;
 
+const getNodeType = d => {
+    if (d) {
+        if (d.type) {
+            const t = d.type.toLowerCase();
+            if (t === 'definition') return 'definition';
+            if (t === 'table') return 'table';
+            if (t === 'rule') return 'rule';
+            if (t === 'section') return 'section';
+        }
+        if (d.group) {
+            const g = d.group.toLowerCase();
+            if (g === 'definition') return 'definition';
+            if (g === 'table') return 'table';
+            if (g === 'rule') return 'rule';
+            if (g === 'section') return 'section';
+        }
+    }
+    return null;
+};
+
+const getNodeGroup = d => {
+    if (d && d.group) {
+        const g = d.group.toLowerCase();
+        if (g === 'bridge') return 'bridge';
+        if (g === 'current') return 'current';
+        if (g === 'concept') return 'concept';
+    }
+    return 'concept'; // fallback
+};
+
+const getCategoryStyle = d => {
+    const type = getNodeType(d);
+    const group = getNodeGroup(d);
+
+    // 1. Rule (red/coral)
+    if (type === 'rule') {
+        return {
+            color: '#ff4646',
+            fill: 'rgba(255, 70, 70, 0.1)',
+            opacity: 0.8,
+            glowKey: 'rule',
+            textColor: '#ff8b8b'
+        };
+    }
+    // 2. Definition (gold/amber)
+    if (type === 'definition') {
+        return {
+            color: '#ffb03a',
+            fill: 'rgba(255, 176, 58, 0.1)',
+            opacity: 0.8,
+            glowKey: 'definition',
+            textColor: '#ffd18c'
+        };
+    }
+    // 3. Table (purple/magenta)
+    if (type === 'table') {
+        return {
+            color: '#d946ef',
+            fill: 'rgba(217, 70, 239, 0.1)',
+            opacity: 0.8,
+            glowKey: 'table',
+            textColor: '#f5d0fe'
+        };
+    }
+    // 4. Section (blue/indigo)
+    if (type === 'section') {
+        return {
+            color: '#3b82f6',
+            fill: 'rgba(59, 130, 246, 0.1)',
+            opacity: 0.8,
+            glowKey: 'section',
+            textColor: '#93c5fd'
+        };
+    }
+    // 5. Bridge (cyan/comparison)
+    if (group === 'bridge') {
+        return {
+            color: '#06b6d4',
+            fill: 'rgba(6, 182, 212, 0.1)',
+            opacity: 0.7,
+            glowKey: 'bridge',
+            textColor: '#67e8f9'
+        };
+    }
+    // 6. Current (active/focus landmark - neon green)
+    if (group === 'current') {
+        return {
+            color: 'var(--nexus-neon)',
+            fill: 'rgba(0, 255, 153, 0.15)',
+            opacity: 0.9,
+            glowKey: 'current',
+            textColor: '#ffffff'
+        };
+    }
+    // 7. Concept / Default (subtle cool steel blue/teal)
+    return {
+        color: '#00d2c4',
+        fill: 'rgba(0, 210, 196, 0.05)',
+        opacity: 0.4,
+        glowKey: 'concept',
+        textColor: '#e0e0e0'
+    };
+};
+
 let simulation;
 let zoomBehavior;
 let svgElement;
@@ -24,8 +128,10 @@ export function mount(containerId, data, dotNetHelper) {
         .attr("height", "100%")
         .style("background", "radial-gradient(circle, #1a1a1a 0%, #121212 100%)");
 
-    // Radial gradient for Nebula effect
+    // Radial gradients for Nebula effects
     const defs = svgElement.append("defs");
+    
+    // Fallback radial gradient for legacy nebulaGlow
     const radialGradient = defs.append("radialGradient")
         .attr("id", "nebulaGlow")
         .attr("cx", "50%")
@@ -34,6 +140,26 @@ export function mount(containerId, data, dotNetHelper) {
     radialGradient.append("stop").attr("offset", "0%").attr("stop-color", "var(--nexus-neon)").attr("stop-opacity", 1);
     radialGradient.append("stop").attr("offset", "100%").attr("stop-color", "var(--nexus-neon)").attr("stop-opacity", 0);
 
+    const colors = {
+        'rule': '#ff4646',
+        'definition': '#ffb03a',
+        'table': '#d946ef',
+        'section': '#3b82f6',
+        'bridge': '#06b6d4',
+        'current': 'var(--nexus-neon)',
+        'concept': '#00d2c4'
+    };
+
+    Object.entries(colors).forEach(([key, color]) => {
+        const radGrad = defs.append("radialGradient")
+            .attr("id", `nebulaGlow-${key}`)
+            .attr("cx", "50%")
+            .attr("cy", "50%")
+            .attr("r", "50%");
+        radGrad.append("stop").attr("offset", "0%").attr("stop-color", color).attr("stop-opacity", 1);
+        radGrad.append("stop").attr("offset", "100%").attr("stop-color", color).attr("stop-opacity", 0);
+    });
+
     // Root Group for Zoom
     rootGroup = svgElement.append("g").attr("class", "zoom-containment");
 
@@ -135,21 +261,33 @@ export function updateData(data) {
         }
     });
 
+    // Sanitize links to filter out any references to non-existent nodes
+    const nodeIds = new Set(data.nodes.map(n => n.id));
+    const validLinks = (data.links || []).filter(l => {
+        const srcId = typeof l.source === 'object' ? l.source.id : l.source;
+        const tgtId = typeof l.target === 'object' ? l.target.id : l.target;
+        return nodeIds.has(srcId) && nodeIds.has(tgtId);
+    });
+
     // Update Links
     link = rootGroup.select(".links-layer")
         .selectAll("path")
-        .data(data.links, d => d.source + "-" + d.target + "-" + d.relationType)
+        .data(validLinks, d => {
+            const srcId = typeof d.source === 'object' ? d.source.id : d.source;
+            const tgtId = typeof d.target === 'object' ? d.target.id : d.target;
+            return srcId + "-" + tgtId + "-" + d.type;
+        })
         .join(
             enter => enter.append("path")
                 .attr("stroke", d => {
-                    if (d.relationType === 'Defines') return 'var(--nexus-accent)';
-                    if (d.relationType === 'Next') return 'rgba(255,255,255,0.2)';
-                    if (d.relationType === 'Contains') return 'var(--nexus-neon)';
+                    if (d.type === 'Defines' || d.type === 'maps_to') return 'var(--nexus-accent, #00ffaa)';
+                    if (d.type === 'Next' || d.type === 'relates_to') return 'rgba(255,255,255,0.2)';
+                    if (d.type === 'Contains' || d.type === 'contains') return 'var(--nexus-neon)';
                     return 'rgba(255,255,255,0.1)';
                 })
                 .attr("fill", "none")
-                .attr("stroke-width", d => d.relationType === 'Defines' ? 2 : 1)
-                .attr("stroke-dasharray", d => d.relationType === 'References' ? "5,5" : "0")
+                .attr("stroke-width", d => (d.type === 'Defines' || d.type === 'maps_to') ? 2 : 1)
+                .attr("stroke-dasharray", d => d.type === 'References' ? "5,5" : "0")
                 .style("opacity", 0)
                 .call(enter => enter.transition().duration(500).style("opacity", 1)),
             update => update,
@@ -174,13 +312,8 @@ export function updateData(data) {
 
                 g.append("circle")
                     .attr("r", 30)
-                    .attr("fill", d => {
-                        if (d.type === 'Definition') return 'var(--nexus-accent)';
-                        if (d.type === 'Table') return 'var(--nexus-neon)';
-                        if (d.type === 'Rule') return '#ff4444';
-                        return "url(#nebulaGlow)";
-                    })
-                    .attr("opacity", d => d.group === 'current' ? 0.6 : 0.2);
+                    .attr("fill", d => `url(#nebulaGlow-${getCategoryStyle(d).glowKey})`)
+                    .attr("opacity", d => getCategoryStyle(d).opacity);
 
                 g.append("rect")
                     .attr("class", "node-pill")
@@ -189,23 +322,20 @@ export function updateData(data) {
                     .attr("width", d => getPillWidth(d))
                     .attr("height", 30)
                     .attr("rx", 15)
-                    .attr("fill", "rgba(20, 20, 20, 0.9)")
-                    .attr("stroke", d => {
-                        if (d.type === 'Definition') return 'var(--nexus-accent)';
-                        if (d.type === 'Rule') return '#ff4444';
-                        return "rgba(255, 255, 255, 0.1)";
-                    })
-                    .attr("stroke-width", 1);
+                    .attr("fill", "rgba(20, 20, 20, 0.95)")
+                    .attr("stroke", d => getCategoryStyle(d).color)
+                    .attr("stroke-width", d => getNodeGroup(d) === 'current' ? 2 : 1.2);
 
                 g.append("text")
                     .text(d => getDisplayLabel(d))
                     .attr("text-anchor", "middle")
                     .attr("y", 5)
-                    .attr("fill", d => d.type === 'Definition' ? 'var(--nexus-accent)' : '#ccc')
-                    .attr("font-size", "0.8rem");
+                    .attr("fill", d => getCategoryStyle(d).textColor)
+                    .attr("font-size", "0.8rem")
+                    .attr("font-weight", d => getNodeGroup(d) === 'current' ? '600' : 'normal');
 
                 g.append("title")
-                    .text(d => d.label);
+                    .text(d => d.description ? `${d.label}\n\n${d.description}` : d.label);
                 
                 g.transition().duration(500).style("opacity", 1);
                 
@@ -216,7 +346,7 @@ export function updateData(data) {
         );
 
     simulation.nodes(data.nodes);
-    simulation.force("link").links(data.links);
+    simulation.force("link").links(validLinks);
     simulation.alpha(0.5).restart();
 
     // Trigger zoom to fit after a short delay to allow simulation to settle
@@ -398,6 +528,15 @@ export function clear() {
             }
             simulation.nodes([]);
         }
+
+        // Reset selections
+        link = null;
+        node = null;
+
+        // Reset D3 zoom transform to clean identity state
+        if (svgElement && zoomBehavior) {
+            svgElement.call(zoomBehavior.transform, d3.zoomIdentity);
+        }
     } catch (e) {
         console.warn("Failed to clear force simulation safely:", e);
     }

src/NexusReader.Web.Client/Program.cs

@@ -51,6 +51,7 @@ builder.Services.AddSingleton<IEmbeddingGenerator<string, Embedding<float>>>(new
 builder.Services.AddSingleton<IBookStorageService>(new ThrowingBookStorageService());
 builder.Services.AddSingleton<IEbookRepository>(new ThrowingEbookRepository());
 builder.Services.AddSingleton<ISyncBroadcaster>(new ThrowingSyncBroadcaster());
+builder.Services.AddSingleton<IEpubExtractor>(new ThrowingEpubExtractor());
 
 builder.Services.AddApplication();
 builder.Services.AddScoped<IEpubReader, WasmEpubReader>();
@@ -99,3 +100,9 @@ public class ThrowingSyncBroadcaster : ISyncBroadcaster
     public Task BroadcastIngestionProgressAsync(string userId, string message, double progress, CancellationToken cancellationToken = default)
         => throw new NotSupportedException("Real-time broadcasting can only be performed by the server.");
 }
+
+public class ThrowingEpubExtractor : IEpubExtractor
+{
+    public Task<FluentResults.Result<List<string>>> ExtractChaptersTextAsync(string relativePath, CancellationToken cancellationToken = default)
+        => throw new NotSupportedException("EPUB text extraction is not supported in the WASM client.");
+}

src/NexusReader.Web/Program.cs

@@ -194,6 +194,7 @@ using (var scope = app.Services.CreateScope())
 
             await dbContext.Database.MigrateAsync();
             await DbInitializer.SeedAsync(services);
+            await TriggerBackgroundProcessingForUnindexedBooksAsync(services);
 
             if (logger.IsEnabled(LogLevel.Information))
             {
@@ -337,13 +338,16 @@ app.MapPost("/api/library/ingest", async ([FromBody] IngestEbookRequest request,
         ? Convert.FromBase64String(request.CoverImageBase64) 
         : null;
 
+    var tenantId = user.FindFirst("TenantId")?.Value ?? "global";
+
     var command = new IngestEbookCommand(
         request.Title,
         request.AuthorName,
         coverData,
         epubData,
         request.Description,
-        userId
+        userId,
+        tenantId
     );
 
     var result = await mediator.Send(command);
@@ -563,6 +567,50 @@ app.MapRazorComponents<App>()
 
 app.Run();
 
+async Task TriggerBackgroundProcessingForUnindexedBooksAsync(IServiceProvider services)
+{
+    var logger = services.GetRequiredService<ILogger<Program>>();
+    try
+    {
+        var dbContextFactory = services.GetRequiredService<IDbContextFactory<NexusReader.Data.Persistence.AppDbContext>>();
+        using var dbContext = await dbContextFactory.CreateDbContextAsync();
+        
+        var unindexedEbooks = await dbContext.Ebooks
+            .Where(e => !e.IsReadyForReading)
+            .ToListAsync();
+            
+        if (unindexedEbooks.Any())
+        {
+            logger.LogInformation("[Startup] Found {Count} un-indexed ebooks. Triggering background processing...", unindexedEbooks.Count);
+            
+            foreach (var ebook in unindexedEbooks)
+            {
+                logger.LogInformation("[Startup] Queuing background processing for ebook: '{Title}' ({Id})", ebook.Title, ebook.Id);
+                
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        using var scope = services.CreateScope();
+                        var scopedMediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+                        await scopedMediator.Send(new ProcessEbookCommand(ebook.Id, ebook.UserId, ebook.TenantId));
+                    }
+                    catch (Exception ex)
+                    {
+                        using var scope = services.CreateScope();
+                        var scopedLogger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
+                        scopedLogger.LogError(ex, "Failed to run background processing for ebook {EbookId} on startup", ebook.Id);
+                    }
+                });
+            }
+        }
+    }
+    catch (Exception ex)
+    {
+        logger.LogError(ex, "Error checking or triggering background processing for unindexed books on startup.");
+    }
+}
+
 public record KnowledgeRequest(string Text, Guid? EbookId = null);
 public record GroundednessRequest(string Answer, string Context);
 public record SemanticSearchRequest(string QueryText, int Limit = 5);

src/NexusReader.Web/Services/ServerIdentityService.cs

@@ -118,4 +118,22 @@ public class ServerIdentityService : IIdentityService
 
         return Result.Ok(result.Value);
     }
+
+    public void ClearCache()
+    {
+        if (OnStateInvalidated != null)
+        {
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await OnStateInvalidated.Invoke();
+                }
+                catch
+                {
+                    // Ignore
+                }
+            });
+        }
+    }
 }

tests/NexusReader.Application.Tests/Commands/SubmitQuizResultCommandHandlerTests.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+using NexusReader.Application.Commands.Quiz;
+using NexusReader.Data.Persistence;
+using NexusReader.Domain.Entities;
+using Xunit;
+
+namespace NexusReader.Application.Tests.Commands;
+
+public class SubmitQuizResultCommandHandlerTests : IDisposable
+{
+    private readonly SqliteConnection _connection;
+    private readonly DbContextOptions<AppDbContext> _contextOptions;
+    private readonly Mock<IDbContextFactory<AppDbContext>> _dbContextFactoryMock;
+
+    public SubmitQuizResultCommandHandlerTests()
+    {
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
+
+        _contextOptions = new DbContextOptionsBuilder<AppDbContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        using var context = new AppDbContext(_contextOptions);
+        context.Database.EnsureCreated();
+
+        _dbContextFactoryMock = new Mock<IDbContextFactory<AppDbContext>>();
+        _dbContextFactoryMock.Setup(f => f.CreateDbContextAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(() => new AppDbContext(_contextOptions));
+    }
+
+    [Fact]
+    public async Task Handle_WithValidRequest_PersistsQuizResultToDatabase()
+    {
+        // Arrange
+        using (var context = new AppDbContext(_contextOptions))
+        {
+            var user = new NexusUser
+            {
+                Id = "user-abc",
+                UserName = "testuser",
+                Email = "test@example.com",
+                TenantId = "tenant-xyz",
+                SubscriptionPlanId = 1
+            };
+            context.Users.Add(user);
+            await context.SaveChangesAsync();
+        }
+
+        var command = new SubmitQuizResultCommand(
+            UserId: "user-abc",
+            Topic: "Sprawdzian: .NET 10",
+            Score: 4,
+            TotalQuestions: 5
+        );
+
+        var handler = new SubmitQuizResultCommandHandler(_dbContextFactoryMock.Object);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+
+        using (var context = new AppDbContext(_contextOptions))
+        {
+            var quizResult = await context.QuizResults.FirstOrDefaultAsync(q => q.UserId == "user-abc");
+            quizResult.Should().NotBeNull();
+            quizResult!.Topic.Should().Be("Sprawdzian: .NET 10");
+            quizResult.Score.Should().Be(4);
+            quizResult.TotalQuestions.Should().Be(5);
+            quizResult.TenantId.Should().Be("tenant-xyz");
+        }
+    }
+
+    [Fact]
+    public async Task Handle_WithNonExistentUser_ReturnsFailureResult()
+    {
+        // Arrange
+        var command = new SubmitQuizResultCommand(
+            UserId: "non-existent",
+            Topic: "Sprawdzian: .NET 10",
+            Score: 4,
+            TotalQuestions: 5
+        );
+
+        var handler = new SubmitQuizResultCommandHandler(_dbContextFactoryMock.Object);
+
+        // Act
+        var result = await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        result.IsFailed.Should().BeTrue();
+        result.Errors.Should().ContainSingle(e => e.Message == "User not found.");
+    }
+
+    public void Dispose()
+    {
+        _connection.Dispose();
+    }
+}

tests/NexusReader.Application.Tests/Queries/QueryTests.cs

@@ -116,11 +116,8 @@ public class QueryTests : IDisposable
     public async Task SearchLibrarySemanticallyQuery_WithEmptyQueryText_ReturnsFailure()
     {
         // Arrange
-        var handler = new SearchLibrarySemanticallyQueryHandler(
-            _embeddingGeneratorMock.Object,
-            _dbContextFactoryMock.Object,
-            _pipelineProviderMock.Object,
-            _mapperMock.Object);
+        var knowledgeServiceMock = new Mock<IKnowledgeService>();
+        var handler = new SearchLibrarySemanticallyQueryHandler(knowledgeServiceMock.Object);
         var query = new SearchLibrarySemanticallyQuery("", "tenant-123");
 
         // Act
@@ -132,39 +129,38 @@ public class QueryTests : IDisposable
     }
 
     [Fact]
-    public async Task SearchLibrarySemanticallyQuery_WithValidQuery_GeneratesEmbeddingAndQueriesDatabase()
+    public async Task SearchLibrarySemanticallyQuery_WithValidQuery_CallsKnowledgeService()
     {
         // Arrange
         var queryText = "test query";
         var tenantId = "tenant-123";
+        var expectedResponse = new List<SemanticSearchResultDto>
+        {
+            new SemanticSearchResultDto
+            {
+                Snippet = "Matched content",
+                RelevanceScore = 0.95f,
+                SourceBookTitle = "Test Book"
+            }
+        };
 
-        var mockEmbedding = new Embedding<float>(new float[768]);
-        var mockResponse = new GeneratedEmbeddings<Embedding<float>>(new[] { mockEmbedding });
-        _embeddingGeneratorMock.Setup(g => g.GenerateAsync(
-            It.Is<IEnumerable<string>>(s => s.Contains(queryText)),
-            It.IsAny<EmbeddingGenerationOptions>(),
-            It.IsAny<CancellationToken>()))
-            .ReturnsAsync(mockResponse);
-
-        var handler = new SearchLibrarySemanticallyQueryHandler(
-            _embeddingGeneratorMock.Object,
-            _dbContextFactoryMock.Object,
-            _pipelineProviderMock.Object,
-            _mapperMock.Object);
+        var knowledgeServiceMock = new Mock<IKnowledgeService>();
+        knowledgeServiceMock.Setup(s => s.SearchLibrarySemanticallyAsync(queryText, tenantId, 5, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Result.Ok(expectedResponse));
 
+        var handler = new SearchLibrarySemanticallyQueryHandler(knowledgeServiceMock.Object);
         var query = new SearchLibrarySemanticallyQuery(queryText, tenantId);
 
         // Act
-        Func<Task> act = async () => await handler.Handle(query, CancellationToken.None);
+        var result = await handler.Handle(query, CancellationToken.None);
 
-        // Assert (SQLite provider will throw an execution/translation exception since CosineDistance is not supported,
-        // which confirms that the query built successfully and attempted execution!)
-        await act.Should().ThrowAsync<Exception>();
+        // Assert
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().HaveCount(1);
+        result.Value.First().Snippet.Should().Be("Matched content");
+        result.Value.First().SourceBookTitle.Should().Be("Test Book");
 
-        _embeddingGeneratorMock.Verify(g => g.GenerateAsync(
-            It.Is<IEnumerable<string>>(s => s.Contains(queryText)),
-            It.IsAny<EmbeddingGenerationOptions>(),
-            It.IsAny<CancellationToken>()), Times.Once);
+        knowledgeServiceMock.Verify(s => s.SearchLibrarySemanticallyAsync(queryText, tenantId, 5, It.IsAny<CancellationToken>()), Times.Once);
     }
 
     [Fact]