diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index 37029cfb5..a1edf6243 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,252 +1,257 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
   should_parse_config
 
   option("--debug","-d")
   option("--execute EXECUTE","-e") do |arg|
     options[:code] = arg
   end
   option("--loadclasses","-L")
   option("--verbose","-v")
   option("--use-nodes")
   option("--detailed-exitcodes")
 
   option("--apply catalog",  "-a catalog") do |arg|
     options[:catalog] = arg
   end
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   def help
     <<-HELP
 
 puppet-apply(8) -- Apply Puppet manifests locally
 ========
 
 SYNOPSIS
 --------
 Applies a standalone Puppet manifest to the local system.
 
 
 USAGE
 -----
 puppet apply [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
-  [-e|--execute] [--detailed-exitcodes] [-l|--logdest <file>] <file>
+  [-e|--execute] [--detailed-exitcodes] [-l|--logdest <file>]
+  [--apply <catalog>] <file>
 
 
 DESCRIPTION
 -----------
 This is the standalone puppet execution tool; use it to apply
 individual manifests.
 
 When provided with a modulepath, via command line or config file, puppet
 apply can effectively mimic the catalog that would be served by puppet
 master with access to the same modules, although there are some subtle
 differences. When combined with scheduling and an automated system for
 pushing manifests, this can be used to implement a serverless Puppet
 site.
 
 Most users should use 'puppet agent' and 'puppet master' for site-wide
 manifests.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'modulepath' is a
 valid configuration parameter, so you can specify '--tags <class>,<tag>'
 as an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an
   exit code of '2' means there were changes, and an exit code of '4'
   means that there were failures during the transaction.
 
 * --help:
   Print this help message
 
 * --loadclasses:
   Load any stored classes. 'puppet agent' caches configured classes
   (usually at /etc/puppet/classes.txt), and setting this option causes
   all of those classes to be set in your puppet manifest.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to the console.
 
 * --execute:
   Execute a specific piece of Puppet code
 
 * --verbose:
   Print extra information.
 
+* --apply:
+  Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
+  either specify a JSON file or pipe in JSON from standard input.
+
 
 EXAMPLE
 -------
     $ puppet apply -l /tmp/manifest.log manifest.pp
     $ puppet apply --modulepath=/root/dev/modules -e "include ntpd::server"
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2005 Puppet Labs, LLC Licensed under the GNU Public
 License
 
     HELP
   end
 
   def run_command
     if options[:catalog]
       apply
     elsif Puppet[:parseonly]
       parseonly
     else
       main
     end
   end
 
   def apply
     if options[:catalog] == "-"
       text = $stdin.read
     else
       text = File.read(options[:catalog])
     end
 
     begin
       catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
       catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
     rescue => detail
       raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
     end
 
     catalog = catalog.to_ral
 
     require 'puppet/configurer'
     configurer = Puppet::Configurer.new
     configurer.run :catalog => catalog
   end
 
   def parseonly
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       Puppet[:manifest] = command_line.args.shift
     end
     begin
       Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
     rescue => detail
       Puppet.err detail
       exit 1
     end
     exit 0
   end
 
   def main
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       manifest = command_line.args.shift
       raise "Could not find file #{manifest}" unless File.exist?(manifest)
       Puppet.warning("Only one file can be applied per run.  Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
       Puppet[:manifest] = manifest
     end
 
     # Collect our facts.
     unless facts = Puppet::Node::Facts.indirection.find(Puppet[:certname])
       raise "Could not find facts for #{Puppet[:certname]}"
     end
 
     # Find our Node
     unless node = Puppet::Node.indirection.find(Puppet[:certname])
       raise "Could not find node #{Puppet[:certname]}"
     end
 
     # Merge in the facts.
     node.merge(facts.values)
 
     # Allow users to load the classes that puppet agent creates.
     if options[:loadclasses]
       file = Puppet[:classfile]
       if FileTest.exists?(file)
         unless FileTest.readable?(file)
           $stderr.puts "#{file} is not readable"
           exit(63)
         end
         node.classes = File.read(file).split(/[\s\n]+/)
       end
     end
 
     begin
       # Compile our catalog
       starttime = Time.now
       catalog = Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
 
       # Translate it to a RAL catalog
       catalog = catalog.to_ral
 
       catalog.finalize
 
       catalog.retrieval_duration = Time.now - starttime
 
       require 'puppet/configurer'
       configurer = Puppet::Configurer.new
       report = configurer.run(:skip_plugin_download => true, :catalog => catalog)
 
       exit( Puppet[:noop] ? 0 : options[:detailed_exitcodes] ? report.exit_status : 0 )
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       $stderr.puts detail.message
       exit(1)
     end
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     # If noop is set, then also enable diffs
     Puppet[:show_diff] = true if Puppet[:noop]
 
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
     client = nil
     server = nil
 
     trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/lib/puppet/application/master.rb b/lib/puppet/application/master.rb
index 39af33dc8..f689b9e01 100644
--- a/lib/puppet/application/master.rb
+++ b/lib/puppet/application/master.rb
@@ -1,245 +1,239 @@
 require 'puppet/application'
 
 class Puppet::Application::Master < Puppet::Application
 
   should_parse_config
   run_mode :master
 
   option("--debug", "-d")
   option("--verbose", "-v")
 
   # internal option, only to be used by ext/rack/config.ru
   option("--rack")
 
   option("--compile host",  "-c host") do |arg|
     options[:node] = arg
   end
 
   option("--logdest DEST",  "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
       puts detail.backtrace if Puppet[:debug]
       $stderr.puts detail.to_s
     end
   end
 
   def help
     <<-HELP
 
 puppet-master(8) -- The puppet master daemon
 ========
 
 SYNOPSIS
 --------
 The central puppet server. Functions as a certificate authority by
 default.
 
 
 USAGE
 -----
 puppet master [-D|--daemonize|--no-daemonize] [-d|--debug] [-h|--help]
   [-l|--logdest <file>|console|syslog] [-v|--verbose] [-V|--version]
-  [--compile <nodename>] [--apply <catalog>]
+  [--compile <node-name>]
 
 
 DESCRIPTION
 -----------
 This command starts an instance of puppet master, running as a daemon
 and using Ruby's built-in Webrick webserver. Puppet master can also be
 managed by other application servers; when this is the case, this
 executable is not used.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet master
 with '--genconfig'.
 
 * --daemonize:
   Send the process into the background. This is the default.
 
 * --no-daemonize:
   Do not send the process into the background.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to syslog, or the console if
   debugging or verbosity is enabled.
 
 * --verbose:
   Enable verbosity.
 
 * --version:
   Print the puppet version number and exit.
 
 * --compile:
-  Capability to compile a catalogue and output it in JSON from the
-  Puppet master. Uses facts contained in the $vardir/yaml/ directory to
-  compile the catalog.
-
-* --apply:
-  Capability to apply JSON catalog (such as one generated with
-  --compile). You can either specify a JSON file or pipe in JSON from
-  standard input.
+  Compile a catalogue and output it in JSON from the puppet master. Uses
+  facts contained in the $vardir/yaml/ directory to compile the catalog.
 
 
 EXAMPLE
 -------
   puppet master
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2005 Puppet Labs, LLC Licensed under the GNU Public
 License
 
     HELP
   end
 
   def preinit
     trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     # Create this first-off, so we have ARGV
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
   end
 
   def run_command
     if options[:node]
       compile
     elsif Puppet[:parseonly]
       parseonly
     else
       main
     end
   end
 
   def compile
     Puppet::Util::Log.newdestination :console
     raise ArgumentError, "Cannot render compiled catalogs without pson support" unless Puppet.features.pson?
     begin
       unless catalog = Puppet::Resource::Catalog.indirection.find(options[:node])
         raise "Could not compile catalog for #{options[:node]}"
       end
 
       jj catalog.to_resource
     rescue => detail
       $stderr.puts detail
       exit(30)
     end
     exit(0)
   end
 
   def parseonly
     begin
       Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
     rescue => detail
       Puppet.err detail
       exit 1
     end
     exit(0)
   end
 
   def main
     require 'etc'
     require 'puppet/file_serving/content'
     require 'puppet/file_serving/metadata'
 
     xmlrpc_handlers = [:Status, :FileServer, :Master, :Report, :Filebucket]
 
     xmlrpc_handlers << :CA if Puppet[:ca]
 
     # Make sure we've got a localhost ssl cert
     Puppet::SSL::Host.localhost
 
     # And now configure our server to *only* hit the CA for data, because that's
     # all it will have write access to.
     Puppet::SSL::Host.ca_location = :only if Puppet::SSL::CertificateAuthority.ca?
 
     if Puppet.features.root?
       begin
         Puppet::Util.chuser
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         $stderr.puts "Could not change user to #{Puppet[:user]}: #{detail}"
         exit(39)
       end
     end
 
     unless options[:rack]
       require 'puppet/network/server'
       @daemon.server = Puppet::Network::Server.new(:xmlrpc_handlers => xmlrpc_handlers)
       @daemon.daemonize if Puppet[:daemonize]
     else
       require 'puppet/network/http/rack'
       @app = Puppet::Network::HTTP::Rack.new(:xmlrpc_handlers => xmlrpc_handlers, :protocols => [:rest, :xmlrpc])
     end
 
     Puppet.notice "Starting Puppet master version #{Puppet.version}"
 
     unless options[:rack]
       @daemon.start
     else
       return @app
     end
   end
 
   def setup
     # Handle the logging settings.
     if options[:debug] or options[:verbose]
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
 
       unless Puppet[:daemonize] or options[:rack]
         Puppet::Util::Log.newdestination(:console)
         options[:setdest] = true
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet.settings.use :main, :master, :ssl
 
     # Cache our nodes in yaml.  Currently not configurable.
     Puppet::Node.indirection.cache_class = :yaml
 
     # Configure all of the SSL stuff.
     if Puppet::SSL::CertificateAuthority.ca?
       Puppet::SSL::Host.ca_location = :local
       Puppet.settings.use :ca
       Puppet::SSL::CertificateAuthority.instance
     else
       Puppet::SSL::Host.ca_location = :none
     end
   end
 end