private readonly ILogger<CombatController> _logger;
 
     private CurrentFight? _currentFight;
+    private bool _wasInCombat;
 
     public CombatController(
         IEnumerable<ICombatModule> combatModules,
 
     public bool Start(CombatData combatData)
     {
-        Stop();
+        Stop("Starting combat");
 
         var combatModule = _combatModules.FirstOrDefault(x => x.IsLoaded);
         if (combatModule == null)
             return false;
     }
 
-    /// <returns>true if still in combat, false otherwise</returns>
-    public bool Update()
+    public EStatus Update()
     {
-        if (_currentFight == null || _movementController.IsPathfinding || _movementController.IsPathRunning)
-            return false;
+        if (_currentFight == null)
+            return EStatus.Complete;
+
+        if (_movementController.IsPathfinding || _movementController.IsPathRunning)
+            return EStatus.Moving;
 
         var target = _targetManager.Target;
         if (target != null)
             }
         }
 
-        return _condition[ConditionFlag.InCombat];
+        if (_condition[ConditionFlag.InCombat])
+        {
+            _wasInCombat = true;
+            return EStatus.InCombat;
+        }
+        else if (_wasInCombat)
+            return EStatus.Complete;
+        else
+            return EStatus.InCombat;
     }
 
     [SuppressMessage("ReSharper", "RedundantJumpStatement")]
             return 0;
     }
 
-    public void Stop()
+    public void Stop(string label)
     {
+        using var scope = _logger.BeginScope(label);
         if (_currentFight != null)
         {
             _logger.LogInformation("Stopping current fight");
         }
 
         _currentFight = null;
+        _wasInCombat = false;
     }
 
-    private void TerritoryChanged(ushort territoryId) => Stop();
+    private void TerritoryChanged(ushort territoryId) => Stop("TerritoryChanged");
 
     public void Dispose()
     {
         _clientState.TerritoryChanged -= TerritoryChanged;
-        Stop();
+        Stop("Dispose");
     }
 
     private sealed class CurrentFight
 
         public HashSet<int> CompletedComplexDatas { get; } = new();
     }
+
+    public enum EStatus
+    {
+        InCombat,
+        Moving,
+        Complete,
+    }
 }
 
             {
                 Stop("HP = 0");
                 _movementController.Stop();
-                _combatController.Stop();
+                _combatController.Stop("HP = 0");
             }
         }
         else if (_keyState[VirtualKey.ESCAPE])
             {
                 Stop("ESC pressed");
                 _movementController.Stop();
-                _combatController.Stop();
+                _combatController.Stop("ESC pressed");
             }
         }
 
             _taskQueue.Clear();
 
         _yesAlreadyIpc.RestoreYesAlready();
-        _combatController.Stop();
+        _combatController.Stop("ClearTasksInternal");
     }
 
     public void Stop(string label, bool continueIfAutomatic = false)
         }
 
         _movementController.Stop();
-        _combatController.Stop();
+        _combatController.Stop("Execute next step");
 
         var newTasks = _taskFactories
             .SelectMany(x =>
 
 
         public ETaskResult Update()
         {
-            if (combatController.Update())
+            if (combatController.Update() != CombatController.EStatus.Complete)
                 return ETaskResult.StillRunning;
 
             // if our quest step has any completion flags, we need to check if they are set
                 return ETaskResult.StillRunning;
             else
             {
-                combatController.Stop();
+                combatController.Stop("Combat task complete");
                 return ETaskResult.TaskComplete;
             }
         }