diff --git a/lib/puppet/application/faces.rb b/lib/puppet/application/faces.rb
index e7fce66b1..3145da821 100644
--- a/lib/puppet/application/faces.rb
+++ b/lib/puppet/application/faces.rb
@@ -1,126 +1,122 @@
 require 'puppet/application'
 require 'puppet/face'
 
 class Puppet::Application::Faces < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do
     Puppet::Util::Log.level = :info
   end
 
   def help
     <<-HELP
 puppet-faces(8) -- List available Faces and actions
 ========
 
 SYNOPSIS
 --------
 Lists the available subcommands (with applicable terminuses and/or actions)
 provided by the Puppet Faces API. This information is automatically read
 from the Puppet code present on the system. By default, the output includes
 all terminuses and actions.
 
 USAGE
 -----
 puppet faces [-d|--debug] [-v|--verbose] [actions|terminuses]
 
 OPTIONS
 -------
 Note that any configuration option valid in the configuration file is also
 a valid long 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 agent with
 '--genconfig'.
 
 * --verbose:
   Sets the log level to "info." This option has no tangible effect at the time
   of this writing.
 
 * --debug:
   Sets the log level to "debug." This option has no tangible effect at the time
   of this writing.
 
 AUTHOR
 ------
 Puppet Labs
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def list(*arguments)
     if arguments.empty?
       arguments = %w{terminuses actions}
     end
     faces.each do |name|
       str = "#{name}:\n"
       if arguments.include?("terminuses")
         begin
-          terms = terminus_classes(name.to_sym)
+          terms = Puppet::Indirector::Face.terminus_classes(name.to_sym)
           str << "\tTerminuses: #{terms.join(", ")}\n"
         rescue => detail
           puts detail.backtrace if Puppet[:trace]
           $stderr.puts "Could not load terminuses for #{name}: #{detail}"
         end
       end
 
       if arguments.include?("actions")
         begin
           actions = actions(name.to_sym)
           str << "\tActions: #{actions.join(", ")}\n"
         rescue => detail
           puts detail.backtrace if Puppet[:trace]
           $stderr.puts "Could not load actions for #{name}: #{detail}"
         end
       end
 
       print str
     end
   end
 
   attr_accessor :name, :arguments
 
   def main
     list(*arguments)
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     load_applications # Call this to load all of the apps
 
     @arguments = command_line.args
     @arguments ||= []
   end
 
   def faces
     Puppet::Face.faces
   end
 
-  def terminus_classes(indirection)
-    Puppet::Indirector::Terminus.terminus_classes(indirection).collect { |t| t.to_s }.sort
-  end
-
   def actions(indirection)
     return [] unless face = Puppet::Face[indirection, '0.0.1']
     face.load_actions
     return face.actions.sort { |a, b| a.to_s <=> b.to_s }
   end
 
   def load_applications
     command_line.available_subcommands.each do |app|
       command_line.require_application app
     end
   end
 end
 
diff --git a/lib/puppet/indirector/terminus.rb b/lib/puppet/indirector/terminus.rb
index 4ebd0d004..d488869d1 100644
--- a/lib/puppet/indirector/terminus.rb
+++ b/lib/puppet/indirector/terminus.rb
@@ -1,148 +1,145 @@
 require 'puppet/indirector'
 require 'puppet/indirector/indirection'
 require 'puppet/util/instance_loader'
 
 # A simple class that can function as the base class for indirected types.
 class Puppet::Indirector::Terminus
   require 'puppet/util/docs'
   extend Puppet::Util::Docs
 
   class << self
     include Puppet::Util::InstanceLoader
 
     attr_accessor :name, :terminus_type
     attr_reader :abstract_terminus, :indirection
 
     # Are we an abstract terminus type, rather than an instance with an
     # associated indirection?
     def abstract_terminus?
       abstract_terminus
     end
 
     # Convert a constant to a short name.
     def const2name(const)
       const.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
     end
 
     # Look up the indirection if we were only provided a name.
     def indirection=(name)
       if name.is_a?(Puppet::Indirector::Indirection)
         @indirection = name
       elsif ind = Puppet::Indirector::Indirection.instance(name)
         @indirection = ind
       else
         raise ArgumentError, "Could not find indirection instance #{name} for #{self.name}"
       end
     end
 
     def indirection_name
       @indirection.name
     end
 
     # Register our subclass with the appropriate indirection.
     # This follows the convention that our terminus is named after the
     # indirection.
     def inherited(subclass)
       longname = subclass.to_s
       if longname =~ /#<Class/
         raise Puppet::DevError, "Terminus subclasses must have associated constants"
       end
       names = longname.split("::")
 
       # Convert everything to a lower-case symbol, converting camelcase to underscore word separation.
       name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
 
       subclass.name = name
 
       # Short-circuit the abstract types, which are those that directly subclass
       # the Terminus class.
       if self == Puppet::Indirector::Terminus
         subclass.mark_as_abstract_terminus
         return
       end
 
       # Set the terminus type to be the name of the abstract terminus type.
       # Yay, class/instance confusion.
       subclass.terminus_type = self.name
 
       # Our subclass is specifically associated with an indirection.
       raise("Invalid name #{longname}") unless names.length > 0
       indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
 
       if indirection_name == "" or indirection_name.nil?
         raise Puppet::DevError, "Could not discern indirection model from class constant"
       end
 
       # This will throw an exception if the indirection instance cannot be found.
       # Do this last, because it also registers the terminus type with the indirection,
       # which needs the above information.
       subclass.indirection = indirection_name
 
       # And add this instance to the instance hash.
       Puppet::Indirector::Terminus.register_terminus_class(subclass)
     end
 
     # Mark that this instance is abstract.
     def mark_as_abstract_terminus
       @abstract_terminus = true
     end
 
     def model
       indirection.model
     end
 
     # Convert a short name to a constant.
     def name2const(name)
       name.to_s.capitalize.sub(/_(.)/) { |i| $1.upcase }
     end
 
     # Register a class, probably autoloaded.
     def register_terminus_class(klass)
       setup_instance_loading klass.indirection_name
       instance_hash(klass.indirection_name)[klass.name] = klass
     end
 
     # Return a terminus by name, using the autoloader.
     def terminus_class(indirection_name, terminus_type)
       setup_instance_loading indirection_name
       loaded_instance(indirection_name, terminus_type)
     end
 
     # Return all terminus classes for a given indirection.
     def terminus_classes(indirection_name)
       setup_instance_loading indirection_name
-
-      # Load them all.
-      instance_loader(indirection_name).loadall
-
-      # And return the list of names.
-      loaded_instances(indirection_name)
+      instance_loader(indirection_name).files_to_load.map do |file|
+        File.basename(file).chomp(".rb").intern
+      end
     end
 
     private
 
     def setup_instance_loading(type)
       instance_load type, "puppet/indirector/#{type}" unless instance_loading?(type)
     end
   end
 
   def indirection
     self.class.indirection
   end
 
   def initialize
     raise Puppet::DevError, "Cannot create instances of abstract terminus types" if self.class.abstract_terminus?
   end
 
   def model
     self.class.model
   end
 
   def name
     self.class.name
   end
 
   def terminus_type
     self.class.terminus_type
   end
 end
diff --git a/lib/puppet/util/autoload.rb b/lib/puppet/util/autoload.rb
index 0e7025aef..6537a4a4e 100644
--- a/lib/puppet/util/autoload.rb
+++ b/lib/puppet/util/autoload.rb
@@ -1,156 +1,158 @@
 require 'puppet/util/warnings'
 require 'puppet/util/cacher'
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
   require 'puppet/util/autoload/file_cache'
 
   include Puppet::Util
   include Puppet::Util::Warnings
   include Puppet::Util::Cacher
   include Puppet::Util::Autoload::FileCache
 
   @autoloaders = {}
   @loaded = []
 
   class << self
     attr_reader :autoloaders
     private :autoloaders
   end
 
   # Send [], []=, and :clear to the @autloaders hash
   Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
 
   # List all loaded files.
   def self.list_loaded
     @loaded.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
       "#{path}: #{hash[:file]}"
     end
   end
 
   # Has a given path been loaded?  This is used for testing whether a
   # changed file should be loaded or just ignored.  This is only
   # used in network/client/master, when downloading plugins, to
   # see if a given plugin is currently loaded and thus should be
   # reloaded.
   def self.loaded?(path)
     path = path.to_s.sub(/\.rb$/, '')
     @loaded.include?(path)
   end
 
   # Save the fact that a given path has been loaded.  This is so
   # we can load downloaded plugins if they've already been loaded
   # into memory.
   def self.loaded(file)
     $" << file + ".rb" unless $".include?(file)
     @loaded << file unless @loaded.include?(file)
   end
 
   attr_accessor :object, :path, :objwarn, :wrap
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if @path !~ /^\w/
     @object = obj
 
     self.class[obj] = self
 
     options.each do |opt, value|
       opt = opt.intern if opt.is_a? String
       begin
         self.send(opt.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "#{opt} is not a valid option"
       end
     end
 
     @wrap = true unless defined?(@wrap)
   end
 
   # Load a single plugin by name.  We use 'load' here so we can reload a
   # given plugin.
   def load(name,env=nil)
     path = name.to_s + ".rb"
 
     searchpath(env).each do |dir|
       file = File.join(dir, path)
       next unless file_exist?(file)
       begin
         Kernel.load file, @wrap
         name = symbolize(name)
         loaded name, file
         return true
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
         puts detail.backtrace if Puppet[:trace]
         raise Puppet::Error, "Could not autoload #{name}: #{detail}"
       end
     end
     false
   end
 
   # Mark the named object as loaded.  Note that this supports unqualified
   # queries, while we store the result as a qualified query in the class.
   def loaded(name, file)
     self.class.loaded(File.join(@path, name.to_s))
   end
 
   # Indicate whether the specfied plugin has been loaded.
   def loaded?(name)
     self.class.loaded?(File.join(@path, name.to_s))
   end
 
   # Load all instances that we can.  This uses require, rather than load,
   # so that already-loaded files don't get reloaded unnecessarily.
   def loadall
     # Load every instance of everything we can find.
-    searchpath.each do |dir|
-      Dir.glob("#{dir}/*.rb").each do |file|
-        name = File.basename(file).sub(".rb", '').intern
-        next if loaded?(name)
-        begin
-          Kernel.require file
-          loaded(name, file)
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => detail
-          puts detail.backtrace if Puppet[:trace]
-          raise Puppet::Error, "Could not autoload #{file}: #{detail}"
-        end
+    files_to_load.each do |file|
+      name = File.basename(file).chomp(".rb").intern
+      next if loaded?(name)
+      begin
+        Kernel.require file
+        loaded(name, file)
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not autoload #{file}: #{detail}"
       end
     end
   end
 
+  def files_to_load
+    searchpath.map { |dir| Dir.glob("#{dir}/*.rb") }.flatten
+  end
+
   # The list of directories to search through for loadable plugins.
   def searchpath(env=nil)
     search_directories(env).uniq.collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
   end
 
   def module_directories(env=nil)
     # We have to require this late in the process because otherwise we might have
     # load order issues.
     require 'puppet/node/environment'
 
     real_env = Puppet::Node::Environment.new(env)
 
     # We're using a per-thread cache of said module directories, so that
     # we don't scan the filesystem each time we try to load something with
     # this autoload instance. But since we don't want to cache for the eternity
     # this env_module_directories gets reset after the compilation on the master.
     # This is also reset after an agent ran.
     # One of the side effect of this change is that this module directories list will be
     # shared among all autoload that we have running at a time. But that won't be an issue
     # as by definition those directories are shared by all autoload.
     Thread.current[:env_module_directories] ||= {}
     Thread.current[:env_module_directories][real_env] ||= real_env.modulepath.collect do |dir|
         Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f) }
       end.flatten.collect { |d| [File.join(d, "plugins"), File.join(d, "lib")] }.flatten.find_all do |d|
         FileTest.directory?(d)
       end
   end
 
   def search_directories(env=nil)
     [module_directories(env), Puppet[:libdir].split(File::PATH_SEPARATOR), $LOAD_PATH].flatten
   end
 end
diff --git a/spec/unit/indirector/terminus_spec.rb b/spec/unit/indirector/terminus_spec.rb
index 33932cfca..2f37c1ff5 100755
--- a/spec/unit/indirector/terminus_spec.rb
+++ b/spec/unit/indirector/terminus_spec.rb
@@ -1,244 +1,250 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/defaults'
 require 'puppet/indirector'
 require 'puppet/indirector/file'
 
 describe Puppet::Indirector::Terminus, :'fails_on_ruby_1.9.2' => true do
   before :each do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @indirection = stub 'indirection', :name => :my_stuff, :register_terminus_type => nil
     Puppet::Indirector::Indirection.stubs(:instance).with(:my_stuff).returns(@indirection)
     @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
       def self.to_s
         "Testing::Abstract"
       end
     end
     @terminus_class = Class.new(@abstract_terminus) do
       def self.to_s
         "MyStuff::TermType"
       end
     end
     @terminus = @terminus_class.new
   end
 
   describe Puppet::Indirector::Terminus do
 
     it "should provide a method for setting terminus class documentation" do
       @terminus_class.should respond_to(:desc)
     end
 
     it "should support a class-level name attribute" do
       @terminus_class.should respond_to(:name)
     end
 
     it "should support a class-level indirection attribute" do
       @terminus_class.should respond_to(:indirection)
     end
 
     it "should support a class-level terminus-type attribute" do
       @terminus_class.should respond_to(:terminus_type)
     end
 
     it "should support a class-level model attribute" do
       @terminus_class.should respond_to(:model)
     end
 
     it "should accept indirection instances as its indirection" do
       indirection = stub 'indirection', :is_a? => true, :register_terminus_type => nil
       proc { @terminus_class.indirection = indirection }.should_not raise_error
       @terminus_class.indirection.should equal(indirection)
     end
 
     it "should look up indirection instances when only a name has been provided" do
       indirection = mock 'indirection'
       Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(indirection)
       @terminus_class.indirection = :myind
       @terminus_class.indirection.should equal(indirection)
     end
 
     it "should fail when provided a name that does not resolve to an indirection" do
       Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(nil)
       proc { @terminus_class.indirection = :myind }.should raise_error(ArgumentError)
 
       # It shouldn't overwrite our existing one (or, more normally, it shouldn't set
       # anything).
       @terminus_class.indirection.should equal(@indirection)
     end
   end
 
   describe Puppet::Indirector::Terminus, " when creating terminus classes" do
     it "should associate the subclass with an indirection based on the subclass constant" do
       @terminus.indirection.should equal(@indirection)
     end
 
     it "should set the subclass's type to the abstract terminus name" do
       @terminus.terminus_type.should == :abstract
     end
 
     it "should set the subclass's name to the indirection name" do
       @terminus.name.should == :term_type
     end
 
     it "should set the subclass's model to the indirection model" do
       @indirection.expects(:model).returns :yay
       @terminus.model.should == :yay
     end
   end
 
   describe Puppet::Indirector::Terminus, " when a terminus instance" do
 
     it "should return the class's name as its name" do
       @terminus.name.should == :term_type
     end
 
     it "should return the class's indirection as its indirection" do
       @terminus.indirection.should equal(@indirection)
     end
 
     it "should set the instances's type to the abstract terminus type's name" do
       @terminus.terminus_type.should == :abstract
     end
 
     it "should set the instances's model to the indirection's model" do
       @indirection.expects(:model).returns :yay
       @terminus.model.should == :yay
     end
   end
 end
 
 # LAK: This could reasonably be in the Indirection instances, too.  It doesn't make
 # a whole heckuva lot of difference, except that with the instance loading in
 # the Terminus base class, we have to have a check to see if we're already
 # instance-loading a given terminus class type.
 describe Puppet::Indirector::Terminus, " when managing terminus classes" do
   it "should provide a method for registering terminus classes" do
     Puppet::Indirector::Terminus.should respond_to(:register_terminus_class)
   end
 
   it "should provide a method for returning terminus classes by name and type" do
     terminus = stub 'terminus_type', :name => :abstract, :indirection_name => :whatever
     Puppet::Indirector::Terminus.register_terminus_class(terminus)
     Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract).should equal(terminus)
   end
 
   it "should set up autoloading for any terminus class types requested" do
     Puppet::Indirector::Terminus.expects(:instance_load).with(:test2, "puppet/indirector/test2")
     Puppet::Indirector::Terminus.terminus_class(:test2, :whatever)
   end
 
   it "should load terminus classes that are not found" do
     # Set up instance loading; it would normally happen automatically
     Puppet::Indirector::Terminus.instance_load :test1, "puppet/indirector/test1"
 
     Puppet::Indirector::Terminus.instance_loader(:test1).expects(:load).with(:yay)
     Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
   end
 
   it "should fail when no indirection can be found", :'fails_on_ruby_1.9.2' => true do
     Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(nil)
 
     @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
       def self.to_s
         "Abstract"
       end
     end
     proc {
       @terminus = Class.new(@abstract_terminus) do
         def self.to_s
           "MyIndirection::TestType"
         end
       end
     }.should raise_error(ArgumentError)
   end
 
   it "should register the terminus class with the terminus base class", :'fails_on_ruby_1.9.2' => true do
     Puppet::Indirector::Terminus.expects(:register_terminus_class).with do |type|
       type.indirection_name == :my_indirection and type.name == :test_terminus
     end
     @indirection = stub 'indirection', :name => :my_indirection, :register_terminus_type => nil
     Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(@indirection)
 
     @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
       def self.to_s
         "Abstract"
       end
     end
 
     @terminus = Class.new(@abstract_terminus) do
       def self.to_s
         "MyIndirection::TestTerminus"
       end
     end
   end
 end
 
 describe Puppet::Indirector::Terminus, " when parsing class constants for indirection and terminus names" do
   before do
     @subclass = mock 'subclass'
     @subclass.stubs(:to_s).returns("TestInd::OneTwo")
     @subclass.stubs(:mark_as_abstract_terminus)
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
   end
 
   it "should fail when anonymous classes are used" do
     proc { Puppet::Indirector::Terminus.inherited(Class.new) }.should raise_error(Puppet::DevError)
   end
 
   it "should use the last term in the constant for the terminus class name" do
     @subclass.expects(:name=).with(:one_two)
     @subclass.stubs(:indirection=)
     Puppet::Indirector::Terminus.inherited(@subclass)
   end
 
   it "should convert the terminus name to a downcased symbol" do
     @subclass.expects(:name=).with(:one_two)
     @subclass.stubs(:indirection=)
     Puppet::Indirector::Terminus.inherited(@subclass)
   end
 
   it "should use the second to last term in the constant for the indirection name" do
     @subclass.expects(:indirection=).with(:test_ind)
     @subclass.stubs(:name=)
     @subclass.stubs(:terminus_type=)
     Puppet::Indirector::File.inherited(@subclass)
   end
 
   it "should convert the indirection name to a downcased symbol" do
     @subclass.expects(:indirection=).with(:test_ind)
     @subclass.stubs(:name=)
     @subclass.stubs(:terminus_type=)
     Puppet::Indirector::File.inherited(@subclass)
   end
 
   it "should convert camel case to lower case with underscores as word separators" do
     @subclass.expects(:name=).with(:one_two)
     @subclass.stubs(:indirection=)
 
     Puppet::Indirector::Terminus.inherited(@subclass)
   end
 end
 
 describe Puppet::Indirector::Terminus, " when creating terminus class types", :'fails_on_ruby_1.9.2' => true do
   before do
     Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     @subclass = Class.new(Puppet::Indirector::Terminus) do
       def self.to_s
         "Puppet::Indirector::Terminus::MyTermType"
       end
     end
   end
 
   it "should set the name of the abstract subclass to be its class constant" do
     @subclass.name.should equal(:my_term_type)
   end
 
   it "should mark abstract terminus types as such" do
     @subclass.should be_abstract_terminus
   end
 
   it "should not allow instances of abstract subclasses to be created" do
     proc { @subclass.new }.should raise_error(Puppet::DevError)
   end
 end
 
+describe Puppet::Indirector::Terminus, " when listing terminus classes" do
+  it "should list the terminus files available to load" do
+    Puppet::Util::Autoload.any_instance.stubs(:files_to_load).returns ["/foo/bar/baz", "/max/runs/marathon"]
+    Puppet::Indirector::Terminus.terminus_classes('my_stuff').should == [:baz, :marathon]
+  end
+end