From e7671974add99e298fbcf343e03cb94d920a0bcb Mon Sep 17 00:00:00 2001
From: justcoding121 <justcoding121@users.noreply.github.com>
Date: Tue, 6 Oct 2026 23:53:16 +0530
Subject: [PATCH 1/4] chore(packaging): point the Homebrew formula at
 v7.0.19-beta.

---
 tools/packaging/homebrew/titanium.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/packaging/homebrew/titanium.rb b/tools/packaging/homebrew/titanium.rb
index d6e856aa9..b826b1483 100644
--- a/tools/packaging/homebrew/titanium.rb
+++ b/tools/packaging/homebrew/titanium.rb
@@ -10,17 +10,17 @@
 class Titanium < Formula
   desc "Titanium Web Proxy CLI (MITM / reverse proxy)"
   homepage "https://github.com/justcoding121/titanium-web-proxy"
-  version "7.0.18"
+  version "7.0.19-beta"
   license "MIT"
 
   on_macos do
     on_arm do
       url "https://github.com/justcoding121/titanium-web-proxy/releases/download/v#{version}/Titanium.Cli-osx-arm64.zip"
-      sha256 "8375729ba30c78ffa78e205dc1eb32b5bbc8b6ee7b8c61c5c3f0614dd42f592b"
+      sha256 "501ac9b954caadd2dbe620b6256b0634956a41dcef7e9515f1468b7447a58928"
     end
     on_intel do
       url "https://github.com/justcoding121/titanium-web-proxy/releases/download/v#{version}/Titanium.Cli-osx-x64.zip"
-      sha256 "56f23954bbf9ba424d3082e3875b3b5c7e5e1658b20368a2ddf9dc27067e3f87"
+      sha256 "223f8febc441539fc40194a27f210d550d21a0c7d6ec04a800bace0b3560a0e4"
     end
   end
 

From efd4cd7bbda931bcd6c24fb39c15e26dbc214dff Mon Sep 17 00:00:00 2001
From: justcoding121 <justcoding121@users.noreply.github.com>
Date: Wed, 7 Oct 2026 01:12:48 +0530
Subject: [PATCH 2/4] chore(packaging): point the Homebrew formula at v7.0.19.

---
 tools/packaging/homebrew/titanium.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/packaging/homebrew/titanium.rb b/tools/packaging/homebrew/titanium.rb
index b826b1483..4eb913a94 100644
--- a/tools/packaging/homebrew/titanium.rb
+++ b/tools/packaging/homebrew/titanium.rb
@@ -10,17 +10,17 @@
 class Titanium < Formula
   desc "Titanium Web Proxy CLI (MITM / reverse proxy)"
   homepage "https://github.com/justcoding121/titanium-web-proxy"
-  version "7.0.19-beta"
+  version "7.0.19"
   license "MIT"
 
   on_macos do
     on_arm do
       url "https://github.com/justcoding121/titanium-web-proxy/releases/download/v#{version}/Titanium.Cli-osx-arm64.zip"
-      sha256 "501ac9b954caadd2dbe620b6256b0634956a41dcef7e9515f1468b7447a58928"
+      sha256 "807a2e7ddbe3572404112b7b7c10187c92d4c87191b35528d2dcf82259d8db16"
     end
     on_intel do
       url "https://github.com/justcoding121/titanium-web-proxy/releases/download/v#{version}/Titanium.Cli-osx-x64.zip"
-      sha256 "223f8febc441539fc40194a27f210d550d21a0c7d6ec04a800bace0b3560a0e4"
+      sha256 "87fe8c227cd9fc5ef376af4dfd0552aff919b0b4fb19e743c404ec0143fa6d37"
     end
   end
 

From 4a524117017aa869a41ae5154d43f18035304368 Mon Sep 17 00:00:00 2001
From: justcoding121 <justcoding121@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:31:33 +0530
Subject: [PATCH 3/4] feat(inspector): wipe the current session run on clear
 and remove empty cache folders

Clear sessions deletes the current run, including rows the list limit already hid. Session retention can wipe every saved run after confirmation, and empty run folders are removed instead of accumulating.
---
 .../Services/SessionBodyDiskCache.cs          | 257 +++++++++++++++--
 .../Services/SessionStore.cs                  |  49 +++-
 .../MainWindowViewModel.Sessions.cs           |   8 +-
 .../ViewModels/MainWindowViewModel.cs         |   2 +-
 .../Views/SessionRetentionWindow.axaml        |  26 +-
 .../Views/SessionRetentionWindow.axaml.cs     |  95 +++++-
 .../AutomationIdCoverageHeadlessTests.cs      |   2 +
 .../CaptureSettingsParityTests.cs             |  11 +
 .../InspectorBodyHonestyTests.cs              |   2 +
 .../SessionStoreRetentionTests.cs             | 272 ++++++++++++++++++
 website/docs/inspector.md                     |  17 +-
 11 files changed, 702 insertions(+), 39 deletions(-)

diff --git a/src/Titanium.Inspector/Services/SessionBodyDiskCache.cs b/src/Titanium.Inspector/Services/SessionBodyDiskCache.cs
index fc7179bc4..7f3a6cd5f 100644
--- a/src/Titanium.Inspector/Services/SessionBodyDiskCache.cs
+++ b/src/Titanium.Inspector/Services/SessionBodyDiskCache.cs
@@ -3,11 +3,15 @@
 
 namespace Titanium.Inspector.Services;
 
+/// <summary>Tracked HAR files under the session cache, for the retention window.</summary>
+public readonly record struct SessionCacheStats(int RunCount, long TotalBytes);
+
 /// <summary>
 /// On-disk session cache under a size budget. Each Inspector process run writes into a
 /// timestamped subfolder under the cache root (<c>{root}/{yyyyMMdd-HHmmss-fff}/{id}.har</c>)
-/// so restarted session ids never overwrite another run. Disk budget counts all runs and
-/// deletes oldest HAR files first (across folders).
+/// so restarted session ids never overwrite another run. The run folder is created on the
+/// first write. Disk budget counts all runs and deletes oldest HAR files first (across folders).
+/// Empty run folders other than the current run are removed.
 /// </summary>
 public sealed class SessionBodyDiskCache : IDisposable
 {
@@ -28,6 +32,8 @@ public sealed class SessionBodyDiskCache : IDisposable
         StringComparer.OrdinalIgnoreCase);
     private long _trackedBytes;
     private bool _disposed;
+    private static readonly object RunPathReserveGate = new();
+    private static readonly HashSet<string> ReservedRunPaths = new(StringComparer.OrdinalIgnoreCase);
 
     public SessionBodyDiskCache(string rootDirectory, long maxBytes, TimeSpan maxAge)
         : this(rootDirectory, maxBytes, maxAge, runStartedUtc: DateTimeOffset.UtcNow)
@@ -44,6 +50,7 @@ internal SessionBodyDiskCache(
         Directory.CreateDirectory(_rootDirectory);
         _runDirectory = CreateRunDirectory(_rootDirectory, runStartedUtc);
         RebuildIndexAndEnforceBudget();
+        SweepEmptyRunFolders();
     }
 
     /// <summary>Updates disk budget. Index updates return immediately; file deletes run in the background.</summary>
@@ -98,6 +105,63 @@ public static string GetDefaultDirectory() =>
     /// <summary>Alias for <see cref="RootDirectoryPath"/> (UI / options).</summary>
     public string DirectoryPath => _rootDirectory;
 
+    /// <summary>
+    /// Run count and tracked bytes. Run count includes indexed parents and on-disk run
+    /// folders that still contain a HAR. Bytes come from the size index.
+    /// </summary>
+    public SessionCacheStats GetCacheStats()
+    {
+        HashSet<string> runs;
+        long bytes;
+        lock (_gate)
+        {
+            bytes = _trackedBytes;
+            runs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var path in _index.Keys)
+            {
+                var dir = Path.GetDirectoryName(path);
+                if (!string.IsNullOrEmpty(dir))
+                {
+                    runs.Add(Path.GetFullPath(dir));
+                }
+            }
+        }
+
+        if (!Directory.Exists(_rootDirectory))
+        {
+            return new SessionCacheStats(runs.Count, bytes);
+        }
+
+        try
+        {
+            var rootFull = Path.GetFullPath(_rootDirectory);
+            if (Directory.EnumerateFiles(_rootDirectory, SessionFileSearchPattern).Any())
+            {
+                runs.Add(rootFull);
+            }
+
+            foreach (var sub in Directory.EnumerateDirectories(_rootDirectory))
+            {
+                var full = Path.GetFullPath(sub);
+                if (runs.Contains(full))
+                {
+                    continue;
+                }
+
+                if (Directory.EnumerateFiles(sub, SessionFileSearchPattern).Any())
+                {
+                    runs.Add(full);
+                }
+            }
+        }
+        catch
+        {
+            // Best-effort stats while a delete is in progress.
+        }
+
+        return new SessionCacheStats(runs.Count, bytes);
+    }
+
     public string PathFor(long sessionId) =>
         Path.Combine(_runDirectory, sessionId.ToString("D", CultureInfo.InvariantCulture) + ".har");
 
@@ -250,25 +314,29 @@ public void DeleteMany(IEnumerable<long> sessionIds)
     }
 
     /// <summary>
-    /// Drops the current run folder from the index and moves it aside. New writes use a fresh folder.
-    /// The moved folder is deleted on a background thread. Other run folders are left in place.
+    /// Drops the current run folder from the index and moves it aside. New writes use a fresh
+    /// folder path, created on the next write. The moved folder is deleted on a background thread.
+    /// Other run folders are left in place. Returns tracked bytes queued for deletion.
     /// </summary>
-    public void AbandonCurrentRun()
+    public long AbandonCurrentRun()
     {
         string old;
+        long freed;
         lock (_writeGate)
         {
             lock (_gate)
             {
                 old = _runDirectory;
                 Interlocked.Increment(ref _runGeneration);
+                var before = _trackedBytes;
                 RemoveIndexEntriesUnder(old);
+                freed = Math.Max(0, before - _trackedBytes);
                 _runDirectory = CreateRunDirectory(_rootDirectory, DateTimeOffset.UtcNow);
             }
 
             if (!Directory.Exists(old))
             {
-                return;
+                return freed;
             }
 
             var trash = Path.Combine(Path.GetTempPath(), "ti-discard-" + Guid.NewGuid().ToString("N"));
@@ -282,6 +350,32 @@ public void AbandonCurrentRun()
                 QueueCleanup([old]);
             }
         }
+
+        return freed;
+    }
+
+    /// <summary>
+    /// Rotates the current run so in-flight spills are rejected, then deletes every run folder
+    /// on the cleanup queue. The replacement folder is not created until the next write.
+    /// Returns tracked bytes queued for deletion. Does not enumerate the cache on the caller thread.
+    /// </summary>
+    public long ScheduleClearAllRuns()
+    {
+        long freed;
+        lock (_writeGate)
+        {
+            lock (_gate)
+            {
+                freed = _trackedBytes;
+                Interlocked.Increment(ref _runGeneration);
+                _index.Clear();
+                _trackedBytes = 0;
+                _runDirectory = CreateRunDirectory(_rootDirectory, DateTimeOffset.UtcNow);
+            }
+        }
+
+        QueueFullWipe();
+        return freed;
     }
 
     /// <summary>Removes session files from the size index immediately and deletes them in the background.</summary>
@@ -406,7 +500,6 @@ public void ClearAllRuns()
             }
         }
 
-        Directory.CreateDirectory(_runDirectory);
         lock (_gate)
         {
             _index.Clear();
@@ -636,16 +729,22 @@ private void TryDeleteEmptyRunFolder(string? folder)
             return;
         }
 
-        try
+        for (var attempt = 0; attempt < 8; attempt++)
         {
-            if (Directory.Exists(full) && IsEmptyDirectory(full))
+            try
             {
+                if (!Directory.Exists(full) || !IsEmptyDirectory(full))
+                {
+                    return;
+                }
+
                 Directory.Delete(full, recursive: false);
+                return;
+            }
+            catch
+            {
+                Thread.Sleep(25 * (attempt + 1));
             }
-        }
-        catch
-        {
-            // Best-effort.
         }
     }
 
@@ -736,6 +835,103 @@ private void DrainCleanupBatch()
         {
             TryDeletePathWithRetry(path);
         }
+
+        SweepEmptyRunFolders();
+    }
+
+    private void QueueFullWipe()
+    {
+        lock (_cleanupGate)
+        {
+            _cleanupTask = _cleanupTask.ContinueWith(
+                _ => RunFullWipe(),
+                CancellationToken.None,
+                TaskContinuationOptions.RunContinuationsAsynchronously,
+                TaskScheduler.Default);
+        }
+    }
+
+    /// <summary>
+    /// Deletes every run folder except whichever path is current at the moment of each delete,
+    /// so a second clear cannot lose the newest run to an older wipe.
+    /// </summary>
+    private void RunFullWipe()
+    {
+        LastCleanupThreadId = Environment.CurrentManagedThreadId;
+        if (!Directory.Exists(_rootDirectory))
+        {
+            return;
+        }
+
+        List<string> dirs;
+        try
+        {
+            dirs = Directory.EnumerateDirectories(_rootDirectory).ToList();
+        }
+        catch
+        {
+            return;
+        }
+
+        foreach (var sub in dirs)
+        {
+            if (IsCurrentRunDirectory(sub))
+            {
+                continue;
+            }
+
+            TryDeletePathWithRetry(sub);
+        }
+
+        try
+        {
+            foreach (var file in Directory.EnumerateFiles(_rootDirectory).ToList())
+            {
+                TryDeletePathWithRetry(file);
+            }
+        }
+        catch
+        {
+            // Best-effort.
+        }
+    }
+
+    private bool IsCurrentRunDirectory(string path)
+    {
+        lock (_writeGate)
+        {
+            return string.Equals(
+                Path.GetFullPath(path),
+                Path.GetFullPath(_runDirectory),
+                StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    /// <summary>Deletes empty subfolders except the current run and the cache root.</summary>
+    private void SweepEmptyRunFolders()
+    {
+        lock (_writeGate)
+        {
+            if (!Directory.Exists(_rootDirectory))
+            {
+                return;
+            }
+
+            List<string> subs;
+            try
+            {
+                subs = Directory.EnumerateDirectories(_rootDirectory).ToList();
+            }
+            catch
+            {
+                return;
+            }
+
+            foreach (var sub in subs)
+            {
+                TryDeleteEmptyRunFolder(sub);
+            }
+        }
     }
 
     private static void TryDeletePathWithRetry(string path)
@@ -783,17 +979,40 @@ private void RemoveIndexEntriesUnder(string directory)
         }
     }
 
+    /// <summary>
+    /// Picks a unique run-folder path. The directory is created on the first write so a run
+    /// that captures nothing does not leave an empty folder. The name is reserved in-process
+    /// so two caches started in the same millisecond do not share a path before either exists.
+    /// </summary>
     internal static string CreateRunDirectory(string root, DateTimeOffset startedUtc)
     {
         var stamp = startedUtc.UtcDateTime.ToString("yyyyMMdd-HHmmss-fff", CultureInfo.InvariantCulture);
-        var path = Path.Combine(root, stamp);
-        // Extremely unlikely collision within the same millisecond.
-        if (Directory.Exists(path))
+        lock (RunPathReserveGate)
         {
-            path = Path.Combine(root, stamp + "-" + Guid.NewGuid().ToString("N")[..6]);
+            var path = Path.Combine(root, stamp);
+            if (TryReserveRunPath(path))
+            {
+                return path;
+            }
+
+            for (var i = 0; i < 5; i++)
+            {
+                path = Path.Combine(root, stamp + "-" + Guid.NewGuid().ToString("N")[..6]);
+                if (TryReserveRunPath(path))
+                {
+                    return path;
+                }
+            }
+
+            path = Path.Combine(root, stamp + "-" + Guid.NewGuid().ToString("N"));
+            TryReserveRunPath(path);
+            return path;
         }
+    }
 
-        Directory.CreateDirectory(path);
-        return path;
+    private static bool TryReserveRunPath(string path)
+    {
+        var full = Path.GetFullPath(path);
+        return !Directory.Exists(full) && ReservedRunPaths.Add(full);
     }
 }
diff --git a/src/Titanium.Inspector/Services/SessionStore.cs b/src/Titanium.Inspector/Services/SessionStore.cs
index ffa5f7f6c..18a194068 100644
--- a/src/Titanium.Inspector/Services/SessionStore.cs
+++ b/src/Titanium.Inspector/Services/SessionStore.cs
@@ -7,6 +7,8 @@ namespace Titanium.Inspector.Services;
 /// Captured sessions: in-memory list (headers/metadata; bodies unloaded), HAR archive on disk
 /// (per-run subfolders under the cache root), and two independent limits — MaxSessionsInMemory
 /// (drop rows from the list) and DiskCacheMaxBytes (delete oldest HAR files across runs).
+/// Empty run folders other than the current run are removed. The current run folder is created
+/// on the first spill.
 /// </summary>
 public sealed class SessionStore : IDisposable
 {
@@ -265,11 +267,13 @@ public void Remove(IEnumerable<long> ids)
     }
 
     /// <summary>
-    /// Drops every in-memory session and rotates the current-run HAR folder.
-    /// Does not raise <see cref="SessionsRemoved"/> — the caller clears the grid itself.
+    /// Drops every in-memory session and deletes the current-run HAR folder, including rows
+    /// already evicted from the list. Earlier runs stay on disk. Does not raise
+    /// <see cref="SessionsRemoved"/> — the caller clears the grid itself.
     /// Disk deletion continues in the background (<see cref="FlushDiskCleanupAsync"/>).
+    /// Returns tracked bytes queued for deletion.
     /// </summary>
-    public void Clear()
+    public long Clear()
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
         lock (_gate)
@@ -281,9 +285,46 @@ public void Clear()
             Interlocked.Increment(ref _spillEpoch);
         }
 
-        _disk?.AbandonCurrentRun();
+        return _disk?.AbandonCurrentRun() ?? 0;
     }
 
+    /// <summary>
+    /// Deletes every saved run, including the current one. In-flight spills are rejected via
+    /// the run generation. Rows stay in the list; spilled bodies are marked missing.
+    /// Deletion runs in the background (<see cref="FlushDiskCleanupAsync"/>).
+    /// Returns tracked bytes queued for deletion.
+    /// </summary>
+    public long ClearAllSavedRuns()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (_disk is null)
+        {
+            return 0;
+        }
+
+        long freed;
+        List<long> spilled;
+        lock (_gate)
+        {
+            spilled = new List<long>();
+            foreach (var snap in _byId.Values)
+            {
+                if (snap.BodiesOnDisk)
+                {
+                    spilled.Add(snap.Id);
+                }
+            }
+
+            freed = _disk.ScheduleClearAllRuns();
+        }
+
+        MarkBodiesMissing(spilled);
+        return freed;
+    }
+
+    /// <summary>Run count and tracked bytes for the retention window. Zero when spill is off.</summary>
+    public SessionCacheStats GetCacheStats() => _disk?.GetCacheStats() ?? default;
+
     /// <summary>
     /// Inserts many sessions under one lock and enforces the memory cap once.
     /// Spill writes are queued; HAR files are not written on the caller thread.
diff --git a/src/Titanium.Inspector/ViewModels/MainWindowViewModel.Sessions.cs b/src/Titanium.Inspector/ViewModels/MainWindowViewModel.Sessions.cs
index 1977ddda0..d60a41122 100644
--- a/src/Titanium.Inspector/ViewModels/MainWindowViewModel.Sessions.cs
+++ b/src/Titanium.Inspector/ViewModels/MainWindowViewModel.Sessions.cs
@@ -41,10 +41,11 @@ private Task ClearSessionsAsync()
 
         _userRemovalDepth++;
         _suppressOpenSessionDetails = true;
+        long freed;
         try
         {
             // Store.Clear does not raise SessionsRemoved. One grid Clear is a single Reset.
-            _store.Clear();
+            freed = _store.Clear();
             Sessions.Clear();
         }
         finally
@@ -57,7 +58,10 @@ private Task ClearSessionsAsync()
         _interception.ResetSessionIdSequence();
         RefreshSessionCountText();
         NotifyFilterSelectionProperties();
-        SetOutcomeStatus("Sessions cleared", StatusSeverity.Success, toastImportant: true);
+        SetOutcomeStatus(
+            SessionRetentionWindow.FormatSessionsClearedStatus(freed),
+            StatusSeverity.Success,
+            toastImportant: true);
         return Task.CompletedTask;
     }
     private Task RemoveSelectedSessionsAsync()
diff --git a/src/Titanium.Inspector/ViewModels/MainWindowViewModel.cs b/src/Titanium.Inspector/ViewModels/MainWindowViewModel.cs
index 1ccd10ea1..a63ad2b40 100644
--- a/src/Titanium.Inspector/ViewModels/MainWindowViewModel.cs
+++ b/src/Titanium.Inspector/ViewModels/MainWindowViewModel.cs
@@ -1030,7 +1030,7 @@ private async Task OpenSessionRetentionAsync()
             return;
         }
 
-        var saved = await AwaitCancellableAsync(SessionRetentionWindow.ShowAsync(owner, _settings));
+        var saved = await AwaitCancellableAsync(SessionRetentionWindow.ShowAsync(owner, _settings, _store));
         if (!saved)
         {
             StatusText = "Session retention cancelled";
diff --git a/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml b/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml
index f148332a9..94a714750 100644
--- a/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml
+++ b/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml
@@ -3,7 +3,7 @@
         x:Class="Titanium.Inspector.Views.SessionRetentionWindow"
         AutomationProperties.AutomationId="SessionRetentionWindow"
         Title="Session retention"
-        Width="520" Height="400"
+        Width="520" Height="460"
         WindowStartupLocation="CenterOwner"
         CanResize="False">
   <DockPanel Margin="16">
@@ -18,7 +18,7 @@
         <StackPanel Spacing="4">
           <TextBlock FontWeight="SemiBold" Text="Maximum sessions to keep" />
           <TextBlock Opacity="0.75" TextWrapping="Wrap"
-                     Text="How many requests stay in the session list. When over this, the oldest rows leave the list but remain on disk until the disk space limit removes them." />
+                     Text="How many requests stay in the session list. When over this, the oldest rows leave the list but remain on disk until Clear sessions or the disk space limit removes them." />
           <TextBox x:Name="MaxSessionsBox" Width="120" HorizontalAlignment="Left" Watermark="10000"
                    AutomationProperties.AutomationId="RetentionMaxSessions" />
         </StackPanel>
@@ -31,12 +31,20 @@
                    AcceptsReturn="True"
                    Opacity="0.85"
                    AutomationProperties.AutomationId="RetentionCacheFolderPath" />
-          <Button x:Name="OpenCacheFolderButton"
-                  Content="Open cache folder"
-                  HorizontalAlignment="Left"
-                  MinWidth="88"
-                  Margin="0,4,0,0"
-                  AutomationProperties.AutomationId="RetentionOpenCacheFolder" />
+          <TextBlock x:Name="CacheUsageText"
+                     Opacity="0.75"
+                     TextWrapping="Wrap"
+                     AutomationProperties.AutomationId="RetentionCacheUsage" />
+          <StackPanel Orientation="Horizontal" Spacing="8" Margin="0,4,0,0">
+            <Button x:Name="OpenCacheFolderButton"
+                    Content="Open cache folder"
+                    MinWidth="88"
+                    AutomationProperties.AutomationId="RetentionOpenCacheFolder" />
+            <Button x:Name="ClearSavedCacheButton"
+                    Content="Clear saved session cache…"
+                    MinWidth="88"
+                    AutomationProperties.AutomationId="RetentionClearSavedCache" />
+          </StackPanel>
         </StackPanel>
 
         <Expander Header="Advanced" IsExpanded="True"
@@ -44,7 +52,7 @@
           <StackPanel Spacing="4" Margin="0,8,0,0">
             <TextBlock FontWeight="SemiBold" Text="Disk space for saved sessions (MB)" />
             <TextBlock Opacity="0.75" TextWrapping="Wrap"
-                       Text="Maximum space for all saved sessions on disk (all Inspector runs). Each run uses a timestamped subfolder; oldest HAR files are deleted first when over this." />
+                       Text="Maximum space for all saved sessions on disk (all Inspector runs). Each run uses a timestamped subfolder; oldest HAR files are deleted first when over this. Empty run folders are removed." />
             <TextBox x:Name="DiskCacheMaxMbBox" Width="120" HorizontalAlignment="Left" Watermark="2048"
                      AutomationProperties.AutomationId="RetentionDiskCacheMb" />
           </StackPanel>
diff --git a/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml.cs b/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml.cs
index 7cdd657bf..fd6379e1d 100644
--- a/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml.cs
+++ b/src/Titanium.Inspector/Views/SessionRetentionWindow.axaml.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Titanium.Inspector.Services;
@@ -7,37 +8,125 @@ namespace Titanium.Inspector.Views;
 public partial class SessionRetentionWindow : Window
 {
     private readonly SettingsService _settings;
+    private readonly SessionStore? _store;
     private bool _saved;
 
     public SessionRetentionWindow() : this(SettingsService.Load())
     {
     }
 
-    public SessionRetentionWindow(SettingsService settings)
+    public SessionRetentionWindow(SettingsService settings, SessionStore? store = null)
     {
         _settings = settings;
+        _store = store;
         InitializeComponent();
         LoadFromSettings();
         SaveButton.Click += OnSave;
         CancelButton.Click += (_, _) => Close();
         OpenCacheFolderButton.Click += OnOpenCacheFolder;
+        ClearSavedCacheButton.Click += OnClearSavedCache;
     }
 
     public bool Saved => _saved;
 
-    public static async Task<bool> ShowAsync(Window owner, SettingsService settings)
+    public static async Task<bool> ShowAsync(Window owner, SettingsService settings, SessionStore? store = null)
     {
-        var w = new SessionRetentionWindow(settings);
+        var w = new SessionRetentionWindow(settings, store);
         await w.ShowDialog(owner);
         return w.Saved;
     }
 
+    public static string FormatCacheUsage(SessionCacheStats stats)
+    {
+        if (stats.RunCount <= 0 && stats.TotalBytes <= 0)
+        {
+            return "No saved sessions on disk.";
+        }
+
+        return DescribeRuns(stats.RunCount) + ", " + SessionDisplayFormat.FormatByteSize(stats.TotalBytes) + " on disk.";
+    }
+
+    public static string FormatClearCacheConfirm(SessionCacheStats stats)
+    {
+        var size = SessionDisplayFormat.FormatByteSize(stats.TotalBytes);
+        return "Delete " + DescribeRuns(stats.RunCount) + " (" + size + ")? "
+            + "This removes saved session files from every run, including the current one. "
+            + "Sessions stay in the list, but their saved bodies are removed.";
+    }
+
+    public static string FormatSessionsClearedStatus(long freedBytes) =>
+        freedBytes > 0
+            ? "Sessions cleared (freed " + SessionDisplayFormat.FormatByteSize(freedBytes) + ")"
+            : "Sessions cleared";
+
+    private static string DescribeRuns(int runCount) =>
+        runCount == 1
+            ? "1 saved run"
+            : runCount.ToString(CultureInfo.InvariantCulture) + " saved runs";
+
     private void LoadFromSettings()
     {
         var s = _settings.Current;
         DiskCacheMaxMbBox.Text = BytesToMb(s.DiskCacheMaxBytes).ToString();
         MaxSessionsBox.Text = s.MaxSessionsInMemory.ToString();
         CacheFolderPathBox.Text = SessionBodyDiskCache.GetDefaultDirectory();
+        RefreshCacheUsage();
+    }
+
+    private void RefreshCacheUsage()
+    {
+        CacheUsageText.Text = _store is null
+            ? "Saved session cache is not available."
+            : FormatCacheUsage(_store.GetCacheStats());
+    }
+
+    private async void OnClearSavedCache(object? sender, RoutedEventArgs e)
+    {
+        try
+        {
+            await ClearSavedCacheAsync();
+        }
+        catch (Exception ex)
+        {
+            StatusText.Text = "Could not clear saved session cache: " + ex.Message;
+        }
+    }
+
+    private async Task ClearSavedCacheAsync()
+    {
+        StatusText.Text = string.Empty;
+        if (_store is null)
+        {
+            StatusText.Text = "Saved session cache is not available.";
+            return;
+        }
+
+        var stats = _store.GetCacheStats();
+        if (stats.RunCount <= 0 && stats.TotalBytes <= 0)
+        {
+            StatusText.Text = "No saved sessions on disk.";
+            RefreshCacheUsage();
+            return;
+        }
+
+        var accepted = await SimpleConfirmDialog.ShowAsync(
+            this,
+            "Clear saved session cache",
+            FormatClearCacheConfirm(stats),
+            "Delete",
+            "Cancel",
+            height: 240);
+        if (!accepted)
+        {
+            StatusText.Text = "Clear saved session cache cancelled";
+            return;
+        }
+
+        var freed = _store.ClearAllSavedRuns();
+        StatusText.Text = freed > 0
+            ? "Cleared saved session cache (freed " + SessionDisplayFormat.FormatByteSize(freed) + ")"
+            : "Cleared saved session cache";
+        RefreshCacheUsage();
     }
 
     private void OnOpenCacheFolder(object? sender, RoutedEventArgs e)
diff --git a/tests/Titanium.E2E.Tests/UiHeadless/AutomationIdCoverageHeadlessTests.cs b/tests/Titanium.E2E.Tests/UiHeadless/AutomationIdCoverageHeadlessTests.cs
index f0b18b6a1..f7ca7b1e0 100644
--- a/tests/Titanium.E2E.Tests/UiHeadless/AutomationIdCoverageHeadlessTests.cs
+++ b/tests/Titanium.E2E.Tests/UiHeadless/AutomationIdCoverageHeadlessTests.cs
@@ -491,7 +491,9 @@ await fx.DispatchAsync(() =>
 
             var retention = new SessionRetentionWindow(settings);
             AssertHasAutomationId(retention, "RetentionCacheFolderPath");
+            AssertHasAutomationId(retention, "RetentionCacheUsage");
             AssertHasAutomationId(retention, "RetentionOpenCacheFolder");
+            AssertHasAutomationId(retention, "RetentionClearSavedCache");
 
             var logging = new LoggingSettingsWindow(settings, applyLogging: null);
             AssertHasAutomationId(logging, "LoggingOpenFolder");
diff --git a/tests/Titanium.Inspector.Tests/CaptureSettingsParityTests.cs b/tests/Titanium.Inspector.Tests/CaptureSettingsParityTests.cs
index 2d81dc449..139939637 100644
--- a/tests/Titanium.Inspector.Tests/CaptureSettingsParityTests.cs
+++ b/tests/Titanium.Inspector.Tests/CaptureSettingsParityTests.cs
@@ -27,6 +27,17 @@ public void SessionRetention_MbConversion_RoundTrips()
         Assert.AreEqual(
             "Maximum sessions: 'abc' is not a whole number greater than 0.",
             SessionRetentionWindow.FormatPositiveNumberError("Maximum sessions", "abc"));
+        Assert.AreEqual("Sessions cleared", SessionRetentionWindow.FormatSessionsClearedStatus(0));
+        Assert.AreEqual(
+            "Sessions cleared (freed 120 MB)",
+            SessionRetentionWindow.FormatSessionsClearedStatus(120L * 1024 * 1024));
+        Assert.AreEqual("No saved sessions on disk.", SessionRetentionWindow.FormatCacheUsage(default));
+        Assert.AreEqual(
+            "1 saved run, 120 MB on disk.",
+            SessionRetentionWindow.FormatCacheUsage(new SessionCacheStats(1, 120L * 1024 * 1024)));
+        StringAssert.Contains(
+            SessionRetentionWindow.FormatClearCacheConfirm(new SessionCacheStats(3, 120L * 1024 * 1024)),
+            "Delete 3 saved runs (120 MB)?");
     }
 
     [TestMethod]
diff --git a/tests/Titanium.Inspector.Tests/InspectorBodyHonestyTests.cs b/tests/Titanium.Inspector.Tests/InspectorBodyHonestyTests.cs
index a84454a08..891f10ed5 100644
--- a/tests/Titanium.Inspector.Tests/InspectorBodyHonestyTests.cs
+++ b/tests/Titanium.Inspector.Tests/InspectorBodyHonestyTests.cs
@@ -133,6 +133,8 @@ public void SessionBodyDiskCache_CorruptHar_FailsLoad()
         try
         {
             using var cache = new SessionBodyDiskCache(dir, maxBytes: 10_000_000, maxAge: TimeSpan.FromDays(1));
+            // The run folder is created on the first cache write; this test plants a file directly.
+            Directory.CreateDirectory(cache.RunDirectoryPath);
             File.WriteAllText(cache.PathFor(7), "{not-valid");
             Assert.IsFalse(cache.TryLoad(new SessionSnapshot { Id = 7 }));
         }
diff --git a/tests/Titanium.Inspector.Tests/SessionStoreRetentionTests.cs b/tests/Titanium.Inspector.Tests/SessionStoreRetentionTests.cs
index d6d33a507..c7ebafe21 100644
--- a/tests/Titanium.Inspector.Tests/SessionStoreRetentionTests.cs
+++ b/tests/Titanium.Inspector.Tests/SessionStoreRetentionTests.cs
@@ -679,6 +679,278 @@ public void BuildBodyCaptureHint_ExplainsDiskPrunedBody()
         StringAssert.Contains(text, "Headers in the list are still available");
     }
 
+    [TestMethod]
+    public void RunFolder_IsNotCreated_UntilFirstWrite()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            var started = new DateTimeOffset(2021, 5, 5, 1, 2, 3, TimeSpan.Zero);
+            using var first = new SessionBodyDiskCache(dir, maxBytes: 8_000_000, maxAge: TimeSpan.FromDays(1), started);
+            using var second = new SessionBodyDiskCache(dir, maxBytes: 8_000_000, maxAge: TimeSpan.FromDays(1), started);
+            Assert.AreNotEqual(
+                Path.GetFullPath(first.RunDirectoryPath),
+                Path.GetFullPath(second.RunDirectoryPath));
+            Assert.IsFalse(Directory.Exists(first.RunDirectoryPath));
+            Assert.IsFalse(Directory.Exists(second.RunDirectoryPath));
+            Assert.AreEqual(0, CountChildDirectories(dir));
+
+            first.Write(MakeSession(1, 32));
+            Assert.IsTrue(Directory.Exists(first.RunDirectoryPath));
+            Assert.IsTrue(File.Exists(first.PathFor(1)));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public void Startup_SweepsEmptyRunFolders_AndKeepsNonEmpty()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            var empty = Path.Combine(dir, "20190101-000000-000");
+            var kept = Path.Combine(dir, "20190202-000000-000");
+            Directory.CreateDirectory(empty);
+            Directory.CreateDirectory(kept);
+            File.WriteAllBytes(Path.Combine(kept, "4.har"), [1, 2, 3, 4]);
+
+            using var cache = new SessionBodyDiskCache(
+                dir,
+                maxBytes: 50_000_000,
+                maxAge: TimeSpan.FromDays(7),
+                new DateTimeOffset(2024, 6, 1, 0, 0, 0, TimeSpan.Zero));
+
+            Assert.IsFalse(Directory.Exists(empty));
+            Assert.IsTrue(File.Exists(Path.Combine(kept, "4.har")));
+            Assert.IsFalse(Directory.Exists(cache.RunDirectoryPath));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task Clear_DeletesEvictedRows_AndDoesNotLeaveEmptyRunFolder()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            using var store = new SessionStore(
+                new SessionStoreOptions
+                {
+                    MaxSessionsInMemory = 1,
+                    SpillBodiesToDisk = true,
+                    DiskCacheMaxBytes = 64L * 1024 * 1024,
+                },
+                dir);
+
+            store.Add(MakeSession(1, 64));
+            await store.FlushSpillAsync();
+            store.Add(MakeSession(2, 64));
+            await store.FlushSpillAsync();
+            Assert.IsNull(store.TryGet(1), "Memory cap evicts the oldest row");
+            Assert.IsTrue(HarExists(dir, 1));
+            Assert.IsTrue(HarExists(dir, 2));
+
+            var freed = store.Clear();
+            Assert.IsTrue(freed > 0);
+            Assert.AreEqual(0, store.Count);
+            await store.FlushDiskCleanupAsync();
+            Assert.IsFalse(HarExists(dir, 1));
+            Assert.IsFalse(HarExists(dir, 2));
+            Assert.AreEqual(0, CountChildDirectories(dir));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task Clear_LeavesPreviousRunFolders()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            string previous;
+            using (var first = new SessionStore(LargeStoreOptions(), dir))
+            {
+                first.Add(MakeSession(1, 64));
+                await first.FlushSpillAsync();
+                previous = first.DiskCacheRunDirectoryPath!;
+            }
+
+            using var second = new SessionStore(LargeStoreOptions(), dir);
+            second.Add(MakeSession(2, 64));
+            await second.FlushSpillAsync();
+            Assert.AreEqual(2, second.GetCacheStats().RunCount);
+
+            second.Clear();
+            await second.FlushDiskCleanupAsync();
+            Assert.IsTrue(File.Exists(Path.Combine(previous, "1.har")));
+            Assert.IsFalse(HarExists(dir, 2));
+            Assert.AreEqual(1, CountChildDirectories(dir));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task ApplyOptions_LowerDiskLimit_RemovesEmptiedOldRunFolder()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            string oldRun;
+            using (var old = new SessionBodyDiskCache(
+                dir,
+                maxBytes: 50_000_000,
+                maxAge: TimeSpan.FromDays(7),
+                new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.Zero)))
+            {
+                old.Write(MakeSession(1, 400));
+                oldRun = old.RunDirectoryPath;
+            }
+
+            using var store = new SessionStore(LargeStoreOptions(), dir);
+            Assert.IsTrue(Directory.Exists(oldRun));
+            store.ApplyOptions(new SessionStoreOptions
+            {
+                MaxSessionsInMemory = 100,
+                SpillBodiesToDisk = true,
+                DiskCacheMaxBytes = 1,
+            });
+            await store.FlushDiskCleanupAsync();
+            Assert.IsFalse(Directory.Exists(oldRun));
+            Assert.AreEqual(0, CountChildDirectories(dir));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task Remove_SweepsEmptyRunFolders_AndKeepsNonEmptyOnes()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            using var store = new SessionStore(LargeStoreOptions(), dir);
+            store.Add(MakeSession(1, 64));
+            await store.FlushSpillAsync();
+
+            var empty = Path.Combine(dir, "19990101-000000-000");
+            var oldRun = Path.Combine(dir, "19990202-000000-000");
+            Directory.CreateDirectory(empty);
+            Directory.CreateDirectory(oldRun);
+            var oldHar = Path.Combine(oldRun, "9.har");
+            File.WriteAllText(oldHar, "{}");
+
+            store.Remove([1]);
+            await store.FlushDiskCleanupAsync();
+            Assert.IsFalse(HarExists(dir, 1));
+            Assert.IsFalse(Directory.Exists(empty));
+            Assert.IsTrue(File.Exists(oldHar));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task ClearAllSavedRuns_DeletesEveryRun_AndRejectsStaleSpill()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            string previous;
+            using (var older = new SessionBodyDiskCache(
+                dir,
+                maxBytes: 64L * 1024 * 1024,
+                maxAge: TimeSpan.FromDays(7),
+                new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.Zero)))
+            {
+                older.Write(MakeSession(1, 64));
+                previous = older.RunDirectoryPath;
+            }
+
+            using var cache = new SessionBodyDiskCache(
+                dir,
+                maxBytes: 64L * 1024 * 1024,
+                maxAge: TimeSpan.FromDays(7),
+                new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero));
+            var generation = cache.CurrentGeneration;
+            cache.Write(MakeSession(2, 64), generation);
+            Assert.IsTrue(Directory.Exists(previous));
+            Assert.AreEqual(2, cache.GetCacheStats().RunCount);
+
+            var freed = cache.ScheduleClearAllRuns();
+            Assert.IsTrue(freed > 0);
+            Assert.AreNotEqual(generation, cache.CurrentGeneration);
+            Assert.AreEqual(0, cache.Write(MakeSession(2, 64), generation).Count);
+
+            await cache.FlushCleanupAsync();
+            Assert.IsFalse(Directory.Exists(previous));
+            Assert.IsFalse(Directory.EnumerateFiles(dir, "*.har", SearchOption.AllDirectories).Any());
+
+            cache.Write(MakeSession(3, 32), cache.CurrentGeneration);
+            Assert.IsTrue(File.Exists(cache.PathFor(3)));
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    [TestMethod]
+    public async Task ClearAllSavedRuns_KeepsListRows_AndMarksBodiesMissing()
+    {
+        var dir = TempCacheDir();
+        try
+        {
+            using var store = new SessionStore(LargeStoreOptions(), dir);
+            store.Add(MakeSession(1, 64));
+            await store.FlushSpillAsync();
+            Assert.IsTrue(store.TryGet(1)!.BodiesOnDisk);
+
+            var freed = store.ClearAllSavedRuns();
+            Assert.IsTrue(freed > 0);
+            Assert.AreEqual(1, store.Count);
+            Assert.IsTrue(store.TryGet(1)!.BodiesMissingFromDisk);
+
+            await store.FlushDiskCleanupAsync();
+            Assert.IsFalse(Directory.EnumerateFiles(dir, "*.har", SearchOption.AllDirectories).Any());
+
+            store.Add(MakeSession(2, 32));
+            await store.FlushSpillAsync();
+            Assert.IsTrue(HarExists(dir, 2));
+            Assert.IsFalse(store.TryGet(2)!.BodiesMissingFromDisk);
+        }
+        finally
+        {
+            TryDeleteDir(dir);
+        }
+    }
+
+    private static SessionStoreOptions LargeStoreOptions() =>
+        new()
+        {
+            MaxSessionsInMemory = 100,
+            SpillBodiesToDisk = true,
+            DiskCacheMaxBytes = 64L * 1024 * 1024,
+        };
+
+    private static int CountChildDirectories(string root) =>
+        Directory.Exists(root) ? Directory.EnumerateDirectories(root).Count() : 0;
+
     private static string? FindHar(string root, long id) =>
         Directory.Exists(root)
             ? Directory.EnumerateFiles(root, id.ToString("D") + ".har", SearchOption.AllDirectories).FirstOrDefault()
diff --git a/website/docs/inspector.md b/website/docs/inspector.md
index 1d85938de..1d3c10c1c 100644
--- a/website/docs/inspector.md
+++ b/website/docs/inspector.md
@@ -94,7 +94,7 @@ Use **Tools → Composer / Breakpoints / AutoResponder / Scripts…** to open th
 
 **Body capture limits:** finite bodies with known `Content-Length` up to 32 MiB are buffered then previewed at 2 MiB (text view capped at 256 KiB). Larger known-length bodies are **not captured** so downloads are not stalled. Bodies with **no declared length** (chunked, HTTP/2 without `Content-Length`, SSE) are never buffered, whatever their content type: they are relayed untouched and the first 2 MiB is previewed live (decoded for gzip/deflate/br), so large downloads/uploads of unknown size (for example a `git clone`) are not aborted by the buffer limit. Size column shows the original length when known.
 
-Search for WebSocket traffic with `is:ws`. Search for gRPC with `is:grpc`, and for gRPC-JSON transcoded sessions with `is:transcoded` (client REST/JSON vs upstream gRPC faces appear in the Headers/Body inspect panes). Quick filters on the toolbar toggle `hide:tunnel`, `hide:image`, and `is:error` into the same search box. A word with no prefix matches the URL, host, process name, exact process ID, method, or exact status code. Prefixes limit the match to one field: `method:`, `status:` (exact or `2xx`–`5xx`), `host:`, `url:`, `process:`, `pid:`, `protocol:`, `content-type:`, and `body:` (including bodies spilled to disk). The status strip shows **Sessions: N** with no filter, and **Sessions: X of Y match filter** when a search or quick filter is active (X matching, Y currently kept). After the session retention limit has dropped older rows, Y is labeled **most recent** (round thousands as **10k**, e.g. `Sessions: 10k most recent · since 14:05`) and the strip adds **since HH:mm** — the start time of the oldest session still kept. If a filter matches nothing, it also shows how many older sessions retention removed, since those are no longer searched. Click the count to open **Session retention…** and change how many sessions are kept.
+Search for WebSocket traffic with `is:ws`. Search for gRPC with `is:grpc`, and for gRPC-JSON transcoded sessions with `is:transcoded` (client REST/JSON vs upstream gRPC faces appear in the Headers/Body inspect panes). Quick filters on the toolbar toggle `hide:tunnel`, `hide:image`, and `is:error` into the same search box. A word with no prefix matches the URL, host, process name, exact process ID, method, or exact status code. Prefixes limit the match to one field: `method:`, `status:` (exact or `2xx`–`5xx`), `host:`, `url:`, `process:`, `pid:`, `protocol:`, `content-type:`, and `body:` (including bodies spilled to disk). The status strip shows **Sessions: N** with no filter, and **Sessions: X of Y match filter** when a search or quick filter is active (X matching, Y currently kept). After the session retention limit has dropped older rows, Y is labeled **most recent** (round thousands as **10k**, e.g. `Sessions: 10k most recent · since 14:05`) and the strip adds **since HH:mm** — the start time of the oldest session still kept. If a filter matches nothing, it also shows how many older sessions retention removed, since those are no longer searched. Click the count to open **Session retention…** and change how many sessions are kept. What **Clear sessions** removes, and what stays on disk, is described in [Session retention and clearing](#session-retention-and-clearing).
 
 **Network throttle:** use the toolbar **Throttle** combo (`None`, `Slow 3G`, `Fast 3G`, `LTE`) to add latency and bandwidth shaping on body writes / WebSocket frames during capture. Off by default (`None`); the hot path skips delay work when no profile is enabled.
 
@@ -146,6 +146,21 @@ abort
 
 ## Advanced
 
+### Session retention and clearing
+
+**Options → Session retention…** sets how many sessions stay in the list and how much disk the saved HAR files may use. Each Inspector run writes into a timestamped folder under the session cache (local application data, `TitaniumInspector/session-cache`). The folder is created on the first captured session, so a run that captures nothing does not leave an empty folder.
+
+The list limit and the disk limit are separate:
+
+| Action | List | Current run on disk | Earlier runs on disk |
+|--------|------|---------------------|----------------------|
+| List is over **Maximum sessions to keep** | Oldest rows leave the list | Those rows stay as HAR files | Unchanged |
+| Over **Disk space for saved sessions** | Rows stay; missing bodies show a hint | Oldest HAR files go first, across every run | Same. An emptied run folder is deleted |
+| **Capture → Clear sessions** | Cleared | Deleted, including rows the list limit already hid | Kept, so you can import them from the cache folder |
+| **Clear saved session cache…** | Kept | Deleted after you confirm the run count and size | Deleted |
+
+**Clear sessions** does not ask for confirmation. The status line reports how much disk it freed. **Clear saved session cache…** is on the Session retention window, next to **Open cache folder**, and asks before it deletes. Sessions stay in the list, but their saved bodies are removed. New captures use a fresh run folder.
+
 ### Excluded hosts
 
 **Options → Excluded hosts…** edits OS bypass, tunnel-only, and auto-tunnel learning. **Capture → Capture local traffic** controls whether loopback uses the system proxy (not a host list).

From 883f510a136061dfb9e73568301bb9abaede703e Mon Sep 17 00:00:00 2001
From: justcoding121 <justcoding121@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:23:02 +0530
Subject: [PATCH 4/4] chore(release): bump product version to 7.0.20 for the
 next beta cut.

---
 src/Titanium.Cli/Titanium.Cli.csproj                          | 2 +-
 src/Titanium.Inspector/Titanium.Inspector.csproj              | 2 +-
 src/Titanium.Plus/Titanium.Plus.csproj                        | 2 +-
 .../Titanium.Web.Proxy.Abstractions.csproj                    | 2 +-
 .../Titanium.Web.Proxy.Configuration.csproj                   | 2 +-
 src/Titanium.Web.Proxy/Properties/AssemblyInfo.cs             | 4 ++--
 src/Titanium.Web.Proxy/Titanium.Web.Proxy.csproj              | 2 +-
 tests/Titanium.E2E.Tests/CliCommandE2ETests.cs                | 4 ++--
 8 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Titanium.Cli/Titanium.Cli.csproj b/src/Titanium.Cli/Titanium.Cli.csproj
index c271e6f1f..fda9e12cd 100644
--- a/src/Titanium.Cli/Titanium.Cli.csproj
+++ b/src/Titanium.Cli/Titanium.Cli.csproj
@@ -7,7 +7,7 @@
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <SignAssembly>false</SignAssembly>
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <Authors>Jehonathan Thomas</Authors>
     <Description>Titanium Web Proxy CLI (titanium / twp).</Description>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
diff --git a/src/Titanium.Inspector/Titanium.Inspector.csproj b/src/Titanium.Inspector/Titanium.Inspector.csproj
index 95c3d84f2..cb1ef6f59 100644
--- a/src/Titanium.Inspector/Titanium.Inspector.csproj
+++ b/src/Titanium.Inspector/Titanium.Inspector.csproj
@@ -8,7 +8,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <SignAssembly>false</SignAssembly>
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <Authors>Jehonathan Thomas</Authors>
     <Description>Titanium Inspector desktop traffic debugger (PolyForm Noncommercial).</Description>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
diff --git a/src/Titanium.Plus/Titanium.Plus.csproj b/src/Titanium.Plus/Titanium.Plus.csproj
index 15571b0bf..50c472e85 100644
--- a/src/Titanium.Plus/Titanium.Plus.csproj
+++ b/src/Titanium.Plus/Titanium.Plus.csproj
@@ -7,7 +7,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>StrongNameKey.snk</AssemblyOriginatorKeyFile>
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <Authors>Jehonathan Thomas</Authors>
     <Description>Titanium Web Proxy Plus advanced features plugin (PolyForm Noncommercial).</Description>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
diff --git a/src/Titanium.Web.Proxy.Abstractions/Titanium.Web.Proxy.Abstractions.csproj b/src/Titanium.Web.Proxy.Abstractions/Titanium.Web.Proxy.Abstractions.csproj
index a1591ec10..3165978bb 100644
--- a/src/Titanium.Web.Proxy.Abstractions/Titanium.Web.Proxy.Abstractions.csproj
+++ b/src/Titanium.Web.Proxy.Abstractions/Titanium.Web.Proxy.Abstractions.csproj
@@ -7,7 +7,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>StrongNameKey.snk</AssemblyOriginatorKeyFile>
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <Authors>Jehonathan Thomas</Authors>
     <Description>Shared contracts for Titanium Web Proxy routing, clusters, middleware, and plugins.</Description>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
diff --git a/src/Titanium.Web.Proxy.Configuration/Titanium.Web.Proxy.Configuration.csproj b/src/Titanium.Web.Proxy.Configuration/Titanium.Web.Proxy.Configuration.csproj
index 5c531fbc0..a093073dd 100644
--- a/src/Titanium.Web.Proxy.Configuration/Titanium.Web.Proxy.Configuration.csproj
+++ b/src/Titanium.Web.Proxy.Configuration/Titanium.Web.Proxy.Configuration.csproj
@@ -7,7 +7,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>StrongNameKey.snk</AssemblyOriginatorKeyFile>
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <Authors>Jehonathan Thomas</Authors>
     <Description>YAML/JSON configuration binding for Titanium Web Proxy CLI and reverse-proxy documents.</Description>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
diff --git a/src/Titanium.Web.Proxy/Properties/AssemblyInfo.cs b/src/Titanium.Web.Proxy/Properties/AssemblyInfo.cs
index 010078847..3c35305cc 100644
--- a/src/Titanium.Web.Proxy/Properties/AssemblyInfo.cs
+++ b/src/Titanium.Web.Proxy/Properties/AssemblyInfo.cs
@@ -77,5 +77,5 @@
 // file-properties version disagreed with the package it was published in. Keep both of the values
 // below equal to <VersionPrefix> (as Major.Minor.Build.0) whenever that property changes.
 
-[assembly: AssemblyVersion("7.0.19.0")]
-[assembly: AssemblyFileVersion("7.0.19.0")]
+[assembly: AssemblyVersion("7.0.20.0")]
+[assembly: AssemblyFileVersion("7.0.20.0")]
diff --git a/src/Titanium.Web.Proxy/Titanium.Web.Proxy.csproj b/src/Titanium.Web.Proxy/Titanium.Web.Proxy.csproj
index 1a55fe166..9b00bf878 100644
--- a/src/Titanium.Web.Proxy/Titanium.Web.Proxy.csproj
+++ b/src/Titanium.Web.Proxy/Titanium.Web.Proxy.csproj
@@ -13,7 +13,7 @@
     <!-- Keep in sync with the AssemblyVersion/AssemblyFileVersion attributes in
          Properties/AssemblyInfo.cs on every bump - GenerateAssemblyInfo is false below, so the SDK
          does not derive those attributes from this property automatically. -->
-    <VersionPrefix>7.0.19</VersionPrefix>
+    <VersionPrefix>7.0.20</VersionPrefix>
     <!-- The library itself is the canonical implementation of the TWP001 experimental HTTP/3 APIs.
          Suppress the diagnostic internally; consumers will still see it. -->
     <!--
diff --git a/tests/Titanium.E2E.Tests/CliCommandE2ETests.cs b/tests/Titanium.E2E.Tests/CliCommandE2ETests.cs
index 247271b61..b91b83175 100644
--- a/tests/Titanium.E2E.Tests/CliCommandE2ETests.cs
+++ b/tests/Titanium.E2E.Tests/CliCommandE2ETests.cs
@@ -126,7 +126,7 @@ public async Task Version_Prints70()
         using var harness = new CliProcessHarness();
         var (code, stdout, _) = await harness.RunOnceAsync(["version"]);
         Assert.AreEqual(0, code);
-        StringAssert.Contains(stdout, "7.0.19");
+        StringAssert.Contains(stdout, "7.0.20");
     }
 
     [TestMethod]
@@ -503,7 +503,7 @@ public async Task Version_Check_SoftNetwork()
         var combined = stdout + stderr;
         // 0 = up to date, 2 = update available, 1 = feed unreachable (transient CI / network).
         Assert.IsTrue(code is 0 or 1 or 2, $"Unexpected exit {code}. Output: {combined}");
-        StringAssert.Contains(combined, "7.0.19");
+        StringAssert.Contains(combined, "7.0.20");
         if (code == 1)
         {
             Assert.IsTrue(