diff --git a/src/Models/Watcher.cs b/src/Models/Watcher.cs
index 66e246bc0..25dd15606 100644
--- a/src/Models/Watcher.cs
+++ b/src/Models/Watcher.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -18,7 +19,9 @@ public LockContext(Watcher target)
 
             public void Dispose()
             {
-                Interlocked.Decrement(ref _target._lockCount);
+                var target = Interlocked.Exchange(ref _target, null);
+                if (target != null && Interlocked.Decrement(ref target._lockCount) == 0)
+                    target.RefreshAfterOperation();
             }
 
             private Watcher _target;
@@ -79,20 +82,39 @@ public Watcher(IRepository repo, string fullpath, string gitDir)
             }
 
             _timer = new Timer(Tick, null, 100, 100);
+            ViewModels.Preferences.Instance.PropertyChanged += OnPreferencesChanged;
 
             // Starts filesystem watchers in another thread to avoid UI blocking
-            Task.Run(() =>
+            Task.Run(UpdateWatching);
+        }
+
+        private void UpdateWatching()
+        {
+            lock (_syncRoot)
             {
+                if (_disposed)
+                    return;
+
                 try
                 {
                     foreach (var watcher in _watchers)
-                        watcher.EnableRaisingEvents = true;
+                        watcher.EnableRaisingEvents = !ViewModels.Preferences.Instance.ManualRefresh;
                 }
                 catch
                 {
-                    // Ignore exceptions. This may occur while `Dispose` is called.
+                    // Ignore failures while starting filesystem watchers.
                 }
-            });
+            }
+        }
+
+        private void OnPreferencesChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName != nameof(ViewModels.Preferences.ManualRefresh))
+                return;
+
+            UpdateWatching();
+            if (!ViewModels.Preferences.Instance.ManualRefresh)
+                OnWatcherError(null, null); // Reload changes missed while filesystem watchers were disabled.
         }
 
         public IDisposable Lock()
@@ -100,6 +122,23 @@ public IDisposable Lock()
             return new LockContext(this);
         }
 
+        private void RefreshAfterOperation()
+        {
+            // Application operations use Lock() while changing the repository. In manual mode
+            // there are no filesystem events to trigger their final refresh, so do it explicitly
+            // when the outermost operation completes, including failed or cancelled operations.
+            if (_disposed || !ViewModels.Preferences.Instance.ManualRefresh)
+                return;
+
+            _repo.RefreshBranches();
+            _repo.RefreshWorktrees();
+            _repo.RefreshWorkingCopyChanges();
+            _repo.RefreshSubmodules();
+            _repo.RefreshStashes();
+            _repo.RefreshTags();
+            _repo.RefreshCommits();
+        }
+
         public void MarkBranchUpdated()
         {
             Interlocked.Exchange(ref _updateBranch, 0);
@@ -128,23 +167,36 @@ public void MarkSubmodulesUpdated()
 
         public void Dispose()
         {
-            foreach (var watcher in _watchers)
+            ViewModels.Preferences.Instance.PropertyChanged -= OnPreferencesChanged;
+            lock (_syncRoot)
             {
-                watcher.EnableRaisingEvents = false;
-                watcher.Dispose();
-            }
+                if (_disposed)
+                    return;
 
-            _watchers.Clear();
-            _timer.Dispose();
-            _timer = null;
+                _disposed = true;
+                foreach (var watcher in _watchers)
+                {
+                    watcher.EnableRaisingEvents = false;
+                    watcher.Dispose();
+                }
+
+                _watchers.Clear();
+                _timer.Dispose();
+                _timer = null;
+            }
         }
 
         private void Tick(object sender)
         {
-            if (Interlocked.Read(ref _lockCount) > 0)
+            if (ViewModels.Preferences.Instance.ManualRefresh || Interlocked.Read(ref _lockCount) > 0)
                 return;
 
             var now = DateTime.Now.ToFileTime();
+            // Wait for a quiet period across all event types before refreshing anything.
+            var quietPeriod = (long)ViewModels.Preferences.Instance.RefreshThrottling * TimeSpan.TicksPerMillisecond;
+            if (now - Interlocked.Read(ref _lastChange) <= quietPeriod)
+                return;
+
             var refreshCommits = false;
             var refreshSubmodules = false;
             var refreshWC = false;
@@ -249,7 +301,10 @@ private void OnRepositoryChanged(object o, FileSystemEventArgs e)
         /// </summary>
         private void OnWatcherError(object o, ErrorEventArgs e)
         {
-            var desired = DateTime.Now.AddSeconds(1).ToFileTime();
+            if (ViewModels.Preferences.Instance.ManualRefresh)
+                return;
+
+            var desired = RecordChange();
             Interlocked.Exchange(ref _updateBranch, desired);
             Interlocked.Exchange(ref _updateTags, desired);
             Interlocked.Exchange(ref _updateStashes, desired);
@@ -283,6 +338,9 @@ private void OnWorkingCopyChanged(object o, FileSystemEventArgs e)
 
         private void HandleGitDirFileChanged(string name)
         {
+            if (ViewModels.Preferences.Instance.ManualRefresh)
+                return;
+
             if (name.Contains("fsmonitor--daemon/", StringComparison.Ordinal) ||
                 name.EndsWith(".lock", StringComparison.Ordinal) ||
                 name.StartsWith("lfs/", StringComparison.Ordinal))
@@ -293,7 +351,7 @@ private void HandleGitDirFileChanged(string name)
                 if (name.EndsWith("/HEAD", StringComparison.Ordinal) ||
                     name.EndsWith("/ORIG_HEAD", StringComparison.Ordinal))
                 {
-                    var desired = DateTime.Now.AddSeconds(1).ToFileTime();
+                    var desired = RecordChange();
                     Interlocked.Exchange(ref _updateSubmodules, desired);
                     Interlocked.Exchange(ref _updateWC, desired);
                 }
@@ -302,15 +360,15 @@ private void HandleGitDirFileChanged(string name)
                 name.Equals("AUTO_MERGE", StringComparison.Ordinal))
             {
                 if (_repo.MayHaveSubmodules())
-                    Interlocked.Exchange(ref _updateSubmodules, DateTime.Now.AddSeconds(1).ToFileTime());
+                    Interlocked.Exchange(ref _updateSubmodules, RecordChange());
             }
             else if (name.StartsWith("refs/tags", StringComparison.Ordinal))
             {
-                Interlocked.Exchange(ref _updateTags, DateTime.Now.AddSeconds(.5).ToFileTime());
+                Interlocked.Exchange(ref _updateTags, RecordChange());
             }
             else if (name.StartsWith("refs/stash", StringComparison.Ordinal) || name.Equals("logs/refs/stash", StringComparison.Ordinal))
             {
-                Interlocked.Exchange(ref _updateStashes, DateTime.Now.AddSeconds(.5).ToFileTime());
+                Interlocked.Exchange(ref _updateStashes, RecordChange());
             }
             else if (name.Equals("HEAD", StringComparison.Ordinal) ||
                 name.Equals("BISECT_START", StringComparison.Ordinal) ||
@@ -318,35 +376,38 @@ private void HandleGitDirFileChanged(string name)
                 name.StartsWith("refs/remotes/", StringComparison.Ordinal) ||
                 (name.StartsWith("worktrees/", StringComparison.Ordinal) && name.EndsWith("/HEAD", StringComparison.Ordinal)))
             {
-                Interlocked.Exchange(ref _updateBranch, DateTime.Now.AddSeconds(.5).ToFileTime());
+                Interlocked.Exchange(ref _updateBranch, RecordChange());
             }
             else if (name.Equals("packed-refs", StringComparison.Ordinal))
             {
-                var desired = DateTime.Now.AddSeconds(.5).ToFileTime();
+                var desired = RecordChange();
                 Interlocked.Exchange(ref _updateBranch, desired);
                 Interlocked.Exchange(ref _updateTags, desired);
             }
             else if (name.StartsWith("reftable/", StringComparison.Ordinal))
             {
-                var desired = DateTime.Now.AddSeconds(.5).ToFileTime();
+                var desired = RecordChange();
                 Interlocked.Exchange(ref _updateBranch, desired);
                 Interlocked.Exchange(ref _updateTags, desired);
                 Interlocked.Exchange(ref _updateStashes, desired);
             }
             else if (name.StartsWith("objects/", StringComparison.Ordinal) || name.Equals("index", StringComparison.Ordinal))
             {
-                Interlocked.Exchange(ref _updateWC, DateTime.Now.AddSeconds(1).ToFileTime());
+                Interlocked.Exchange(ref _updateWC, RecordChange());
             }
         }
 
         private void HandleWorkingCopyFileChanged(string name, string fullpath)
         {
+            if (ViewModels.Preferences.Instance.ManualRefresh)
+                return;
+
             if (name.StartsWith(".vs/", StringComparison.Ordinal))
                 return;
 
             if (name.Equals(".gitmodules", StringComparison.Ordinal))
             {
-                var desired = DateTime.Now.AddSeconds(1).ToFileTime();
+                var desired = RecordChange();
                 Interlocked.Exchange(ref _updateSubmodules, desired);
                 Interlocked.Exchange(ref _updateWC, desired);
                 return;
@@ -355,11 +416,11 @@ private void HandleWorkingCopyFileChanged(string name, string fullpath)
             var dir = Directory.Exists(fullpath) ? fullpath : Path.GetDirectoryName(fullpath);
             if (IsInSubmodule(dir))
             {
-                Interlocked.Exchange(ref _updateSubmodules, DateTime.Now.AddSeconds(1).ToFileTime());
+                Interlocked.Exchange(ref _updateSubmodules, RecordChange());
                 return;
             }
 
-            Interlocked.Exchange(ref _updateWC, DateTime.Now.AddSeconds(1).ToFileTime());
+            Interlocked.Exchange(ref _updateWC, RecordChange());
         }
 
         private bool IsInSubmodule(string folder)
@@ -373,12 +434,22 @@ private bool IsInSubmodule(string folder)
             return IsInSubmodule(Path.GetDirectoryName(folder));
         }
 
+        private long RecordChange()
+        {
+            var now = DateTime.Now.ToFileTime();
+            Interlocked.Exchange(ref _lastChange, now);
+            return now;
+        }
+
         private readonly IRepository _repo;
+        private readonly object _syncRoot = new object();
+        private bool _disposed;
         private readonly string _root;
         private List<FileSystemWatcher> _watchers;
         private Timer _timer;
 
         private long _lockCount;
+        private long _lastChange;
         private long _updateWC;
         private long _updateBranch;
         private long _updateSubmodules;
diff --git a/src/Resources/Locales/en_US.axaml b/src/Resources/Locales/en_US.axaml
index 62ac98e48..e8999bff2 100644
--- a/src/Resources/Locales/en_US.axaml
+++ b/src/Resources/Locales/en_US.axaml
@@ -707,7 +707,9 @@
   <x:String x:Key="Text.Preferences.General.DateFormat" xml:space="preserve">Date Format</x:String>
   <x:String x:Key="Text.Preferences.General.EnableCompactFolders" xml:space="preserve">Enable compact folders in changes tree</x:String>
   <x:String x:Key="Text.Preferences.General.Locale" xml:space="preserve">Language</x:String>
+  <x:String x:Key="Text.Preferences.General.ManualRefresh" xml:space="preserve">Manual refresh</x:String>
   <x:String x:Key="Text.Preferences.General.MaxHistoryCommits" xml:space="preserve">History Commits</x:String>
+  <x:String x:Key="Text.Preferences.General.RefreshThrottling" xml:space="preserve">Refresh throttling</x:String>
   <x:String x:Key="Text.Preferences.General.ShowChangesPageByDefault" xml:space="preserve">Show `LOCAL CHANGES` page by default</x:String>
   <x:String x:Key="Text.Preferences.General.ShowChangesTabInCommitDetailByDefault" xml:space="preserve">Show `CHANGES` tab in commit detail by default</x:String>
   <x:String x:Key="Text.Preferences.General.ShowRelativeTimeInGraph" xml:space="preserve">Show relative time in commit graph</x:String>
diff --git a/src/ViewModels/AssumeUnchangedManager.cs b/src/ViewModels/AssumeUnchangedManager.cs
index 8cd4a1663..e0c76eb77 100644
--- a/src/ViewModels/AssumeUnchangedManager.cs
+++ b/src/ViewModels/AssumeUnchangedManager.cs
@@ -26,6 +26,7 @@ public async Task RemoveAsync(string file)
         {
             if (!string.IsNullOrEmpty(file))
             {
+                using var lockWatcher = _repo.LockWatcher();
                 var log = _repo.CreateLog("Remove Assume Unchanged File");
 
                 await new Commands.AssumeUnchanged(_repo.FullPath, file, false)
diff --git a/src/ViewModels/Preferences.cs b/src/ViewModels/Preferences.cs
index 9d9fb3f9f..f0def6297 100644
--- a/src/ViewModels/Preferences.cs
+++ b/src/ViewModels/Preferences.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text.Json;
@@ -135,6 +135,18 @@ public int MaxHistoryCommits
             set => SetProperty(ref _maxHistoryCommits, value);
         }
 
+        public int RefreshThrottling
+        {
+            get => _refreshThrottling;
+            set => SetProperty(ref _refreshThrottling, Math.Clamp(value, 0, 5000));
+        }
+
+        public bool ManualRefresh
+        {
+            get => _manualRefresh;
+            set => SetProperty(ref _manualRefresh, value);
+        }
+
         public int SubjectGuideLength
         {
             get => _subjectGuideLength;
@@ -801,6 +813,8 @@ private bool RemoveInvalidRepositoriesRecursive(List<RepositoryNode> collection)
         private LayoutInfo _layout = new();
 
         private int _maxHistoryCommits = 20000;
+        private int _refreshThrottling = 1000;
+        private bool _manualRefresh = false;
         private int _subjectGuideLength = 50;
         private bool _useFixedTabWidth = true;
         private bool _useAutoHideScrollBars = true;
diff --git a/src/ViewModels/Repository.cs b/src/ViewModels/Repository.cs
index 1ea5951a8..b03bf90d5 100644
--- a/src/ViewModels/Repository.cs
+++ b/src/ViewModels/Repository.cs
@@ -564,6 +564,7 @@ public async Task InstallLFSAsync()
 
         public async Task<bool> TrackLFSFileAsync(string pattern, bool isFilenameMode)
         {
+            using var lockWatcher = LockWatcher();
             var log = CreateLog("Track LFS");
             var succ = await new Commands.LFS(FullPath)
                 .Use(log)
@@ -1924,6 +1925,7 @@ private async Task AutoFetchOnUIThread()
                 if (remotes.Count == 0)
                     return;
 
+                using var lockWatcher = LockWatcher();
                 IsAutoFetching = true;
                 log = CreateLog("Auto-Fetch");
 
diff --git a/src/Views/Preferences.axaml b/src/Views/Preferences.axaml
index 6b3aa863c..60109f0eb 100644
--- a/src/Views/Preferences.axaml
+++ b/src/Views/Preferences.axaml
@@ -47,7 +47,7 @@
           <TabItem.Header>
             <TextBlock Classes="tab_header" Text="{DynamicResource Text.Preferences.General}"/>
           </TabItem.Header>
-          <Grid Margin="8" RowDefinitions="32,32,32,32,32,32,32,32,32,32,32,32,Auto" ColumnDefinitions="Auto,*">
+          <Grid Margin="8" RowDefinitions="32,32,32,32,32,32,32,32,32,32,32,32,32,Auto" ColumnDefinitions="Auto,*">
             <TextBlock Grid.Row="0" Grid.Column="0"
                        Text="{DynamicResource Text.Preferences.General.Locale}"
                        HorizontalAlignment="Right"
@@ -141,42 +141,66 @@
                          Text="{Binding MaxHistoryCommits}"/>
             </Grid>
 
-            <CheckBox Grid.Row="5" Grid.Column="1"
+            <TextBlock Grid.Row="5" Grid.Column="0"
+                       Text="{DynamicResource Text.Preferences.General.RefreshThrottling}"
+                       HorizontalAlignment="Right"
+                       Margin="0,0,16,0"/>
+            <Grid Grid.Row="5" Grid.Column="1" ColumnDefinitions="*,64,Auto">
+              <Slider Grid.Column="0"
+                      Minimum="0" Maximum="5000"
+                      TickPlacement="BottomRight" TickFrequency="100"
+                      IsSnapToTickEnabled="True"
+                      IsEnabled="{Binding !ManualRefresh}"
+                      VerticalAlignment="Center"
+                      Foreground="{DynamicResource Brush.Border1}"
+                      Value="{Binding RefreshThrottling, Mode=TwoWay}"/>
+
+              <TextBlock Grid.Column="1"
+                         HorizontalAlignment="Right" VerticalAlignment="Center"
+                         Foreground="{DynamicResource Brush.FG1}"
+                         Text="{Binding RefreshThrottling, StringFormat='{}{0} ms'}"/>
+              <CheckBox Grid.Column="2"
+                        Margin="16,0,0,0"
+                        Content="{DynamicResource Text.Preferences.General.ManualRefresh}"
+                        IsChecked="{Binding ManualRefresh, Mode=TwoWay}"/>
+            </Grid>
+
+            <CheckBox Grid.Row="6" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.ShowChangesPageByDefault}"
                       IsChecked="{Binding ShowLocalChangesByDefault, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="6" Grid.Column="1"
+            <CheckBox Grid.Row="7" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.ShowChangesTabInCommitDetailByDefault}"
                       IsChecked="{Binding ShowChangesInCommitDetailByDefault, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="7" Grid.Column="1"
+            <CheckBox Grid.Row="8" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.ShowTagsInGraph}"
                       IsChecked="{Binding ShowTagsInGraph, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="8" Grid.Column="1"
+            <CheckBox Grid.Row="9" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.ShowRelativeTimeInGraph}"
                       IsChecked="{Binding DisplayTimeAsPeriodInHistories, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="9" Grid.Column="1"
+            <CheckBox Grid.Row="10" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.UseCompactBranchNames}"
                       IsChecked="{Binding UseCompactBranchNamesInGraph, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="10" Grid.Column="1"
+            <CheckBox Grid.Row="11" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.EnableCompactFolders}"
                       IsChecked="{Binding EnableCompactFoldersInChangesTree, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="11" Grid.Column="1"
+            <CheckBox Grid.Row="12" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.UseGitHubStyleAvatar}"
                       IsChecked="{Binding UseGitHubStyleAvatar, Mode=TwoWay}"/>
 
-            <CheckBox Grid.Row="12" Grid.Column="1"
+            <CheckBox Grid.Row="13" Grid.Column="1"
                       Height="32"
                       Content="{DynamicResource Text.Preferences.General.Check4UpdatesOnStartup}"
                       IsVisible="{x:Static s:App.IsCheckForUpdateCommandVisible}"
diff --git a/src/Views/RepositoryToolbar.axaml b/src/Views/RepositoryToolbar.axaml
index 08ed8e83c..e42757bca 100644
--- a/src/Views/RepositoryToolbar.axaml
+++ b/src/Views/RepositoryToolbar.axaml
@@ -24,6 +24,18 @@
     </StackPanel>
 
     <StackPanel Grid.Column="1" Orientation="Horizontal">
+      <Button Classes="icon_button" Width="32" Margin="0,0,16,0"
+              Command="{Binding RefreshAll}"
+              IsVisible="{Binding Source={x:Static vm:Preferences.Instance}, Path=ManualRefresh}">
+        <ToolTip.Tip>
+          <TextBlock>
+            <Run Text="{DynamicResource Text.PageTabBar.Tab.Refresh}"/>
+            <Run Text=" F5" FontSize="11" Foreground="{DynamicResource MenuFlyoutItemKeyboardAcceleratorTextForeground}"/>
+          </TextBlock>
+        </ToolTip.Tip>
+        <Path Width="14" Height="14" Data="{StaticResource Icons.Loading}"/>
+      </Button>
+
       <Button Classes="icon_button" Width="32" Tapped="Fetch">
         <ToolTip.Tip>
           <StackPanel Orientation="Vertical">
diff --git a/tests/WatcherChecks/Program.cs b/tests/WatcherChecks/Program.cs
new file mode 100644
index 000000000..4b3461c0c
--- /dev/null
+++ b/tests/WatcherChecks/Program.cs
@@ -0,0 +1,201 @@
+using System.Reflection;
+using SourceGit.Models;
+
+var root = Path.Combine(Path.GetTempPath(), $"sourcegit-watcher-{Guid.NewGuid():N}");
+Directory.CreateDirectory(Path.Combine(root, ".git"));
+try
+{
+    var repo = new TestRepository();
+    using var watcher = new Watcher(repo, root, Path.Combine(root, ".git"));
+    var flags = BindingFlags.Instance | BindingFlags.NonPublic;
+    var timer = (Timer)typeof(Watcher).GetField("_timer", flags).GetValue(watcher);
+    timer.Change(Timeout.Infinite, Timeout.Infinite);
+
+    void Invoke(string method, params object[] args) => typeof(Watcher).GetMethod(method, flags).Invoke(watcher, args);
+    void Tick() => Invoke("Tick", new object[] { null });
+    void WorkingCopy() => Invoke("HandleWorkingCopyFileChanged", "output.dll", Path.Combine(root, "output.dll"));
+    void Git(string path) => Invoke("HandleGitDirFileChanged", path);
+    void Check(bool condition, string message)
+    {
+        if (!condition)
+            throw new Exception(message);
+    }
+
+    SourceGit.ViewModels.Preferences.Instance.RefreshThrottling = 200;
+    Git("HEAD");
+    Git("refs/tags/v1");
+    Git("refs/stash");
+    for (var i = 0; i < 6; i++)
+    {
+        WorkingCopy();
+        Thread.Sleep(80);
+        Tick();
+        Check(repo.Calls.Count == 0, "Continuous working-copy changes must delay every pending refresh.");
+    }
+
+    Thread.Sleep(160);
+    Tick();
+    Check(repo.Calls.SequenceEqual(new[] { "branches", "worktrees", "working-copy", "submodules", "stashes", "tags", "commits" }),
+        "A quiet period must refresh all pending categories once.");
+    repo.Calls.Clear();
+    Tick();
+    Check(repo.Calls.Count == 0, "Pending refreshes must be consumed.");
+
+    WorkingCopy();
+    Thread.Sleep(240);
+    Invoke("HandleWorkingCopyFileChanged", ".vs/cache", Path.Combine(root, ".vs", "cache"));
+    Git("index.lock");
+    Tick();
+    Check(repo.Calls.SequenceEqual(new[] { "working-copy" }), "Ignored paths must not restart the quiet period.");
+    repo.Calls.Clear();
+
+    SourceGit.ViewModels.Preferences.Instance.RefreshThrottling = 5000;
+    WorkingCopy();
+    Tick();
+    Check(repo.Calls.Count == 0, "The maximum setting must delay refreshes.");
+    typeof(Watcher).GetField("_lastChange", flags).SetValue(watcher, DateTime.Now.AddMilliseconds(-5100).ToFileTime());
+    Tick();
+    Check(repo.Calls.SequenceEqual(new[] { "working-copy" }), "Refresh must resume after the maximum quiet period.");
+    repo.Calls.Clear();
+
+    WorkingCopy();
+    SourceGit.ViewModels.Preferences.Instance.RefreshThrottling = 0;
+    Tick();
+    Check(repo.Calls.SequenceEqual(new[] { "working-copy" }), "Changing the setting to zero must release pending refreshes immediately.");
+    repo.Calls.Clear();
+
+    using (watcher.Lock())
+    {
+        WorkingCopy();
+        Tick();
+        Check(repo.Calls.Count == 0, "Watcher locks must still suppress refreshes.");
+    }
+    Tick();
+    Check(repo.Calls.SequenceEqual(new[] { "working-copy" }), "Unlocking must preserve pending refreshes.");
+    repo.Calls.Clear();
+
+    SourceGit.ViewModels.Preferences.Instance.RefreshThrottling = 200;
+    Invoke("OnWatcherError", null, new ErrorEventArgs(new InternalBufferOverflowException()));
+    Tick();
+    Check(repo.Calls.Count == 0, "Watcher overflow recovery must respect the quiet period.");
+    Thread.Sleep(240);
+    Tick();
+    Check(repo.Calls.Count == 7, "Watcher overflow recovery must reload all categories.");
+    repo.Calls.Clear();
+
+    var preferences = SourceGit.ViewModels.Preferences.Instance;
+    var filesystemWatchers = (List<FileSystemWatcher>)typeof(Watcher).GetField("_watchers", flags).GetValue(watcher);
+    WorkingCopy();
+    preferences.ManualRefresh = true;
+    Check(filesystemWatchers.All(x => !x.EnableRaisingEvents), "Manual mode must disable filesystem hooks immediately.");
+    preferences.RefreshThrottling = 0;
+    WorkingCopy();
+    Git("HEAD");
+    Invoke("OnWatcherError", null, new ErrorEventArgs(new InternalBufferOverflowException()));
+    Tick();
+    Check(repo.Calls.Count == 0, "Manual mode must suppress queued changes and overflow recovery, even with zero throttling.");
+
+    preferences.RefreshThrottling = 5000;
+    using (watcher.Lock())
+    {
+        using (watcher.Lock())
+        {
+            WorkingCopy();
+            Git("HEAD");
+            Tick();
+        }
+
+        Check(repo.Calls.Count == 0, "Nested application operations must not refresh before the outer operation finishes.");
+    }
+    Check(repo.Calls.Count == 7, "Application operations must refresh in manual mode without waiting for throttling.");
+    Check(filesystemWatchers.All(x => !x.EnableRaisingEvents), "Application refreshes must leave external filesystem hooks disabled.");
+    repo.Calls.Clear();
+    Tick();
+    Check(repo.Calls.Count == 0, "Completing an application operation must not enable filesystem refreshes.");
+
+    try
+    {
+        using var operation = watcher.Lock();
+        throw new OperationCanceledException();
+    }
+    catch (OperationCanceledException)
+    {
+        Check(repo.Calls.Count == 7, "Cancelled or failed operations must refresh any partial repository changes.");
+    }
+    repo.Calls.Clear();
+
+    var completedOperation = watcher.Lock();
+    completedOperation.Dispose();
+    completedOperation.Dispose();
+    Check(repo.Calls.Count == 7, "Disposing an operation twice must refresh only once and preserve the lock count.");
+    repo.Calls.Clear();
+
+    using (var manualWatcher = new Watcher(repo, root, Path.Combine(root, ".git")))
+    {
+        var manualFilesystemWatchers = (List<FileSystemWatcher>)typeof(Watcher).GetField("_watchers", flags).GetValue(manualWatcher);
+        // Run the startup action explicitly as well, to check that it cannot enable hooks in manual mode.
+        typeof(Watcher).GetMethod("UpdateWatching", flags).Invoke(manualWatcher, null);
+        Check(manualFilesystemWatchers.All(x => !x.EnableRaisingEvents), "Repositories opened in manual mode must leave hooks disabled.");
+        var operation = manualWatcher.Lock();
+        manualWatcher.Dispose();
+        operation.Dispose();
+        Check(repo.Calls.Count == 0, "An operation finishing after the repository closes must not refresh it.");
+    }
+
+    preferences.RefreshThrottling = 0;
+    preferences.ManualRefresh = false;
+    Check(filesystemWatchers.All(x => x.EnableRaisingEvents), "Returning to automatic mode must re-enable filesystem hooks.");
+    Thread.Sleep(1);
+    Tick();
+    Check(repo.Calls.Count == 7, "Returning to automatic mode must reload changes missed while hooks were disabled.");
+    repo.Calls.Clear();
+    Tick();
+    Check(repo.Calls.Count == 0, "Automatic recovery must refresh only once.");
+    using (watcher.Lock())
+    {
+    }
+    Check(repo.Calls.Count == 0, "Automatic mode must retain its existing event-driven refresh behavior.");
+    Console.WriteLine("Watcher checks passed.");
+}
+finally
+{
+    Directory.Delete(root, true);
+}
+
+sealed class TestRepository : IRepository
+{
+    public List<string> Calls { get; } = new();
+    public bool MayHaveSubmodules() => true;
+    public void RefreshBranches() => Calls.Add("branches");
+    public void RefreshWorktrees() => Calls.Add("worktrees");
+    public void RefreshTags() => Calls.Add("tags");
+    public void RefreshCommits() => Calls.Add("commits");
+    public void RefreshSubmodules() => Calls.Add("submodules");
+    public void RefreshWorkingCopyChanges() => Calls.Add("working-copy");
+    public void RefreshStashes() => Calls.Add("stashes");
+}
+
+namespace SourceGit.ViewModels
+{
+    // Keep these watcher checks independent of the desktop application and user settings.
+    public sealed class Preferences : System.ComponentModel.INotifyPropertyChanged
+    {
+        public static Preferences Instance { get; } = new();
+        public int RefreshThrottling { get; set; } = 1000;
+        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
+        public bool ManualRefresh
+        {
+            get => _manualRefresh;
+            set
+            {
+                if (_manualRefresh == value)
+                    return;
+
+                _manualRefresh = value;
+                PropertyChanged?.Invoke(this, new System.ComponentModel.PropertyChangedEventArgs(nameof(ManualRefresh)));
+            }
+        }
+
+        private bool _manualRefresh;
+    }
+}
diff --git a/tests/WatcherChecks/WatcherChecks.csproj b/tests/WatcherChecks/WatcherChecks.csproj
new file mode 100644
index 000000000..cc64995a4
--- /dev/null
+++ b/tests/WatcherChecks/WatcherChecks.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../../src/Models/Watcher.cs" Link="Watcher.cs" />
+    <Compile Include="../../src/Models/IRepository.cs" Link="IRepository.cs" />
+  </ItemGroup>
+</Project>