diff --git a/DebugProbe.AspNetCore.Tests/BodyCaptureConsistencyTests.cs b/DebugProbe.AspNetCore.Tests/BodyCaptureConsistencyTests.cs
new file mode 100644
index 0000000..71bcbfc
--- /dev/null
+++ b/DebugProbe.AspNetCore.Tests/BodyCaptureConsistencyTests.cs
@@ -0,0 +1,118 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text;
+using DebugProbe.AspNetCore.Handlers;
+using DebugProbe.AspNetCore.Middleware;
+using DebugProbe.AspNetCore.Models;
+using DebugProbe.AspNetCore.Options;
+using DebugProbe.AspNetCore.Storage;
+
+namespace DebugProbe.AspNetCore.Tests;
+
+public class BodyCaptureConsistencyTests
+{
+    [Theory]
+    [InlineData("empty")]
+    [InlineData("under")]
+    [InlineData("exact")]
+    [InlineData("over")]
+    [InlineData("utf8-boundary")]
+    [InlineData("utf16-boundary")]
+    [InlineData("charset")]
+    [InlineData("invalid-charset")]
+    [InlineData("unsupported-charset")]
+    [InlineData("binary")]
+    [InlineData("redacted")]
+    [InlineData("truncated-redacted")]
+    public async Task All_four_capture_paths_use_the_same_rules_and_preserve_the_payload(string scenario)
+    {
+        var text = scenario switch
+        {
+            "empty" => "",
+            "exact" => new string('a', 1024),
+            "over" => new string('a', 1500),
+            "utf8-boundary" => new string('a', 1023) + "€tail",
+            "utf16-boundary" => new string('a', 511) + "😀tail",
+            "charset" => "café",
+            "redacted" => "{\"password\":\"secret\",\"name\":\"Ada\"}",
+            "truncated-redacted" => "{\"password\":\"secret\",\"padding\":\"" + new string('a', 1500) + "\"}",
+            _ => "hello"
+        };
+        var encoding = scenario == "charset" ? Encoding.Latin1 : scenario == "utf16-boundary" ? Encoding.Unicode : Encoding.UTF8;
+        var contentType = scenario switch
+        {
+            "charset" => "text/plain; charset=iso-8859-1",
+            "utf16-boundary" => "text/plain; charset=utf-16",
+            "invalid-charset" => "text/plain; charset=not-a-real-charset",
+            "unsupported-charset" => "text/plain; charset=utf-7",
+            "binary" => "application/octet-stream",
+            "redacted" or "truncated-redacted" => "application/json; charset=utf-8",
+            _ => "text/plain; charset=utf-8"
+        };
+        var expected = scenario switch
+        {
+            "over" => new string('a', 1024) + "[truncated]",
+            "utf8-boundary" => new string('a', 1023) + "[truncated]",
+            "utf16-boundary" => new string('a', 511) + "[truncated]",
+            "binary" => "[Body not captured: non-text content]",
+            "redacted" => "{\"password\":\"[REDACTED]\",\"name\":\"Ada\"}",
+            "truncated-redacted" => "[Body not captured: truncated content cannot be redacted]",
+            _ => text
+        };
+        var bytes = encoding.GetBytes(text);
+        var options = new DebugProbeOptions
+        {
+            MaxBodySizeKb = 1,
+            RedactedJsonFields = scenario.Contains("redacted") ? ["password"] : []
+        };
+        var context = new DefaultHttpContext();
+        context.Request.Method = "POST";
+        context.Request.Path = "/echo";
+        context.Request.ContentType = contentType;
+        // No Content-Length: the limit must also work for chunked requests.
+        context.Request.Body = new MemoryStream(bytes);
+        context.Response.Body = new MemoryStream();
+        context.Response.ContentType = contentType;
+        var store = new DebugEntryStore(options);
+        var middleware = new DebugProbeMiddleware(async ctx =>
+        {
+            using var received = new MemoryStream();
+            await ctx.Request.Body.CopyToAsync(received);
+            Assert.Equal(bytes, received.ToArray());
+            await ctx.Response.Body.WriteAsync(bytes);
+        }, options);
+
+        await middleware.Invoke(context, store);
+        var incoming = Assert.Single(store.GetAll());
+        Assert.Equal(expected, incoming.RequestBody);
+        Assert.Equal(expected, incoming.ResponseBody);
+        Assert.Equal(bytes, ((MemoryStream)context.Response.Body).ToArray());
+
+        var entry = new DebugEntry();
+        context.Items["DebugProbeEntry"] = entry;
+        using var client = new HttpClient(new DebugProbeHttpClientHandler(new HttpContextAccessor { HttpContext = context }, options)
+        {
+            InnerHandler = new EchoHandler()
+        });
+        using var content = new ByteArrayContent(bytes);
+        content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
+        using var response = await client.PostAsync("https://example.test/echo", content);
+        Assert.Equal(bytes, await response.Content.ReadAsByteArrayAsync());
+        var outgoing = Assert.Single(entry.OutgoingRequests);
+        Assert.Equal(expected, outgoing.RequestBody);
+        Assert.Equal(expected, outgoing.ResponseBody);
+    }
+
+    private sealed class EchoHandler : HttpMessageHandler
+    {
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            var response = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new ByteArrayContent(await request.Content!.ReadAsByteArrayAsync(cancellationToken))
+            };
+            response.Content.Headers.ContentType = request.Content.Headers.ContentType;
+            return response;
+        }
+    }
+}
diff --git a/DebugProbe.AspNetCore.Tests/CaptureFailureIsolationTests.cs b/DebugProbe.AspNetCore.Tests/CaptureFailureIsolationTests.cs
new file mode 100644
index 0000000..d88f1bc
--- /dev/null
+++ b/DebugProbe.AspNetCore.Tests/CaptureFailureIsolationTests.cs
@@ -0,0 +1,209 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text;
+using DebugProbe.AspNetCore.Handlers;
+using DebugProbe.AspNetCore.Internal.Streams;
+using DebugProbe.AspNetCore.Middleware;
+using DebugProbe.AspNetCore.Models;
+using DebugProbe.AspNetCore.Options;
+using DebugProbe.AspNetCore.Storage;
+
+namespace DebugProbe.AspNetCore.Tests;
+
+public class CaptureFailureIsolationTests
+{
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Incoming_capture_read_failure_preserves_body_and_runs_application_once(bool seekable)
+    {
+        var context = CreateContext();
+        context.Request.Method = "POST";
+        context.Request.ContentType = "text/plain";
+        context.Request.Body = new FailOnceStream(seekable);
+        var calls = 0;
+        var middleware = new DebugProbeMiddleware(async ctx =>
+        {
+            calls++;
+            using var reader = new StreamReader(ctx.Request.Body, leaveOpen: true);
+            Assert.Equal("hello", await reader.ReadToEndAsync());
+            await ctx.Response.WriteAsync("ok");
+        }, new DebugProbeOptions());
+
+        await middleware.Invoke(context, new DebugEntryStore(new DebugProbeOptions()));
+
+        Assert.Equal(1, calls);
+        Assert.Equal("ok", Encoding.UTF8.GetString(((MemoryStream)context.Response.Body).ToArray()));
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Finalization_failure_preserves_response_or_original_application_exception(bool failApplication)
+    {
+        var context = CreateContext();
+        var originalBody = context.Response.Body;
+        var options = new DebugProbeOptions();
+        var store = new DebugEntryStore(options);
+        var originalException = new InvalidOperationException("application failed");
+        var calls = 0;
+        var middleware = new DebugProbeMiddleware(async ctx =>
+        {
+            calls++;
+            await ctx.Response.WriteAsync("original response");
+            // Simulate a diagnostics-only failure while formatting captured headers.
+            ctx.Request.Headers["X-Test"] = "value";
+            options.RedactedHeaders = null!;
+            if (failApplication)
+                throw originalException;
+        }, options);
+
+        if (failApplication)
+            Assert.Same(originalException, await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(context, store)));
+        else
+            await middleware.Invoke(context, store);
+
+        Assert.Equal(1, calls);
+        Assert.Same(originalBody, context.Response.Body);
+        Assert.Equal("original response", Encoding.UTF8.GetString(((MemoryStream)originalBody).ToArray()));
+        Assert.False(context.Items.ContainsKey("DebugProbeEntry"));
+        Assert.Empty(store.GetAll());
+    }
+
+    [Fact]
+    public async Task Exception_formatting_failure_does_not_replace_application_exception()
+    {
+        var original = new UnformattableException();
+        var context = CreateContext();
+        var originalBody = context.Response.Body;
+        var middleware = new DebugProbeMiddleware(_ => throw original, new DebugProbeOptions());
+
+        Assert.Same(original, await Assert.ThrowsAsync<UnformattableException>(() =>
+            middleware.Invoke(context, new DebugEntryStore(new DebugProbeOptions()))));
+        Assert.Same(originalBody, context.Response.Body);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Outgoing_partial_capture_failure_replays_all_response_bytes(bool seekable)
+    {
+        var context = CreateContext();
+        var entry = new DebugEntry();
+        context.Items["DebugProbeEntry"] = entry;
+        var response = new HttpResponseMessage(HttpStatusCode.Accepted)
+        {
+            Content = new StreamContent(new FailOnceStream(seekable))
+        };
+        response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
+        response.Headers.Add("X-Original", "yes");
+        var transport = new StubHandler(_ => Task.FromResult(response));
+        using var client = CreateClient(context, transport);
+
+        using var result = await client.GetAsync("https://example.test", HttpCompletionOption.ResponseHeadersRead);
+
+        Assert.Same(response, result);
+        Assert.Equal(HttpStatusCode.Accepted, result.StatusCode);
+        Assert.Equal("yes", Assert.Single(result.Headers.GetValues("X-Original")));
+        Assert.Equal("hello", await result.Content.ReadAsStringAsync());
+        Assert.Equal(1, transport.Calls);
+        Assert.Empty(entry.OutgoingRequests);
+    }
+
+    [Fact]
+    public async Task Outgoing_capture_failure_does_not_replace_transport_exception()
+    {
+        var original = new UnformattableException();
+        var context = CreateContext();
+        context.Items["DebugProbeEntry"] = new DebugEntry();
+        var transport = new StubHandler(_ => throw original);
+        using var client = CreateClient(context, transport);
+
+        Assert.Same(original, await Assert.ThrowsAsync<UnformattableException>(() => client.GetAsync("https://example.test")));
+        Assert.Equal(1, transport.Calls);
+    }
+
+    [Fact]
+    public async Task Transport_cancellation_is_not_swallowed()
+    {
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        var context = CreateContext();
+        context.Items["DebugProbeEntry"] = new DebugEntry();
+        var transport = new StubHandler(_ => Task.FromCanceled<HttpResponseMessage>(cancellation.Token));
+        using var client = CreateClient(context, transport);
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.GetAsync("https://example.test"));
+        Assert.Equal(1, transport.Calls);
+    }
+
+    [Fact]
+    public async Task Diagnostic_copy_failure_does_not_block_response_writes()
+    {
+        using var original = new MemoryStream();
+        var capture = new BoundedResponseCaptureStream(original, 32);
+        capture.Dispose(); // Make the diagnostic memory buffer unavailable.
+
+        await capture.WriteAsync("hello"u8.ToArray());
+
+        Assert.Equal("hello", Encoding.UTF8.GetString(original.ToArray()));
+    }
+
+    [Fact]
+    public async Task Application_response_stream_errors_are_not_swallowed()
+    {
+        using var original = new MemoryStream();
+        using var capture = new BoundedResponseCaptureStream(original, 32);
+        original.Dispose();
+
+        await Assert.ThrowsAsync<ObjectDisposedException>(async () => await capture.WriteAsync("hello"u8.ToArray()));
+    }
+
+    private static DefaultHttpContext CreateContext()
+    {
+        var context = new DefaultHttpContext();
+        context.Request.Method = "GET";
+        context.Request.Path = "/test";
+        context.Request.Scheme = "http";
+        context.Request.Host = new HostString("example.test");
+        context.Response.ContentType = "text/plain";
+        context.Response.Body = new MemoryStream();
+        return context;
+    }
+
+    private static HttpClient CreateClient(HttpContext context, HttpMessageHandler transport) => new(
+        new DebugProbeHttpClientHandler(new HttpContextAccessor { HttpContext = context }, new DebugProbeOptions())
+        {
+            InnerHandler = transport
+        });
+
+    private sealed class UnformattableException : Exception
+    {
+        public override string ToString() => throw new InvalidOperationException("diagnostic formatting failed");
+    }
+
+    private sealed class StubHandler(Func<HttpRequestMessage, Task<HttpResponseMessage>> send) : HttpMessageHandler
+    {
+        public int Calls { get; private set; }
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            Calls++;
+            return send(request);
+        }
+    }
+
+    // Consume a prefix, fail once without consuming data, then let the application read normally.
+    private sealed class FailOnceStream(bool seekable) : MemoryStream("hello"u8.ToArray())
+    {
+        private int _reads;
+        public override bool CanSeek => seekable;
+
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            _reads++;
+            if (_reads == 2)
+                throw new IOException("capture read failed");
+            return base.ReadAsync(_reads == 1 ? buffer[..Math.Min(2, buffer.Length)] : buffer, cancellationToken);
+        }
+    }
+}
diff --git a/DebugProbe.AspNetCore.Tests/ConcurrencyTests.cs b/DebugProbe.AspNetCore.Tests/ConcurrencyTests.cs
new file mode 100644
index 0000000..bce66f4
--- /dev/null
+++ b/DebugProbe.AspNetCore.Tests/ConcurrencyTests.cs
@@ -0,0 +1,134 @@
+using System.Net;
+using System.Text.Json;
+using DebugProbe.AspNetCore.Models;
+using DebugProbe.AspNetCore.Options;
+using DebugProbe.AspNetCore.Storage;
+using DebugProbe.AspNetCore.Tests.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace DebugProbe.AspNetCore.Tests;
+
+public class ConcurrencyTests
+{
+    [Fact]
+    public async Task Parallel_adds_preserve_all_counts_and_keep_latest_requests()
+    {
+        const int total = 2000;
+        const int limit = 20;
+        var store = new DebugEntryStore(new DebugProbeOptions { MaxRequests = limit });
+
+        await Parallel.ForAsync(0, total, (i, _) =>
+        {
+            store.Add(new DebugEntry { Id = i.ToString(), ResponseBody = "System.Exception: same failure" });
+            Assert.InRange(store.GetAll().Count, 1, limit);
+            return ValueTask.CompletedTask;
+        });
+
+        Assert.Equal(limit, store.GetAll().Count);
+        Assert.Equal(limit, store.GetAll().Select(entry => entry.Id).Distinct().Count());
+        Assert.Equal(total, Assert.Single(store.ExceptionGroups.Values).Count);
+    }
+
+    [Fact]
+    public async Task Parallel_add_clear_and_reads_remain_bounded_and_consistent()
+    {
+        const int limit = 10;
+        var store = new DebugEntryStore(new DebugProbeOptions { MaxRequests = limit });
+        var remoteEnvironment = new DebugEnvironment { Environment = "remote" };
+
+        await Parallel.ForAsync(0, 2000, (i, _) =>
+        {
+            if (i % 7 == 0)
+                store.Clear();
+            else
+                store.Add(new DebugEntry { Id = i.ToString(), ResponseBody = $"Type{i}Exception: failure" }, remoteEnvironment);
+
+            var requests = store.GetAll();
+            var groups = store.ExceptionGroups;
+            Assert.InRange(requests.Count, 0, limit);
+            Assert.InRange(groups.Count, 0, limit);
+            foreach (var entry in requests)
+            {
+                store.Get(entry.Id);
+                store.GetEnvironment(entry);
+            }
+            Assert.All(groups, pair => Assert.Equal(pair.Key, pair.Value.Fingerprint));
+            return ValueTask.CompletedTask;
+        });
+
+        var previous = store.GetAll();
+        store.Clear();
+        Assert.Empty(store.GetAll());
+        Assert.Empty(store.ExceptionGroups);
+        Assert.All(previous, entry => Assert.Same(store.Environment, store.GetEnvironment(entry)));
+        store.Add(new DebugEntry { Id = "fresh", ResponseBody = "System.Exception: fresh" });
+        Assert.Equal("fresh", Assert.Single(store.GetAll()).Id);
+        Assert.Equal(1, Assert.Single(store.ExceptionGroups.Values).Count);
+    }
+
+    [Fact]
+    public void Exception_group_snapshots_remain_stable_after_updates_and_clear()
+    {
+        var store = new DebugEntryStore(new DebugProbeOptions());
+        var entry = new DebugEntry { Id = "test", ResponseBody = "System.Exception: failure" };
+        store.Add(entry);
+        var snapshot = store.ExceptionGroups;
+        store.Add(entry);
+        Assert.Equal(1, Assert.Single(snapshot.Values).Count);
+        Assert.Equal(2, Assert.Single(store.ExceptionGroups.Values).Count);
+        store.Clear();
+        Assert.Single(snapshot);
+    }
+
+    [Fact]
+    public async Task Parallel_http_calls_are_recorded_once_and_attached_to_the_correct_request()
+    {
+        const int requestCount = 12;
+        const int outgoingCount = 64;
+        await using var app = await DebugProbeTestApp.CreateAsync(
+            endpoints => endpoints.MapGet("/proxy/{id}", async (string id, IHttpClientFactory factory) =>
+            {
+                using var client = factory.CreateClient("remote");
+                await Task.WhenAll(Enumerable.Range(0, outgoingCount).Select(async i =>
+                {
+                    using var response = await client.GetAsync($"https://remote.test/{id}/{i}");
+                    response.EnsureSuccessStatusCode();
+                }));
+                return Results.Text("ok");
+            }),
+            options =>
+            {
+                options.MaxRequests = requestCount;
+                options.CaptureRequestBody = false;
+                options.CaptureResponseBody = false;
+            },
+            configureServices: services => services.AddHttpClient("remote")
+                .ConfigurePrimaryHttpMessageHandler(() => new ParallelHandler()));
+
+        await Task.WhenAll(Enumerable.Range(0, requestCount).Select(async id =>
+            Assert.Equal("ok", await app.Client.GetStringAsync($"/proxy/{id}"))));
+
+        var requests = app.Store.GetAll();
+        Assert.Equal(requestCount, requests.Count);
+        foreach (var entry in requests)
+        {
+            var id = entry.Path.Split('/').Last();
+            Assert.Equal(outgoingCount, entry.OutgoingRequests.Count);
+            Assert.Equal(outgoingCount, entry.OutgoingRequests.Select(call => call.Url).Distinct().Count());
+            Assert.All(entry.OutgoingRequests, call => Assert.StartsWith($"https://remote.test/{id}/", call.Url));
+
+            // Remote comparison uses System.Text.Json to round-trip captured traces.
+            var copy = JsonSerializer.Deserialize<DebugEntry>(JsonSerializer.Serialize(entry))!;
+            Assert.Equal(entry.OutgoingRequests.Select(call => call.Url), copy.OutgoingRequests.Select(call => call.Url));
+        }
+    }
+
+    private sealed class ParallelHandler : HttpMessageHandler
+    {
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            await Task.Yield();
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("ok") };
+        }
+    }
+}
diff --git a/DebugProbe.AspNetCore.Tests/Configuration/DebugProbeOptionsTests.cs b/DebugProbe.AspNetCore.Tests/Configuration/DebugProbeOptionsTests.cs
index a63b99b..bf8d2f1 100644
--- a/DebugProbe.AspNetCore.Tests/Configuration/DebugProbeOptionsTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Configuration/DebugProbeOptionsTests.cs
@@ -2,6 +2,7 @@
 using DebugProbe.AspNetCore.Options;
 using DebugProbe.AspNetCore.Storage;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 
 namespace DebugProbe.AspNetCore.Tests.Configuration;
 
@@ -12,17 +13,19 @@ public void Defaults_work_correctly()
     {
         var options = new DebugProbeOptions();
 
-        Assert.Equal(20, options.MaxEntries);
-        Assert.Equal(32, options.MaxBodyCaptureSizeKb);
+        Assert.Equal(20, options.MaxRequests);
+        Assert.Equal(32, options.MaxBodySizeKb);
         Assert.Null(options.AllowLocalCompareTargets);
         Assert.False(options.AllowUiInProduction);
         Assert.Null(options.AuthorizationPolicy);
-        Assert.True(options.CaptureOutgoingHttpClientRequests);
-        Assert.Empty(options.IgnorePaths);
+        Assert.True(options.CaptureOutgoingRequests);
+        Assert.Contains("/health", options.ExcludedPaths);
+        Assert.True(options.Enabled);
+        Assert.True(options.CaptureRequestBody);
+        Assert.True(options.CaptureResponseBody);
         Assert.Equal(["Authorization", "Cookie", "Set-Cookie"], options.RedactedHeaders);
         Assert.Empty(options.RedactedQueryParameters);
         Assert.Empty(options.RedactedJsonFields);
-        Assert.Equal("[REDACTED]", options.RedactionText);
     }
 
     [Fact]
@@ -32,97 +35,83 @@ public void Custom_options_are_registered_and_used()
 
         services.AddDebugProbe(options =>
         {
-            options.MaxEntries = 2;
-            options.MaxBodyCaptureSizeKb = 4;
+            options.MaxRequests = 2;
+            options.MaxBodySizeKb = 4;
             options.AllowLocalCompareTargets = true;
             options.AuthorizationPolicy = "DebugProbePolicy";
-            options.IgnorePaths = ["/health"];
-            options.CaptureOutgoingHttpClientRequests = false;
+            options.ExcludedPaths = ["/health"];
+            options.CaptureOutgoingRequests = false;
             options.RedactedHeaders = ["X-Api-Key"];
             options.RedactedQueryParameters = ["token"];
             options.RedactedJsonFields = ["password"];
-            options.RedactionText = "***";
         });
 
         using var provider = services.BuildServiceProvider();
         var options = provider.GetRequiredService<DebugProbeOptions>();
         var store = provider.GetRequiredService<DebugEntryStore>();
 
-        Assert.Equal(2, options.MaxEntries);
-        Assert.Equal(4, options.MaxBodyCaptureSizeKb);
+        Assert.Equal(2, options.MaxRequests);
+        Assert.Equal(4, options.MaxBodySizeKb);
         Assert.True(options.AllowLocalCompareTargets);
         Assert.Equal("DebugProbePolicy", options.AuthorizationPolicy);
-        Assert.Equal(["/health"], options.IgnorePaths);
-        Assert.False(options.CaptureOutgoingHttpClientRequests);
+        Assert.Equal(["/health"], options.ExcludedPaths);
+        Assert.False(options.CaptureOutgoingRequests);
         Assert.Equal(["X-Api-Key"], options.RedactedHeaders);
         Assert.Equal(["token"], options.RedactedQueryParameters);
         Assert.Equal(["password"], options.RedactedJsonFields);
-        Assert.Equal("***", options.RedactionText);
         Assert.NotNull(store.Environment);
     }
-    [Fact]
-    public void MaxEntries_zero_throws_InvalidOperationException()
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    public void Invalid_request_limit_is_rejected(int limit)
     {
         var services = new ServiceCollection();
-
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-            services.AddDebugProbe(options =>
-            {
-                options.MaxEntries = 0;
-            }));
-
-        Assert.Contains("MaxEntries", exception.Message);
+        services.AddDebugProbe(options => options.MaxRequests = limit);
+        using var provider = services.BuildServiceProvider();
+        var exception = Assert.Throws<OptionsValidationException>(() => provider.GetRequiredService<DebugProbeOptions>());
+        Assert.Contains("MaxRequests", exception.Message);
     }
 
-    [Fact]
-    public void MaxEntries_negative_throws_InvalidOperationException()
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(int.MaxValue)]
+    public void Invalid_body_limit_is_rejected(int limit)
     {
         var services = new ServiceCollection();
-
-        var exception = Assert.Throws<InvalidOperationException>(() =>
-            services.AddDebugProbe(options =>
-            {
-                options.MaxEntries = -1;
-            }));
-
-        Assert.Contains("MaxEntries", exception.Message);
-    }
-
-    [Fact]
-    public void MaxBodyCaptureSizeKb_negative_throws_ArgumentOutOfRangeException()
-    {
-        var options = new DebugProbeOptions();
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => options.MaxBodyCaptureSizeKb = -1);
+        services.AddDebugProbe(options => options.MaxBodySizeKb = limit);
+        using var provider = services.BuildServiceProvider();
+        var exception = Assert.Throws<OptionsValidationException>(() => provider.GetRequiredService<DebugProbeOptions>());
+        Assert.Contains("MaxBodySizeKb", exception.Message);
     }
 
     [Fact]
-    public void MaxBodyCaptureSizeKb_zero_is_valid()
+    public void MaxBodySizeKb_zero_is_valid()
     {
         var options = new DebugProbeOptions();
-        options.MaxBodyCaptureSizeKb = 0;
+        options.MaxBodySizeKb = 0;
 
-        Assert.Equal(0, options.MaxBodyCaptureSizeKb);
+        Assert.Equal(0, options.MaxBodySizeKb);
     }
 
     [Fact]
-    public void SlowRequestThresholdMs_defaults_to_1000()
+    public void SlowRequestThreshold_defaults_to_1000()
     {
         var options = new DebugProbeOptions();
-        Assert.Equal(1000, options.SlowRequestThresholdMs);
+        Assert.Equal(TimeSpan.FromSeconds(1), options.SlowRequestThreshold);
     }
 
     [Fact]
-    public void SlowRequestThresholdMs_can_be_configured()
+    public void SlowRequestThreshold_can_be_configured()
     {
         var services = new ServiceCollection();
         services.AddDebugProbe(options =>
         {
-            options.SlowRequestThresholdMs = 500;
+            options.SlowRequestThreshold = TimeSpan.FromMilliseconds(500);
         });
 
         using var provider = services.BuildServiceProvider();
         var options = provider.GetRequiredService<DebugProbeOptions>();
-        Assert.Equal(500, options.SlowRequestThresholdMs);
+        Assert.Equal(TimeSpan.FromMilliseconds(500), options.SlowRequestThreshold);
     }
 }
diff --git a/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeAuthorizationEndpointTests.cs b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeAuthorizationEndpointTests.cs
index 630a33c..34f12a0 100644
--- a/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeAuthorizationEndpointTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeAuthorizationEndpointTests.cs
@@ -55,7 +55,7 @@ public async Task Debug_endpoints_require_configured_authorization_policy()
                 app.UseAuthentication();
                 app.UseAuthorization();
             },
-            configureUseDebugProbe: options => options.AuthorizationPolicy = "DebugProbePolicy");
+            configureOptions: options => options.AuthorizationPolicy = "DebugProbePolicy");
 
         await app.Client.GetAsync("/hello");
         var traceId = app.SingleEntry.Id;
diff --git a/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeConfigurationTests.cs b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeConfigurationTests.cs
new file mode 100644
index 0000000..d80a66d
--- /dev/null
+++ b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeConfigurationTests.cs
@@ -0,0 +1,88 @@
+using System.Net;
+using DebugProbe.AspNetCore.Extensions;
+using DebugProbe.AspNetCore.Options;
+using DebugProbe.AspNetCore.Tests.Infrastructure;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
+
+namespace DebugProbe.AspNetCore.Tests.Extensions;
+
+public class DebugProbeConfigurationTests
+{
+    [Fact]
+    public async Task Custom_prefix_applies_to_navigation_assets_compare_and_clear()
+    {
+        await using var app = await DebugProbeWebApplication.CreateAsync(
+            Environments.Development,
+            endpoints => endpoints.MapGet("/hello", () => Results.Text("hello")),
+            options => options.RoutePrefix = "tools/probe/");
+
+        await app.Client.GetAsync("/hello");
+        var id = app.SingleEntry.Id;
+        var html = await app.Client.GetStringAsync("/tools/probe");
+        Assert.Contains($"data-url=\"/tools/probe/{id}\"", html);
+        Assert.Contains("src=\"/tools/probe/js/debugprobe-ui.js\"", html);
+        Assert.Contains("data-debugprobe-prefix=\"/tools/probe\"", html);
+        Assert.DoesNotContain("{{route_prefix}}", html);
+        var details = await app.Client.GetStringAsync($"/tools/probe/{id}");
+        Assert.Contains("href=\"/tools/probe\"", details);
+        var compare = await app.Client.GetStringAsync($"/tools/probe/compare?localTraceId={id}");
+        Assert.Contains("data-debugprobe-prefix=\"/tools/probe\"", compare);
+        var script = await app.Client.GetStringAsync("/tools/probe/js/debugprobe-ui.js");
+        Assert.Contains("dataset.debugprobePrefix", script);
+        Assert.DoesNotContain("/debug/clear", script);
+        Assert.Equal(HttpStatusCode.NotFound, (await app.Client.GetAsync("/debug")).StatusCode);
+        Assert.Equal(HttpStatusCode.OK, (await app.Client.PostAsync("/tools/probe/clear", null)).StatusCode);
+        Assert.Empty(app.Store.GetAll());
+    }
+
+    [Fact]
+    public async Task Disabled_probe_leaves_application_working_without_capture_or_endpoints()
+    {
+        await using var app = await DebugProbeWebApplication.CreateAsync(
+            Environments.Development,
+            endpoints => endpoints.MapGet("/hello", () => Results.Text("hello")),
+            options => options.Enabled = false);
+
+        Assert.Equal("hello", await app.Client.GetStringAsync("/hello"));
+        Assert.Equal(HttpStatusCode.NotFound, (await app.Client.GetAsync("/debug")).StatusCode);
+        Assert.Equal(HttpStatusCode.NotFound, (await app.Client.GetAsync("/debug/environment")).StatusCode);
+        Assert.Empty(app.Store.GetAll());
+    }
+
+    [Fact]
+    public void Options_can_be_bound_from_configuration()
+    {
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
+        {
+            ["DebugProbe:MaxRequests"] = "50",
+            ["DebugProbe:RoutePrefix"] = "tools/probe/",
+            ["DebugProbe:SlowRequestThreshold"] = "00:00:02",
+            ["DebugProbe:CaptureResponseBody"] = "false"
+        }).Build();
+        var services = new ServiceCollection();
+        services.AddDebugProbe();
+        services.Configure<DebugProbeOptions>(configuration.GetSection("DebugProbe"));
+        using var provider = services.BuildServiceProvider();
+        var options = provider.GetRequiredService<IOptions<DebugProbeOptions>>().Value;
+        Assert.Same(options, provider.GetRequiredService<DebugProbeOptions>());
+        Assert.Equal(50, options.MaxRequests);
+        Assert.Equal("/tools/probe", options.RoutePrefix);
+        Assert.Equal(TimeSpan.FromSeconds(2), options.SlowRequestThreshold);
+        Assert.False(options.CaptureResponseBody);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("/")]
+    [InlineData("/bad?query")]
+    public void Invalid_prefix_is_rejected(string prefix)
+    {
+        var services = new ServiceCollection();
+        services.AddDebugProbe(options => options.RoutePrefix = prefix);
+        using var provider = services.BuildServiceProvider();
+        Assert.Throws<OptionsValidationException>(() => provider.GetRequiredService<DebugProbeOptions>());
+    }
+}
diff --git a/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeProductionEndpointTests.cs b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeProductionEndpointTests.cs
index 4f2fe84..9897bc8 100644
--- a/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeProductionEndpointTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Extensions/DebugProbeProductionEndpointTests.cs
@@ -15,7 +15,7 @@ public async Task Production_does_not_map_ui_endpoints_by_default()
 
         var capturedResponse = await app.Client.GetAsync("/hello");
         var debugResponse = await app.Client.GetAsync("/debug");
-        var comparePageResponse = await app.Client.GetAsync($"/compare?localTraceId={app.SingleEntry.Id}");
+        var comparePageResponse = await app.Client.GetAsync($"/debug/compare?localTraceId={app.SingleEntry.Id}");
         var scriptResponse = await app.Client.GetAsync("/debug/js/debugprobe-ui.js");
         var logoResponse = await app.Client.GetAsync("/debug/logo.png");
         var environmentResponse = await app.Client.GetAsync("/debug/environment");
@@ -44,7 +44,7 @@ public async Task Production_maps_ui_endpoints_when_explicitly_allowed()
 
         var debugResponse = await app.Client.GetAsync("/debug");
         var detailsResponse = await app.Client.GetAsync($"/debug/{app.SingleEntry.Id}");
-        var comparePageResponse = await app.Client.GetAsync($"/compare?localTraceId={app.SingleEntry.Id}");
+        var comparePageResponse = await app.Client.GetAsync($"/debug/compare?localTraceId={app.SingleEntry.Id}");
         var scriptResponse = await app.Client.GetAsync("/debug/js/debugprobe-ui.js");
         var logoResponse = await app.Client.GetAsync("/debug/logo.png");
         var environmentResponse = await app.Client.GetAsync("/debug/environment");
diff --git a/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerBodyTests.cs b/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerBodyTests.cs
index 15fbe46..d4a3d0c 100644
--- a/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerBodyTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerBodyTests.cs
@@ -9,6 +9,28 @@ namespace DebugProbe.AspNetCore.Tests.Handlers;
 
 public class DebugProbeHttpClientHandlerBodyTests
 {
+    [Theory]
+    [InlineData(false, true, 32)]
+    [InlineData(true, false, 32)]
+    [InlineData(true, true, 0)]
+    public async Task Body_capture_controls_preserve_outgoing_response(bool request, bool response, int limit)
+    {
+        var (client, entry) = BuildClient(new DebugProbeOptions
+        {
+            CaptureRequestBody = request,
+            CaptureResponseBody = response,
+            MaxBodySizeKb = limit
+        }, new StringContent("pong"));
+        using (client)
+        using (var result = await client.PostAsync("https://example.test/", new StringContent("ping")))
+        {
+            Assert.Equal("pong", await result.Content.ReadAsStringAsync());
+            var outgoing = Assert.Single(entry.OutgoingRequests);
+            Assert.Equal(request && limit > 0 ? "ping" : "", outgoing.RequestBody);
+            Assert.Equal(response && limit > 0 ? "pong" : "", outgoing.ResponseBody);
+        }
+    }
+
     // ---------------------------------------------------------------------------
     // Helpers
     // ---------------------------------------------------------------------------
@@ -49,7 +71,7 @@ public async Task Body_under_limit_is_captured_without_truncation_marker()
         const int limitKb = 1;                    // 1 KB limit
         var bodyText = new string('A', 100);      // 100 bytes — well under 1 KB
 
-        var options = new DebugProbeOptions { MaxBodyCaptureSizeKb = limitKb };
+        var options = new DebugProbeOptions { MaxBodySizeKb = limitKb };
         var (client, entry) = BuildClient(options,
             responseContent: new StringContent(bodyText, Encoding.UTF8, "text/plain"));
 
@@ -66,7 +88,7 @@ public async Task Body_exactly_at_limit_is_captured_without_truncation_marker()
         const int limitKb = 1;
         var bodyText = new string('B', 1024);     // exactly 1 KB
 
-        var options = new DebugProbeOptions { MaxBodyCaptureSizeKb = limitKb };
+        var options = new DebugProbeOptions { MaxBodySizeKb = limitKb };
         var (client, entry) = BuildClient(options,
             responseContent: new StringContent(bodyText, Encoding.UTF8, "text/plain"));
 
@@ -83,7 +105,7 @@ public async Task Body_over_limit_is_truncated_and_marker_is_appended()
         const int limitKb = 1;
         var bodyText = new string('C', 2048);     // 2 KB — double the limit
 
-        var options = new DebugProbeOptions { MaxBodyCaptureSizeKb = limitKb };
+        var options = new DebugProbeOptions { MaxBodySizeKb = limitKb };
         var (client, entry) = BuildClient(options,
             responseContent: new StringContent(bodyText, Encoding.UTF8, "text/plain"));
 
@@ -106,7 +128,7 @@ public async Task Capturing_streamed_response_body_does_not_consume_body_for_cal
             CharSet = Encoding.UTF8.WebName
         };
 
-        var options = new DebugProbeOptions { MaxBodyCaptureSizeKb = limitKb };
+        var options = new DebugProbeOptions { MaxBodySizeKb = limitKb };
         var (client, entry) = BuildClient(options, responseContent);
 
         using var response = await client.GetAsync("https://example.test/");
@@ -123,7 +145,7 @@ public async Task Captured_body_uses_content_type_charset()
         const string bodyText = "Hello \u0100";
         var responseContent = new StringContent(bodyText, Encoding.Unicode, "text/plain");
 
-        var options = new DebugProbeOptions { MaxBodyCaptureSizeKb = 1 };
+        var options = new DebugProbeOptions { MaxBodySizeKb = 1 };
         var (client, entry) = BuildClient(options, responseContent);
 
         using var response = await client.GetAsync("https://example.test/");
@@ -159,7 +181,7 @@ public async Task Non_text_content_returns_empty_string()
         await client.GetAsync("https://example.test/");
 
         var outgoing = Assert.Single(entry.OutgoingRequests);
-        Assert.Equal(string.Empty, outgoing.ResponseBody);
+        Assert.Equal("[Body not captured: non-text content]", outgoing.ResponseBody);
     }
 
     // ---------------------------------------------------------------------------
diff --git a/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerTests.cs b/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerTests.cs
index 5c48917..27cf64a 100644
--- a/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Handlers/DebugProbeHttpClientHandlerTests.cs
@@ -48,8 +48,8 @@ public async Task Captures_outgoing_http_call_on_active_trace()
         Assert.True(outgoing.IsSuccessStatusCode);
         Assert.Equal("[REDACTED]", outgoing.RequestHeaders["Authorization"]);
         Assert.Equal("remote", outgoing.ResponseHeaders["X-Trace"]);
-        Assert.Contains("\"name\": \"Ada\"", outgoing.RequestBody);
-        Assert.Contains("\"ok\": true", outgoing.ResponseBody);
+        Assert.Contains("\"name\":\"Ada\"", outgoing.RequestBody);
+        Assert.Contains("\"ok\":true", outgoing.ResponseBody);
     }
 
     [Fact]
@@ -91,8 +91,8 @@ public async Task Redacts_configured_outgoing_url_headers_and_json_fields()
 
         Assert.Equal("https://api.example.test/orders?token=[REDACTED]&safe=yes", outgoing.Url);
         Assert.Equal("[REDACTED]", outgoing.RequestHeaders["X-Api-Key"]);
-        Assert.Contains("\"password\": \"[REDACTED]\"", outgoing.RequestBody);
-        Assert.Contains("\"refreshToken\": \"[REDACTED]\"", outgoing.ResponseBody);
+        Assert.Contains("\"password\":\"[REDACTED]\"", outgoing.RequestBody);
+        Assert.Contains("\"refreshToken\":\"[REDACTED]\"", outgoing.ResponseBody);
     }
 
     private sealed class StubHandler(Func<HttpRequestMessage, HttpResponseMessage> send) : HttpMessageHandler
diff --git a/DebugProbe.AspNetCore.Tests/Handlers/OutgoingHttpClientCaptureOptionsTests.cs b/DebugProbe.AspNetCore.Tests/Handlers/OutgoingHttpClientCaptureOptionsTests.cs
index 4b5aa10..a149d1e 100644
--- a/DebugProbe.AspNetCore.Tests/Handlers/OutgoingHttpClientCaptureOptionsTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Handlers/OutgoingHttpClientCaptureOptionsTests.cs
@@ -21,7 +21,7 @@ public async Task Disabled_outgoing_capture_does_not_store_outgoing_traces()
                     return Results.Text(body);
                 });
             },
-            configureOptions: options => options.CaptureOutgoingHttpClientRequests = false,
+            configureOptions: options => options.CaptureOutgoingRequests = false,
             configureServices: services =>
             {
                 services.AddHttpClient("outgoing")
diff --git a/DebugProbe.AspNetCore.Tests/Infrastructure/DebugProbeWebApplication.cs b/DebugProbe.AspNetCore.Tests/Infrastructure/DebugProbeWebApplication.cs
index 1b6042e..ed1c014 100644
--- a/DebugProbe.AspNetCore.Tests/Infrastructure/DebugProbeWebApplication.cs
+++ b/DebugProbe.AspNetCore.Tests/Infrastructure/DebugProbeWebApplication.cs
@@ -30,8 +30,7 @@ public static async Task<DebugProbeWebApplication> CreateAsync(
         Action<IEndpointRouteBuilder>? mapEndpoints = null,
         Action<DebugProbeOptions>? configureOptions = null,
         Action<IServiceCollection>? configureServices = null,
-        Action<WebApplication>? configureBeforeDebugProbe = null,
-        Action<DebugProbeOptions>? configureUseDebugProbe = null)
+        Action<WebApplication>? configureBeforeDebugProbe = null)
     {
         var builder = WebApplication.CreateBuilder(new WebApplicationOptions
         {
@@ -48,7 +47,7 @@ public static async Task<DebugProbeWebApplication> CreateAsync(
 
         app.UseRouting();
         configureBeforeDebugProbe?.Invoke(app);
-        app.UseDebugProbe(configureUseDebugProbe);
+        app.UseDebugProbe();
 
         mapEndpoints?.Invoke(app);
 
diff --git a/DebugProbe.AspNetCore.Tests/Middleware/MiddlewareExecutionFlowTests.cs b/DebugProbe.AspNetCore.Tests/Middleware/MiddlewareExecutionFlowTests.cs
index 730f86a..fb3a19d 100644
--- a/DebugProbe.AspNetCore.Tests/Middleware/MiddlewareExecutionFlowTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Middleware/MiddlewareExecutionFlowTests.cs
@@ -9,6 +9,43 @@ namespace DebugProbe.AspNetCore.Tests.Middleware;
 
 public class MiddlewareExecutionFlowTests
 {
+    [Theory]
+    [InlineData(false, true, 32)]
+    [InlineData(true, false, 32)]
+    [InlineData(true, true, 0)]
+    public async Task Body_capture_controls_preserve_application_data(bool request, bool response, int limit)
+    {
+        await using var app = await DebugProbeTestApp.CreateAsync(
+            endpoints => endpoints.MapPost("/echo", async (HttpContext context) =>
+            {
+                using var reader = new StreamReader(context.Request.Body);
+                return Results.Text(await reader.ReadToEndAsync());
+            }),
+            options =>
+            {
+                options.CaptureRequestBody = request;
+                options.CaptureResponseBody = response;
+                options.MaxBodySizeKb = limit;
+            });
+
+        using var content = new StringContent("hello");
+        var result = await app.Client.PostAsync("/echo", content);
+        Assert.Equal("hello", await result.Content.ReadAsStringAsync());
+        Assert.Equal(request && limit > 0 ? "hello" : "", app.SingleEntry.RequestBody);
+        Assert.Equal(response && limit > 0 ? "hello" : "", app.SingleEntry.ResponseBody);
+        Assert.Equal(5, app.SingleEntry.ResponseSize);
+    }
+
+    [Fact]
+    public async Task Default_path_exclusions_can_be_removed()
+    {
+        await using var app = await DebugProbeTestApp.CreateAsync(
+            endpoints => endpoints.MapGet("/health", () => Results.Text("ok")),
+            options => options.ExcludedPaths = []);
+        await app.Client.GetAsync("/health");
+        Assert.Equal("/health", app.SingleEntry.Path);
+    }
+
     [Fact]
     public async Task Middleware_executes_and_request_continues_through_pipeline()
     {
@@ -34,7 +71,7 @@ public async Task Ignored_paths_are_skipped()
     {
         await using var app = await DebugProbeTestApp.CreateAsync(
             endpoints => endpoints.MapGet("/health", () => Results.Ok()),
-            options => options.IgnorePaths = ["/health"]);
+            options => options.ExcludedPaths = ["/health"]);
 
         var response = await app.Client.GetAsync("/health");
 
@@ -46,7 +83,7 @@ public async Task Similar_paths_are_not_skipped()
     {
         await using var app = await DebugProbeTestApp.CreateAsync(
             endpoints => endpoints.MapGet("/healthcare", () => Results.Ok()),
-            options => options.IgnorePaths = ["/health"]);
+            options => options.ExcludedPaths = ["/health"]);
 
         var response = await app.Client.GetAsync("/healthcare");
         Assert.Equal(HttpStatusCode.OK, response.StatusCode);
diff --git a/DebugProbe.AspNetCore.Tests/Middleware/RequestBodyCaptureTests.cs b/DebugProbe.AspNetCore.Tests/Middleware/RequestBodyCaptureTests.cs
index cf0183c..a9c886c 100644
--- a/DebugProbe.AspNetCore.Tests/Middleware/RequestBodyCaptureTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Middleware/RequestBodyCaptureTests.cs
@@ -31,7 +31,7 @@ public async Task Handles_empty_request_body()
     [Fact]
     public async Task Handles_large_request_body_within_limit()
     {
-        await using var app = await CreateEchoAppAsync(options => options.MaxBodyCaptureSizeKb = 2);
+        await using var app = await CreateEchoAppAsync(options => options.MaxBodySizeKb = 2);
         var body = new string('a', 1500);
 
         await app.Client.PostAsync("/echo", JsonContent(body));
@@ -42,12 +42,12 @@ public async Task Handles_large_request_body_within_limit()
     [Fact]
     public async Task Respects_max_body_capture_size_for_request()
     {
-        await using var app = await CreateEchoAppAsync(options => options.MaxBodyCaptureSizeKb = 1);
+        await using var app = await CreateEchoAppAsync(options => options.MaxBodySizeKb = 1);
         var body = new string('a', 1200);
 
         await app.Client.PostAsync("/echo", JsonContent(body));
 
-        Assert.Equal("[Body too large]", app.SingleEntry.RequestBody);
+        Assert.Equal(body[..1024] + "[truncated]", app.SingleEntry.RequestBody);
     }
 
     [Fact]
diff --git a/DebugProbe.AspNetCore.Tests/Middleware/ResponseBodyCaptureTests.cs b/DebugProbe.AspNetCore.Tests/Middleware/ResponseBodyCaptureTests.cs
index 17f338b..0327b5a 100644
--- a/DebugProbe.AspNetCore.Tests/Middleware/ResponseBodyCaptureTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Middleware/ResponseBodyCaptureTests.cs
@@ -36,7 +36,7 @@ public async Task Handles_large_response_within_limit()
         var body = new string('x', 1500);
         await using var app = await DebugProbeTestApp.CreateAsync(
             endpoints => endpoints.MapGet("/large", () => Results.Text(body, "text/plain")),
-            options => options.MaxBodyCaptureSizeKb = 2);
+            options => options.MaxBodySizeKb = 2);
 
         await app.Client.GetAsync("/large");
 
@@ -64,13 +64,13 @@ public async Task Validates_bounded_response_capture_behavior()
         var body = new string('x', 1200);
         await using var app = await DebugProbeTestApp.CreateAsync(
             endpoints => endpoints.MapGet("/too-large", () => Results.Text(body, "text/plain")),
-            options => options.MaxBodyCaptureSizeKb = 1);
+            options => options.MaxBodySizeKb = 1);
 
         var response = await app.Client.GetAsync("/too-large");
 
         var entry = app.SingleEntry;
         Assert.Equal(body, await response.Content.ReadAsStringAsync());
-        Assert.Equal("[Body too large]", entry.ResponseBody);
+        Assert.Equal(body[..1024] + "[truncated]", entry.ResponseBody);
         Assert.Equal(body.Length, entry.ResponseSize);
     }
 }
diff --git a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererEnvDiffTests.cs b/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererEnvDiffTests.cs
deleted file mode 100644
index 6bb19d7..0000000
--- a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererEnvDiffTests.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-using System;
-using System.Collections.Generic;
-using DebugProbe.AspNetCore.Internal.Rendering;
-using DebugProbe.AspNetCore.Models;
-using DebugProbe.AspNetCore.Options;
-using DebugProbe.AspNetCore.Storage;
-using Xunit;
-
-[assembly: CollectionBehavior(DisableTestParallelization = true)]
-
-namespace DebugProbe.AspNetCore.Tests.Rendering;
-
-public class HtmlRendererEnvDiffTests
-{
-    [Fact]
-    public void Render_index_page_with_AutoEnvironmentDiff_disabled_does_not_compare()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = false };
-        var store = new DebugEntryStore(options);
-
-        var entry1 = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-5),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        var entry2 = new DebugEntry
-        {
-            Id = "2",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-2),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"error\"}"
-        };
-
-        var devEnv = new DebugEnvironment { Environment = "Development" };
-        var prodEnv = new DebugEnvironment { Environment = "Production" };
-
-        store.Add(entry1, devEnv);
-        store.Add(entry2, prodEnv);
-
-        // Act
-        var html = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-
-        // Assert
-        Assert.DoesNotContain("class=\"dbp-badge dbp-badge-envdiff\"", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_same_environment_shows_no_badge()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = true };
-        var store = new DebugEntryStore(options);
-
-        var entry1 = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-5),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        var entry2 = new DebugEntry
-        {
-            Id = "2",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-2),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"error\"}"
-        };
-
-        var devEnv = new DebugEnvironment { Environment = "Development" };
-
-        store.Add(entry1, devEnv);
-        store.Add(entry2, devEnv);
-
-        // Act
-        var html = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-
-        // Assert
-        Assert.DoesNotContain("class=\"dbp-badge dbp-badge-envdiff\"", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_different_environments_and_identical_payloads_shows_no_badge()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = true };
-        var store = new DebugEntryStore(options);
-
-        var entry1 = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-5),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        var entry2 = new DebugEntry
-        {
-            Id = "2",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-2),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-
-        var devEnv = new DebugEnvironment { Environment = "Development" };
-        var prodEnv = new DebugEnvironment { Environment = "Production" };
-
-        store.Add(entry1, devEnv);
-        store.Add(entry2, prodEnv);
-
-        // Act
-        var html = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-
-        // Assert
-        Assert.DoesNotContain("class=\"dbp-badge dbp-badge-envdiff\"", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_different_environments_and_differing_payloads_shows_badge()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = true };
-        var store = new DebugEntryStore(options);
-
-        var entry1 = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-5),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        var entry2 = new DebugEntry
-        {
-            Id = "2",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-2),
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"error\"}"
-        };
-
-        var devEnv = new DebugEnvironment { Environment = "Development" };
-        var prodEnv = new DebugEnvironment { Environment = "Production" };
-
-        store.Add(entry1, devEnv);
-        store.Add(entry2, prodEnv);
-
-        // Act
-        var html = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-
-        // Assert
-        Assert.Contains("class=\"dbp-badge dbp-badge-envdiff\"", html);
-        Assert.Contains("Payload differences detected between: Production, Development", html);
-    }
-
-    [Fact]
-    public void Route_normalization_matches_slash_and_query_string()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = true };
-        var store = new DebugEntryStore(options);
-
-        // entry1 path has trailing slash, entry2 path has query string. They should normalize to /api/users
-        var entry1 = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-5),
-            Method = "GET",
-            Path = "/api/users/",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        var entry2 = new DebugEntry
-        {
-            Id = "2",
-            Timestamp = DateTimeOffset.UtcNow.AddMinutes(-2),
-            Path = "/api/users?id=123",
-            Method = "GET",
-            ResponseBody = "{\"status\": \"error\"}"
-        };
-
-        var devEnv = new DebugEnvironment { Environment = "Development" };
-        var prodEnv = new DebugEnvironment { Environment = "Production" };
-
-        store.Add(entry1, devEnv);
-        store.Add(entry2, prodEnv);
-
-        // Act
-        var html = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-
-        // Assert
-        Assert.Contains("class=\"dbp-badge dbp-badge-envdiff\"", html);
-    }
-
-    [Fact]
-    public void Empty_store_and_single_entry_show_no_badge()
-    {
-        // Arrange
-        var options = new DebugProbeOptions { AutoEnvironmentDiff = true };
-        var store = new DebugEntryStore(options);
-
-        // Act & Assert (empty)
-        var htmlEmpty = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-        Assert.DoesNotContain("class=\"dbp-badge dbp-badge-envdiff\"", htmlEmpty);
-
-        // Add single entry
-        var entry = new DebugEntry
-        {
-            Id = "1",
-            Timestamp = DateTimeOffset.UtcNow,
-            Method = "GET",
-            Path = "/api/users",
-            ResponseBody = "{\"status\": \"ok\"}"
-        };
-        store.Add(entry, new DebugEnvironment { Environment = "Development" });
-
-        // Act & Assert (single entry)
-        var htmlSingle = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-        Assert.DoesNotContain("class=\"dbp-badge dbp-badge-envdiff\"", htmlSingle);
-    }
-}
diff --git a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTests.cs b/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTests.cs
index 813946e..18acd8e 100644
--- a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTests.cs
@@ -118,7 +118,7 @@ public void Details_page_renders_waterfall_section_with_ruler_and_tooltips_when_
         var entry = CreateEntry();
         entry.DurationMs = 500;
         
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api.test/v1/users?id=123",
@@ -128,7 +128,7 @@ public void Details_page_renders_waterfall_section_with_ruler_and_tooltips_when_
             IsSuccessStatusCode = true
         });
 
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "POST",
             Url = "https://untrusted-api.test/v1/search?query=a&b=%3Cscript%3E",
@@ -171,7 +171,7 @@ public void Details_page_renders_waterfall_section_with_ruler_and_tooltips_when_
     public void Details_page_renders_curl_copy_attributes_and_buttons()
     {
         var entry = CreateEntry();
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "PUT",
             Url = "https://external-api.test/v1/update",
@@ -209,7 +209,7 @@ public void Details_page_renders_curl_copy_attributes_and_buttons()
     public void Details_page_renders_csharp_copy_attributes_and_buttons()
     {
         var entry = CreateEntry();
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "PUT",
             Url = "https://external-api.test/v1/update",
@@ -247,7 +247,7 @@ public void Details_page_renders_csharp_copy_attributes_and_buttons()
     public void Details_page_renders_markdown_copy_attributes_and_buttons()
     {
         var entry = CreateEntry();
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "PUT",
             Url = "https://external-api.test/v1/update",
@@ -291,7 +291,7 @@ public void Render_index_page_with_slow_badge()
         };
 
         // Case 1: Threshold = 1000 (Default)
-        var htmlDefault = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var htmlDefault = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("/debug/1", htmlDefault);
         Assert.Contains("/debug/2", htmlDefault);
         
@@ -299,11 +299,11 @@ public void Render_index_page_with_slow_badge()
         Assert.Contains("1500 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", htmlDefault);
 
         // Case 2: Threshold = 0 (disabled)
-        var htmlDisabled = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 0 });
+        var htmlDisabled = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(0) });
         Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", htmlDisabled);
 
         // Case 3: Threshold = 2000
-        var htmlHigh = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 2000 });
+        var htmlHigh = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(2000) });
         Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", htmlHigh);
     }
 
@@ -312,7 +312,7 @@ public void Render_details_page_with_slow_badge()
     {
         var entry = CreateEntry();
         entry.DurationMs = 1200; // > 1000
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api.test",
@@ -321,7 +321,7 @@ public void Render_details_page_with_slow_badge()
             TimestampUtc = entry.Timestamp.UtcDateTime.AddMilliseconds(200),
             IsSuccessStatusCode = true
         });
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api2.test",
@@ -332,7 +332,7 @@ public void Render_details_page_with_slow_badge()
         });
 
         // Case 1: Threshold = 1000
-        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         
         // Detail Header should have badge
         Assert.Contains("1200 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", html);
@@ -344,7 +344,7 @@ public void Render_details_page_with_slow_badge()
         Assert.Contains("200 ms</div>", html);
 
         // Case 2: Threshold = 0
-        var htmlDisabled = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThresholdMs = 0 });
+        var htmlDisabled = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(0) });
         Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", htmlDisabled);
     }
 
@@ -398,7 +398,7 @@ public void Render_slow_badge_boundary_exact_threshold()
         {
             new DebugEntry { Id = "1", Method = "GET", Path = "/exact", DurationMs = 1000, StatusCode = 200 }
         };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("1000 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", html);
     }
 
@@ -409,7 +409,7 @@ public void Render_slow_badge_boundary_threshold_minus_one()
         {
             new DebugEntry { Id = "1", Method = "GET", Path = "/minus-one", DurationMs = 999, StatusCode = 200 }
         };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("999 ms</td>", html);
         Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", html);
     }
@@ -421,7 +421,7 @@ public void Render_slow_badge_boundary_threshold_plus_one()
         {
             new DebugEntry { Id = "1", Method = "GET", Path = "/plus-one", DurationMs = 1001, StatusCode = 200 }
         };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("1001 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", html);
     }
 
@@ -432,19 +432,7 @@ public void Render_slow_badge_boundary_zero_threshold_disabled()
         {
             new DebugEntry { Id = "1", Method = "GET", Path = "/zero", DurationMs = 5000, StatusCode = 200 }
         };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 0 });
-        Assert.Contains("5000 ms</td>", html);
-        Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", html);
-    }
-
-    [Fact]
-    public void Render_slow_badge_boundary_negative_threshold_disabled()
-    {
-        var items = new List<DebugEntry>
-        {
-            new DebugEntry { Id = "1", Method = "GET", Path = "/negative", DurationMs = 5000, StatusCode = 200 }
-        };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = -100 });
+        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(0) });
         Assert.Contains("5000 ms</td>", html);
         Assert.DoesNotContain("<span class=\"dbp-badge dbp-badge-slow\"", html);
     }
@@ -456,7 +444,7 @@ public void Render_slow_badge_large_duration_formatting()
         {
             new DebugEntry { Id = "1", Method = "GET", Path = "/large", DurationMs = 120500, StatusCode = 200 }
         };
-        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderIndexPage(items, new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("120500 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", html);
     }
 
@@ -465,7 +453,7 @@ public void Render_details_page_independent_outgoing_call_badge_behavior()
     {
         var entry = CreateEntry();
         entry.DurationMs = 500; // < 1000 (not slow)
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api.test",
@@ -475,7 +463,7 @@ public void Render_details_page_independent_outgoing_call_badge_behavior()
             IsSuccessStatusCode = true
         });
 
-        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         
         // Root request should not have the slow badge
         Assert.Contains("<strong>500 ms</strong>", html);
@@ -490,7 +478,7 @@ public void Render_details_page_outgoing_call_boundary_exact()
     {
         var entry = CreateEntry();
         entry.DurationMs = 200;
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api.test",
@@ -500,7 +488,7 @@ public void Render_details_page_outgoing_call_boundary_exact()
             IsSuccessStatusCode = true
         });
 
-        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("1000 ms <span class=\"dbp-badge dbp-badge-slow\" title=\"Exceeds 1000ms threshold\">SLOW</span>", html);
     }
 
@@ -509,7 +497,7 @@ public void Render_details_page_outgoing_call_boundary_minus_one()
     {
         var entry = CreateEntry();
         entry.DurationMs = 200;
-        entry.OutgoingRequests.Add(new DebugOutgoingRequest
+        entry.OutgoingRequests.Enqueue(new DebugOutgoingRequest
         {
             Method = "GET",
             Url = "https://external-api.test",
@@ -519,7 +507,7 @@ public void Render_details_page_outgoing_call_boundary_minus_one()
             IsSuccessStatusCode = true
         });
 
-        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThresholdMs = 1000 });
+        var html = HtmlRenderer.RenderDetailsPage(entry, CreateEnvironment(), "{}", "{}", new DebugProbeOptions { SlowRequestThreshold = TimeSpan.FromMilliseconds(1000) });
         Assert.Contains("999 ms</div>", html);
         Assert.DoesNotContain(" 999 ms <span class=\"dbp-badge dbp-badge-slow\"", html);
     }
diff --git a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTrendTests.cs b/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTrendTests.cs
deleted file mode 100644
index 207e4df..0000000
--- a/DebugProbe.AspNetCore.Tests/Rendering/HtmlRendererTrendTests.cs
+++ /dev/null
@@ -1,218 +0,0 @@
-using System;
-using System.Collections.Generic;
-using DebugProbe.AspNetCore.Internal.Rendering;
-using DebugProbe.AspNetCore.Models;
-using DebugProbe.AspNetCore.Options;
-using Microsoft.Extensions.Options;
-using Xunit;
-using DebugProbe.AspNetCore.Storage;
-
-namespace DebugProbe.AspNetCore.Tests.Rendering;
-
-public class HtmlRendererTrendTests
-{
-    [Fact]
-    public void Render_index_page_with_no_data_generates_flat_sparkline()
-    {
-        var html = HtmlRenderer.RenderIndexPage([], new DebugProbeOptions { TrendLookbackMinutes = 30 });
-
-        // Flat sparkline check: Y values should all be 14
-        Assert.Contains("14", html);
-        Assert.Contains("trend-neutral", html);
-        Assert.Contains("→", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_increased_errors_shows_trend_up()
-    {
-        var now = DateTimeOffset.UtcNow;
-        var options = new DebugProbeOptions { TrendLookbackMinutes = 10 };
-
-        var items = new List<DebugEntry>
-        {
-            // Preceding half: [now - 10m, now - 5m). 1 request, 0 errors -> 0% error rate.
-            new() { Id = "1", Timestamp = now.AddMinutes(-7), StatusCode = 200, Method = "GET", Path = "/api" },
-            // Current half: [now - 5m, now]. 1 request, 1 error -> 100% error rate.
-            new() { Id = "2", Timestamp = now.AddMinutes(-2), StatusCode = 500, Method = "GET", Path = "/api" }
-        };
-
-        var html = HtmlRenderer.RenderIndexPage(items, options);
-
-        Assert.Contains("trend-up", html);
-        Assert.Contains("↑", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_decreased_errors_shows_trend_down()
-    {
-        var now = DateTimeOffset.UtcNow;
-        var options = new DebugProbeOptions { TrendLookbackMinutes = 10 };
-
-        var items = new List<DebugEntry>
-        {
-            // Preceding half: [now - 10m, now - 5m). 1 request, 1 error -> 100% error rate.
-            new() { Id = "1", Timestamp = now.AddMinutes(-7), StatusCode = 500, Method = "GET", Path = "/api" },
-            // Current half: [now - 5m, now]. 1 request, 0 errors -> 0% error rate.
-            new() { Id = "2", Timestamp = now.AddMinutes(-2), StatusCode = 200, Method = "GET", Path = "/api" }
-        };
-
-        var html = HtmlRenderer.RenderIndexPage(items, options);
-
-        Assert.Contains("trend-down", html);
-        Assert.Contains("↓", html);
-    }
-
-    [Fact]
-    public void Render_index_page_with_unchanged_errors_shows_trend_neutral()
-    {
-        var now = DateTimeOffset.UtcNow;
-        var options = new DebugProbeOptions { TrendLookbackMinutes = 10 };
-
-        var items = new List<DebugEntry>
-        {
-            // Preceding half: [now - 10m, now - 5m). 1 request, 0 errors -> 0% error rate.
-            new() { Id = "1", Timestamp = now.AddMinutes(-7), StatusCode = 200, Method = "GET", Path = "/api" },
-            // Current half: [now - 5m, now]. 1 request, 0 errors -> 0% error rate.
-            new() { Id = "2", Timestamp = now.AddMinutes(-2), StatusCode = 200, Method = "GET", Path = "/api" }
-        };
-
-        var html = HtmlRenderer.RenderIndexPage(items, options);
-
-        Assert.Contains("trend-neutral", html);
-        Assert.Contains("→", html);
-    }
-
-    [Fact]
-    public void Render_index_page_scenario_a_and_b_regression_test()
-    {
-        var options = new DebugProbeOptions { MaxEntries = 10, TrendLookbackMinutes = 2 };
-
-        var now = DateTimeOffset.UtcNow;
-
-        // Scenario A: 8 successes at t = now - 90s, then 5 errors at t = now - 5s
-        // Since MaxEntries = 10, 3 successes are evicted. 5 successes remain in previous window, 5 errors in current.
-        // TotalB = 5 > 0, TotalA = 5 > 0.
-        var itemsA = new List<DebugEntry>();
-        for (int i = 0; i < 5; i++)
-        {
-            itemsA.Add(new DebugEntry { Id = $"success-{i}", Timestamp = now.AddSeconds(-90), StatusCode = 200, Method = "GET", Path = "/api" });
-        }
-        for (int i = 0; i < 5; i++)
-        {
-            itemsA.Add(new DebugEntry { Id = $"error-{i}", Timestamp = now.AddSeconds(-5), StatusCode = 500, Method = "GET", Path = "/api" });
-        }
-
-        // Expected: should show Trend Up (↑) because previous window is valid and error rate went up from 0% to 100%
-        var htmlA = HtmlRenderer.RenderIndexPage(itemsA, options);
-        Assert.Contains("trend-up", htmlA);
-        Assert.Contains("↑", htmlA);
-
-        // Scenario B: 8 recovery successes are sent, evicting all baseline successes and some errors.
-        // Queue now has 8 recovery successes and 2 errors (all in current window).
-        // Previous window is empty (TotalB = 0).
-        var itemsB = new List<DebugEntry>();
-        for (int i = 0; i < 2; i++)
-        {
-            itemsB.Add(new DebugEntry { Id = $"error-{i}", Timestamp = now.AddSeconds(-5), StatusCode = 500, Method = "GET", Path = "/api" });
-        }
-        for (int i = 0; i < 8; i++)
-        {
-            itemsB.Add(new DebugEntry { Id = $"recovery-{i}", Timestamp = now.AddSeconds(-2), StatusCode = 200, Method = "GET", Path = "/api" });
-        }
-
-        // Expected: should show Trend Neutral (→) because previous window is empty
-        var htmlB = HtmlRenderer.RenderIndexPage(itemsB, options);
-        Assert.Contains("trend-neutral", htmlB);
-        Assert.Contains("→", htmlB);
-    }
-
-    [Fact]
-    public void Render_index_page_previous_window_evicted_shows_neutral()
-    {
-        var options = new DebugProbeOptions { MaxEntries = 10, TrendLookbackMinutes = 2 };
-        var items = new List<DebugEntry>();
-
-        var now = DateTimeOffset.UtcNow;
-        // All baseline entries from previous window are evicted. Previous window has 0 entries.
-        for (int i = 0; i < 10; i++)
-        {
-            items.Add(new DebugEntry { Id = $"recovery-{i}", Timestamp = now.AddSeconds(-2), StatusCode = 200, Method = "GET", Path = "/api" });
-        }
-
-        var html = HtmlRenderer.RenderIndexPage(items, options);
-        Assert.Contains("trend-neutral", html);
-        Assert.Contains("→", html);
-    }
-
-    [Fact]
-    public void Render_index_page_previous_window_no_traffic_shows_neutral()
-    {
-        var options = new DebugProbeOptions { MaxEntries = 100, TrendLookbackMinutes = 2 };
-        var items = new List<DebugEntry>();
-
-        var now = DateTimeOffset.UtcNow;
-        // Only 5 errors are sent now. No traffic occurred in the previous window.
-        for (int i = 0; i < 5; i++)
-        {
-            items.Add(new DebugEntry { Id = $"error-{i}", Timestamp = now.AddSeconds(-5), StatusCode = 500, Method = "GET", Path = "/api" });
-        }
-
-        var html = HtmlRenderer.RenderIndexPage(items, options);
-        Assert.Contains("trend-neutral", html);
-        Assert.Contains("→", html);
-    }
-
-    [Fact]
-    public void Render_index_page_happy_path_with_no_eviction_flips_trend()
-    {
-        var options = new DebugProbeOptions { MaxEntries = 100, TrendLookbackMinutes = 2 };
-        var store = new DebugEntryStore(options);
-
-        var now = DateTimeOffset.UtcNow;
-        // Phase 1: 8 successes at t = now - 90s (previous window)
-        for (int i = 0; i < 8; i++)
-        {
-            store.Add(new DebugEntry { Id = $"success-{i}", Timestamp = now.AddSeconds(-90), StatusCode = 200, Method = "GET", Path = "/api" });
-        }
-
-        // Phase 2: 5 errors at t = now - 5s (current window)
-        for (int i = 0; i < 5; i++)
-        {
-            store.Add(new DebugEntry { Id = $"error-{i}", Timestamp = now.AddSeconds(-5), StatusCode = 500, Method = "GET", Path = "/api" });
-        }
-
-        var htmlErrors = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-        Assert.Contains("trend-up", htmlErrors);
-        Assert.Contains("↑", htmlErrors);
-
-        store.Clear();
-
-        // Phase 3: 5 errors at t = now - 90s (previous window)
-        for (int i = 0; i < 5; i++)
-        {
-            store.Add(new DebugEntry { Id = $"error-{i}", Timestamp = now.AddSeconds(-90), StatusCode = 500, Method = "GET", Path = "/api" });
-        }
-
-        // Phase 4: 8 successes at t = now - 5s (current window)
-        for (int i = 0; i < 8; i++)
-        {
-            store.Add(new DebugEntry { Id = $"success-{i}", Timestamp = now.AddSeconds(-5), StatusCode = 200, Method = "GET", Path = "/api" });
-        }
-
-        var htmlRecovery = HtmlRenderer.RenderIndexPage(store.GetAll(), options);
-        Assert.Contains("trend-down", htmlRecovery);
-        Assert.Contains("↓", htmlRecovery);
-    }
-
-    [Fact]
-    public void Options_validator_rejects_trend_lookback_less_than_two()
-    {
-        var validator = new DebugProbeOptionsValidator();
-        var options = new DebugProbeOptions { TrendLookbackMinutes = 1 };
-
-        var result = validator.Validate(null, options);
-
-        Assert.True(result.Failed);
-        Assert.Contains("TrendLookbackMinutes must be greater than or equal to 2", result.FailureMessage);
-    }
-}
diff --git a/DebugProbe.AspNetCore.Tests/Rendering/RendererIsolationTests.cs b/DebugProbe.AspNetCore.Tests/Rendering/RendererIsolationTests.cs
new file mode 100644
index 0000000..40c5ddb
--- /dev/null
+++ b/DebugProbe.AspNetCore.Tests/Rendering/RendererIsolationTests.cs
@@ -0,0 +1,52 @@
+using DebugProbe.AspNetCore.Internal.Rendering;
+using DebugProbe.AspNetCore.Models;
+using DebugProbe.AspNetCore.Options;
+using DebugProbe.AspNetCore.Storage;
+using DebugProbe.AspNetCore.Tests.Infrastructure;
+using Microsoft.Extensions.Hosting;
+
+namespace DebugProbe.AspNetCore.Tests.Rendering;
+
+public class RendererIsolationTests
+{
+    [Fact]
+    public void Renderer_uses_only_explicitly_supplied_groups()
+    {
+        var first = new DebugEntryStore(new DebugProbeOptions());
+        first.Add(new DebugEntry { Id = "first", ResponseBody = "System.Exception: first application" });
+        var second = new DebugEntryStore(new DebugProbeOptions());
+        second.Add(new DebugEntry { Id = "second", ResponseBody = "System.Exception: second application" });
+
+        var firstHtml = HtmlRenderer.RenderIndexPage([], exceptionGroups: first.ExceptionGroups.Values.ToArray());
+        var secondHtml = HtmlRenderer.RenderIndexPage([], exceptionGroups: second.ExceptionGroups.Values.ToArray());
+        var emptyHtml = HtmlRenderer.RenderIndexPage([]);
+
+        Assert.Contains("first application", firstHtml);
+        Assert.DoesNotContain("second application", firstHtml);
+        Assert.Contains("second application", secondHtml);
+        Assert.DoesNotContain("first application", secondHtml);
+        Assert.DoesNotContain("Exception Groups", emptyHtml);
+        first.Clear();
+        Assert.Contains("second application", HtmlRenderer.RenderIndexPage([], exceptionGroups: second.ExceptionGroups.Values.ToArray()));
+    }
+
+    [Fact]
+    public async Task Two_running_applications_display_their_own_exception_groups()
+    {
+        await using var first = await DebugProbeWebApplication.CreateAsync(Environments.Development,
+            endpoints => endpoints.MapGet("/failure", () => Results.Text("System.Exception: first application")));
+        await using var second = await DebugProbeWebApplication.CreateAsync(Environments.Development,
+            endpoints => endpoints.MapGet("/failure", () => Results.Text("System.Exception: second application")));
+
+        await Task.WhenAll(first.Client.GetAsync("/failure"), second.Client.GetAsync("/failure"));
+        var pages = await Task.WhenAll(first.Client.GetStringAsync("/debug"), second.Client.GetStringAsync("/debug"));
+
+        Assert.Contains("first application", pages[0]);
+        Assert.DoesNotContain("second application", pages[0]);
+        Assert.Contains("second application", pages[1]);
+        Assert.DoesNotContain("first application", pages[1]);
+        await first.Client.PostAsync("/debug/clear", null);
+        Assert.DoesNotContain("Exception Groups", await first.Client.GetStringAsync("/debug"));
+        Assert.Contains("second application", await second.Client.GetStringAsync("/debug"));
+    }
+}
diff --git a/DebugProbe.AspNetCore.Tests/Storage/DebugEntryStoreTests.cs b/DebugProbe.AspNetCore.Tests/Storage/DebugEntryStoreTests.cs
index b43aa7a..73b80fa 100644
--- a/DebugProbe.AspNetCore.Tests/Storage/DebugEntryStoreTests.cs
+++ b/DebugProbe.AspNetCore.Tests/Storage/DebugEntryStoreTests.cs
@@ -8,6 +8,20 @@ namespace DebugProbe.AspNetCore.Tests.Storage;
 
 public class DebugEntryStoreTests
 {
+    [Fact]
+    public void Exception_groups_are_bounded_without_resetting_existing_counts()
+    {
+        var store = new DebugEntryStore(new DebugProbeOptions { MaxRequests = 2 });
+        foreach (var message in new[] { "first", "first", "second", "third" })
+            store.Add(new DebugEntry { Id = Guid.NewGuid().ToString(), ResponseBody = $"System.Exception: {message}" });
+
+        Assert.Equal(2, store.GetAll().Count);
+        Assert.Equal(2, store.ExceptionGroups.Count);
+        Assert.DoesNotContain(store.ExceptionGroups.Values, group => group.SampleMessage == "first");
+        store.Add(new DebugEntry { Id = "next", ResponseBody = "System.Exception: third" });
+        Assert.Equal(2, store.ExceptionGroups.Values.Single(group => group.SampleMessage == "third").Count);
+    }
+
     [Fact]
     public void Add_identical_type_and_message_increments_count()
     {
diff --git a/DebugProbe.AspNetCore/Assets/css/debugprobe.css b/DebugProbe.AspNetCore/Assets/css/debugprobe.css
index eaf0ae6..5f9024d 100644
--- a/DebugProbe.AspNetCore/Assets/css/debugprobe.css
+++ b/DebugProbe.AspNetCore/Assets/css/debugprobe.css
@@ -75,59 +75,6 @@ h4 {
     margin-bottom: 14px;
 }
 
-.stats-bar {
-    display: grid;
-    grid-template-columns: repeat(5, minmax(150px, 1fr));
-    gap: 10px;
-    margin-bottom: 14px;
-}
-
-.stat-tile {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    gap: 8px;
-    min-height: 52px;
-    padding: 0 16px;
-    background: #fff;
-    border: 1px solid #e9e9e9;
-    border-radius: 8px;
-    text-align: center;
-}
-
-.stat-tile strong {
-    color: #1f2937;
-    font-size: 22px;
-    line-height: 1;
-}
-
-.stat-tile span {
-    color: #666;
-    font-size: 13px;
-    font-weight: 700;
-    text-transform: uppercase;
-}
-
-.trend-arrow {
-    display: inline-block;
-    font-size: 16px;
-    margin-left: 4px;
-    vertical-align: middle;
-    line-height: 1;
-}
-
-.trend-up {
-    color: #e74c3c;
-}
-
-.trend-down {
-    color: #27ae60;
-}
-
-.trend-neutral {
-    color: #9ca3af;
-}
-
 
 .filters input,
 .filters select {
@@ -687,10 +634,6 @@ tbody tr:last-child td {
         grid-template-columns: 1fr;
     }
 
-    .stats-bar {
-        grid-template-columns: repeat(2, minmax(0, 1fr));
-    }
-
     .compare-controls {
         grid-template-columns: 1fr;
     }
diff --git a/DebugProbe.AspNetCore/Assets/html/_shared/layout.html b/DebugProbe.AspNetCore/Assets/html/_shared/layout.html
index fd65aad..8b18b7a 100644
--- a/DebugProbe.AspNetCore/Assets/html/_shared/layout.html
+++ b/DebugProbe.AspNetCore/Assets/html/_shared/layout.html
@@ -1,19 +1,19 @@
 <head>
     <meta charset="utf-8">
-    <link rel="icon" href="/debug/favicon.ico" type="image/x-icon">
+    <link rel="icon" href="{{route_prefix}}/favicon.ico" type="image/x-icon">
     {{styles}}
 </head>
-<body>
+<body data-debugprobe-prefix="{{route_prefix}}">
     <div class="topbar">
         <span class="logo">
-            <img src="/debug/logo.png" alt="DebugProbe" />
+            <img src="{{route_prefix}}/logo.png" alt="DebugProbe" />
         </span>
         {{env_block}}
     </div>
 
     {{content}}
 
-    <script src="/debug/js/debugprobe-ui.js"></script>
-    <script src="/debug/js/debugprobe-compare-engine.js"></script>
-    <script src="/debug/js/debugprobe-compare-renderer.js"></script>
+    <script src="{{route_prefix}}/js/debugprobe-ui.js"></script>
+    <script src="{{route_prefix}}/js/debugprobe-compare-engine.js"></script>
+    <script src="{{route_prefix}}/js/debugprobe-compare-renderer.js"></script>
 </body>
diff --git a/DebugProbe.AspNetCore/Assets/html/details.html b/DebugProbe.AspNetCore/Assets/html/details.html
index cf30155..8c6a3ed 100644
--- a/DebugProbe.AspNetCore/Assets/html/details.html
+++ b/DebugProbe.AspNetCore/Assets/html/details.html
@@ -1,6 +1,6 @@
 <div class="container">
 
-    <a href="/debug">&#8592; Back</a>
+    <a href="{{route_prefix}}">&#8592; Back</a>
 
     <div class="details-grid">
 
diff --git a/DebugProbe.AspNetCore/Assets/html/index.html b/DebugProbe.AspNetCore/Assets/html/index.html
index e330e94..19d6593 100644
--- a/DebugProbe.AspNetCore/Assets/html/index.html
+++ b/DebugProbe.AspNetCore/Assets/html/index.html
@@ -6,31 +6,6 @@ <h2>Requests</h2>
         </div>
     </div>
 
-    <div class="stats-bar" aria-label="Request summary">
-        <div class="stat-tile">
-            <strong>{{total_requests}}</strong>
-            <span>Requests</span>
-        </div>
-        <div class="stat-tile">
-            <strong>{{avg_response_time}}</strong>
-            <span>Avg</span>
-        </div>
-        <div class="stat-tile">
-            <strong>{{slow_requests}}</strong>
-            <span>Over 1s</span>
-        </div>
-        <div class="stat-tile">
-            <strong>{{error_rate}}{{error_trend}}</strong>
-            <span>Errors</span>
-        </div>
-        <div class="stat-tile">
-            <div style="display: flex; align-items: center; justify-content: center; height: 28px; width: 120px;">
-                {{sparkline}}
-            </div>
-            <span>Activity</span>
-        </div>
-    </div>
-
     <div class="filters" aria-label="Request filters">
         <input id="requestSearch" type="search" placeholder="Search path, method, status, or trace id" autocomplete="off" />
         <select id="methodFilter" aria-label="Filter by method">
diff --git a/DebugProbe.AspNetCore/Assets/js/debugprobe-compare-renderer.js b/DebugProbe.AspNetCore/Assets/js/debugprobe-compare-renderer.js
index 630cd90..24209e4 100644
--- a/DebugProbe.AspNetCore/Assets/js/debugprobe-compare-renderer.js
+++ b/DebugProbe.AspNetCore/Assets/js/debugprobe-compare-renderer.js
@@ -13,7 +13,7 @@ window.runCompare = async function () {
     setCompareActionsVisible(false);
 
     try {
-        const res = await fetch(`/debug/compare/${id}?baseUrl=${encodeURIComponent(base)}&remoteTraceId=${encodeURIComponent(remoteId)}`);
+        const res = await fetch(`${document.body.dataset.debugprobePrefix}/compare/${id}?baseUrl=${encodeURIComponent(base)}&remoteTraceId=${encodeURIComponent(remoteId)}`);
 
         if (!res.ok) {
             const text = await res.text();
@@ -64,7 +64,7 @@ function getCompareShareUrl() {
         return '';
     }
 
-    return `${window.location.origin}/compare?baseUrl=${encodeURIComponent(base)}&traceId=${encodeURIComponent(traceId)}&localTraceId=${encodeURIComponent(localTraceId)}`;
+    return `${window.location.origin}${document.body.dataset.debugprobePrefix}/compare?baseUrl=${encodeURIComponent(base)}&traceId=${encodeURIComponent(traceId)}&localTraceId=${encodeURIComponent(localTraceId)}`;
 }
 
 document.addEventListener('DOMContentLoaded', () => {
diff --git a/DebugProbe.AspNetCore/Assets/js/debugprobe-ui.js b/DebugProbe.AspNetCore/Assets/js/debugprobe-ui.js
index 79a7000..d198f5a 100644
--- a/DebugProbe.AspNetCore/Assets/js/debugprobe-ui.js
+++ b/DebugProbe.AspNetCore/Assets/js/debugprobe-ui.js
@@ -283,7 +283,7 @@ if (clearBtn) {
     clearBtn.addEventListener("click", async () => {
         if (!confirm("Clear all requests?")) return;
 
-        await fetch("/debug/clear", { method: "POST" });
+        await fetch(`${document.body.dataset.debugprobePrefix}/clear`, { method: "POST" });
         location.reload();
     });
 }
@@ -488,7 +488,7 @@ document.addEventListener("keydown", (e) => {
 
     // "Escape" must always work, even inside input/textarea/contenteditable elements
     if (key === "Escape" || key === "Esc") {
-        const backLink = document.querySelector('a[href="/debug"]') || 
+        const backLink = document.querySelector(`a[href="${document.body.dataset.debugprobePrefix}"]`) ||
                          Array.from(document.querySelectorAll("a")).find(a => a.textContent.includes("Back"));
         if (backLink) {
             backLink.click();
diff --git a/DebugProbe.AspNetCore/Extensions/DebugProbeExtensions.cs b/DebugProbe.AspNetCore/Extensions/DebugProbeExtensions.cs
index 3375206..86ccefa 100644
--- a/DebugProbe.AspNetCore/Extensions/DebugProbeExtensions.cs
+++ b/DebugProbe.AspNetCore/Extensions/DebugProbeExtensions.cs
@@ -14,6 +14,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Http;
+using Microsoft.Extensions.Options;
 
 namespace DebugProbe.AspNetCore.Extensions;
 
@@ -32,56 +33,41 @@ public static class DebugProbeExtensions
     /// </summary>
     public static IServiceCollection AddDebugProbe(this IServiceCollection services, Action<DebugProbeOptions>? configure = null)
     {
-        var options = new DebugProbeOptions();
-
-        configure?.Invoke(options);
-
-        var validator = new DebugProbeOptionsValidator();
-        var result = validator.Validate(null, options);
-        if (result.Failed)
-            throw new InvalidOperationException(result.FailureMessage);
-
-        services.AddSingleton(options);
-
+        services.AddOptions<DebugProbeOptions>()
+            .Configure(options => configure?.Invoke(options))
+            .ValidateOnStart();
+        services.AddSingleton<IValidateOptions<DebugProbeOptions>, DebugProbeOptionsValidator>();
+        services.PostConfigure<DebugProbeOptions>(options =>
+        {
+            if (!string.IsNullOrWhiteSpace(options.RoutePrefix))
+                options.RoutePrefix = "/" + options.RoutePrefix.Trim('/');
+        });
+        services.AddSingleton(sp => sp.GetRequiredService<IOptions<DebugProbeOptions>>().Value);
         services.AddSingleton<DebugEntryStore>();
-
         services.AddHttpContextAccessor();
-
         services.AddHttpClient();
-
-        if (options.CaptureOutgoingHttpClientRequests)
+        services.AddTransient<DebugProbeHttpClientHandler>();
+        services.ConfigureAll<HttpClientFactoryOptions>(httpClientOptions =>
         {
-            services.AddTransient<DebugProbeHttpClientHandler>();
-
-            services.ConfigureAll<HttpClientFactoryOptions>(httpClientOptions =>
+            httpClientOptions.HttpMessageHandlerBuilderActions.Add(builder =>
             {
-                httpClientOptions.HttpMessageHandlerBuilderActions.Add(builder =>
-                {
+                var options = builder.Services.GetRequiredService<DebugProbeOptions>();
+                if (options.Enabled && options.CaptureOutgoingRequests)
                     builder.AdditionalHandlers.Add(builder.Services.GetRequiredService<DebugProbeHttpClientHandler>());
-                });
             });
-        }
+        });
 
         return services;
     }
 
-    /// <summary>
-    /// Registers DebugProbe services.
-    /// </summary>
+    /// <summary>Enables the middleware and maps the DebugProbe endpoints.</summary>
     public static IApplicationBuilder UseDebugProbe(this IApplicationBuilder app)
-    {
-        return app.UseDebugProbe(configure: null);
-    }
-
-    /// <summary>
-    /// Registers DebugProbe services and configures runtime endpoint options.
-    /// </summary>
-    public static IApplicationBuilder UseDebugProbe(this IApplicationBuilder app, Action<DebugProbeOptions>? configure)
     {
         var options = app.ApplicationServices.GetRequiredService<DebugProbeOptions>();
-        var environment = app.ApplicationServices.GetRequiredService<IHostEnvironment>();
+        if (!options.Enabled)
+            return app;
 
-        configure?.Invoke(options);
+        var environment = app.ApplicationServices.GetRequiredService<IHostEnvironment>();
 
         options.AllowLocalCompareTargets ??= environment.IsDevelopment();
 
@@ -100,7 +86,7 @@ public static IApplicationBuilder UseDebugProbe(this IApplicationBuilder app, Ac
                         .OrderByDescending(x => x.Timestamp)
                         .ToList();
 
-                    var html = HtmlRenderer.RenderIndexPage(items, options);
+                    var html = HtmlRenderer.RenderIndexPage(items, options, store.ExceptionGroups.Values.ToArray());
                     ctx.Response.ContentType = "text/html; charset=utf-8";
 
                     await ctx.Response.WriteAsync(html);
@@ -128,14 +114,14 @@ public static IApplicationBuilder UseDebugProbe(this IApplicationBuilder app, Ac
 
                 }).ExcludeFromDescription(), options);
 
-                RequireDebugAuthorization(webApp.MapGet("/compare", (string? baseUrl, string? traceId, string? localTraceId) =>
+                RequireDebugAuthorization(webApp.MapGet($"{prefix}/compare", (string? baseUrl, string? traceId, string? localTraceId) =>
                 {
                     if (string.IsNullOrWhiteSpace(localTraceId))
                     {
                         return Results.BadRequest("Missing local trace id");
                     }
 
-                    var html = HtmlRenderer.RenderComparePage(localTraceId, baseUrl ?? "", traceId ?? "");
+                    var html = HtmlRenderer.RenderComparePage(localTraceId, baseUrl ?? "", traceId ?? "", options);
 
                     return Results.Content(html, "text/html; charset=utf-8", System.Text.Encoding.UTF8);
 
diff --git a/DebugProbe.AspNetCore/Handlers/DebugProbeHttpClientHandler.cs b/DebugProbe.AspNetCore/Handlers/DebugProbeHttpClientHandler.cs
index 812ea16..1eea76a 100644
--- a/DebugProbe.AspNetCore/Handlers/DebugProbeHttpClientHandler.cs
+++ b/DebugProbe.AspNetCore/Handlers/DebugProbeHttpClientHandler.cs
@@ -1,6 +1,5 @@
 using System.Diagnostics;
 using System.Net;
-using System.Text;
 using DebugProbe.AspNetCore.Internal.Utils;
 using DebugProbe.AspNetCore.Models;
 using DebugProbe.AspNetCore.Options;
@@ -31,25 +30,38 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
     {
         var started = Stopwatch.StartNew();
 
+        HttpResponseMessage response;
         try
         {
-            var response = await base.SendAsync(request, cancellationToken);
-
-            await CaptureRequest(request, response, null, started.ElapsedMilliseconds, cancellationToken);
-
-            return response;
+            response = await base.SendAsync(request, cancellationToken);
         }
         catch (Exception ex)
         {
-            await CaptureRequest(request, null, ex, started.ElapsedMilliseconds, cancellationToken);
-
+            await TryCaptureRequest(request, null, ex, started.ElapsedMilliseconds, cancellationToken);
             throw;
         }
+
+        await TryCaptureRequest(request, response, null, started.ElapsedMilliseconds, cancellationToken);
+        return response;
     }
 
     /// <summary>
     /// Captures outgoing request details and stores them in the active DebugProbe entry.
     /// </summary>
+    private async Task TryCaptureRequest(
+        HttpRequestMessage request, HttpResponseMessage? response, Exception? exception,
+        long durationMs, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await CaptureRequest(request, response, exception, durationMs, cancellationToken);
+        }
+        catch (Exception)
+        {
+            // Diagnostics must not replace a successful response or the original transport exception.
+        }
+    }
+
     private async Task CaptureRequest(
         HttpRequestMessage request,
         HttpResponseMessage? response,
@@ -57,7 +69,7 @@ private async Task CaptureRequest(
         long durationMs,
         CancellationToken cancellationToken)
     {
-        if (!TryGetActiveEntry(out var entry))
+        if (!_options.Enabled || !_options.CaptureOutgoingRequests || !TryGetActiveEntry(out var entry))
         {
             return;
         }
@@ -83,11 +95,15 @@ private async Task CaptureRequest(
             ResponseHeaders = response != null ? response.Headers.ToDictionary(x => x.Key, x => RedactionUtils.RedactHeader(x.Key, string.Join(", ", x.Value), _options)) : []
         };
 
-        outgoing.RequestBody = (await CaptureBodyAsync(request.Content, cancellationToken)).Body;
+        outgoing.RequestBody = _options.CaptureRequestBody
+            ? await CaptureBodyAsync(request.Content, content => request.Content = content, cancellationToken)
+            : string.Empty;
 
-        outgoing.ResponseBody = await CaptureResponseBodyAsync(response, cancellationToken);
+        outgoing.ResponseBody = _options.CaptureResponseBody
+            ? await CaptureResponseBodyAsync(response, cancellationToken)
+            : string.Empty;
 
-        entry.OutgoingRequests.Add(outgoing);
+        entry.OutgoingRequests.Enqueue(outgoing);
     }
 
     private bool TryGetActiveEntry(out DebugEntry entry)
@@ -115,76 +131,40 @@ private async Task<string> CaptureResponseBodyAsync(HttpResponseMessage? respons
             return string.Empty;
         }
 
-        var result = await CaptureBodyAsync(content, cancellationToken);
-
-        if (result.BytesRead.Length > 0)
-        {
-            response!.Content = new PrefixReplayHttpContent(content, result.Stream, result.BytesRead);
-        }
-
-        return result.Body;
+        return await CaptureBodyAsync(content, replacement => response!.Content = replacement, cancellationToken);
     }
 
-    private async Task<BodyCaptureResult> CaptureBodyAsync(HttpContent? content, CancellationToken cancellationToken)
+    private async Task<string> CaptureBodyAsync(
+        HttpContent? content, Action<HttpContent> replaceContent, CancellationToken cancellationToken)
     {
-        if (content == null ||
-            !HttpContentUtils.IsTextContent(content.Headers.ContentType?.MediaType))
-        {
+        if (content == null || content.Headers.ContentLength == 0 || _options.MaxBodySizeBytes <= 0)
             return string.Empty;
-        }
 
-        if (_options.MaxBodyCaptureSizeBytes <= 0)
-            return string.Empty;
+        if (!HttpContentUtils.IsTextContent(content.Headers.ContentType?.MediaType))
+            return BodyCaptureUtils.BinaryBodyMessage;
 
-        var limit = _options.MaxBodyCaptureSizeBytes;
+        var limit = _options.MaxBodySizeBytes;
         var buffer = new byte[limit + 1];
         var totalRead = 0;
-
         var stream = await content.ReadAsStreamAsync(cancellationToken);
-
-        int bytesRead;
-        while (totalRead < buffer.Length &&
-               (bytesRead = await stream.ReadAsync(buffer.AsMemory(totalRead, buffer.Length - totalRead), cancellationToken)) > 0)
-        {
-            totalRead += bytesRead;
-        }
-
-        var truncated = totalRead > limit;
-        var encoding = GetEncoding(content);
-        var body = encoding.GetString(buffer, 0, Math.Min(totalRead, limit));
-
-        if (truncated)
-        {
-            body += "[truncated]";
-        }
-
-        return new BodyCaptureResult(
-            JsonUtils.Format(RedactionUtils.RedactJsonFields(body, _options)),
-            stream,
-            buffer[..totalRead]);
-    }
-
-    private static Encoding GetEncoding(HttpContent content)
-    {
-        var charset = content.Headers.ContentType?.CharSet;
-        if (string.IsNullOrWhiteSpace(charset))
-        {
-            return Encoding.UTF8;
-        }
-
+        var originalPosition = stream.CanSeek ? stream.Position : (long?)null;
         try
         {
-            return Encoding.GetEncoding(charset.Trim('"'));
+            int bytesRead;
+            while (totalRead < buffer.Length &&
+                   (bytesRead = await stream.ReadAsync(buffer.AsMemory(totalRead, buffer.Length - totalRead), cancellationToken)) > 0)
+                totalRead += bytesRead;
         }
-        catch
+        finally
         {
-            return Encoding.UTF8;
+            // Restore consumed bytes even when capture fails or is cancelled midway through a read.
+            if (originalPosition.HasValue)
+                stream.Position = originalPosition.Value;
+            else if (totalRead > 0)
+                replaceContent(new PrefixReplayHttpContent(content, stream, buffer[..totalRead]));
         }
-    }
 
-    private readonly record struct BodyCaptureResult(string Body, Stream Stream, byte[] BytesRead)
-    {
-        public static implicit operator BodyCaptureResult(string body) => new(body, Stream.Null, []);
+        return BodyCaptureUtils.Format(buffer.AsSpan(0, totalRead), totalRead, content.Headers.ContentType?.ToString(), _options);
     }
 
     private sealed class PrefixReplayHttpContent : HttpContent
diff --git a/DebugProbe.AspNetCore/Internal/Rendering/HtmlRenderer.cs b/DebugProbe.AspNetCore/Internal/Rendering/HtmlRenderer.cs
index 55b5a9c..8b4b235 100644
--- a/DebugProbe.AspNetCore/Internal/Rendering/HtmlRenderer.cs
+++ b/DebugProbe.AspNetCore/Internal/Rendering/HtmlRenderer.cs
@@ -2,7 +2,6 @@
 using DebugProbe.AspNetCore.Internal.Resources;
 using DebugProbe.AspNetCore.Internal.Utils;
 using DebugProbe.AspNetCore.Models;
-using DebugProbe.AspNetCore.Storage;
 using DebugProbe.AspNetCore.Options;
 
 namespace DebugProbe.AspNetCore.Internal.Rendering;
@@ -14,80 +13,23 @@ internal static class HtmlRenderer
 {
     public static string Env { get; } = EnvironmentUtils.TryGetEnvironment();
 
-    public static string BuildLayout(string content)
+    public static string BuildLayout(string content, DebugProbeOptions? options = null)
     {
+        options ??= new DebugProbeOptions();
         var envBlock = string.IsNullOrWhiteSpace(Env) ? "" : $"<span class=\"env\">{Encode(Env)}</span>";
 
         return EmbeddedResources.Layout
             .Replace("{{styles}}", $"<style>{EmbeddedResources.Css}</style>")
             .Replace("{{content}}", content)
-            .Replace("{{env_block}}", envBlock);
+            .Replace("{{env_block}}", envBlock)
+            .Replace("{{route_prefix}}", Encode(options.RoutePrefix));
     }
 
-    private static string NormalizePath(string? path)
-    {
-        if (string.IsNullOrEmpty(path))
-            return string.Empty;
-
-        var queryIndex = path.IndexOf('?');
-        var normalized = queryIndex >= 0 ? path[..queryIndex] : path;
-
-        if (normalized.Length > 1 && normalized.EndsWith('/'))
-        {
-            normalized = normalized.TrimEnd('/');
-        }
-
-        return normalized;
-    }
-
-    public static string RenderIndexPage(List<DebugEntry> items, DebugProbeOptions? options = null)
+    public static string RenderIndexPage(
+        List<DebugEntry> items, DebugProbeOptions? options = null,
+        IReadOnlyCollection<ExceptionGroup>? exceptionGroups = null)
     {
         options ??= new DebugProbeOptions();
-        var slowRequestThresholdMs = options.SlowRequestThresholdMs;
-        var store = DebugEntryStore.Instance;
-
-        var routesWithDiffs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        var routeDiffTooltips = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-
-        if (options.AutoEnvironmentDiff && items.Count > 0)
-        {
-            var groups = new Dictionary<string, Dictionary<string, DebugEntry>>(StringComparer.OrdinalIgnoreCase);
-
-            foreach (var entry in items)
-            {
-                var method = entry.Method ?? string.Empty;
-                var normalizedPath = NormalizePath(entry.Path);
-                var groupKey = $"{method}:{normalizedPath}";
-                var env = store?.GetEnvironment(entry)?.Environment ?? "Unknown";
-
-                if (!groups.TryGetValue(groupKey, out var envDict))
-                {
-                    envDict = new Dictionary<string, DebugEntry>(StringComparer.OrdinalIgnoreCase);
-                    groups[groupKey] = envDict;
-                }
-
-                if (!envDict.ContainsKey(env))
-                {
-                    envDict[env] = entry;
-                }
-            }
-
-            foreach (var kvp in groups)
-            {
-                var envDict = kvp.Value;
-                if (envDict.Count >= 2)
-                {
-                    var topTwo = envDict.Values.OrderByDescending(e => e.Timestamp).Take(2).ToList();
-                    var diffs = DebugProbe.AspNetCore.Internal.Compare.DebugEntryComparer.Compare(topTwo[0], topTwo[1]);
-                    if (diffs != null && diffs.Count > 0)
-                    {
-                        routesWithDiffs.Add(kvp.Key);
-                        var envNames = topTwo.Select(e => store?.GetEnvironment(e)?.Environment ?? "Unknown").Distinct();
-                        routeDiffTooltips[kvp.Key] = string.Join(", ", envNames);
-                    }
-                }
-            }
-        }
 
         var rows = string.Join("", items.Select(x =>
         {
@@ -95,28 +37,15 @@ public static string RenderIndexPage(List<DebugEntry> items, DebugProbeOptions?
             var badge = RenderSlowBadge(TimeSpan.FromMilliseconds(x.DurationMs), options);
             var badgeHtml = string.IsNullOrEmpty(badge) ? "" : " " + badge;
 
-            var method = x.Method ?? string.Empty;
-            var normalizedPath = NormalizePath(x.Path);
-            var groupKey = $"{method}:{normalizedPath}";
-            var envDiffBadgeHtml = "";
-
-            if (options.AutoEnvironmentDiff && routesWithDiffs.Contains(groupKey))
-            {
-                if (routeDiffTooltips.TryGetValue(groupKey, out var envList))
-                {
-                    envDiffBadgeHtml = $@" <span class=""dbp-badge dbp-badge-envdiff"" title=""Payload differences detected between: {Encode(envList)}"">⚠ Env diff</span>";
-                }
-            }
-
             return $@"
-        <tr data-url=""/debug/{Encode(x.Id)}""
+        <tr data-url=""{Encode(options.RoutePrefix)}/{Encode(x.Id)}""
             data-method=""{Encode(x.Method)}""
             data-status-family=""{x.StatusCode / 100}""
             data-search=""{Encode($"{x.Id} {x.Method} {x.Path} {x.Query} {x.StatusCode}")}""
             class=""clickable-row"">
             <td>{x.Timestamp:HH:mm:ss}</td>
             <td><span class=""method-pill"">{Encode(x.Method)}</span></td>
-            <td class=""request-path""><span class=""request-path-value"" title=""{Encode(pathWithQuery)}"">{Encode(pathWithQuery)}</span>{envDiffBadgeHtml}</td>
+            <td class=""request-path""><span class=""request-path-value"" title=""{Encode(pathWithQuery)}"">{Encode(pathWithQuery)}</span></td>
             <td><span class=""status {GetStatusClass(x.StatusCode)}"">{x.StatusCode}</span></td>
             <td>{x.DurationMs} ms{badgeHtml}</td>
         </tr>";
@@ -132,99 +61,10 @@ public static string RenderIndexPage(List<DebugEntry> items, DebugProbeOptions?
             .OrderBy(method => method, StringComparer.OrdinalIgnoreCase)
             .Select(method => $@"<option value=""{Encode(method)}"">{Encode(method)}</option>"));
 
-        var totalRequests = items.Count;
-        var averageResponseMs = totalRequests == 0 ? 0 : (int)Math.Round(items.Average(x => x.DurationMs));
-        var slowRequests = slowRequestThresholdMs > 0 ? items.Count(x => x.DurationMs >= slowRequestThresholdMs) : 0;
-        var errorRate = totalRequests == 0 ? 0 : items.Count(x => x.StatusCode >= 400) * 100d / totalRequests;
-
-        // Trend calculations
-        store ??= DebugEntryStore.Instance;
-        var now = DateTimeOffset.UtcNow;
-        var limitTime = now.AddMinutes(-options.TrendLookbackMinutes);
-        var midTime = now.AddMinutes(-options.TrendLookbackMinutes / 2.0);
-
-        int[] buckets = new int[options.TrendLookbackMinutes];
-        int totalA = 0;
-        int errorsA = 0;
-        int totalB = 0;
-        int errorsB = 0;
-
-        foreach (var entry in items)
-        {
-            var t = entry.Timestamp;
-            var elapsed = now - t;
-            if (elapsed.TotalMinutes < options.TrendLookbackMinutes)
-            {
-                double mins = Math.Max(0.0, elapsed.TotalMinutes);
-                int bucketIndex = options.TrendLookbackMinutes - 1 - (int)Math.Floor(mins);
-                if (bucketIndex >= 0 && bucketIndex < options.TrendLookbackMinutes)
-                {
-                    buckets[bucketIndex]++;
-                }
-            }
-
-            if (t >= midTime)
-            {
-                totalA++;
-                if (entry.StatusCode >= 400)
-                {
-                    errorsA++;
-                }
-            }
-            else if (t >= limitTime && t < midTime)
-            {
-                totalB++;
-                if (entry.StatusCode >= 400)
-                {
-                    errorsB++;
-                }
-            }
-        }
-
-        int maxVal = buckets.Max();
-        var pointsList = new List<string>();
-        for (int i = 0; i < options.TrendLookbackMinutes; i++)
-        {
-            double x = (double)i / (options.TrendLookbackMinutes - 1) * 120.0;
-            double y = maxVal == 0 ? 14.0 : 26.0 - ((double)buckets[i] / maxVal * 24.0);
-            pointsList.Add($"{x:0.##},{y:0.##}");
-        }
-        string pointsString = string.Join(" ", pointsList);
-
-        string sparklineSvg = $@"<svg width=""120"" height=""28"" viewBox=""0 0 120 28"" style=""overflow: visible;"" xmlns=""http://www.w3.org/2000/svg""><polyline fill=""none"" stroke=""#6c5ce7"" stroke-width=""2"" stroke-linecap=""round"" stroke-linejoin=""round"" points=""{pointsString}"" /></svg>";
-
-        double errorRateA = totalA == 0 ? 0.0 : (double)errorsA / totalA;
-        double errorRateB = totalB == 0 ? 0.0 : (double)errorsB / totalB;
-
-        string trendArrow;
-        string arrowClass;
-        if (totalA == 0 || totalB == 0)
-        {
-            trendArrow = "→";
-            arrowClass = "trend-neutral";
-        }
-        else if (errorRateA > errorRateB)
-        {
-            trendArrow = "↑";
-            arrowClass = "trend-up";
-        }
-        else if (errorRateA < errorRateB)
-        {
-            trendArrow = "↓";
-            arrowClass = "trend-down";
-        }
-        else
-        {
-            trendArrow = "→";
-            arrowClass = "trend-neutral";
-        }
-
-        string errorTrendHtml = $" <span class=\"trend-arrow {arrowClass}\" title=\"vs preceding period\">{trendArrow}</span>";
-
         var exceptionPanel = "";
-        if (store != null && !store.ExceptionGroups.IsEmpty)
+        if (exceptionGroups != null && exceptionGroups.Count > 0)
         {
-            var sortedGroups = store.ExceptionGroups.Values
+            var sortedGroups = exceptionGroups
                 .OrderByDescending(g => g.Count)
                 .ToList();
 
@@ -268,13 +108,7 @@ public static string RenderIndexPage(List<DebugEntry> items, DebugProbeOptions?
         return BuildLayout(pageHtml
             .Replace("{{rows}}", rows)
             .Replace("{{total_count}}", items.Count.ToString())
-            .Replace("{{method_options}}", methodOptions)
-            .Replace("{{total_requests}}", FormatCompactNumber(totalRequests))
-            .Replace("{{avg_response_time}}", $"{averageResponseMs} ms")
-            .Replace("{{slow_requests}}", FormatCompactNumber(slowRequests))
-            .Replace("{{error_rate}}", $"{errorRate:0.#}%")
-            .Replace("{{error_trend}}", errorTrendHtml)
-            .Replace("{{sparkline}}", sparklineSvg));
+            .Replace("{{method_options}}", methodOptions), options);
     }
 
     public static string RenderDetailsPage(DebugEntry x, DebugEnvironment e, string req, string res, DebugProbeOptions? options = null)
@@ -315,9 +149,10 @@ public static string RenderDetailsPage(DebugEntry x, DebugEnvironment e, string
             ],
             options: options);
 
-        var waterfall = BuildWaterfallSection(x, options);
+        var outgoingSnapshot = x.OutgoingRequests.ToArray();
+        var waterfall = BuildWaterfallSection(x, outgoingSnapshot, options);
 
-        var outgoingRequests = string.Join("", x.OutgoingRequests.Select(r => BuildOutgoingRequestCard(r, options)));
+        var outgoingRequests = string.Join("", outgoingSnapshot.Select(r => BuildOutgoingRequestCard(r, options)));
 
         var combinedOutgoing = waterfall + outgoingRequests;
 
@@ -334,7 +169,7 @@ public static string RenderDetailsPage(DebugEntry x, DebugEnvironment e, string
             .Replace("{{durationMs}}", x.DurationMs.ToString())
             .Replace("{{durationBadge}}", RenderSlowBadge(TimeSpan.FromMilliseconds(x.DurationMs), options))
             .Replace("{{completed}}", x.Timestamp.AddMilliseconds(x.DurationMs).ToLocalTime().ToString("HH:mm:ss"))
-            .Replace("{{dependencyCount}}", x.OutgoingRequests.Count.ToString())
+            .Replace("{{dependencyCount}}", outgoingSnapshot.Length.ToString())
 
             .Replace("{{env}}", Encode(e.Environment))
             .Replace("{{culture}}", Encode(e.Culture))
@@ -351,10 +186,10 @@ public static string RenderDetailsPage(DebugEntry x, DebugEnvironment e, string
             .Replace("{{incomingRequest}}", incomingRequest)
             .Replace("{{incomingResponse}}", incomingResponse);
 
-        return BuildLayout(content);
+        return BuildLayout(content, options);
     }
 
-    public static string RenderComparePage(string localTraceId, string baseUrl, string traceId)
+    public static string RenderComparePage(string localTraceId, string baseUrl, string traceId, DebugProbeOptions? options = null)
     {
         var content = $@"
         <div class=""container compare-page"">
@@ -376,7 +211,7 @@ public static string RenderComparePage(string localTraceId, string baseUrl, stri
             </section>
         </div>";
 
-        return BuildLayout(content);
+        return BuildLayout(content, options);
     }
 
     private static string BuildOutgoingRequestCard(DebugOutgoingRequest request, DebugProbeOptions options)
@@ -414,12 +249,12 @@ private static string BuildOutgoingRequestCard(DebugOutgoingRequest request, Deb
             options: options);
     }
 
-    private static string BuildWaterfallSection(DebugEntry entry, DebugProbeOptions options)
+    private static string BuildWaterfallSection(DebugEntry entry, DebugOutgoingRequest[] outgoingRequests, DebugProbeOptions options)
     {
         const double MinPercent = 0.0;
         const double MaxPercent = 100.0;
 
-        if (entry.OutgoingRequests.Count == 0)
+        if (outgoingRequests.Length == 0)
         {
             return string.Empty;
         }
@@ -449,7 +284,7 @@ private static string BuildWaterfallSection(DebugEntry entry, DebugProbeOptions
 
         var rowsHtml = new List<string>();
 
-        foreach (var outgoing in entry.OutgoingRequests)
+        foreach (var outgoing in outgoingRequests)
         {
             var startOffsetMs = (outgoing.TimestampUtc - entry.Timestamp.UtcDateTime).TotalMilliseconds - outgoing.DurationMs;
 
@@ -689,16 +524,6 @@ private static string GetStatusClass(int statusCode)
         };
     }
 
-    private static string FormatCompactNumber(int value)
-    {
-        return value switch
-        {
-            >= 1_000_000 => $"{value / 1_000_000d:0.#}M",
-            >= 1_000 => $"{value / 1_000d:0.#}K",
-            _ => value.ToString()
-        };
-    }
-
     private static string FormatBytes(int value)
     {
         return value switch
@@ -711,9 +536,9 @@ private static string FormatBytes(int value)
 
     private static string RenderSlowBadge(TimeSpan duration, DebugProbeOptions options)
     {
-        if (options.SlowRequestThresholdMs > 0 && duration.TotalMilliseconds >= options.SlowRequestThresholdMs)
+        if (options.SlowRequestThreshold > TimeSpan.Zero && duration >= options.SlowRequestThreshold)
         {
-            return $@"<span class=""dbp-badge dbp-badge-slow"" title=""Exceeds {options.SlowRequestThresholdMs}ms threshold"">SLOW</span>";
+            return $@"<span class=""dbp-badge dbp-badge-slow"" title=""Exceeds {options.SlowRequestThreshold.TotalMilliseconds}ms threshold"">SLOW</span>";
         }
         return string.Empty;
     }
diff --git a/DebugProbe.AspNetCore/Internal/Streams/BoundedResponseCaptureStream.cs b/DebugProbe.AspNetCore/Internal/Streams/BoundedResponseCaptureStream.cs
index 563039b..f521f4d 100644
--- a/DebugProbe.AspNetCore/Internal/Streams/BoundedResponseCaptureStream.cs
+++ b/DebugProbe.AspNetCore/Internal/Streams/BoundedResponseCaptureStream.cs
@@ -5,6 +5,7 @@ internal sealed class BoundedResponseCaptureStream : Stream
     private readonly Stream _inner;
     private readonly MemoryStream _capture = new();
     private readonly int _captureLimit;
+    private bool _captureFailed;
 
     public BoundedResponseCaptureStream(Stream inner, int captureLimit)
     {
@@ -14,7 +15,7 @@ public BoundedResponseCaptureStream(Stream inner, int captureLimit)
 
     public long TotalBytesWritten { get; private set; }
 
-    public byte[] CapturedBytes => _capture.ToArray();
+    public byte[] CapturedBytes => _captureFailed ? [] : _capture.ToArray();
 
     public override bool CanRead => false;
     public override bool CanSeek => false;
@@ -75,14 +76,20 @@ private void Capture(ReadOnlySpan<byte> buffer)
     {
         TotalBytesWritten += buffer.Length;
 
-        var remaining = _captureLimit - (int)_capture.Length;
+        if (_captureFailed)
+            return;
 
-        if (remaining <= 0)
+        try
         {
-            return;
+            var remaining = _captureLimit - (int)_capture.Length;
+            if (remaining > 0)
+                _capture.Write(buffer[..Math.Min(buffer.Length, remaining)]);
+        }
+        catch (Exception)
+        {
+            // Only the diagnostic copy is optional; writes to the application's stream still propagate errors.
+            _captureFailed = true;
         }
-
-        _capture.Write(buffer[..Math.Min(buffer.Length, remaining)]);
     }
 
     protected override void Dispose(bool disposing)
diff --git a/DebugProbe.AspNetCore/Internal/Utils/BodyCaptureUtils.cs b/DebugProbe.AspNetCore/Internal/Utils/BodyCaptureUtils.cs
new file mode 100644
index 0000000..484303a
--- /dev/null
+++ b/DebugProbe.AspNetCore/Internal/Utils/BodyCaptureUtils.cs
@@ -0,0 +1,60 @@
+using System.Net.Http.Headers;
+using System.Text;
+using DebugProbe.AspNetCore.Options;
+
+namespace DebugProbe.AspNetCore.Internal.Utils;
+
+internal static class BodyCaptureUtils
+{
+    public const string BinaryBodyMessage = "[Body not captured: non-text content]";
+    public const string TruncatedRedactionMessage = "[Body not captured: truncated content cannot be redacted]";
+
+    public static string Format(ReadOnlySpan<byte> bytes, long totalBytes, string? contentType, DebugProbeOptions options)
+    {
+        var limit = options.MaxBodySizeBytes;
+        if (limit <= 0 || totalBytes == 0)
+        {
+            return string.Empty;
+        }
+
+        if (!HttpContentUtils.IsTextContent(contentType))
+        {
+            return BinaryBodyMessage;
+        }
+
+        var truncated = totalBytes > limit;
+        
+        // Incomplete JSON cannot be reliably redacted. Never store a potentially sensitive prefix.
+        if (truncated && options.RedactedJsonFields.Length > 0)
+        {
+            return TruncatedRedactionMessage;
+        }
+
+        var encoding = GetEncoding(contentType);
+        var prefix = bytes[..Math.Min(bytes.Length, limit)];
+        var chars = new char[encoding.GetMaxCharCount(prefix.Length)];
+
+        encoding.GetDecoder().Convert(prefix, chars, flush: !truncated, out _, out var charsUsed, out _);
+        
+        var body = RedactionUtils.RedactJsonFields(new string(chars, 0, charsUsed), options);
+        
+        return truncated ? body + "[truncated]" : body;
+    }
+
+    private static Encoding GetEncoding(string? contentType)
+    {
+        if (MediaTypeHeaderValue.TryParse(contentType, out var parsed) && !string.IsNullOrWhiteSpace(parsed.CharSet))
+        {
+            try
+            {
+                return Encoding.GetEncoding(parsed.CharSet.Trim('"'));
+            }
+            catch (Exception ex) when (ex is ArgumentException or NotSupportedException)
+            {
+                // Missing or unsupported charsets use UTF-8 for all capture paths.
+            }
+        }
+
+        return Encoding.UTF8;
+    }
+}
diff --git a/DebugProbe.AspNetCore/Internal/Utils/HttpContentUtils.cs b/DebugProbe.AspNetCore/Internal/Utils/HttpContentUtils.cs
index 02d9575..1df3984 100644
--- a/DebugProbe.AspNetCore/Internal/Utils/HttpContentUtils.cs
+++ b/DebugProbe.AspNetCore/Internal/Utils/HttpContentUtils.cs
@@ -1,4 +1,4 @@
-namespace DebugProbe.AspNetCore.Internal.Utils;
+namespace DebugProbe.AspNetCore.Internal.Utils;
 
 internal static class HttpContentUtils
 {
@@ -17,13 +17,4 @@ public static bool IsTextContent(string? contentType)
                contentType.Contains("x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase);
     }
 
-    public static string Trim(string? value, int max = 2000)
-    {
-        if (string.IsNullOrEmpty(value))
-        {
-            return value ?? string.Empty;
-        }
-
-        return value.Length <= max ? value : value[..max];
-    }
 }
diff --git a/DebugProbe.AspNetCore/Internal/Utils/RedactionUtils.cs b/DebugProbe.AspNetCore/Internal/Utils/RedactionUtils.cs
index c7e43e7..00c93cf 100644
--- a/DebugProbe.AspNetCore/Internal/Utils/RedactionUtils.cs
+++ b/DebugProbe.AspNetCore/Internal/Utils/RedactionUtils.cs
@@ -7,9 +7,10 @@ namespace DebugProbe.AspNetCore.Internal.Utils;
 
 internal static class RedactionUtils
 {
+    private const string RedactionText = "[REDACTED]";
     public static string RedactHeader(string name, string value, DebugProbeOptions options)
     {
-        return IsMatch(name, options.RedactedHeaders) ? options.RedactionText : value;
+        return IsMatch(name, options.RedactedHeaders) ? RedactionText : value;
     }
 
     public static string RedactQueryString(string? queryString, DebugProbeOptions options)
@@ -98,7 +99,7 @@ private static string RedactQuery(string query, DebugProbeOptions options)
                 continue;
             }
 
-            parts[i] = $"{name}={options.RedactionText}";
+            parts[i] = $"{name}={RedactionText}";
         }
 
         return string.Join("&", parts);
@@ -112,7 +113,7 @@ private static void RedactNode(JsonNode node, DebugProbeOptions options)
             {
                 if (IsMatch(property.Key, options.RedactedJsonFields))
                 {
-                    jsonObject[property.Key] = options.RedactionText;
+                    jsonObject[property.Key] = RedactionText;
                     continue;
                 }
 
diff --git a/DebugProbe.AspNetCore/Middleware/DebugProbeMiddleware.cs b/DebugProbe.AspNetCore/Middleware/DebugProbeMiddleware.cs
index 13a131f..6d25976 100644
--- a/DebugProbe.AspNetCore/Middleware/DebugProbeMiddleware.cs
+++ b/DebugProbe.AspNetCore/Middleware/DebugProbeMiddleware.cs
@@ -6,6 +6,7 @@
 using DebugProbe.AspNetCore.Options;
 using DebugProbe.AspNetCore.Storage;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 
 namespace DebugProbe.AspNetCore.Middleware;
 
@@ -15,30 +16,6 @@ namespace DebugProbe.AspNetCore.Middleware;
 /// </summary>
 public class DebugProbeMiddleware
 {
-    private const string BodyTooLargeMessage = "[Body too large]";
-    private const string BinaryBodyMessage = "[Body not captured: non-text content]";
-
-    private static readonly string[] DefaultIgnorePaths =
-    [
-        "/compare",
-        "/swagger",
-        "/health",
-        "/healthz",
-        "/ready",
-        "/live",
-        "/.well-known",
-
-        // browser noise
-        "/favicon.ico",
-
-        // scanners
-        "/.git",
-        "/wp-admin",
-        "/phpmyadmin",
-        "/cgi-bin",
-        "/server-status"
-    ];
-
     private readonly RequestDelegate _next;
     private readonly DebugProbeOptions _options;
 
@@ -56,35 +33,44 @@ public DebugProbeMiddleware(RequestDelegate next, DebugProbeOptions options)
     /// </summary>
     public async Task Invoke(HttpContext context, DebugEntryStore store)
     {
-        if (IsIgnoredPath(context.Request.Path))
-        {
-            await _next(context);
-            return;
-        }
-
-        var maxBodySize = _options.MaxBodyCaptureSizeBytes;
-
-        var requestBody = await CaptureRequestBodyAsync(context, maxBodySize);
-
         var originalBody = context.Response.Body;
+        BoundedResponseCaptureStream? responseCapture = null;
+        DebugEntry? entry = null;
+        var requestBody = string.Empty;
+        var maxBodySize = 0;
 
-        await using var responseCapture =
-            new BoundedResponseCaptureStream(originalBody, maxBodySize + 1);
-
-        context.Response.Body = responseCapture;
-
-        var entry = new DebugEntry
+        try
         {
-            Id = Guid.NewGuid().ToString(),
-            Timestamp = DateTime.UtcNow
-        };
+            if (_options.Enabled && !IsIgnoredPath(context.Request.Path))
+            {
+                maxBodySize = _options.MaxBodySizeBytes;
+                requestBody = _options.CaptureRequestBody && maxBodySize > 0
+                    ? await CaptureRequestBodyAsync(context, maxBodySize)
+                    : string.Empty;
+                responseCapture = new BoundedResponseCaptureStream(originalBody,
+                    _options.CaptureResponseBody && maxBodySize > 0 ? maxBodySize + 1 : 0);
+                entry = new DebugEntry { Id = Guid.NewGuid().ToString(), Timestamp = DateTime.UtcNow };
+                context.Response.Body = responseCapture;
+                context.Items["DebugProbeEntry"] = entry;
+            }
+        }
+        catch (Exception)
+        {
+            // Capture is best-effort; setup failures must not prevent the application from running.
+            context.Response.Body = originalBody;
+            responseCapture?.Dispose();
+            responseCapture = null;
+        }
 
-        context.Items["DebugProbeEntry"] = entry;
+        if (responseCapture == null || entry == null)
+        {
+            await _next(context);
+            return;
+        }
 
         var started = Stopwatch.StartNew();
 
-        var exception = false;
-        string? exceptionResponseBody = null;
+        Exception? applicationException = null;
 
         try
         {
@@ -92,8 +78,7 @@ public async Task Invoke(HttpContext context, DebugEntryStore store)
         }
         catch (Exception ex)
         {
-            exception = true;
-            exceptionResponseBody = ex.ToString();
+            applicationException = ex;
             throw;
         }
         finally
@@ -104,53 +89,63 @@ public async Task Invoke(HttpContext context, DebugEntryStore store)
 
             context.Response.Body = originalBody;
 
-            var statusCode = exception && context.Response.StatusCode == 200 ? 500 : context.Response.StatusCode;
+            try
+            {
+                context.Items.Remove("DebugProbeEntry");
+                var statusCode = applicationException != null && context.Response.StatusCode == 200 ? 500 : context.Response.StatusCode;
 
-            var responseBody = exception
-                ? HttpContentUtils.Trim(exceptionResponseBody, maxBodySize)
-                : CaptureResponseBody(context, responseCapture, maxBodySize);
+                var responseBody = !_options.CaptureResponseBody || maxBodySize == 0
+                    ? string.Empty
+                    : applicationException != null
+                    ? CaptureExceptionBody(applicationException)
+                    : CaptureResponseBody(context, responseCapture);
 
-            entry.Method = context.Request.Method;
+                entry.Method = context.Request.Method;
 
-            entry.Path = context.Request.Path;
+                entry.Path = context.Request.Path;
 
-            entry.Query = RedactionUtils.RedactQueryString(context.Request.QueryString.ToString(), _options);
+                entry.Query = RedactionUtils.RedactQueryString(context.Request.QueryString.ToString(), _options);
 
-            entry.StatusCode = statusCode;
+                entry.StatusCode = statusCode;
 
-            entry.RequestTimeUtc = DateTime.UtcNow;
+                entry.RequestTimeUtc = DateTime.UtcNow;
 
-            entry.DurationMs = durationMs;
+                entry.DurationMs = durationMs;
 
-            entry.RequestSize = context.Request.ContentLength ?? Encoding.UTF8.GetByteCount(requestBody);
+                entry.RequestSize = context.Request.ContentLength ?? Encoding.UTF8.GetByteCount(requestBody);
 
-            entry.ResponseSize = responseCapture.TotalBytesWritten;
+                entry.ResponseSize = responseCapture.TotalBytesWritten;
 
-            entry.RequestHeaders =
-                context.Request.Headers.ToDictionary(
-                    x => x.Key,
-                    x => RedactionUtils.RedactHeader(x.Key, x.Value.ToString(), _options));
+                entry.RequestHeaders =
+                    context.Request.Headers.ToDictionary(
+                        x => x.Key,
+                        x => RedactionUtils.RedactHeader(x.Key, x.Value.ToString(), _options));
 
-            entry.RequestUrl =
-                RedactionUtils.RedactUrl(
-                    $"{context.Request.Scheme}://{context.Request.Host}" +
-                    $"{context.Request.Path}{context.Request.QueryString}",
-                    _options);
+                entry.RequestUrl =
+                    RedactionUtils.RedactUrl(
+                        $"{context.Request.Scheme}://{context.Request.Host}" +
+                        $"{context.Request.Path}{context.Request.QueryString}",
+                        _options);
 
-            entry.RequestBody = RedactionUtils.RedactJsonFields(
-                HttpContentUtils.Trim(requestBody, maxBodySize),
-                _options);
+                entry.RequestBody = requestBody;
 
-            entry.ResponseBody = RedactionUtils.RedactJsonFields(
-                HttpContentUtils.Trim(responseBody, maxBodySize),
-                _options);
+                entry.ResponseBody = responseBody;
 
-            entry.ResponseHeaders =
-                context.Response.Headers.ToDictionary(
-                    x => x.Key,
-                    x => RedactionUtils.RedactHeader(x.Key, x.Value.ToString(), _options));
+                entry.ResponseHeaders =
+                    context.Response.Headers.ToDictionary(
+                        x => x.Key,
+                        x => RedactionUtils.RedactHeader(x.Key, x.Value.ToString(), _options));
 
-            store.Add(entry);
+                store.Add(entry);
+            }
+            catch (Exception)
+            {
+                // Never replace the application response or its original exception with a capture failure.
+            }
+            finally
+            {
+                responseCapture.Dispose();
+            }
         }
     }
 
@@ -158,8 +153,7 @@ private bool IsIgnoredPath(PathString requestPath)
     {
         var path = requestPath.Value ?? string.Empty;
 
-        return DefaultIgnorePaths
-            .Concat(_options.IgnorePaths)
+        return _options.ExcludedPaths
             .Append(_options.RoutePrefix)
             .Distinct(StringComparer.OrdinalIgnoreCase)
             .Any(ignorePath => 
@@ -167,7 +161,7 @@ private bool IsIgnoredPath(PathString requestPath)
                 path.StartsWith(ignorePath.TrimEnd('/') + "/", StringComparison.OrdinalIgnoreCase));
     }
 
-    private static async Task<string> CaptureRequestBodyAsync(HttpContext context, int maxBodySize)
+    private async Task<string> CaptureRequestBodyAsync(HttpContext context, int maxBodySize)
     {
         if (!HasBody(context.Request))
         {
@@ -176,12 +170,7 @@ private static async Task<string> CaptureRequestBodyAsync(HttpContext context, i
 
         if (!HttpContentUtils.IsTextContent(context.Request.ContentType))
         {
-            return BinaryBodyMessage;
-        }
-
-        if (context.Request.ContentLength > maxBodySize)
-        {
-            return BodyTooLargeMessage;
+            return context.Request.ContentLength == 0 ? string.Empty : BodyCaptureUtils.BinaryBodyMessage;
         }
 
         context.Request.EnableBuffering();
@@ -191,34 +180,38 @@ private static async Task<string> CaptureRequestBodyAsync(HttpContext context, i
             return string.Empty;
         }
 
-        context.Request.Body.Position = 0;
-
-        var bytes = await ReadAtMostAsync(context.Request.Body, maxBodySize + 1);
-
-        context.Request.Body.Position = 0;
-
-        return bytes.Length > maxBodySize ? BodyTooLargeMessage : Encoding.UTF8.GetString(bytes);
-    }
-
-    private static string CaptureResponseBody(HttpContext context, BoundedResponseCaptureStream responseCapture, int maxBodySize)
-    {
-        if (!HttpContentUtils.IsTextContent(context.Response.ContentType))
+        var originalPosition = context.Request.Body.Position;
+        try
         {
-            return responseCapture.TotalBytesWritten == 0
-                ? string.Empty
-                : BinaryBodyMessage;
+            var bytes = await ReadAtMostAsync(context.Request.Body, maxBodySize + 1);
+            
+            return BodyCaptureUtils.Format(bytes, bytes.Length, context.Request.ContentType, _options);
         }
-
-        if (responseCapture.TotalBytesWritten > maxBodySize)
+        finally
         {
-            return BodyTooLargeMessage;
+            context.Request.Body.Position = originalPosition;
         }
+    }
 
-        return Encoding.UTF8.GetString(responseCapture.CapturedBytes);
+    private string CaptureResponseBody(HttpContext context, BoundedResponseCaptureStream responseCapture)
+    {
+        return BodyCaptureUtils.Format(responseCapture.CapturedBytes, responseCapture.TotalBytesWritten,
+            context.Response.ContentType, _options);
+    }
+
+    private string CaptureExceptionBody(Exception exception)
+    {
+        var bytes = Encoding.UTF8.GetBytes(exception.ToString());
+       
+        return BodyCaptureUtils.Format(bytes, bytes.Length, "text/plain; charset=utf-8", _options);
     }
 
     private static bool HasBody(HttpRequest request)
     {
+        var detection = request.HttpContext.Features.Get<IHttpRequestBodyDetectionFeature>();
+        if (detection != null)
+            return detection.CanHaveBody;
+
         if (request.ContentLength == 0)
         {
             return false;
diff --git a/DebugProbe.AspNetCore/Models/DebugEntry.cs b/DebugProbe.AspNetCore/Models/DebugEntry.cs
index 2abed63..5fa09be 100644
--- a/DebugProbe.AspNetCore/Models/DebugEntry.cs
+++ b/DebugProbe.AspNetCore/Models/DebugEntry.cs
@@ -1,3 +1,5 @@
+using System.Collections.Concurrent;
+
 namespace DebugProbe.AspNetCore.Models;
 
 public class DebugEntry
@@ -32,5 +34,6 @@ public class DebugEntry
 
     public DateTimeOffset Timestamp { get; set; }
 
-    public List<DebugOutgoingRequest> OutgoingRequests { get; set; } = [];
+    /// <summary>Outgoing calls in capture completion order. Supports parallel additions and snapshot enumeration.</summary>
+    public ConcurrentQueue<DebugOutgoingRequest> OutgoingRequests { get; set; } = new();
 }
diff --git a/DebugProbe.AspNetCore/Options/DebugProbeOptions.cs b/DebugProbe.AspNetCore/Options/DebugProbeOptions.cs
index 1f47949..015268a 100644
--- a/DebugProbe.AspNetCore/Options/DebugProbeOptions.cs
+++ b/DebugProbe.AspNetCore/Options/DebugProbeOptions.cs
@@ -1,114 +1,59 @@
 namespace DebugProbe.AspNetCore.Options;
 
-/// <summary>
-/// Configuration options for DebugProbe.
-/// </summary>
+/// <summary>Configuration options for DebugProbe.</summary>
 public class DebugProbeOptions
 {
-    /// <summary>
-    /// Maximum number of stored entries.
-    /// </summary>
-    public int MaxEntries { get; set; } = 20;
+    /// <summary>Enables request capture and DebugProbe endpoints.</summary>
+    public bool Enabled { get; set; } = true;
 
-    /// <summary>
-    /// Maximum captured request or response body size in kilobytes.
-    /// </summary>
-    private int _maxBodyCaptureSizeKb = 32;
-    public int MaxBodyCaptureSizeKb
-    {
-        get => _maxBodyCaptureSizeKb;
-        set
-        {
-            if (value < 0)
-                throw new ArgumentOutOfRangeException(nameof(MaxBodyCaptureSizeKb),
-                    "MaxBodyCaptureSizeKb must be 0 or greater. Use 0 to disable body capture.");
-            _maxBodyCaptureSizeKb = value;
-        }
-    }
-
-    internal int MaxBodyCaptureSizeBytes => MaxBodyCaptureSizeKb * 1024;
+    /// <summary>Maximum number of requests kept in memory.</summary>
+    public int MaxRequests { get; set; } = 20;
 
-    /// <summary>
-    /// Duration in milliseconds above which a request or outgoing dependency is flagged as slow in the UI. Set to 0 or negative to disable the badge.
-    /// </summary>
-    public int SlowRequestThresholdMs { get; set; } = 1000;
+    /// <summary>Maximum captured size of each body in kilobytes. Zero disables body capture.</summary>
+    public int MaxBodySizeKb { get; set; } = 32;
 
-    /// <summary>
-    /// Lookback window in minutes for the request rate sparkline and error rate trend.
-    /// Defaults to 30. Must be greater than or equal to 2.
-    /// </summary>
-    public int TrendLookbackMinutes { get; set; } = 2;
+    internal int MaxBodySizeBytes => checked(MaxBodySizeKb * 1024);
 
-    /// <summary>
-    /// Allows compare operations to target localhost and private network addresses.
-    /// Defaults to true in Development and false in other environments unless explicitly configured.
-    /// </summary>
+    /// <summary>Captures incoming and outgoing request bodies.</summary>
+    public bool CaptureRequestBody { get; set; } = true;
+
+    /// <summary>Captures incoming and outgoing response bodies.</summary>
+    public bool CaptureResponseBody { get; set; } = true;
+
+    /// <summary>Duration at which requests are marked slow. Zero disables the badge.</summary>
+    public TimeSpan SlowRequestThreshold { get; set; } = TimeSpan.FromSeconds(1);
+
+    /// <summary>Allows compare operations against localhost and private networks. Null allows them only in Development.</summary>
     public bool? AllowLocalCompareTargets { get; set; }
 
-    /// <summary>
-    /// Allows DebugProbe UI endpoints to be registered in Production.
-    /// Defaults to false.
-    /// </summary>
+    /// <summary>Allows dashboard and API endpoints in Production. Capture remains enabled independently.</summary>
     public bool AllowUiInProduction { get; set; }
 
-    /// <summary>
-    /// Optional ASP.NET Core authorization policy required for DebugProbe endpoints.
-    /// When not configured, DebugProbe endpoints do not require authorization.
-    /// </summary>
+    /// <summary>Optional authorization policy required for all DebugProbe endpoints.</summary>
     public string? AuthorizationPolicy { get; set; }
 
-    /// <summary>
-    /// Captures outgoing requests made through IHttpClientFactory.
-    /// Defaults to true.
-    /// </summary>
-    public bool CaptureOutgoingHttpClientRequests { get; set; } = true;
+    /// <summary>Captures outgoing requests made through IHttpClientFactory during an incoming request.</summary>
+    public bool CaptureOutgoingRequests { get; set; } = true;
 
     /// <summary>
-    /// Enables automatic comparison of trace payloads for the same endpoint across different environments.
-    /// Defaults to false.
+    /// Paths excluded from capture, including child paths. Replace with an empty array to capture all application paths.
+    /// DebugProbe's own endpoints are always excluded.
     /// </summary>
-    public bool AutoEnvironmentDiff { get; set; } = false;
-
-    /// <summary>
-    /// Additional request paths to ignore.
-    /// </summary>
-    public string[] IgnorePaths { get; set; } = [];
-
-    /// <summary>
-    /// Header names whose values should be redacted before traces are stored.
-    /// </summary>
-    public string[] RedactedHeaders { get; set; } =
+    public string[] ExcludedPaths { get; set; } =
     [
-        "Authorization",
-        "Cookie",
-        "Set-Cookie"
+        "/swagger", "/health", "/healthz", "/ready", "/live", "/.well-known",
+        "/favicon.ico", "/.git", "/wp-admin", "/phpmyadmin", "/cgi-bin", "/server-status"
     ];
 
-    /// <summary>
-    /// Query parameter names whose values should be redacted before traces are stored.
-    /// </summary>
+    /// <summary>Header names whose values are replaced with [REDACTED]. Matching is case-insensitive.</summary>
+    public string[] RedactedHeaders { get; set; } = ["Authorization", "Cookie", "Set-Cookie"];
+
+    /// <summary>Query parameter names whose values are replaced with [REDACTED].</summary>
     public string[] RedactedQueryParameters { get; set; } = [];
 
-    /// <summary>
-    /// JSON property names whose values should be redacted before traces are stored.
-    /// </summary>
+    /// <summary>JSON property names whose values are replaced with [REDACTED].</summary>
     public string[] RedactedJsonFields { get; set; } = [];
 
-    /// <summary>
-    /// Value used when sensitive data is redacted.
-    /// </summary>
-    public string RedactionText { get; set; } = "[REDACTED]";
-
-    /// <summary>
-    /// The route prefix for the DebugProbe dashboard and API endpoints.
-    /// Defaults to <c>"/debug"</c>. A leading slash is added automatically if omitted.
-    /// </summary>
-    private string _routePrefix = "/debug";
-    public string RoutePrefix
-    {
-        get => _routePrefix;
-        set => _routePrefix = string.IsNullOrWhiteSpace(value)
-            ? "/debug"
-            : "/" + value.TrimStart('/');
-    }
+    /// <summary>Route prefix for all DebugProbe endpoints. A leading slash is optional.</summary>
+    public string RoutePrefix { get; set; } = "/debug";
 }
diff --git a/DebugProbe.AspNetCore/Options/DebugProbeOptionsValidator.cs b/DebugProbe.AspNetCore/Options/DebugProbeOptionsValidator.cs
index 46f8467..08f892c 100644
--- a/DebugProbe.AspNetCore/Options/DebugProbeOptionsValidator.cs
+++ b/DebugProbe.AspNetCore/Options/DebugProbeOptionsValidator.cs
@@ -2,29 +2,25 @@
 
 namespace DebugProbe.AspNetCore.Options;
 
-internal sealed class DebugProbeOptionsValidator
-    : IValidateOptions<DebugProbeOptions>
+internal sealed class DebugProbeOptionsValidator : IValidateOptions<DebugProbeOptions>
 {
-    public ValidateOptionsResult Validate(
-        string? name,
-        DebugProbeOptions options)
+    public ValidateOptionsResult Validate(string? name, DebugProbeOptions options)
     {
-        if (options.MaxEntries < 1)
-        {
-            return ValidateOptionsResult.Fail(
-                $"DebugProbe configuration is invalid. " +
-                $"MaxEntries must be greater than or equal to 1. " +
-                $"Provided value: {options.MaxEntries}.");
-        }
-
-        if (options.TrendLookbackMinutes < 2)
-        {
-            return ValidateOptionsResult.Fail(
-                $"DebugProbe configuration is invalid. " +
-                $"TrendLookbackMinutes must be greater than or equal to 2 (to allow splitting into two windows). " +
-                $"Provided value: {options.TrendLookbackMinutes}.");
-        }
-
-        return ValidateOptionsResult.Success;
+        var errors = new List<string>();
+        if (options.MaxRequests < 1)
+            errors.Add("MaxRequests must be at least 1.");
+        if (options.MaxBodySizeKb < 0 || options.MaxBodySizeKb > (int.MaxValue - 1) / 1024)
+            errors.Add($"MaxBodySizeKb must be between 0 and {(int.MaxValue - 1) / 1024}.");
+        if (options.SlowRequestThreshold < TimeSpan.Zero)
+            errors.Add("SlowRequestThreshold must be zero or greater.");
+        if (string.IsNullOrWhiteSpace(options.RoutePrefix) || options.RoutePrefix == "/" ||
+            options.RoutePrefix.Any(c => !(char.IsAsciiLetterOrDigit(c) || c is '/' or '-' or '_')) ||
+            options.RoutePrefix.Contains("//"))
+            errors.Add("RoutePrefix must contain a non-empty path using letters, digits, '/', '-' or '_'.");
+        if (options.ExcludedPaths is null || options.ExcludedPaths.Any(p => string.IsNullOrWhiteSpace(p) || !p.StartsWith('/')))
+            errors.Add("ExcludedPaths must contain paths starting with '/'.");
+        if (options.RedactedHeaders is null || options.RedactedQueryParameters is null || options.RedactedJsonFields is null)
+            errors.Add("Redaction lists must not be null. Use an empty array instead.");
+        return errors.Count == 0 ? ValidateOptionsResult.Success : ValidateOptionsResult.Fail(errors);
     }
-}
\ No newline at end of file
+}
diff --git a/DebugProbe.AspNetCore/README.md b/DebugProbe.AspNetCore/README.md
index bb15f31..393dd70 100644
--- a/DebugProbe.AspNetCore/README.md
+++ b/DebugProbe.AspNetCore/README.md
@@ -41,18 +41,19 @@ DebugProbe does not require authentication by default.
 ```csharp
 builder.Services.AddDebugProbe(options =>
 {
-    options.MaxEntries = 10;
+    options.MaxRequests = 10;
 
-    options.MaxBodyCaptureSizeKb = 256;
+    options.MaxBodySizeKb = 256;
 
     options.AllowLocalCompareTargets = true;
 
     options.AllowUiInProduction = false;
 
-    options.CaptureOutgoingHttpClientRequests = true;
+    options.CaptureOutgoingRequests = true;
 
-    options.IgnorePaths =
+    options.ExcludedPaths =
     [
+        ..options.ExcludedPaths,
         "/api/auth/login",
         "/api/auth/refresh"
     ];
@@ -80,6 +81,38 @@ builder.Services.AddDebugProbe(options =>
 app.UseDebugProbe();
 ```
 
+Configure options in `AddDebugProbe`; `UseDebugProbe()` only enables the middleware and endpoints.
+
+- `Enabled = false` disables capture and all DebugProbe endpoints.
+- `MaxBodySizeKb = 0` disables all body capture. Headers and request metadata are still captured.
+- `CaptureRequestBody` and `CaptureResponseBody` independently control incoming and outgoing bodies (both default to `true`).
+- `SlowRequestThreshold = TimeSpan.FromSeconds(1)` controls slow badges; `TimeSpan.Zero` disables them.
+- `ExcludedPaths` replaces the defaults. Use `[..options.ExcludedPaths, "/other"]` to extend them, or `[]` to capture all application paths.
+- `RoutePrefix` defaults to `"/debug"` and applies to the dashboard, assets, APIs, and compare page (`/debug/compare`).
+
+Standard .NET options configuration is also supported:
+
+```csharp
+builder.Services.AddDebugProbe();
+builder.Services.Configure<DebugProbeOptions>(builder.Configuration.GetSection("DebugProbe"));
+```
+
+Body capture uses the same rules for incoming and outgoing requests and responses:
+
+- The size limit applies to original body bytes; oversized text keeps a prefix followed by `[truncated]`.
+- Text uses the declared charset, with UTF-8 as the fallback; truncation does not leave a partial encoded character.
+- Binary content is represented by `[Body not captured: non-text content]`; empty or disabled bodies are empty strings.
+- If JSON field redaction is configured, truncated content is omitted because incomplete JSON cannot be reliably redacted.
+- Captured JSON is redacted before storage and formatted for display. Application payloads remain intact.
+
+Options are validated at startup. Configuration is fixed for the application's lifetime.
+
+This refactor renames `MaxEntries` to `MaxRequests`, `MaxBodyCaptureSizeKb` to `MaxBodySizeKb`,
+`IgnorePaths` to `ExcludedPaths`, and `CaptureOutgoingHttpClientRequests` to `CaptureOutgoingRequests`.
+`SlowRequestThresholdMs` is replaced by the `TimeSpan`-valued `SlowRequestThreshold`.
+`TrendLookbackMinutes`, `AutoEnvironmentDiff`, `RedactionText`, and the configuration overload of `UseDebugProbe` have been removed.
+Sensitive values use the fixed `[REDACTED]` marker. Trace comparison remains available manually.
+
 To protect DebugProbe endpoints, configure an ASP.NET Core authorization policy and require it when DebugProbe is registered:
 
 ```csharp
@@ -92,15 +125,19 @@ builder.Services.AddAuthorization(options =>
     });
 });
 
-app.UseAuthentication();
-app.UseAuthorization();
-
-app.UseDebugProbe(options =>
+builder.Services.AddDebugProbe(options =>
 {
     options.AuthorizationPolicy = "DebugProbePolicy";
 });
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.UseDebugProbe();
 ```
 
+Captured outgoing calls use a concurrent queue (`OutgoingRequests.Enqueue(...)` replaces `Add(...)`).
+Storage operations are synchronized; `ExceptionGroups` returns a read-only dictionary snapshot.
+
 ## Features
 
 - Request inspection
@@ -154,13 +191,14 @@ builder.Services.AddAuthorization(options =>
     });
 });
 
-app.UseAuthentication();
-app.UseAuthorization();
-
-app.UseDebugProbe(options =>
+builder.Services.AddDebugProbe(options =>
 {
     options.AuthorizationPolicy = "DebugProbePolicy";
 });
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.UseDebugProbe();
 ```
 
 DebugProbe masks common sensitive headers automatically:
diff --git a/DebugProbe.AspNetCore/Storage/DebugEntryStore.cs b/DebugProbe.AspNetCore/Storage/DebugEntryStore.cs
index 421acb7..45fb339 100644
--- a/DebugProbe.AspNetCore/Storage/DebugEntryStore.cs
+++ b/DebugProbe.AspNetCore/Storage/DebugEntryStore.cs
@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using System.Globalization;
 using System.Reflection;
 using System.Security.Cryptography;
@@ -19,28 +18,32 @@ public class DebugEntryStore
     private static readonly Regex NumberRegex = new(@"\b\d+(\.\d+)?\b", RegexOptions.Compiled);
 
     /// <summary>
-    /// Gets the static instance of DebugEntryStore.
+    /// Gets a snapshot of the exception groups. Later updates and clears do not change this snapshot.
     /// </summary>
-    public static DebugEntryStore? Instance { get; private set; }
-
-    /// <summary>
-    /// Gets the exception groups.
-    /// </summary>
-    public ConcurrentDictionary<string, ExceptionGroup> ExceptionGroups { get; } = new();
+    public IReadOnlyDictionary<string, ExceptionGroup> ExceptionGroups
+    {
+        get
+        {
+            lock (_sync)
+                return new Dictionary<string, ExceptionGroup>(_exceptionGroups);
+        }
+    }
 
     /// <summary>
     /// Gets environment information for the current application.
     /// </summary>
     public DebugEnvironment Environment { get; }
 
-    private readonly ConcurrentQueue<DebugEntry> _queue = new();
-    private readonly ConcurrentDictionary<string, DebugEnvironment> _entryEnvironments = new();
+    // A single lock keeps requests, environment mappings, and group counts consistent during Add and Clear.
+    private readonly object _sync = new();
+    private readonly Queue<DebugEntry> _queue = new();
+    private readonly Dictionary<string, ExceptionGroup> _exceptionGroups = new();
+    private readonly Dictionary<string, DebugEnvironment> _entryEnvironments = new();
     private readonly int _limit;
 
     public DebugEntryStore(DebugProbeOptions options)
     {
-        Instance = this;
-        _limit = options.MaxEntries;
+        _limit = options.MaxRequests;
 
         Environment = new DebugEnvironment
         {
@@ -62,70 +65,85 @@ public void Add(DebugEntry entry)
 
     public void Add(DebugEntry entry, DebugEnvironment environment)
     {
-        _queue.Enqueue(entry);
-        if (environment != null && entry.Id != null)
+        lock (_sync)
         {
-            _entryEnvironments[entry.Id] = environment;
-        }
+            _queue.Enqueue(entry);
+            if (environment != null && entry.Id != null)
+            {
+                _entryEnvironments[entry.Id] = environment;
+            }
 
-        if (TryParseException(entry.ResponseBody, out var type, out var message))
-        {
-            var normalizedMessage = NormalizeMessage(message);
-            var fingerprint = ComputeHash(type + normalizedMessage);
+            if (TryParseException(entry.ResponseBody, out var type, out var message))
+            {
+                var normalizedMessage = NormalizeMessage(message);
+                var fingerprint = ComputeHash(type + normalizedMessage);
 
-            ExceptionGroups.AddOrUpdate(fingerprint,
-                key => new ExceptionGroup
+                _exceptionGroups.TryGetValue(fingerprint, out var existing);
+                _exceptionGroups[fingerprint] = new ExceptionGroup
                 {
                     Fingerprint = fingerprint,
                     Type = type,
-                    SampleMessage = message,
-                    Count = 1,
+                    SampleMessage = existing?.SampleMessage ?? message,
+                    Count = (existing?.Count ?? 0) + 1,
                     LastSeen = DateTimeOffset.UtcNow
-                },
-                (key, existing) => new ExceptionGroup
-                {
-                    Fingerprint = existing.Fingerprint,
-                    Type = existing.Type,
-                    SampleMessage = existing.SampleMessage,
-                    Count = existing.Count + 1,
-                    LastSeen = DateTimeOffset.UtcNow
-                });
-        }
+                };
+            }
 
-        while (_queue.Count > _limit)
-        {
-            // ExceptionGroups counts are a running tally and must NOT be decremented on MaxEntries eviction.
-            if (_queue.TryDequeue(out var evicted) && evicted.Id != null)
+            // Keep aggregate groups bounded independently of request eviction.
+            while (_exceptionGroups.Count > _limit)
             {
-                _entryEnvironments.TryRemove(evicted.Id, out _);
+                var oldest = _exceptionGroups.Values.MinBy(group => group.LastSeen)!;
+                _exceptionGroups.Remove(oldest.Fingerprint);
+            }
+
+            while (_queue.Count > _limit)
+            {
+                // ExceptionGroups counts are a running tally and must NOT be decremented on MaxRequests eviction.
+                var evicted = _queue.Dequeue();
+                if (evicted.Id != null)
+                {
+                    _entryEnvironments.Remove(evicted.Id);
+                }
             }
         }
     }
 
     public DebugEnvironment GetEnvironment(DebugEntry entry)
     {
-        if (entry.Id != null && _entryEnvironments.TryGetValue(entry.Id, out var env))
+        lock (_sync)
         {
-            return env;
+            if (entry.Id != null && _entryEnvironments.TryGetValue(entry.Id, out var env))
+            {
+                return env;
+            }
+            return Environment;
         }
-        return Environment;
     }
 
     public List<DebugEntry> GetAll()
     {
-        return _queue.ToList();
+        lock (_sync)
+        {
+            return _queue.ToList();
+        }
     }
 
     public DebugEntry? Get(string id)
     {
-        return _queue.FirstOrDefault(x => x.Id == id);
+        lock (_sync)
+        {
+            return _queue.FirstOrDefault(x => x.Id == id);
+        }
     }
 
     public void Clear()
     {
-        while (_queue.TryDequeue(out _)) { }
-        _entryEnvironments.Clear();
-        ExceptionGroups.Clear();
+        lock (_sync)
+        {
+            _queue.Clear();
+            _entryEnvironments.Clear();
+            _exceptionGroups.Clear();
+        }
     }
 
     private static bool TryParseException(string? body, out string type, out string message)
diff --git a/DebugProbe.SampleApi/Program.cs b/DebugProbe.SampleApi/Program.cs
index 67a6241..1b37158 100644
--- a/DebugProbe.SampleApi/Program.cs
+++ b/DebugProbe.SampleApi/Program.cs
@@ -10,7 +10,7 @@
 builder.Services.AddSwaggerGen();
 builder.Services.AddDebugProbe(options =>
 {
-    options.MaxEntries = 10;
+    options.MaxRequests = 10;
     options.AllowUiInProduction = true;
 });
 
diff --git a/README.md b/README.md
index a9789db..393dd70 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# DebugProbe.AspNetCore
+# DebugProbe.AspNetCore
 
 DebugProbe.AspNetCore is a lightweight ASP.NET Core debugging tool for inspecting HTTP traffic directly inside your application.
 
@@ -41,18 +41,19 @@ DebugProbe does not require authentication by default.
 ```csharp
 builder.Services.AddDebugProbe(options =>
 {
-    options.MaxEntries = 10;
+    options.MaxRequests = 10;
 
-    options.MaxBodyCaptureSizeKb = 256;
+    options.MaxBodySizeKb = 256;
 
     options.AllowLocalCompareTargets = true;
 
     options.AllowUiInProduction = false;
 
-    options.CaptureOutgoingHttpClientRequests = true;
+    options.CaptureOutgoingRequests = true;
 
-    options.IgnorePaths =
+    options.ExcludedPaths =
     [
+        ..options.ExcludedPaths,
         "/api/auth/login",
         "/api/auth/refresh"
     ];
@@ -80,6 +81,38 @@ builder.Services.AddDebugProbe(options =>
 app.UseDebugProbe();
 ```
 
+Configure options in `AddDebugProbe`; `UseDebugProbe()` only enables the middleware and endpoints.
+
+- `Enabled = false` disables capture and all DebugProbe endpoints.
+- `MaxBodySizeKb = 0` disables all body capture. Headers and request metadata are still captured.
+- `CaptureRequestBody` and `CaptureResponseBody` independently control incoming and outgoing bodies (both default to `true`).
+- `SlowRequestThreshold = TimeSpan.FromSeconds(1)` controls slow badges; `TimeSpan.Zero` disables them.
+- `ExcludedPaths` replaces the defaults. Use `[..options.ExcludedPaths, "/other"]` to extend them, or `[]` to capture all application paths.
+- `RoutePrefix` defaults to `"/debug"` and applies to the dashboard, assets, APIs, and compare page (`/debug/compare`).
+
+Standard .NET options configuration is also supported:
+
+```csharp
+builder.Services.AddDebugProbe();
+builder.Services.Configure<DebugProbeOptions>(builder.Configuration.GetSection("DebugProbe"));
+```
+
+Body capture uses the same rules for incoming and outgoing requests and responses:
+
+- The size limit applies to original body bytes; oversized text keeps a prefix followed by `[truncated]`.
+- Text uses the declared charset, with UTF-8 as the fallback; truncation does not leave a partial encoded character.
+- Binary content is represented by `[Body not captured: non-text content]`; empty or disabled bodies are empty strings.
+- If JSON field redaction is configured, truncated content is omitted because incomplete JSON cannot be reliably redacted.
+- Captured JSON is redacted before storage and formatted for display. Application payloads remain intact.
+
+Options are validated at startup. Configuration is fixed for the application's lifetime.
+
+This refactor renames `MaxEntries` to `MaxRequests`, `MaxBodyCaptureSizeKb` to `MaxBodySizeKb`,
+`IgnorePaths` to `ExcludedPaths`, and `CaptureOutgoingHttpClientRequests` to `CaptureOutgoingRequests`.
+`SlowRequestThresholdMs` is replaced by the `TimeSpan`-valued `SlowRequestThreshold`.
+`TrendLookbackMinutes`, `AutoEnvironmentDiff`, `RedactionText`, and the configuration overload of `UseDebugProbe` have been removed.
+Sensitive values use the fixed `[REDACTED]` marker. Trace comparison remains available manually.
+
 To protect DebugProbe endpoints, configure an ASP.NET Core authorization policy and require it when DebugProbe is registered:
 
 ```csharp
@@ -92,15 +125,19 @@ builder.Services.AddAuthorization(options =>
     });
 });
 
-app.UseAuthentication();
-app.UseAuthorization();
-
-app.UseDebugProbe(options =>
+builder.Services.AddDebugProbe(options =>
 {
     options.AuthorizationPolicy = "DebugProbePolicy";
 });
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.UseDebugProbe();
 ```
 
+Captured outgoing calls use a concurrent queue (`OutgoingRequests.Enqueue(...)` replaces `Add(...)`).
+Storage operations are synchronized; `ExceptionGroups` returns a read-only dictionary snapshot.
+
 ## Features
 
 - Request inspection
@@ -154,13 +191,14 @@ builder.Services.AddAuthorization(options =>
     });
 });
 
-app.UseAuthentication();
-app.UseAuthorization();
-
-app.UseDebugProbe(options =>
+builder.Services.AddDebugProbe(options =>
 {
     options.AuthorizationPolicy = "DebugProbePolicy";
 });
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.UseDebugProbe();
 ```
 
 DebugProbe masks common sensitive headers automatically: