Prune deleted local files from MRU history when listing

When building the MRU picker list, remove non-selectable entries
(missing local paths, blank inputs) from go.toml and save once so
later lists avoid repeated filesystem checks.

Author: kzu

src/Tests/RunHistoryTests.cs

@@ -237,6 +237,44 @@ public void List_skips_missing_local_paths_keeps_remote_refs()
             var listed = RunHistory.List(path);
             Assert.Single(listed);
             Assert.Equal("still/here", listed[0].Input);
+
+            // Deleted local entries are pruned from storage (single save after list build).
+            var stored = SettingsStore.Load(path);
+            Assert.Single(stored.History!);
+            Assert.Equal("still/here", stored.History![0].Input);
+        }
+        finally
+        {
+            TryDelete(path);
+        }
+    }
+
+    [Fact]
+    public void List_prunes_blank_and_missing_paths_in_one_save()
+    {
+        var path = NewSettingsPath();
+        try
+        {
+            var missing1 = Path.Combine(Path.GetTempPath(), "go-hist-m1-" + Guid.NewGuid().ToString("N"), "a.cs");
+            var missing2 = Path.Combine(Path.GetTempPath(), "go-hist-m2-" + Guid.NewGuid().ToString("N"), "b.cs");
+            SettingsStore.Save(new Settings
+            {
+                History =
+                [
+                    new HistoryEntry { Input = missing1, LastUsedUtc = DateTimeOffset.UtcNow, UseCount = 3 },
+                    new HistoryEntry { Input = "   ", LastUsedUtc = DateTimeOffset.UtcNow, UseCount = 1 },
+                    new HistoryEntry { Input = "keep/ref", LastUsedUtc = DateTimeOffset.UtcNow, UseCount = 2 },
+                    new HistoryEntry { Input = missing2, LastUsedUtc = DateTimeOffset.UtcNow, UseCount = 4 },
+                ],
+            }, path);
+
+            var listed = RunHistory.List(path);
+            Assert.Single(listed);
+            Assert.Equal("keep/ref", listed[0].Input);
+
+            var stored = SettingsStore.Load(path);
+            Assert.Single(stored.History!);
+            Assert.Equal("keep/ref", stored.History![0].Input);
         }
         finally
         {

src/go/RunHistory.cs

@@ -16,24 +16,48 @@ public static class RunHistory
     /// <summary>
     /// Loads history from <paramref name="settingsPath"/> (default: root go.toml),
     /// ordered most-used first, then most-recently-used, then alphabetically.
+    /// Drops non-selectable entries (e.g. deleted local files) from storage so later
+    /// lists skip the filesystem checks; saves at most once after pruning.
     /// </summary>
     public static IReadOnlyList<RunHistoryEntry> List(string? settingsPath = null)
     {
         var settings = SettingsStore.Load(settingsPath);
         if (settings.History is not { Count: > 0 })
             return [];
 
-        return settings.History
-            .Where(static h => !string.IsNullOrWhiteSpace(h.Input))
-            .Where(static h => IsSelectable(h.Input))
-            .Select(static h => new RunHistoryEntry(
+        var pruned = false;
+        var listed = new List<RunHistoryEntry>(settings.History.Count);
+        for (var i = settings.History.Count - 1; i >= 0; i--)
+        {
+            var h = settings.History[i];
+            if (string.IsNullOrWhiteSpace(h.Input) || !IsSelectable(h.Input))
+            {
+                settings.History.RemoveAt(i);
+                pruned = true;
+                continue;
+            }
+
+            listed.Add(new RunHistoryEntry(
                 h.Input,
                 h.LastUsedUtc == default ? DateTimeOffset.MinValue : h.LastUsedUtc,
-                h.UseCount <= 0 ? 1 : h.UseCount))
-            .OrderByDescending(static e => e.UseCount)
-            .ThenByDescending(static e => e.LastUsedUtc)
-            .ThenBy(static e => e.Display, StringComparer.OrdinalIgnoreCase)
-            .ToList();
+                h.UseCount <= 0 ? 1 : h.UseCount));
+        }
+
+        if (pruned)
+            SettingsStore.Save(settings, settingsPath);
+
+        listed.Sort(static (a, b) =>
+        {
+            var byCount = b.UseCount.CompareTo(a.UseCount);
+            if (byCount != 0)
+                return byCount;
+            var byTime = b.LastUsedUtc.CompareTo(a.LastUsedUtc);
+            if (byTime != 0)
+                return byTime;
+            return StringComparer.OrdinalIgnoreCase.Compare(a.Display, b.Display);
+        });
+
+        return listed;
     }
 
     /// <summary>

src/go/help.md

@@ -4,7 +4,7 @@ Usage: [command] [arguments...] [options...] [-h|--help] [--version]
 Runs a file-based .NET app from a .cs entrypoint.
 
 Arguments:
-  [0] <string?>     Path to an existing .cs file or remote ref (owner/repo[@ref][:path]). When omitted in an interactive terminal, selects from previous runs (MRU) then prompts for optional app args; otherwise shows help.
+  [0] <string?>     Path to an existing .cs file or remote ref (owner/repo[@ref][:path]). When omitted, selects from previous runs (MRU) then prompts for optional app args.
   [1] <string[]>    Arguments to pass to the app.
 
 Options: