fix: ResponseIdValidationService owns its IMemoryCache; remove shared SizeLimit; remove dead cleanupOldSessions JS

- ResponseIdValidationService now creates and owns a dedicated MemoryCache
  instance (parameterless DI ctor) rather than injecting the shared
  IMemoryCache. This prevents the SizeLimit constraint from forcing every
  other IMemoryCache caller in the app to call SetSize, which would cause
  runtime InvalidOperationExceptions in ASP.NET Core's built-in caches.
- An IMemoryCache overload ctor is retained for unit test injection.
- Remove SizeLimit from AddMemoryCache() in Program.cs; the dedicated
  cache in ResponseIdValidationService already carries SizeLimit=10_000.
- Remove cleanupOldSessions() from chat-module.js: loadChatHistory()
  already enforces the 2-hour TTL on load, making the 7-day cleanup
  function unreachable dead code.

Author: BenjaminMichaelis

EssentialCSharp.Web/Program.cs

@@ -259,7 +259,7 @@ private static void Main(string[] args)
         // MCP server — always enabled, authenticated via opaque DB-backed tokens.
         builder.Services.AddScoped<McpApiTokenService>();
 
-        builder.Services.AddMemoryCache(options => options.SizeLimit = 10_000);
+        builder.Services.AddMemoryCache();
         builder.Services.AddSingleton<ResponseIdValidationService>();
 
         builder.Services.AddAuthentication()

EssentialCSharp.Web/Services/ResponseIdValidationService.cs

@@ -11,15 +11,53 @@ namespace EssentialCSharp.Web.Services;
 /// matching the OpenAI Responses API conversation window. This eliminates arbitrary eviction (no
 /// per-user <see cref="HashSet{T}"/> cap needed) and gives each ID its own natural TTL.
 ///
-/// <para><b>Cache-miss = allow</b> (graceful degradation): in a single-instance deployment a cache
-/// miss occurs only after a server restart. In a multi-instance deployment the cache is in-process only,
-/// so a request routed to a different instance will always miss. In both scenarios the user is allowed
-/// to continue rather than being locked out. This is an accepted trade-off for a soft control on an
+/// <para>This service creates and owns a dedicated <see cref="MemoryCache"/> with a bounded
+/// <c>SizeLimit</c>, rather than using the shared <c>IMemoryCache</c>. This prevents the
+/// <c>SizeLimit</c> from applying globally (which would require every other cache user in the app to
+/// call <c>SetSize</c>) while still bounding memory use for this service.</para>
+///
+/// <para><b>Cache-miss = allow</b> (graceful degradation): a cache miss can occur after a server
+/// restart, when a sliding-expiration entry times out (2 h of inactivity), under memory pressure
+/// (OS or GC-triggered eviction), or when the configured <c>SizeLimit</c> forces eviction of the
+/// least-recently-used entries. In a multi-instance deployment the in-process cache is not shared, so
+/// requests routed to a different instance always miss. In all these scenarios the user is allowed to
+/// continue rather than being locked out. This is an accepted trade-off for a soft control on an
 /// already-authenticated, rate-limited endpoint. Upgrade to <c>IDistributedCache</c> (e.g., Redis) to
-/// close this gap in multi-instance deployments.</para>
+/// close this gap in multi-instance or high-eviction deployments.</para>
 /// </remarks>
-public sealed class ResponseIdValidationService(IMemoryCache cache)
+public sealed class ResponseIdValidationService : IDisposable
 {
+    private const int CacheSizeLimit = 10_000;
+
+    private readonly IMemoryCache _cache;
+    private readonly bool _ownsCache;
+
+    /// <summary>
+    /// Production constructor. Creates and owns a dedicated <see cref="MemoryCache"/> with a bounded
+    /// <see cref="MemoryCacheOptions.SizeLimit"/> so the app-wide shared <c>IMemoryCache</c> is unaffected.
+    /// </summary>
+    public ResponseIdValidationService()
+        : this(new MemoryCache(new MemoryCacheOptions { SizeLimit = CacheSizeLimit }), ownsCache: true) { }
+
+    /// <summary>
+    /// Testing constructor. The caller owns and disposes the supplied cache.
+    /// </summary>
+    public ResponseIdValidationService(IMemoryCache cache)
+        : this(cache, ownsCache: false) { }
+
+    private ResponseIdValidationService(IMemoryCache cache, bool ownsCache)
+    {
+        _cache = cache;
+        _ownsCache = ownsCache;
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (_ownsCache && _cache is IDisposable disposable)
+            disposable.Dispose();
+    }
+
     /// <summary>
     /// Records a newly issued response ID as belonging to the specified user.
     /// </summary>
@@ -33,11 +71,11 @@ public void RecordResponseId(string? userId, string? responseId)
         // Create a fresh options instance per call — MemoryCacheEntryOptions has mutable
         // list properties (ExpirationTokens, PostEvictionCallbacks) and sharing a static
         // instance would cause future additions to affect all entries.
-        // Size = 1 unit per entry is required when AddMemoryCache sets a SizeLimit.
+        // SetSize(1) accounts for this entry against the dedicated cache's SizeLimit.
         var entryOptions = new MemoryCacheEntryOptions()
             .SetSlidingExpiration(TimeSpan.FromHours(2))
             .SetSize(1);
-        cache.Set(ResponseKey(responseId), userId, entryOptions);
+        _cache.Set(ResponseKey(responseId), userId, entryOptions);
     }
 
     /// <summary>
@@ -60,7 +98,7 @@ public bool ValidateResponseId(string? userId, string? responseId)
             return false;
         }
 
-        if (!cache.TryGetValue(ResponseKey(responseId), out string? ownerUserId))
+        if (!_cache.TryGetValue(ResponseKey(responseId), out string? ownerUserId))
         {
             return true; // Cache miss — allow (graceful degradation; see class remarks)
         }

EssentialCSharp.Web/wwwroot/js/chat-module.js

@@ -379,29 +379,6 @@ export function useChatWidget() {
         }
     }
 
-    // Clean up old chat sessions (keep only last 7 days)
-    function cleanupOldSessions() {
-        try {
-            const saved = localStorage.getItem('aiChatHistory');
-            if (saved) {
-                const data = JSON.parse(saved);
-                const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
-                
-                if (data.timestamp && data.timestamp < sevenDaysAgo) {
-                    localStorage.removeItem('aiChatHistory');
-                    sessionStorage.removeItem('aiChatLastResponseId');
-                    chatMessages.value = [];
-                    lastResponseId.value = null;
-                }
-            }
-        } catch (error) {
-            console.warn('Failed to cleanup old sessions:', error);
-        }
-    }
-
-    // Run cleanup on initialization
-    cleanupOldSessions();
-
     return {
         // State
         isAuthenticated,