diff --git a/lib/puppet/provider/service/windows.rb b/lib/puppet/provider/service/windows.rb
index e773fa546..717e585fd 100644
--- a/lib/puppet/provider/service/windows.rb
+++ b/lib/puppet/provider/service/windows.rb
@@ -1,110 +1,111 @@
 # Windows Service Control Manager (SCM) provider
 
 require 'win32/service' if Puppet.features.microsoft_windows?
 
 Puppet::Type.type(:service).provide :windows do
 
   desc <<-EOT
-    Support for Windows Service Control Manager (SCM).
+    Support for Windows Service Control Manager (SCM). This provider can
+    start, stop, enable, and disable services, and the SCM provides working
+    status methods for all services.
 
-    Services are controlled according to the capabilities of the `win32-service`
-    gem. All SCM operations (start/stop/enable/disable/query) are supported.
-    Control of service groups (dependencies) is not yet supported.
+    Control of service groups (dependencies) is not yet supported, nor is running
+    services as a specific user.
   EOT
 
   defaultfor :operatingsystem => :windows
   confine    :operatingsystem => :windows
 
   has_feature :refreshable
 
   def enable
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START )
     raise Puppet::Error.new("Win32 service enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot enable #{@resource[:name]}, error was: #{detail}" )
   end
 
   def disable
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED )
     raise Puppet::Error.new("Win32 service disable of #{@resource[:name]} failed" ) if( w32ss.nil? )
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot disable #{@resource[:name]}, error was: #{detail}" )
   end
 
   def manual_start
     w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START )
     raise Puppet::Error.new("Win32 service manual enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot enable #{@resource[:name]} for manual start, error was: #{detail}" )
   end
 
   def enabled?
     w32ss = Win32::Service.config_info( @resource[:name] )
     raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceConfigInfo ) )
     debug("Service #{@resource[:name]} start type is #{w32ss.start_type}")
     case w32ss.start_type
       when Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START),
            Win32::Service.get_start_type(Win32::Service::SERVICE_BOOT_START),
            Win32::Service.get_start_type(Win32::Service::SERVICE_SYSTEM_START)
         :true
       when Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
         :manual
       when Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
         :false
       else
         raise Puppet::Error.new("Unknown start type: #{w32ss.start_type}")
     end
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot get start type for #{@resource[:name]}, error was: #{detail}" )
   end
 
   def start
     if enabled? == :false
       # If disabled and not managing enable, respect disabled and fail.
       if @resource[:enable].nil?
         raise Puppet::Error, "Will not start disabled service #{@resource[:name]} without managing enable. Specify 'enable => false' to override."
       # Otherwise start. If enable => false, we will later sync enable and
       # disable the service again.
       elsif @resource[:enable] == :true
         enable
       else
         manual_start
       end
     end
 
     Win32::Service.start( @resource[:name] )
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}" )
   end
 
   def stop
     Win32::Service.stop( @resource[:name] )
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot stop #{@resource[:name]}, error was: #{detail}" )
   end
 
   def restart
     self.stop
     self.start
   end
 
   def status
     w32ss = Win32::Service.status( @resource[:name] )
     raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceStatus ) )
     state = case w32ss.current_state
       when "stopped", "pause pending", "stop pending", "paused" then :stopped
       when "running", "continue pending", "start pending"       then :running
       else
         raise Puppet::Error.new("Unknown service state '#{w32ss.current_state}' for service '#{@resource[:name]}'")
     end
     debug("Service #{@resource[:name]} is #{w32ss.current_state}")
     return state
   rescue Win32::Service::Error => detail
     raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}" )
   end
 
   # returns all providers for all existing services and startup state
   def self.instances
     Win32::Service.services.collect { |s| new(:name => s.service_name) }
   end
 end
diff --git a/lib/puppet/type/service.rb b/lib/puppet/type/service.rb
index 2a89f667a..9f70ff12c 100644
--- a/lib/puppet/type/service.rb
+++ b/lib/puppet/type/service.rb
@@ -1,207 +1,213 @@
 # This is our main way of managing processes right now.
 #
 # a service is distinct from a process in that services
 # can only be managed through the interface of an init script
 # which is why they have a search path for initscripts and such
 
 module Puppet
 
   newtype(:service) do
     @doc = "Manage running services.  Service support unfortunately varies
       widely by platform --- some platforms have very little if any concept of a
       running service, and some have a very codified and powerful concept.
       Puppet's service support is usually capable of doing the right thing, but
       the more information you can provide, the better behaviour you will get.
 
       Puppet 2.7 and newer expect init scripts to have a working status command.
       If this isn't the case for any of your services' init scripts, you will
       need to set `hasstatus` to false and possibly specify a custom status
       command in the `status` attribute.
 
       Note that if a `service` receives an event from another resource,
       the service will get restarted. The actual command to restart the
       service depends on the platform. You can provide an explicit command for
       restarting with the `restart` attribute, or you can set `hasrestart` to
       true to use the init script's restart command; if you do neither, the
       service's stop and start commands will be used."
 
     feature :refreshable, "The provider can restart the service.",
       :methods => [:restart]
 
     feature :enableable, "The provider can enable and disable the service",
       :methods => [:disable, :enable, :enabled?]
 
     feature :controllable, "The provider uses a control variable."
 
     newproperty(:enable, :required_features => :enableable) do
       desc "Whether a service should be enabled to start at boot.
         This property behaves quite differently depending on the platform;
         wherever possible, it relies on local tools to enable or disable
         a given service."
 
       newvalue(:true, :event => :service_enabled) do
         provider.enable
       end
 
       newvalue(:false, :event => :service_disabled) do
         provider.disable
       end
 
       newvalue(:manual, :event => :service_manual_start) do
         provider.manual_start
       end
 
       def retrieve
         provider.enabled?
       end
 
       validate do |value|
         if value == :manual and !Puppet.features.microsoft_windows?
           raise Puppet::Error.new("Setting enable to manual is only supported on Microsoft Windows.")
         end
       end
     end
 
     # Handle whether the service should actually be running right now.
     newproperty(:ensure) do
       desc "Whether a service should be running."
 
       newvalue(:stopped, :event => :service_stopped) do
         provider.stop
       end
 
       newvalue(:running, :event => :service_started) do
         provider.start
       end
 
       aliasvalue(:false, :stopped)
       aliasvalue(:true, :running)
 
       def retrieve
         provider.status
       end
 
       def sync
         event = super()
 
         if property = @resource.property(:enable)
           val = property.retrieve
           property.sync unless property.safe_insync?(val)
         end
 
         event
       end
     end
 
     newparam(:binary) do
       desc "The path to the daemon.  This is only used for
         systems that do not support init scripts.  This binary will be
         used to start the service if no `start` parameter is
         provided."
     end
 
     newparam(:hasstatus) do
       desc "Declare whether the service's init script has a functional status
         command; defaults to `true`. This attribute's default value changed in
         Puppet 2.7.0.
 
         If a service's init script does not support any kind of status command,
         you should set `hasstatus` to false and either provide a specific
         command using the `status` attribute or expect that Puppet will look for
         the service name in the process table. Be aware that 'virtual' init
         scripts (like 'network' under Red Hat systems) will respond poorly to
         refresh events from other resources if you override the default behavior
         without providing a status command."
 
       newvalues(:true, :false)
 
       defaultto :true
     end
     newparam(:name) do
-      desc "The name of the service to run.  This name is used to find
-        the service in whatever service subsystem it is in."
+      desc <<-EOT
+        The name of the service to run.
+
+        This name is used to find the service; on platforms where services
+        have short system names and long display names, this should be the
+        short name. (To take an example from Windows, you would use "wuauserv"
+        rather than "Automatic Updates.")
+      EOT
       isnamevar
     end
 
     newparam(:path) do
       desc "The search path for finding init scripts.  Multiple values should
         be separated by colons or provided as an array."
 
       munge do |value|
         value = [value] unless value.is_a?(Array)
         # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
         # It affects stand-alone blocks, too.
         paths = value.flatten.collect { |p| x = p.split(File::PATH_SEPARATOR) }.flatten
       end
 
       defaultto { provider.class.defpath if provider.class.respond_to?(:defpath) }
     end
     newparam(:pattern) do
       desc "The pattern to search for in the process table.
         This is used for stopping services on platforms that do not
         support init scripts, and is also used for determining service
         status on those service whose init scripts do not include a status
         command.
 
         Defaults to the name of the service. The pattern can be a simple string
         or any legal Ruby pattern."
 
       defaultto { @resource[:binary] || @resource[:name] }
     end
     newparam(:restart) do
       desc "Specify a *restart* command manually.  If left
         unspecified, the service will be stopped and then started."
     end
     newparam(:start) do
       desc "Specify a *start* command manually.  Most service subsystems
         support a `start` command, so this will not need to be
         specified."
     end
     newparam(:status) do
       desc "Specify a *status* command manually.  This command must
         return 0 if the service is running and a nonzero value otherwise.
         Ideally, these return codes should conform to
         [the LSB's specification for init script status actions](http://refspecs.freestandards.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/iniscrptact.html),
         but Puppet only considers the difference between 0 and nonzero
         to be relevant.
 
         If left unspecified, the status method will be determined
         automatically, usually by looking for the service in the process
         table."
     end
 
     newparam(:stop) do
       desc "Specify a *stop* command manually."
     end
 
     newparam(:control) do
       desc "The control variable used to manage services (originally for HP-UX).
         Defaults to the upcased service name plus `START` replacing dots with
         underscores, for those providers that support the `controllable` feature."
       defaultto { resource.name.gsub(".","_").upcase + "_START" if resource.provider.controllable? }
     end
 
     newparam :hasrestart do
       desc "Specify that an init script has a `restart` command.  If this is
         false and you do not specify a command in the `restart` attribute,
         the init script's `stop` and `start` commands will be used. Defaults
         to true; note that this is a change from earlier versions of Puppet."
       newvalues(:true, :false)
     end
 
     newparam(:manifest) do
       desc "Specify a command to config a service, or a path to a manifest to do so."
     end
 
     # Basically just a synonym for restarting.  Used to respond
     # to events.
     def refresh
       # Only restart if we're actually running
       if (@parameters[:ensure] || newattr(:ensure)).retrieve == :running
         provider.restart
       else
         debug "Skipping restart; service is not running"
       end
     end
   end
 end