roby 0.8.0 → 3.0.0

data/lib/roby/models/task_event.rb

@@ -0,0 +1,62 @@
+module Roby
+    module Models
+        # Model-level API for task events
+        module TaskEvent
+            include MetaRuby::ModelAsClass
+
+            # The task model this event is defined on
+            # @return [Model<Task>]
+            attr_accessor :task_model
+
+            # If the event model defines a controlable event
+            # By default, an event is controlable if the model
+            # responds to #call
+            def controlable?; respond_to?(:call) end
+
+            # Called by Task.update_terminal_flag to update the flag
+            attr_predicate :terminal?, true
+
+            # @return [Symbol] the event name
+            attr_accessor :symbol
+
+            def setup_submodel(submodel, task_model: nil, symbol: nil, command: false, terminal: false, **options, &block)
+                super(submodel, options, &block)
+                submodel.task_model = task_model
+                submodel.symbol     = symbol
+                submodel.terminal   = terminal
+
+                if command
+                    if command.respond_to?(:call)
+                        # check that the supplied command handler can take two arguments
+                        check_arity(command, 2, strict: true)
+                        submodel.singleton_class.class_eval do
+                            define_method(:call, &command)
+                        end
+                    else
+                        submodel.singleton_class.class_eval do
+                            def call(task, context) # :nodoc:
+                                task.event(symbol).emit(*context)
+                            end
+                        end
+                    end
+                end
+
+                submodel
+            end
+
+            # @return [TaskEventGeneratorMatcher] returns an object that allows
+            #   to match all generators of this type
+            def match
+                Queries::TaskEventGeneratorMatcher.new(task_model.match, symbol.to_s)
+            end
+
+            # @return [TaskEventGeneratorMatcher] returns an object that allows
+            #   to match all generators of this type, as well as any generator
+            #   that is forwarded to it
+            def generalized_match
+                Queries::TaskEventGeneratorMatcher.new(task_model.match, symbol.to_s).generalized
+            end
+        end
+    end
+end
+

data/lib/roby/models/task_service.rb

@@ -0,0 +1,78 @@
+module Roby
+    module Models
+        # Ruby (the language) has no support for multiple inheritance. Instead, it
+        # uses module to extend classes outside of the class hierarchy.
+        #
+        # TaskService are the equivalent concept in the world of task models. They
+        # are a limited for of task models, which can be used to represent that
+        # certain task models have multiple functions.
+        #
+        # For instance,
+        #   
+        #   task_service "CameraDriver" do
+        #      # CameraDriver is an abstract model used to represent that some tasks
+        #      # are providing the services of cameras. They can be used to tag tasks
+        #      # that belong to different class hirerachies.
+        #      # 
+        #      # One can set up arguments on TaskService the same way than class models:
+        #      argument :camera_name
+        #      argument :aperture
+        #      argument :aperture
+        #   end
+        #
+        #   FirewireDriver.provides CameraDriver
+        #   # FirewireDriver can now be used in relationships where CameraDriver was
+        #   # needed
+        class TaskServiceModel < Module
+            include MetaRuby::ModelAsModule
+            include Arguments
+
+            def clear_model
+                super
+                arguments.clear
+            end
+
+            def query(*args)
+                query = Queries::Query.new
+                if args.empty? && self != TaskService
+                    query.which_fullfills(self)
+                else
+                    query.which_fullfills(*args)
+                end
+                query
+            end
+
+            def match(*args)
+                matcher = Queries::TaskMatcher.new
+                if args.empty? && self != TaskService
+                    matcher.which_fullfills(self)
+                else
+                    matcher.which_fullfills(*args)
+                end
+                matcher
+            end
+        end
+
+        module TaskServiceDefinitionDSL
+            # Define a new task service. When defining the service, one does:
+            #
+            #   module MyApplication
+            #      task_service 'NavigationService' do
+            #         argument :target, type: Eigen::Vector3
+            #      end
+            #   end
+            #
+            # Then, to use it:
+            #
+            #   class GoTo
+            #     provides MyApplication::NavigationService
+            #   end
+            #
+            def task_service(name, &block)
+                MetaRuby::ModelAsModule.create_and_register_submodel(self, name, TaskService, &block)
+            end
+        end
+        Module.include TaskServiceDefinitionDSL
+    end
+end
+

data/lib/roby/or_generator.rb

@@ -0,0 +1,88 @@
+module Roby
+    # Fires when the first of its source events fires.
+    #
+    # For instance,
+    #
+    #    a = task1.start_event
+    #    b = task2.start_event
+    #    (a | b) # will emit as soon as one of task1 and task2 are started
+    #
+    # Or events will emit only once, unless #reset is called:
+    #
+    #    a = task1.intermediate_event
+    #    b = task2.intermediate_event
+    #    or_ev = (a | b)
+    #
+    #    a.intermediate_event! # or_ev emits here
+    #    b.intermediate_event! # or_ev does *not* emit 
+    #    a.intermediate_event! # or_ev does *not* emit
+    #    b.intermediate_event! # or_ev does *not* emit
+    #
+    #    or_ev.reset
+    #    b.intermediate_event! # or_ev emits here
+    #    a.intermediate_event! # or_ev does *not* emit
+    #    b.intermediate_event! # or_ev does *not* emit
+    #
+    # The OrGenerator tracks its sources via the signalling relations, so
+    #
+    #    or_ev << c.intermediate_event
+    #
+    # is equivalent to
+    #
+    #    c.intermediate_event.add_signal or_ev
+    #
+    class OrGenerator < EventGenerator
+        # Creates a new OrGenerator without any sources.
+        def initialize
+            super do |context|
+                emit_if_first(context)
+            end
+            @active = true
+        end
+
+        # True if there is no source events
+        def empty?; parent_objects(EventStructure::Signal).empty? end
+
+        # Or generators will emit only once, unless this method is called. See
+        # the documentation of OrGenerator for an example.
+        def reset
+            @active = true
+            each_parent_object(EventStructure::Signal) do |source|
+                if source.respond_to?(:reset)
+                    source.reset
+                end
+            end
+        end
+
+        # Helper method called to emit the event when it is required
+        def emit_if_first(context) # :nodoc:
+            return unless @active
+            @active = false
+            emit(context)
+        end
+
+        # Tracks the event's parents in the signalling relation
+        def added_signal_parent(parent, info) # :nodoc:
+            super
+            parent.if_unreachable(cancel_at_emission: true) do |reason, event|
+                if !emitted? && each_parent_object(EventStructure::Signal).all? { |ev| ev.unreachable? }
+                    unreachable!(reason || parent)
+                end
+            end
+        end
+
+        def removed_signal_parent(parent)
+            super
+            if !emitted? && each_parent_object(EventStructure::Signal).all? { |ev| ev.unreachable? }
+                unreachable!
+            end
+        end
+
+        # Adds +generator+ to the sources of this event
+        def << (generator)
+            generator.add_signal self
+            self
+        end
+    end
+end
+

data/lib/roby/plan.rb

@@ -1,946 +1,1833 @@
 module Roby
     # A plan object manages a collection of tasks and events.
-    #
-    # == Adding and removing objects from plans
-    # The #add, #add_mission and #add_permanent calls allow to add objects in
-    # plans. The #remove_object removes the same objects from the plan. Note
-    # that you should never remove objects yourself: a GC mechanism will do
-    # that properly for you, taking into account the consequences of the object
-    # removal.
-    #
-    # To reduce the complexity of object management, a garbage collection
-    # mechanism is in place during the plan execution, stopping and removing
-    # tasks that are not useful anymore for the system's goals. This garbage
-    # collection mechanism runs at the end of the execution cycle. Once an
-    # object is not active (i.e. for a task, once it is stopped), the object is
-    # /finalized/ and either the #finalized_task or the #finalized_event hook is
-    # called.
-    #
-    # Two special kinds of objects exist in plans:
-    # * the +missions+ (#missions, #mission?, #add_mission and #unmark_mission) are the
-    #   final goals of the system.  A task is +useful+ if it helps into the
-    #   Realization of a mission (it is the child of a mission through one of the
-    #   task relations).
-    # * the +permanent+ objects (#add_permanent, #unmark_permanent, #permanent?, #permanent_tasks and
-    #   #permanent_events) are plan objects that are not affected by the plan's
-    #   garbage collection mechanism. As for missions, task that are useful to
-    #   permanent tasks are also 
-    #
-    class Plan < BasicObject
-	extend Logger::Hierarchy
-	extend Logger::Forward
-
-        # The ExecutionEngine object which handles this plan. The role of this
-        # object is to provide the event propagation, error propagation and
-        # garbage collection mechanisms for the execution.
-        attr_accessor :engine
-        # The DecisionControl object which is associated with this plan. This
-        # object's role is to handle the conflicts that can occur during event
-        # propagation.
-        def control; engine.control end
-
-	# The task index for this plan. This is a TaskIndex object which allows
+    class Plan < DistributedObject
+        extend Logger::Hierarchy
+        extend Logger::Forward
+        include DRoby::EventLogging
+        
+        # The Peer ID of the local owner (i.e. of the local process / execution
+        # engine)
+        attr_accessor :local_owner
+
+        # The task index for this plan. This is a {Queries::Index} object which allows
         # efficient resolving of queries.
-	attr_reader :task_index
-
-	# The list of tasks that are included in this plan
-	attr_reader :known_tasks
-	# The set of events that are defined by #known_tasks
-	attr_reader :task_events
-        # The list of the robot's missions. Do not change that set directly, use
-        # #add_mission and #remove_mission instead.
-	attr_reader :missions
-	# The list of tasks that are kept outside GC. Do not change that set
-        # directly, use #permanent and #auto instead.
-	attr_reader :permanent_tasks
-	# The list of events that are not included in a task
-	attr_reader :free_events
-	# The list of events that are kept outside GC. Do not change that set
+        attr_reader :task_index
+
+        # The list of tasks that are included in this plan
+        attr_reader :tasks
+        # The set of events that are defined by #tasks
+        attr_reader :task_events
+        # The set of the robot's missions
+        # @see add_mission_task unmark_mission_task
+        attr_reader :mission_tasks
+        # The set of tasks that are kept around "just in case"
+        # @see add_permanent_task unmark_permanent_task
+        attr_reader :permanent_tasks
+        # The list of events that are not included in a task
+        attr_reader :free_events
+        # The list of events that are kept outside GC. Do not change that set
         # directly, use #permanent and #auto instead.
-	attr_reader :permanent_events
-
-	# A map of event => task repairs. Whenever an exception is found,
-	# exception propagation checks that no repair is defined for that
-	# particular event or for events that are forwarded by it.
-        #
-        # See also #add_repair and #remove_repair
-	attr_reader :repairs
-
-	# A set of tasks which are useful (and as such would not been garbage
-	# collected), but we want to GC anyway
-	attr_reader :force_gc
-
-	# A set of task for which GC should not be attempted, either because
-	# they are not interruptible or because their start or stop command
-	# failed
-	attr_reader :gc_quarantine
-
-	# The set of transactions which are built on top of this plan
-	attr_reader :transactions
-
-	# If this object is the main plan, checks if we are subscribed to
-	# the whole remote plan
-	def sibling_on?(peer)
-	    if Roby.plan == self then peer.remote_plan
-	    else super
-	    end
-	end
-
-        # The set of relations available for this plan
-        attr_reader :relations
-
-        # The propagation engine for this object. It is either nil (if no
-        # propagation engine is available) or self.
-        attr_reader :propagation_engine
-
-	def initialize
-	    @missions	 = ValueSet.new
-	    @permanent_tasks   = ValueSet.new
-	    @permanent_events   = ValueSet.new
-	    @known_tasks = ValueSet.new
-	    @free_events = ValueSet.new
-	    @task_events = ValueSet.new
-	    @force_gc    = ValueSet.new
-	    @gc_quarantine = ValueSet.new
-	    @transactions = ValueSet.new
-	    @repairs     = Hash.new
-            @exception_handlers = Array.new
-
-            @relations = TaskStructure.relations + EventStructure.relations
-            @structure_checks = relations.
-                map { |r| r.method(:check_structure) if r.respond_to?(:check_structure) }.
-                compact
-
-	    @task_index  = Roby::TaskIndex.new
-
-	    super() if defined? super
-	end
-
-	def inspect # :nodoc:
-	    "#<#{to_s}: missions=#{missions.to_s} tasks=#{known_tasks.to_s} events=#{free_events.to_s} transactions=#{transactions.to_s}>"
-	end
+        attr_reader :permanent_events
+        # A set of pair of task matching objects and blocks defining this plan's
+        # triggers
+        #
+        # See {#add_trigger}
+        attr_reader :triggers
+
+        # The set of transactions which are built on top of this plan
+        attr_reader :transactions
+
+        # If this object is the main plan, checks if we are subscribed to
+        # the whole remote plan
+        def sibling_on?(peer)
+            if Roby.plan == self then peer.remote_plan
+            else super
+            end
+        end
+
+        # The set of PlanService instances that are defined on this plan
+        attr_reader :plan_services
+
+        # A template plan is meant to be injected in another plan
+        #
+        # When a {PlanObject} is included in a template plan, adding relations
+        # to other tasks causes the plans to merge as needed. Doing the same
+        # operation with plain plans causes an error
+        #
+        # @see TemplatePlan
+        def template?; false end
+
+        # Check that this is an executable plan. This is always true for
+        # plain Plan objects and false for transcations
+        def executable?; false end
+
+        # The event logger
+        attr_accessor :event_logger
+
+        # The observer object that reacts to relation changes
+        attr_reader :graph_observer
+
+        def initialize(graph_observer: nil, event_logger: DRoby::NullEventLogger.new)
+            @local_owner = DRoby::PeerID.new('local')
+
+            @mission_tasks    = Set.new
+            @permanent_tasks  = Set.new
+            @permanent_events = Set.new
+            @tasks = Set.new
+            @free_events = Set.new
+            @task_events = Set.new
+            @transactions = Set.new
+            @fault_response_tables = Array.new
+            @triggers = []
+
+            @plan_services = Hash.new
+
+            self.event_logger = event_logger
+            @active_fault_response_tables = Array.new
+            @task_index  = Roby::Queries::Index.new
+
+            @graph_observer = graph_observer
+            create_relations
+
+            super()
+        end
+
+        def create_relations
+            @task_relation_graphs, @event_relation_graphs =
+                self.class.instanciate_relation_graphs(graph_observer: graph_observer)
+
+            @structure_checks = Array.new
+            each_relation_graph do |graph|
+                if graph.respond_to?(:check_structure)
+                    structure_checks << graph.method(:check_structure)
+                end
+            end
+        end
+
+        def refresh_relations
+            create_relations
+        end
+
+        def self.instanciate_relation_graphs(graph_observer: nil)
+            task_relation_graphs  = Relations::Space.new_relation_graph_mapping
+            Task.all_relation_spaces.each do |space|
+                task_relation_graphs.merge!(
+                    space.instanciate(observer: graph_observer))
+            end
+
+            event_relation_graphs = Relations::Space.new_relation_graph_mapping
+            EventGenerator.all_relation_spaces.each do |space|
+                event_relation_graphs.merge!(
+                    space.instanciate(observer: graph_observer))
+            end
+            return task_relation_graphs, event_relation_graphs
+        end
+
+        def dedupe(source)
+            @task_relation_graphs.each do |relation, graph|
+                if relation != graph
+                    graph.dedupe(source.task_relation_graph_for(relation))
+                end
+            end
+            @event_relation_graphs.each do |relation, graph|
+                if relation != graph
+                    graph.dedupe(source.event_relation_graph_for(relation))
+                end
+            end
+        end
+
+        # The graphs that make task relations, formatted as required by
+        # {Relations::DirectedRelationSupport#relation_graphs}
+        #
+        # @see each_task_relation_graph
+        attr_reader :task_relation_graphs
+
+        # The graphs that make event relations, formatted as required by
+        # {Relations::DirectedRelationSupport#relation_graphs}
+        #
+        # @see each_event_relation_graph
+        attr_reader :event_relation_graphs
+
+        # Enumerate the graph objects that contain this plan's relation
+        # information
+        #
+        # @yieldparam [Relations::Graph] graph
+        def each_relation_graph(&block)
+            return enum_for(__method__) if !block_given?
+            each_event_relation_graph(&block)
+            each_task_relation_graph(&block)
+        end
+
+        # Enumerate all graphs (event and tasks) that form this plan
+        def each_relation_graph
+            return enum_for(__method__) if !block_given?
+            each_task_relation_graph { |g| yield(g) }
+            each_event_relation_graph { |g| yield(g) }
+        end
+
+        # Enumerate the graph objects that contain this plan's event relation
+        # information
+        #
+        # @yieldparam [Relations::EventRelationGraph] graph
+        def each_event_relation_graph
+            return enum_for(__method__) if !block_given?
+            event_relation_graphs.each do |k, v|
+                yield(v) if k == v
+            end
+        end
+
+        # Resolves an event graph object from the graph class (i.e. the graph model)
+        def event_relation_graph_for(model)
+            event_relation_graphs.fetch(model)
+        end
+
+        # Enumerate the graph objects that contain this plan's task relation
+        # information
+        #
+        # @yieldparam [Relations::TaskRelationGraph] graph
+        def each_task_relation_graph
+            return enum_for(__method__) if !block_given?
+            task_relation_graphs.each do |k, v|
+                yield(v) if k == v
+            end
+        end
+
+        # Resolves a task graph object from the graph class (i.e. the graph model)
+        def task_relation_graph_for(model)
+            task_relation_graphs.fetch(model)
+        end
+
+        def dup
+            new_plan = Plan.new
+            copy_to(new_plan)
+            new_plan
+        end
+
+        def inspect # :nodoc:
+            "#<#{to_s}: mission_tasks=#{mission_tasks.to_s} tasks=#{tasks.to_s} events=#{free_events.to_s} transactions=#{transactions.to_s}>"
+        end
+
+        # Calls the given block in the execution thread of this plan's engine.
+        # If there is no engine attached to this plan, yields immediately
+        #
+        # See ExecutionEngine#execute
+        def execute(&block)
+            yield
+        end
+
+        # @deprecated use {#merge} instead
+        def copy_to(copy)
+            copy.merge(self)
+        end
+
+        def merge_base(plan)
+            free_events.merge(plan.free_events)
+            mission_tasks.merge(plan.mission_tasks)
+            tasks.merge(plan.tasks)
+            permanent_tasks.merge(plan.permanent_tasks)
+            permanent_events.merge(plan.permanent_events)
+            task_index.merge(plan.task_index)
+            task_events.merge(plan.task_events)
+        end
+        
+        def merge_relation_graphs(plan)
+            # Now merge the relation graphs
+            #
+            # Since task_relation_graphs contains both Class<Graph>=>Graph and
+            # Graph=>Graph, we merge only the graphs for which
+            # self.task_relation_graphs has an entry (i.e. Class<Graph>) and
+            # ignore the rest
+            plan.task_relation_graphs.each do |rel_id, rel|
+                next if rel_id == rel
+                next if !(this_rel = task_relation_graphs.fetch(rel_id, nil))
+                this_rel.merge(rel)
+            end
+            plan.event_relation_graphs.each do |rel_id, rel|
+                next if rel_id == rel
+                next if !(this_rel = event_relation_graphs.fetch(rel_id, nil))
+                this_rel.merge(rel)
+            end
+        end
+
+        def replace_relation_graphs(merged_graphs)
+            merged_graphs.each do |self_g, new_g|
+                self_g.replace(new_g)
+            end
+        end
+
+        def merge_transaction(transaction, merged_graphs, added, removed, updated)
+            merging_plan(transaction)
+            merge_base(transaction)
+            replace_relation_graphs(merged_graphs)
+            merged_plan(transaction)
+        end
+
+        def merge_transaction!(transaction, merged_graphs, added, removed, updated)
+            # Note: Task#plan= updates its bound events
+            tasks, events = transaction.tasks.dup, transaction.free_events.dup
+            tasks.each { |t| t.plan = self }
+            events.each { |e| e.plan = self }
+
+            merge_transaction(transaction, merged_graphs, added, removed, updated)
+        end
+
+        def find_triggers_matches(plan)
+            triggers.map do |tr|
+                [tr, tr.each(plan).to_a]
+            end
+        end
+
+        def apply_triggers_matches(matches)
+            matches.each do |trigger, matched_tasks|
+                matched_tasks.each do |t|
+                    trigger.call(t)
+                end
+            end
+        end
+
+        # Merges the content of a plan into self
+        #
+        # It is assumed that self and plan do not intersect.
+        #
+        # Unlike {#merge!}, it does not update its argument, neither update the
+        # plan objects to point to self afterwards
+        #
+        # @param [Roby::Plan] plan the plan to merge into self
+        def merge(plan)
+            return if plan == self
+
+            trigger_matches = find_triggers_matches(plan)
+            merging_plan(plan)
+            merge_base(plan)
+            merge_relation_graphs(plan)
+            merged_plan(plan)
+            apply_triggers_matches(trigger_matches)
+        end
+
+        # Moves the content of other_plan into self, and clears other_plan
+        #
+        # It is assumed that other_plan and plan do not intersect
+        #
+        # Unlike {#merge}, it ensures that all plan objects have their
+        # {PlanObject#plan} attribute properly updated, and it cleans plan
+        #
+        # @param [Roby::Plan] plan the plan to merge into self
+        def merge!(plan)
+            return if plan == self
+
+            tasks, events = plan.tasks.dup, plan.free_events.dup
+            tasks.each { |t| t.plan = self }
+            events.each { |e| e.plan = self }
+            merge(plan)
+        end
+
+        # Hook called just before performing a {#merge}
+        def merging_plan(plan)
+        end
+
+        # Hook called when a {#merge} has been performed
+        def merged_plan(plan)
+        end
+
+        def deep_copy
+            plan = Roby::Plan.new
+            mappings = deep_copy_to(plan)
+            return plan, mappings
+        end
+
+        # Copies this plan's state (tasks, events and their relations) into the
+        # provided plan
+        #
+        # It returns the mapping from the plan objects in +self+ to the plan
+        # objects in +copy+. For instance, if +t+ is a task in +plan+, then
+        #
+        #   mapping = plan.copy_to(copy)
+        #   mapping[t] => corresponding task in +copy+
+        def deep_copy_to(copy)
+            mappings = Hash.new do |h, k|
+                if !self.include?(k)
+                    raise InternalError, "#{k} is listed in a relation, but is not included in the corresponding plan #{self}"
+                else
+                    raise InternalError, "#{k} is an object in #{self} for which no mapping has been created in #{copy}"
+                end
+            end
+
+            # First create a copy of all the tasks
+            tasks.each do |t|
+                new_t = t.dup
+                mappings[t] = new_t
+
+                t.each_event do |ev|
+                    new_ev = ev.dup
+                    new_ev.instance_variable_set :@task, new_t
+                    new_t.bound_events[ev.symbol] = new_ev
+                    mappings[ev] = new_ev
+                end
+
+                copy.register_task(new_t)
+                new_t.each_event do |ev|
+                    copy.register_event(ev)
+                end
+            end
+            free_events.each do |e|
+                new_e = e.dup
+                mappings[e] = new_e
+                copy.register_event(new_e)
+            end
+
+            mission_tasks.each { |t| copy.add_mission_task(mappings[t]) }
+            permanent_tasks.each { |t| copy.add_permanent_task(mappings[t]) }
+            permanent_events.each { |e| copy.add_permanent_event(mappings[e]) }
+
+            copy_relation_graphs_to(copy, mappings)
+            mappings
+        end
+
+        def copy_relation_graphs_to(copy, mappings)
+            each_task_relation_graph do |graph|
+                target_graph = copy.task_relation_graph_for(graph.class)
+                graph.each_edge do |parent, child|
+                    target_graph.add_edge(
+                        mappings[parent], mappings[child], graph.edge_info(parent, child))
+                end
+            end
+
+            each_event_relation_graph do |graph|
+                target_graph = copy.event_relation_graph_for(graph.class)
+                graph.each_edge do |parent, child|
+                    target_graph.add_edge(
+                        mappings[parent], mappings[child], graph.edge_info(parent, child))
+                end
+            end
+        end
+
+        # Verifies that all graphs that should be acyclic are
+        def validate_graphs(graphs)
+            # Make a topological sort of the graphs
+            seen = Set.new
+            Relations.each_graph_topologically(graphs) do |g|
+                if seen.include?(g)
+                    next
+                elsif !g.dag?
+                    next
+                end
+
+                if !g.acyclic?
+                    raise Relations::CycleFoundError, "#{g.class} has cycles"
+                end
+                seen << g
+                seen.merge(g.recursive_subsets)
+            end
+        end
+
+        # @api private
+        #
+        # Normalize an validate the arguments to {#add} into a list of plan objects
+        def normalize_add_arguments(objects)
+            if !objects.respond_to?(:each)
+                objects = [objects]
+            end
+
+            objects.map do |o|
+                if o.respond_to?(:as_plan) then o.as_plan
+                elsif o.respond_to?(:to_event) then o.to_event
+                elsif o.respond_to?(:to_task) then o.to_task
+                else raise ArgumentError, "found #{o || 'nil'} which is neither a task nor an event"
+                end
+            end
+        end
+
+        # If this plan is a toplevel plan, returns self. If it is a
+        # transaction, returns the underlying plan
+        def real_plan
+            ret = self
+            while ret.respond_to?(:plan)
+                ret = ret.plan
+            end
+            ret
+        end
+
+        # True if this plan is root in the plan hierarchy
+        def root_plan?
+            true
+        end
+
+        # Returns the set of stacked transaction
+        #
+        # @return [Array] the list of plans in the transaction stack, the first
+        #   element being the most-nested transaction and the last element the
+        #   underlying real plan (equal to {#real_plan})
+        def transaction_stack
+            plan_chain = [self]
+            while plan_chain.last.respond_to?(:plan)
+                plan_chain << plan_chain.last.plan
+            end
+            plan_chain
+        end
+
+        # @deprecated use {#add_mission_task} instead
+        def add_mission(task)
+            Roby.warn_deprecated "#add_mission is deprecated, use #add_mission_task instead"
+            add_mission_task(task)
+        end
+
+        # @deprecated use {#mission_task?} instead
+        def mission?(task)
+            Roby.warn_deprecated "#mission? is deprecated, use #mission_task? instead"
+            mission_task?(task)
+        end
+
+        # @deprecated use {#unmark_mission_task} instead
+        def unmark_mission(task)
+            Roby.warn_deprecated "#unmark_mission is deprecated, use #unmark_mission_task instead"
+            unmark_mission_task(task)
+        end
+
+        # Tests whether a task is present in the plan
+        def has_task?(task)
+            tasks.include?(task)
+        end
+
+        # Add a task to the plan's set of missions
+        #
+        # A mission represents the system's overall goal. As such a mission task
+        # and all its dependencies are protected against the garbage collection
+        # mechanisms, and the emission of a mission's failed event causes a
+        # MissionFailedError exception to be generated.
+        #
+        # Note that this method should be used to add the task to the plan and
+        # mark it as mission, and to mark an already added task as mission as
+        # well.
+        #
+        # @see mission_task? unmark_mission_task
+        def add_mission_task(task)
+            task = normalize_add_arguments([task]).first
+            return if mission_tasks.include?(task)
+            add([task])
+            mission_tasks << task
+            task.mission = true if task.self_owned?
+            notify_task_status_change(task, :mission)
+            task
+        end
+
+        # Checks if a task is part of the plan's missions
+        #
+        # @see add_mission_task unmark_mission_task
+        def mission_task?(task)
+            @mission_tasks.include?(task.to_task)
+        end
+
+        # Removes a task from the plan's missions
+        #
+        # It does not remove the task from the plan. In a plan that is being
+        # executed, it is done by garbage collection. In a static plan, it can
+        # either be done with {#static_garbage_collect} or directly by calling
+        # {#remove_task} or {#remove_free_event}
+        #
+        # @see add_mission_task mission_task?
+        def unmark_mission_task(task)
+            task = task.to_task
+            return if !@mission_tasks.include?(task)
+            @mission_tasks.delete(task)
+            task.mission = false if task.self_owned?
+            notify_task_status_change(task, :normal)
+            self
+        end
+
+        # @deprecated use {#add_permanent_task} or {#add_permanent_event} instead
+        def add_permanent(object)
+            Roby.warn_deprecated "#add_permanent is deprecated, use either #add_permanent_task or #add_permanent_event instead"
+            object = normalize_add_arguments([object]).first
+            if object.respond_to?(:to_task)
+                add_permanent_task(object)
+            else
+                add_permanent_event(object)
+            end
+            object
+        end
+
+        # @deprecated use {#unmark_permanent_task} or {#unmark_permanent_event} instead
+        def unmark_permanent(object)
+            Roby.warn_deprecated "#unmark_permanent is deprecated, use either #unmark_permanent_task or #unmark_permanent_event"
+            if object.respond_to?(:to_task)
+                unmark_permanent_task(object)
+            elsif object.respond_to?(:to_event)
+                unmark_permanent_event(object)
+            else
+                raise ArgumentError, "expected a task or event and got #{object}"
+            end
+        end
+
+        # @deprecated use {#permanent_task?} or {#permanent_event?} instead
+        def permanent?(object)
+            Roby.warn_deprecated "#permanent? is deprecated, use either #permanent_task? or #permanent_event?"
+            if object.respond_to?(:to_task)
+                permanent_task?(object)
+            elsif object.respond_to?(:to_event)
+                permanent_event?(object)
+            else
+                raise ArgumentError, "expected a task or event and got #{object}"
+            end
+        end
+
+        # Mark a task as permanent, optionally adding to the plan
+        #
+        # Permanent tasks are protected against garbage collection. Like
+        # missions, failure of a permanent task will generate a plan exception
+        # {PermanentTaskError}. Unlike missions, this exception is non-fatal.
+        def add_permanent_task(task)
+            task = normalize_add_arguments([task]).first
+            return if permanent_tasks.include?(task)
+            add([task])
+            permanent_tasks << task
+            notify_task_status_change(task, :permanent)
+            task
+        end
+
+        # True if the given task is registered as a permanent task on self
+        def permanent_task?(task)
+            @permanent_tasks.include?(task)
+        end
+
+        # Removes a task from the set of permanent tasks
+        #
+        # This does not remove the event from the plan. In plans being executed,
+        # the removal will be done by garabage collection. In plans used as data
+        # structures, either use {#static_garbage_collect} or remove the event
+        # directly with {#remove_task} or {#remove_free_event}
+        #
+        # @see add_permanent_event permanent_event?
+        def unmark_permanent_task(task)
+            if @permanent_tasks.delete?(task.to_task)
+                notify_task_status_change(task, :normal)
+            end
+        end
+
+        # Mark an event as permanent, optionally adding to the plan
+        #
+        # Permanent events are protected against garbage collection
+        def add_permanent_event(event)
+            event = normalize_add_arguments([event]).first
+            return if permanent_events.include?(event)
+            add([event])
+            permanent_events << event
+            notify_event_status_change(event, :permanent)
+            event
+        end
+
+        # True if the given event is registered as a permanent event on self
+        def permanent_event?(generator)
+            @permanent_events.include?(generator) 
+        end
+
+        # Removes a task from the set of permanent tasks
+        #
+        # This does not remove the event from the plan. In plans being executed,
+        # the removal will be done by garabage collection. In plans used as data
+        # structures, either use {#static_garbage_collect} or remove the event
+        # directly with {#remove_task} or {#remove_free_event}
+        #
+        # @see add_permanent_event permanent_event?
+        def unmark_permanent_event(event)
+            if @permanent_events.delete?(event.to_event)
+                notify_event_status_change(event, :normal)
+            end
+        end
+
+        # @api private
+        #
+        # Perform notifications related to the status change of a task
+        def notify_task_status_change(task, status)
+            if services = plan_services[task]
+                services.each { |s| s.notify_task_status_change(status) }
+            end
+            log(:task_status_change, task, status)
+        end
+
+        # @api private
+        #
+        # Perform notifications related to the status change of an event
+        def notify_event_status_change(event, status)
+            log(:event_status_change, event, status)
+        end
+
+        def edit
+            if block_given?
+                yield
+            end
+        end
+
+        # True if this plan owns the given object, i.e. if all the owners of the
+        # object are also owners of the plan.
+        def owns?(object)
+            (object.owners - owners).empty?
+        end
+
+        def force_replace_task(from, to)
+            handle_force_replace(from, to) do
+                from.replace_by(to)
+            end
+        end
+
+        def force_replace(from, to)
+            handle_force_replace(from, to) do
+                from.replace_subplan_by(to)
+            end
+        end
+
+        def handle_force_replace(from, to)
+            if !from.plan
+                raise ArgumentError, "#{from} has been removed from plan, cannot use as source in a replacement"
+            elsif !to.plan
+                raise ArgumentError, "#{to} has been removed from plan, cannot use as target in a replacement"
+            elsif from.plan != self
+                raise ArgumentError, "trying to replace #{from} but its plan is #{from.plan}, expected #{self}"
+            elsif to.plan.template?
+                add(to)
+            elsif to.plan != self
+                raise ArgumentError, "trying to replace #{to} but its plan is #{to.plan}, expected #{self}"
+            elsif from == to
+                return 
+            end
+
+            # Swap the subplans of +from+ and +to+
+            yield(from, to)
+
+            if mission_task?(from)
+                add_mission_task(to)
+                replaced(from, to)
+                unmark_mission_task(from)
+            elsif permanent_task?(from)
+                add_permanent_task(to)
+                replaced(from, to)
+                unmark_permanent_task(from)
+            else
+                add(to)
+                replaced(from, to)
+            end
+        end
+
+        def handle_replace(from, to) # :nodoc:
+            handle_force_replace(from, to) do
+                # Check that +to+ is valid in all hierarchy relations where +from+ is a child
+                if !to.fullfills?(*from.fullfilled_model)
+                    models = from.fullfilled_model.first
+                    missing = models.find_all do |m|
+                        !to.fullfills?(m)
+                    end
+                    if missing.empty?
+                        mismatching_argument = from.fullfilled_model.last.find do |key, expected_value|
+                            (value = to.arguments[key]) && (expected_value != value)
+                        end
+                        raise InvalidReplace.new(from, to), "argument mismatch for #{mismatching_argument.first}"
+                    else
+                        raise InvalidReplace.new(from, to), "missing provided models #{missing.map(&:name).join(", ")}"
+                    end
+                end
+
+                # Swap the subplans of +from+ and +to+
+                yield(from, to)
+            end
+        end
+
+        # Replace the task +from+ by +to+ in all relations +from+ is part of
+        # (including events).
+        #
+        # See also #replace
+        def replace_task(from, to)
+            handle_replace(from, to) do
+                from.replace_by(to)
+            end
+        end
+
+        # Replace +from+ by +to+ in the plan, in all relations in which +from+
+        # and its events are /children/. It therefore replaces the subplan
+        # generated by +from+ (i.e. +from+ and all the tasks/events that can be
+        # reached by following the task and event relations) by the subplan
+        # generated by +to+.
+        #
+        # See also #replace_task
+        def replace(from, to)
+            handle_replace(from, to) do
+                from.replace_subplan_by(to)
+            end
+        end
+
+        # Register a new plan service on this plan
+        def add_plan_service(service)
+            if service.task.plan != self
+                raise "trying to register a plan service on #{self} for #{service.task}, which is included in #{service.task.plan}"
+            end
+
+            set = (plan_services[service.task] ||= Set.new)
+            if !set.include?(service)
+                set << service
+            end
+            self
+        end
+
+        # Deregisters a plan service from this plan
+        def remove_plan_service(service)
+            if set = plan_services[service.task]
+                set.delete(service)
+                if set.empty?
+                    plan_services.delete(service.task)
+                end
+            end
+        end
+
+        # Change the actual task a given plan service is representing
+        def move_plan_service(service, new_task)
+            return if new_task == service.task
+
+            remove_plan_service(service)
+            service.task = new_task
+            add_plan_service(service)
+        end
+
+        # Find all the defined plan services for a given task
+        def find_all_plan_services(task)
+            plan_services[task] || Array.new
+        end
+
+        # If at least one plan service is defined for +task+, returns one of
+        # them. Otherwise, returns nil.
+        def find_plan_service(task)
+            if set = plan_services[task]
+                set.find { true }
+            end
+        end
+
+        # Replace subgraphs by another in the plan
+        #
+        # It copies relations that are not within the keys in task_mappings and
+        # event_mappings to the corresponding task/events. The targets might be
+        # nil, in which case the relations involving the source will be simply
+        # ignored.
+        #
+        # If needed, instead of providing an object as target, one can provide a
+        # resolver object which will be called with #call and the source, The
+        # resolver should be given as a second element of a pair, e.g.
+        #
+        #    source => [nil, #call]
+        #
+        def replace_subplan(task_mappings, event_mappings, task_children: true, event_children: true)
+            new_relations, removed_relations =
+                compute_subplan_replacement(task_mappings, each_task_relation_graph,
+                                            child_objects: task_children)
+            apply_replacement_operations(new_relations, removed_relations)
+
+            new_relations, removed_relations =
+                compute_subplan_replacement(event_mappings, each_event_relation_graph,
+                                            child_objects: event_children)
+            apply_replacement_operations(new_relations, removed_relations)
+        end
+
+        def compute_subplan_replacement(mappings, relation_graphs, child_objects: true)
+            new_relations, removed_relations = Array.new, Array.new
+            relation_graphs.each do |graph|
+                next if graph.strong?
+
+                resolved_mappings = Hash.new
+                mappings.each do |obj, (mapped_obj, mapped_obj_resolver)|
+                    next if !mapped_obj && !mapped_obj_resolver
+
+                    graph.each_in_neighbour(obj) do |parent|
+                        next if mappings.has_key?(parent)
+                        if !graph.copy_on_replace?
+                            removed_relations << [graph, parent, obj]
+                        end
+                        if !mapped_obj
+                            mapped_obj = mapped_obj_resolver.call(obj)
+                            resolved_mappings[obj] = mapped_obj
+                        end
+                        new_relations << [graph, parent, mapped_obj, graph.edge_info(parent, obj)]
+                    end
+
+                    next if !child_objects
+                    graph.each_out_neighbour(obj) do |child|
+                        next if mappings.has_key?(child)
+                        if !graph.copy_on_replace?
+                            removed_relations << [graph, obj, child]
+                        end
+                        if !mapped_obj
+                            mapped_obj = mapped_obj_resolver.call(obj)
+                            resolved_mappings[obj] = mapped_obj
+                        end
+                        new_relations << [graph, mapped_obj, child, graph.edge_info(obj, child)]
+                    end
+                end
+                mappings.merge!(resolved_mappings)
+            end
+            return new_relations, removed_relations
+        end
+
+        def apply_replacement_operations(new_relations, removed_relations)
+            removed_relations.each do |graph, parent, child|
+                graph.remove_relation(parent, child)
+            end
+            new_relations.each do |graph, parent, child, info|
+                graph.add_relation(parent, child, info)
+            end
+        end
+
+        # Hook called when +replacing_task+ has replaced +replaced_task+ in this plan
+        def replaced(replaced_task, replacing_task)
+            # Make the PlanService object follow the replacement
+            if services = plan_services.delete(replaced_task)
+                services.each do |srv|
+                    srv.task = replacing_task
+                    (plan_services[replacing_task] ||= Set.new) << srv
+                end
+            end
+        end
+
+        # @api private
+        #
+        # Registers a task object in this plan
+        #
+        # It is for Roby internal usage only, for the creation of template
+        # plans. Use {#add}.
+        def register_task(task)
+            task.plan = self
+            tasks << task
+            task_index.add(task)
+            task_events.merge(task.each_event)
+        end
+
+        # @api private
+        #
+        # Registers a task object in this plan
+        #
+        # It is for Roby internal usage only, for the creation of template
+        # plans. Use {#add}.
+        def register_event(event)
+            event.plan = self
+            if event.root_object?
+                free_events << event
+            else
+                task_events << event
+            end
+        end
+
+        # call-seq:
+        #   plan.add(task) => plan
+        #   plan.add(event) => plan
+        #   plan.add([task, event, task2, ...]) => plan
+        #   plan.add([t1, t2, ...]) => plan
+        #
+        # Adds the subplan of the given tasks and events into the plan.
+        #
+        # That means that it adds the listed tasks/events and the task/events
+        # that are reachable through any relations).
+        def add(objects)
+            is_scalar = objects.respond_to?(:each)
+            objects = normalize_add_arguments(objects)
+
+            plans = Set.new
+            objects.each do |plan_object|
+                p = plan_object.plan
+                next if p == self
+                if plan_object.removed_at
+                    raise ArgumentError, "cannot add #{plan_object} in #{self}, it has been removed from the plan"
+                elsif !p
+                    raise InternalError, "there seem to be an inconsistency, #{plan_object}#plan is nil but #removed_at is not set"
+                elsif p.empty?
+                    raise InternalError, "there seem to be an inconsistency, #{plan_object} is associated with #{p} but #{p} is empty"
+                elsif !p.template?
+                    raise ModelViolation, "cannot add #{plan_object} in #{self}, it is already included in #{p}"
+                end
+                plans << p
+            end
+
+            plans.each do |p|
+                merge!(p)
+            end
+
+            if is_scalar
+                objects.first
+            else objects
+            end
+        end
+
+        # @api private
+        #
+        # A trigger created by {Plan#add_trigger}
+        class Trigger
+            # The query that is being watched
+            attr_reader :query
+            # The block that will be called if {#query} matches
+            attr_reader :block
+
+            def initialize(query, block)
+                @query = query.query
+                @block = block
+            end
+
+            # Whether self would be triggering on task
+            #
+            # @param [Roby::Task] task
+            # @return [Boolean]
+            def ===(task)
+                query === task
+            end
+
+            # Lists the tasks that match the query
+            #
+            # @param [Plan] plan
+            # @yieldparam [Roby::Task] task tasks that match {#query}
+            def each(plan, &block)
+                query.plan = plan
+                query.reset
+                query.each(&block)
+            end
+
+            # Call the trigger's observer for the given task
+            def call(task)
+                block.call(task)
+            end
+        end
+
+        # Add a trigger
+        #
+        # This registers a notification: the given block will be called for each
+        # new task that match the given query object. It yields right away for
+        # the tasks that are already in the plan
+        #
+        # @param [#===] query_object the object against which tasks are tested.
+        #   Tasks for which #=== returns true are yield to the block
+        # @yieldparam [Roby::Task] task the task that matched the query object
+        # @return [Object] an ID object that can be used in {#remove_trigger}
+        def add_trigger(query_object, &block)
+            tr = Trigger.new(query_object, block)
+            triggers << tr
+            tr.each(self) do |t|
+                tr.call(t)
+            end
+            tr
+        end
+
+        # Removes a trigger
+        #
+        # @param [Object] trigger the trigger to be removed. This is the return value of
+        #   the corresponding {#add_trigger} call
+        # @return [void]
+        def remove_trigger(trigger)
+            triggers.delete(trigger)
+            nil
+        end
+
+        # Creates a new transaction and yields it. Ensures that the transaction
+        # is discarded if the block returns without having committed it.
+        def in_transaction
+            yield(trsc = Transaction.new(self))
+
+        ensure
+            if trsc && !trsc.finalized?
+                trsc.discard_transaction
+            end
+        end
 
-        # Calls the given block in the execution thread of this plan's engine.
-        # If there is no engine attached to this plan, yields immediately
+        # Hook called when a new transaction has been built on top of this plan
+        def added_transaction(trsc)
+        end
+
+        # Removes the transaction +trsc+ from the list of known transactions
+        # built on this plan
+        def remove_transaction(trsc)
+            transactions.delete(trsc)
+        end
+
+        # @api private
         #
-        # See ExecutionEngine#execute
-        def execute(&block)
-            if engine
-                engine.execute(&block)
-            else
-                yield
+        # Default set of graphs that should be discovered by
+        # {#compute_useful_tasks}
+        def default_useful_task_graphs
+            each_task_relation_graph.find_all { |g| g.root_relation? && !g.weak? }
+        end
+
+        # @api private
+        #
+        # Compute the subplan that is useful for a given set of tasks
+        #
+        # @param [Set<Roby::Task>] seeds the root "useful" tasks
+        # @param [Array<Relations::BidirectionalDirectedAdjancencyGraph>] graphs the
+        #   graphs through which "usefulness" is propagated
+        def compute_useful_tasks(seeds, graphs: default_useful_task_graphs)
+            seeds = seeds.to_set
+            visitors = graphs.map do |g|
+                [g, RGL::DFSVisitor.new(g), seeds.dup]
             end
+
+            result = seeds.dup
+
+            has_pending_seeds = true
+            while has_pending_seeds
+                has_pending_seeds = false
+                visitors.each do |graph, visitor, seeds|
+                    next if seeds.empty?
+
+                    new_seeds = Array.new
+                    seeds.each do |vertex|
+                        if !visitor.finished_vertex?(vertex) && graph.has_vertex?(vertex)
+                            graph.depth_first_visit(vertex, visitor) do |v|
+                                yield(v) if block_given?
+                                new_seeds << v
+                            end
+                        end
+                    end
+                    if !new_seeds.empty?
+                        has_pending_seeds = true
+                        result.merge(new_seeds)
+                        visitors.each { |g, _, s| s.merge(new_seeds) if g != graph }
+                    end
+                    seeds.clear
+                end
+            end
+
+            result
         end
 
-	# call-seq:
-	#   plan.partition_event_task(objects) => events, tasks
-	#
-	def partition_event_task(objects)
-	    if objects.respond_to?(:to_task) then return nil, [objects.to_task]
-	    elsif objects.respond_to?(:to_event) then return [objects.to_event], nil
-	    elsif !objects.respond_to?(:each)
-		raise TypeError, "expecting a task, event, or a collection of tasks and events, got #{objects}"
-	    end
-
-	    evts, tasks = objects.partition do |o|
-		if o.respond_to?(:to_event) then true
-		elsif o.respond_to?(:to_task) then false
-		else raise ArgumentError, "found #{o || 'nil'} which is neither a task nor an event"
-		end
-	    end
-	    return evts, tasks
-	end
-
-	# If this plan is a toplevel plan, returns self. If it is a
-	# transaction, returns the underlying plan
-	def real_plan
-	    ret = self
-	    while ret.respond_to?(:plan)
-		ret = ret.plan
-	    end
-	    ret
-	end
-
-        # Returns the set of stacked transaction, starting at +self+
-        def transaction_stack
-            plan_chain = [self]
-            while plan_chain.last.respond_to?(:plan)
-                plan_chain << plan_chain.last.plan
+        def locally_useful_roots(with_transactions: true)
+            # Create the set of tasks which must be kept as-is
+            seeds = @mission_tasks | @permanent_tasks
+            if with_transactions
+                for trsc in transactions
+                    seeds.merge trsc.proxy_tasks.keys.to_set
+                end
             end
-            plan_chain
+            seeds
         end
 
-	# Inserts a new mission in the plan.
-        #
-        # In the plan manager, missions are the tasks which constitute the
-        # robot's goal. This is the base for two things:
-        # * if a mission fails, the MissionFailedError is raised
-        # * the mission and all the tasks and events which are useful for it,
-        #   are not removed automatically by the garbage collection mechanism.
-        #   A task or event is <b>useful</b> if it is part of the child subgraph
-        #   of the mission, i.e. if there is a path in the relation graphs where
-        #   the mission is the source and the task is the target.
-        def add_mission(task)
-	    return if @missions.include?(task)
-
-	    @missions << task
-	    add(task)
-	    task.mission = true if task.self_owned?
-	    added_mission(task)
-	    self
-	end
-        def insert(task) # :nodoc:
-            Roby.warn_deprecated "#insert has been replaced by #add_mission"
-            add_mission(task)
-        end
-	# Hook called when +tasks+ have been inserted in this plan
-	def added_mission(tasks)
-            super if defined? super 
-            if respond_to?(:inserted)
-                Roby.warn_deprecated "the #inserted hook has been replaced by #added_mission"
-                inserted(tasks)
-            end
-        end
-	# Checks if +task+ is a mission of this plan
-	def mission?(task); @missions.include?(task) end
-
-        def remove_mission(task) # :nodoc:
-            Roby.warn_deprecated "#remove_mission renamed #unmark_mission"
-            unmark_mission(task)
-        end
-
-	# Removes the task in +tasks+ from the list of missions
-	def unmark_mission(task)
-	    @missions.delete(task)
-	    add(task)
-	    task.mission = false if task.self_owned?
-
-	    unmarked_mission(task)
-	    self
-	end
-	# Hook called when +tasks+ have been discarded from this plan
-	def unmarked_mission(task)
-            super if defined? super
-            if respond_to?(:removed_mission)
-                Roby.warn_deprecated "the #removed_mission hook has been replaced by #unmarked_mission"
-                removed_mission(task)
-            end
-            if respond_to?(:discarded)
-                Roby.warn_deprecated "the #discarded hook has been replaced by #unmarked_mission"
-                discarded(task)
-            end
-        end
-        def discard(task) # :nodoc:
-            Roby.warn_deprecated "#discard has been replaced by #unmark_mission"
-            unmark_mission(task)
-        end
-
-	# Adds +object+ in the list of permanent tasks. Permanent tasks are
-        # tasks that are not to be subject to the plan's garbage collection
-        # mechanism (i.e. they will not be removed even though they are not
-        # directly linked to a mission).
-        #
-        # #object is at the same time added in the plan, meaning that all the
-        # tasks and events related to it are added in the plan as well. See
-        # #add.
-        #
-        # Unlike missions, the failure of a permanent task does not constitute
-        # an error.
-        #
-        # See also #unmark_permanent and #permanent?
-	def add_permanent(object)
-            if object.kind_of?(Task)
-                @permanent_tasks << object
+        def locally_useful_tasks
+            compute_useful_tasks(locally_useful_roots)
+        end
+
+        def useful_tasks(with_transactions: true)
+            compute_useful_tasks(locally_useful_roots(with_transactions: with_transactions))
+        end
+
+        def unneeded_tasks
+            tasks - useful_tasks
+        end
+
+        def local_tasks
+            task_index.self_owned
+        end
+
+        def quarantined_tasks
+            tasks.find_all(&:quarantined?)
+        end
+
+        def remote_tasks
+            if local_tasks = task_index.self_owned
+                tasks - local_tasks
             else
-                @permanent_events << object
+                tasks
+            end
+        end
+
+        # Computes the set of useful tasks and checks that +task+ is in it.
+        # This is quite slow. It is here for debugging purposes. Do not use it
+        # in production code
+        def useful_task?(task)
+            tasks.include?(task) && !unneeded_tasks.include?(task)
+        end
+
+        class UsefulFreeEventVisitor < RGL::DFSVisitor
+            attr_reader :useful_free_events, :task_events, :stack
+            def initialize(graph, task_events, permanent_events)
+                super(graph)
+                @task_events = task_events
+                @useful_free_events = permanent_events.dup
+                @useful = false
+            end
+
+            def useful?
+                @useful
+            end
+
+            def handle_examine_edge(u, v)
+                if task_events.include?(v) || useful_free_events.include?(v)
+                    color_map[v] = :BLACK
+                    @useful = true
+                end
             end
-	    add(object)
-            self
-	end
 
-        def permanent(object) # :nodoc:
-            Roby.warn_deprecated "#permanent has been replaced by #add_permanent"
-            add_permanent(object)
+            def follow_edge?(u, v)
+                !task_events.include?(v)
+            end
         end
 
-	# Removes +object+ from the list of permanent objects. Permanent objects
-        # are protected from the plan's garbage collection. This does not remove
-        # the task/event itself from the plan.
+        # @api private
+        #
+        # Compute the set of events that are "useful" to the plan.
         #
-        # See also #add_permanent and #permanent?
-	def unmark_permanent(object)
-            @permanent_tasks.delete(object) 
-            @permanent_events.delete(object)
+        # It contains every event that is connected to an event in
+        # {#permanent_events} or to an event on a task in the plan
+        #
+        # @return [Set<EventGenerator>]
+        def compute_useful_free_events
+            # Quick path for a very common case
+            return Set.new if free_events.empty?
+
+            graphs = each_event_relation_graph.
+                find_all { |g| g.root_relation? && !g.weak? }
+
+            seen = Set.new
+            result = permanent_events.dup
+            pending_events = free_events.to_a
+            while !pending_events.empty?
+                # This basically computes the subplan that contains "seed" and
+                # determines if it is useful or not
+                seed = pending_events.shift
+                next if seen.include?(seed)
+
+                visitors = Array.new
+                graphs.each do |g|
+                    visitors << [g, UsefulFreeEventVisitor.new(g, task_events, permanent_events), [seed].to_set]
+                    visitors << [g.reverse, UsefulFreeEventVisitor.new(g.reverse, task_events, permanent_events), [seed].to_set]
+                end
+
+                component = [seed].to_set
+                has_pending_seeds = true
+                while has_pending_seeds
+                    has_pending_seeds = false
+                    visitors.each do |graph, visitor, seeds|
+                        next if seeds.empty?
+
+                        new_seeds = Array.new
+                        seeds.each do |vertex|
+                            if !visitor.finished_vertex?(vertex) && graph.has_vertex?(vertex)
+                                graph.depth_first_visit(vertex, visitor) { |v| new_seeds << v }
+                            end
+                        end
+                        if !new_seeds.empty?
+                            has_pending_seeds = true
+                            component.merge(new_seeds)
+                            visitors.each { |g, _, s| s.merge(new_seeds) if g != graph }
+                        end
+                        seeds.clear
+                    end
+                end
+                seen.merge(component)
+                if visitors.any? { |_, v, _| v.useful? }
+                    result.merge(component)
+                end
+            end
+
+            result
         end
 
-        def auto(obj) # :nodoc:
-            Roby.warn_deprecated "#auto has been replaced by #unmark_permanent"
-            unmark_permanent(obj)
+        # Computes the set of events that are useful in the plan Events are
+        # 'useful' when they are chained to a task.
+        def useful_events
+            compute_useful_free_events
         end
 
-        # True if +obj+ is neither a permanent task nor a permanent object.
-        #
-        # See also #add_permanent and #unmark_permanent
-	def permanent?(obj); @permanent_tasks.include?(obj) || @permanent_events.include?(obj) end
+        # The set of events that can be removed from the plan
+        def unneeded_events
+            useful_events = self.useful_events
 
-	def edit
-	    if block_given?
-		Roby.synchronize do
-		    yield
-		end
-	    end
-	end
+            result = (free_events - useful_events)
+            result.delete_if do |ev|
+                transactions.any? { |trsc| trsc.find_local_object_for_event(ev) }
+            end
+            result
+        end
 
-        # True if this plan owns the given object, i.e. if all the owners of the
-        # object are also owners of the plan.
-	def owns?(object)
-	    (object.owners - owners).empty?
-	end
-
-	# Remove all tasks
-	def clear
-	    @known_tasks.each { |t| t.clear_relations }
-	    @known_tasks.clear
-	    @free_events.each { |e| e.clear_relations }
-	    @free_events.clear
-	    @missions.clear
-	    @permanent_tasks.clear
-	    @permanent_events.clear
-	end
-
-	def handle_replace(from, to) # :nodoc:
-	    return if from == to
-
-	    # Check that +to+ is valid in all hierarchy relations where +from+ is a child
-	    if !to.fullfills?(*from.fullfilled_model)
-		raise InvalidReplace.new(from, to), "task #{to} does not fullfill #{from.fullfilled_model}"
-	    end
-
-	    # Check that +to+ is in the same execution state than +from+
-	    if !to.compatible_state?(from)
-		raise InvalidReplace.new(from, to), "cannot replace #{from} by #{to} as their state is incompatible: from is #{from.running?} and to is #{to.running?}"
-	    end
-
-	    # Swap the subplans of +from+ and +to+
-	    yield(from, to)
-
-	    if mission?(from)
-		unmark_mission(from)
-		add_mission(to)
-	    elsif permanent?(from)
-		unmark_permanent(from)
-		add_permanent(to)
-	    else
-		add(to)
-	    end
-	    replaced(from, to)
-	end
+        # The number of tasks
+        def num_tasks
+            tasks.size
+        end
 
-        # Replace the task +from+ by +to+ in all relations +from+ is part of
-        # (including events).
+        # The number of events that are not task events
+        def num_free_events
+            free_events.size
+        end
+
+        # The number of events, both free and task events
+        def num_events
+            task_events.size + free_events.size
+        end
+
+        # Tests whether a task is present in this plan
+        def has_task?(task)
+            tasks.include?(task)
+        end
+
+        # Tests whether a task event is present in this plan
+        def has_task_event?(generator)
+            task_events.include?(generator)
+        end
+
+        # Tests whether a free event is present in this plan
+        def has_free_event?(generator)
+            free_events.include?(generator)
+        end
+
+        # @deprecated use the more specific {#has_task?}, {#has_free_event?} or
+        #   {#has_task_event?} instead
+        def include?(object)
+            Roby.warn_deprecated "Plan#include? is deprecated, use one of the more specific #has_task? #has_task_event? and #has_free_event?"
+            has_free_event?(object) || has_task_event?(object) || has_task?(object)
+        end
+
+        # Count of tasks in this plan
+        def size
+            Roby.warn_deprecated "Plan#size is deprecated, use #num_tasks instead"
+            @tasks.size
+        end
+        # Returns true if there is no task in this plan
+        def empty?; @tasks.empty? && @free_events.empty? end
+        # Iterates on all tasks
         #
-        # See also #replace
-	def replace_task(from, to)
-	    handle_replace(from, to) do
-		from.replace_by(to)
-	    end
-	end
+        # @yieldparam [Task] task
+        def each_task
+            return enum_for(__method__) if !block_given?
+            @tasks.each { |t| yield(t) }
+        end
+ 
+        # Returns +object+ if object is a plan object from this plan, or if
+        # it has no plan yet (in which case it is added to the plan first).
+        # Otherwise, raises ArgumentError.
+        #
+        # This method is provided for consistency with Transaction#[]
+        def [](object, create = true)
+            if object.plan == self
+                object
+            elsif !object.finalized? && object.plan.template?
+                add(object)
+                object
+            elsif object.finalized? && create
+                raise ArgumentError, "#{object} is has been finalized, and can't be reused"
+            else
+                raise ArgumentError, "#{object} is not from #{self}"
+            end
+        end
 
-        # Replace +from+ by +to+ in the plan, in all relations in which +from+
-        # and its events are /children/. It therefore replaces the subplan
-        # generated by +from+ (i.e. +from+ and all the tasks/events that can be
-        # reached by following the task and event relations) by the subplan
-        # generated by +to+.
+        def self.can_gc?(task)
+            if task.starting? then true # wait for the task to be started before deciding ...
+            elsif task.running? && !task.finishing?
+                task.event(:stop).controlable?
+            else true
+            end
+        end
+
+        # @api private
         #
-        # See also #replace_task
-	def replace(from, to)
-	    handle_replace(from, to) do
-		from.replace_subplan_by(to)
-	    end
-	end
+        # Perform sanity checks on a plan object that will be finalized
+        def verify_plan_object_finalization_sanity(object)
+            if !object.root_object?
+                raise ArgumentError, "cannot remove #{object} which is a non-root object"
+            elsif object.plan != self
+                if !object.plan
+                    if object.removed_at
+                        if PlanObject.debug_finalization_place?
+                            raise ArgumentError, "#{object} has already been removed from its plan\n" +
+                                "Removed at\n  #{object.removed_at.join("\n  ")}"
+                        else
+                            raise ArgumentError, "#{object} has already been removed from its plan. Set PlanObject.debug_finalization_place to true to get the backtrace of where (in the code) the object got finalized"
+                        end
+                    else
+                        raise ArgumentError, "#{object} has never been included in this plan"
+                    end
+                end
+                raise ArgumentError, "#{object} is not in #{self}: #plan == #{object.plan}"
+            end
+        end
+
+        def finalize_task(task, timestamp = nil)
+            verify_plan_object_finalization_sanity(task)
+            if (task.plan != self) && has_task?(task)
+                raise ArgumentError, "#{task} is included in #{self} but #plan == #{task.plan}"
+            end
+
+            if services = plan_services.delete(task)
+                services.each(&:finalized!)
+            end
 
-	# Hook called when +to+ has replaced +from+ in this plan
-	def replaced(from, to); super if defined? super end
+            # Remove relations first. This is needed by transaction since
+            # removing relations may need wrapping some new task, and in
+            # that case these new task will be discovered as well
+            task.clear_relations(remove_internal: true)
+            task.mission = false
 
-	# Check that this is an executable plan. This is always true for
-	# plain Plan objects and false for transcations
-	def executable?; true end
+            for ev in task.bound_events.each_value
+                finalized_event(ev)
+            end
+            finalized_task(task)
 
-        def discover(objects) # :nodoc:
-            Roby.warn_deprecated "#discover has been replaced by #add"
-            add(objects)
+            for ev in task.bound_events.each_value
+                ev.finalized!(timestamp)
+            end
+            task.finalized!(timestamp)
         end
 
-	# call-seq:
-        #   plan.add(task) => plan
-        #   plan.add(event) => plan
-        #   plan.add([task, event, task2, ...]) => plan
-	#   plan.add([t1, t2, ...]) => plan
-	#
-        # Adds the subplan of the given tasks and events into the plan.
-        #
-        # That means that it adds the listed tasks/events and the task/events
-        # that are reachable through any relations). The #added_events and
-        # #added_tasks hooks are called for the objects that were not in
-        # the plan.
-	def add(objects)
-	    event_seeds, tasks = partition_event_task(objects)
-	    event_seeds = (event_seeds || ValueSet.new).to_value_set
-
-	    if tasks
-		tasks = tasks.to_value_set
-		new_tasks = useful_task_component(nil, tasks, tasks)
-		unless new_tasks.empty?
-		    old_task_events = task_events.dup
-		    new_tasks = add_task_set(new_tasks)
-		    event_seeds.merge(task_events - old_task_events)
-		end
-	    end
-
-	    if !event_seeds.empty?
-		events = event_seeds.dup
-
-		# now, we include the set of free events that are linked to
-		# +new_tasks+ in +events+
-		EventStructure.each_root_relation do |rel|
-		    components = rel.generated_subgraphs(event_seeds, false)
-		    components.concat rel.reverse.generated_subgraphs(event_seeds, false)
-		    for c in components
-			events.merge(c.to_value_set)
-		    end
-		end
-
-		add_event_set(events - task_events - free_events)
-	    end
-
-	    self
-	end
-
-	# Add +events+ to the set of known events and call added_events
-	# for the new events
-	#
-	# This is for internal use, use #add instead
-	def add_event_set(events)
-	    events = events.difference(free_events)
-	    events.delete_if do |e|
-		if !e.root_object?
-		    true
-		else
-		    e.plan = self
-		    false
-		end
-	    end
-
-	    unless events.empty?
-		free_events.merge(events)
-		added_events(events)
-	    end
-
-	    events
-	end
-
-	# Add +tasks+ to the set of known tasks and call added_tasks for
-	# the new tasks
-	#
-	# This is for internal use, use #add instead
-	def add_task_set(tasks)
-	    tasks = tasks.difference(known_tasks)
-	    for t in tasks
-		t.plan = self
-		task_events.merge t.bound_events.values.to_value_set
-		task_index.add t
-	    end
-	    known_tasks.merge tasks
-	    added_tasks(tasks)
-
-	    for t in tasks
-		t.instantiate_model_event_relations
-	    end
-	    tasks
-	end
-
-        def added_tasks(tasks)
-            if respond_to?(:discovered)
-                Roby.warn_deprecated "the #discovered hook is deprecated, use #added_tasks instead"
-                discovered(tasks)
-            end
-            if respond_to?(:discovered_tasks)
-                Roby.warn_deprecated "the #discovered_tasks hook is deprecated, use #added_tasks instead"
-                discovered_tasks(tasks)
-            end
-
-            if engine
-                engine.event_ordering.clear
-            end
-            super if defined? super
-        end
-
-	# Hook called when new events have been discovered in this plan
-	def added_events(events)
-            if engine
-                engine.event_ordering.clear
-            end
-
-            if respond_to?(:discovered_events)
-                Roby.warn_deprecated "the #discovered_events hook has been replaced by #added_events"
-                discovered_events(events)
-            end
-	    super if defined? super
-	end
+        def finalize_event(event, timestamp = nil)
+            verify_plan_object_finalization_sanity(event)
+            if (event.plan != self) && has_free_event?(event)
+                raise ArgumentError, "#{event} is included in #{self} but #plan == #{event.plan}"
+            end
 
-        # Creates a new transaction and yields it. Ensures that the transaction
-        # is discarded if the block returns without having committed it.
-        def in_transaction
-            yield(trsc = Transaction.new(self))
+            # Remove relations first. This is needed by transaction since
+            # removing relations may need wrapping some new event, and in
+            # that case these new event will be discovered as well
+            event.clear_relations
+            finalized_event(event)
+            event.finalized!(timestamp)
+        end
 
-        ensure
-            if trsc && !trsc.finalized?
-                trsc.discard_transaction
+        def remove_task(task, timestamp = Time.now)
+            if !@tasks.delete?(task)
+                raise ArgumentError, "#{task} is not a task of #{self}"
             end
+            remove_task!(task, timestamp)
         end
-	# Hook called when a new transaction has been built on top of this plan
-	def added_transaction(trsc); super if defined? super end
-	# Removes the transaction +trsc+ from the list of known transactions
-	# built on this plan
-	def remove_transaction(trsc)
-	    transactions.delete(trsc)
-	    removed_transaction(trsc)
-	end
-	# Hook called when a new transaction has been built on top of this plan
-	def removed_transaction(trsc); super if defined? super end
-
-	# Merges the set of tasks that are useful for +seeds+ into +useful_set+.
-	# Only the tasks that are in +complete_set+ are included.
-	def useful_task_component(complete_set, useful_set, seeds)
-	    old_useful_set = useful_set.dup
-	    for rel in TaskStructure.relations
-		next if !rel.root_relation?
-		for subgraph in rel.generated_subgraphs(seeds, false)
-		    useful_set.merge(subgraph)
-		end
-	    end
-
-	    if complete_set
-		useful_set &= complete_set
-	    end
-
-	    if useful_set.size == old_useful_set.size || (complete_set && useful_set.size == complete_set.size)
-		useful_set
-	    else
-		useful_task_component(complete_set, useful_set, (useful_set - old_useful_set))
-	    end
-	end
-
-	# Returns the set of useful tasks in this plan
-	def locally_useful_tasks
-	    # Remove all missions that are finished
-	    for finished_mission in (@missions & task_index.by_state[:finished?])
-		if !task_index.repaired_tasks.include?(finished_mission)
-		    unmark_mission(finished_mission)
-		end
-	    end
-	    for finished_permanent in (@permanent_tasks & task_index.by_state[:finished?])
-		if !task_index.repaired_tasks.include?(finished_permanent)
-		    unmark_permanent(finished_permanent)
-		end
-	    end
-
-	    # Create the set of tasks which must be kept as-is
-	    seeds = @missions | @permanent_tasks
-	    for trsc in transactions
-		seeds.merge trsc.proxy_objects.keys.to_value_set
-	    end
-
-	    return ValueSet.new if seeds.empty?
-
-	    # Compute the set of LOCAL tasks which serve the seeds.  The set of
-	    # locally_useful_tasks is the union of the seeds and of this one 
-	    useful_task_component(local_tasks, seeds & local_tasks, seeds) | seeds
-	end
-
-	def local_tasks
-	    task_index.by_owner[Roby::Distributed] || ValueSet.new
-	end
-
-	def remote_tasks
-	    if local_tasks = task_index.by_owner[Roby::Distributed]
-		known_tasks - local_tasks
-	    else
-		known_tasks
-	    end
-	end
-
-	# Returns the set of unused tasks
-	def unneeded_tasks
-	    # Get the set of local tasks that are serving one of our own missions or
-	    # permanent tasks
-	    useful = self.locally_useful_tasks
-
-	    # Append to that the set of tasks that are useful for our peers and
-	    # include the set of local tasks that are serving tasks in
-	    # +remotely_useful+
-	    remotely_useful = Distributed.remotely_useful_objects(remote_tasks, true, nil)
-	    serving_remote = useful_task_component(local_tasks, useful & local_tasks, remotely_useful)
-
-	    useful.merge remotely_useful
-	    useful.merge serving_remote
-
-	    (known_tasks - useful)
-	end
-
-	# Computes the set of useful tasks and checks that +task+ is in it.
-	# This is quite slow. It is here for debugging purposes. Do not use it
-	# in production code
-	def useful_task?(task)
-	    known_tasks.include?(task) && !unneeded_tasks.include?(task)
-	end
-
-	def useful_event_component(useful_events)
-	    current_size = useful_events.size
-	    for rel in EventStructure.relations
-		next unless rel.root_relation?
-
-		for subgraph in rel.components(free_events, false)
-		    subgraph = subgraph.to_value_set
-		    if subgraph.intersects?(useful_events) || subgraph.intersects?(task_events)
-			useful_events.merge(subgraph)
-			if useful_events.include_all?(free_events)
-			    return free_events
-			end
-		    end
-		end
-
-		if useful_events.include_all?(free_events)
-		    return free_events
-		end
-	    end
-
-	    if current_size != useful_events.size
-		useful_event_component(useful_events)
-	    else
-		useful_events
-	    end
-	end
-
-	# Computes the set of events that are useful in the plan Events are
-	# 'useful' when they are chained to a task.
-	def useful_events
-	    return ValueSet.new if free_events.empty?
-	    (free_events & useful_event_component(permanent_events.dup))
-	end
-
-	# The set of events that can be removed from the plan
-	def unneeded_events
-	    useful_events = self.useful_events
-
-	    result = (free_events - useful_events)
-	    result.delete_if do |ev|
-		transactions.any? { |trsc| trsc.wrap(ev, false) }
-	    end
-	    result
-	end
-
-	# Checks if +task+ is included in this plan
-	def include?(object); @known_tasks.include?(object) || @free_events.include?(object) end
-	# Count of tasks in this plan
-	def size; @known_tasks.size end
-	# Returns true if there is no task in this plan
-	def empty?; @known_tasks.empty? end
-	# Iterates on all tasks
-	def each_task; @known_tasks.each { |t| yield(t) } end
- 
-        # Install a plan repair for +failure_point+ with +task+. A plan repair
-        # is a task which, during its lifetime, is supposed to fix the problem
-        # encountered at +failure_point+
-        #
-        # +failure_point+ is an Event object which represents the event causing
-        # the problem.
-        #
-        # See also #repairs and #remove_repair
-	def add_repair(failure_point, task)
-	    if !failure_point.kind_of?(Event)
-		raise TypeError, "failure point #{failure_point} should be an event"
-	    elsif task.plan && task.plan != self
-		raise ArgumentError, "wrong plan: #{task} is in #{task.plan}, not #{plan}"
-	    elsif repairs.has_key?(failure_point)
-		raise ArgumentError, "there is already a plan repair defined for #{failure_point}: #{repairs[failure_point]}"
-	    elsif !task.plan
-		add(task)
-	    end
-
-	    repairs[failure_point] = task
-	    if failure_point.generator.respond_to?(:task)
-		task_index.repaired_tasks << failure_point.generator.task
-	    end
-	end
-
-        # Removes +task+ from the set of active plan repairs.
-        #
-        # See also #repairs and #add_repair
-	def remove_repair(task)
-	    repairs.delete_if do |ev, repair|
-		if repair == task
-		    if ev.generator.respond_to?(:task)
-			task_index.repaired_tasks.delete(ev.generator.task)
-		    end
-		    true
-		end
-	    end
-	end
-
-	# Return all repairs which apply on +event+
-	def repairs_for(event)
-	    result = Hash.new
-
-	    if event.generator.respond_to?(:task)
-		equivalent_generators = event.generator.generated_subgraph(EventStructure::Forwarding)
-
-		history = event.generator.task.history
-		id    = event.propagation_id
-		index = history.index(event)
-		while index < history.size
-		    ev = history[index]
-		    break if ev.propagation_id != id
-
-		    if equivalent_generators.include?(ev.generator) &&
-			(task = repairs[ev])
-
-			result[ev] = task
-		    end
-
-		    index += 1
-		end
-	    elsif task = repairs[event]
-		result[event] = task
-	    end
-
-	    result
-	end
-
-	# Returns +object+ if object is a plan object from this plan, or if
-	# it has no plan yet (in which case it is added to the plan first).
-	# Otherwise, raises ArgumentError.
-	#
-	# This method is provided for consistency with Transaction#[]
-	def [](object, create = true)
-            if !object.plan && !object.finalized?
-		add(object)
-            elsif object.finalized? && create
-		raise ArgumentError, "#{object} is has been finalized, and can't be reused"
-	    elsif object.plan != self
-		raise ArgumentError, "#{object} is not from #{self}"
-	    end
-	    object
-	end
-
-	def self.can_gc?(task)
-	    if task.starting? then true # wait for the task to be started before deciding ...
-	    elsif task.running? && !task.finishing?
-		task.event(:stop).controlable?
-	    else true
-	    end
-	end
-
-        def discard_modifications(object)
-            remove_object(object)
-        end
-
-        # Remove +object+ from this plan. You usually don't have to do that
-        # manually. Object removal is handled by the plan's garbage collection
-        # mechanism.
-	def remove_object(object)
-	    if !object.root_object?
-		raise ArgumentError, "cannot remove #{object} which is a non-root object"
-	    elsif object.plan != self
-		if known_tasks.include?(object) || free_events.include?(object)
-		    raise ArgumentError, "#{object} is included in #{self} but #plan == #{object.plan}"
-		elsif !object.plan
-		    if object.removed_at
-			raise ArgumentError, "#{object} has been removed at\n  #{object.removed_at.join("\n  ")}"
-		    else
-			raise ArgumentError, "#{object} has not been included in this plan"
-		    end
-		end
-		raise ArgumentError, "#{object} is not in #{self}: #plan == #{object.plan}"
-	    end
-
-	    # Remove relations first. This is needed by transaction since
-	    # removing relations may need wrapping some new objects, and in
-	    # that case these new objects will be discovered as well
-	    object.clear_relations
-
-	    @free_events.delete(object)
-	    @missions.delete(object)
-            if object.respond_to? :mission=
-                object.mission = false
-            end
-	    @known_tasks.delete(object)
-	    @permanent_tasks.delete(object)
-	    @permanent_events.delete(object)
-	    force_gc.delete(object)
-
-	    object.plan = nil
-	    object.removed_at = caller
-
-	    case object
-	    when EventGenerator
-		finalized_event(object)
-
-	    when Task
-		task_index.remove(object)
-
-		for ev in object.bound_events.values
-		    task_events.delete(ev)
-		    finalized_event(ev)
-		end
-		finalized_task(object)
-
-	    else
-		raise ArgumentError, "unknown object type #{object}"
-	    end
-
-	    self
-	end
-
-	# Hook called when +task+ is marked as garbage. It will be garbage
-	# collected as soon as possible
-	def garbage(task)
-	    # Remove all signals that go *to* the task
-	    #
-	    # While we want events which come from the task to be properly
-	    # forwarded, the signals that go to the task are to be ignored
-	    if task.self_owned?
-		task.each_event do |ev|
-		    ev.parent_objects(EventStructure::Signal).each do |signalling_event|
-			signalling_event.remove_signal ev
-		    end
-		end
-	    end
-
-	    super if defined? super
-	end
-
-	# backward compatibility
-	def finalized(task) # :nodoc:
-	    super if defined? super
-	end
-
-	# Hook called when +task+ has been removed from this plan
-	def finalized_task(task)
-            finalized_transaction_object(task) { |trsc, proxy| trsc.finalized_plan_task(proxy) }
-	    super if defined? super
-	    finalized(task)
-	end
-
-	# Hook called when +event+ has been removed from this plan
-	def finalized_event(event)
-            if engine && executable?
-                engine.finalized_event(event)
-            end
-            finalized_transaction_object(event) { |trsc, proxy| trsc.finalized_plan_event(proxy) }
-            super if defined? super 
-        end
-
-        # Generic filter which checks if +object+ is included in one of the
-        # transactions of this plan. If it is the case, it yields the
-        # transaction and the associated proxy
-        def finalized_transaction_object(object) 
-            return unless object.root_object?
+
+        def remove_task!(task, timestamp = Time.now)
+            @tasks.delete(task)
+            @mission_tasks.delete(task)
+            @permanent_tasks.delete(task)
+            @task_index.remove(task)
+
+            for ev in task.bound_events.each_value
+                @task_events.delete(ev)
+            end
+            finalize_task(task, timestamp)
+            self
+        end
+
+        def remove_free_event(event, timestamp = Time.now)
+            if !@free_events.delete?(event)
+                raise ArgumentError, "#{event} is not a free event of #{self}"
+            end
+            remove_free_event!(event, timestamp)
+        end
+
+        def remove_free_event!(event, timestamp = Time.now)
+            @free_events.delete(event)
+            @permanent_events.delete(event)
+            finalize_event(event, timestamp)
+            self
+        end
+
+        # @deprecated use {#remove_task} or {#remove_free_event} instead
+        def remove_object(object, timestamp = Time.now)
+            Roby.warn_deprecated "#remove_object is deprecated, use either #remove_task or #remove_free_event"
+            if has_task?(object)
+                remove_task(object, timestamp)
+            elsif has_free_event?(object)
+                remove_free_event(object, timestamp)
+            else
+                raise ArgumentError, "#{object} is neither a task nor a free event of #{self}"
+            end
+        end
+
+        def clear!
+            each_task_relation_graph do |g|
+                g.clear
+            end
+            each_event_relation_graph do |g|
+                g.clear
+            end
+            @free_events.clear
+            @mission_tasks.clear
+            @tasks.clear
+            @permanent_tasks.clear
+            @permanent_events.clear
+            @task_index.clear
+            @task_events.clear
+        end
+
+        # Remove all tasks
+        def clear
+            tasks, @tasks = @tasks, Set.new
+            free_events, @free_events = @free_events, Set.new
+
+            clear!
+
+            remaining = tasks.find_all do |t|
+                if executable? && t.running?
+                    true
+                else
+                    finalize_task(t)
+                    false
+                end
+            end
+            if !remaining.empty?
+                Roby.warn "#{remaining.size} tasks remaining after clearing the plan as they are still running"
+                remaining.each do |t|
+                    Roby.warn "  #{t}"
+                end
+            end
+            free_events.each do |e|
+                finalize_event(e)
+            end
+
+            self
+        end
+
+        # Hook called when +task+ has been removed from this plan
+        def finalized_task(task)
             for trsc in transactions
                 next unless trsc.proxying?
+                if proxy = trsc.find_local_object_for_task(task)
+                    trsc.finalized_plan_task(proxy)
+                end
+            end
+            log(:finalized_task, droby_id, task)
+        end
 
-                if proxy = trsc.wrap(object, false)
-                    yield(trsc, proxy)
+        # Hook called when +event+ has been removed from this plan
+        def finalized_event(event)
+            log(:finalized_event, droby_id, event)
+            return unless event.root_object?
+            for trsc in transactions
+                next unless trsc.proxying?
+                if proxy = trsc.find_local_object_for_event(event)
+                    trsc.finalized_plan_event(proxy)
                 end
             end
         end
 
-	# Replace +task+ with a fresh copy of itself.
+        # Replace +task+ with a fresh copy of itself.
         #
         # The new task takes the place of the old one in the plan: any relation
         # that was going to/from +task+ or one of its events is removed, and the
         # corresponding one is created, but this time involving the newly
         # created task.
         def recreate(task)
-	    new_task = task.create_fresh_copy
-	    replace_task(task, new_task)
+            new_task = task.create_fresh_copy
+            replace_task(task, new_task)
             new_task
         end
 
-	# Replace +task+ with a fresh copy of itself and start it.
+        # Creates a new planning pattern replacing the given task and its
+        # current planner
         #
-        # See #recreate for details about the new task.
-	def respawn(task)
-            new = recreate(task)
-            engine.once { new.start!(nil) }
-	    new
-	end
+        # @param [Roby::Task] task the task that needs to be replanned
+        # @return [Roby::Task] the new planning pattern
+        def replan(task)
+            if !task.planning_task
+                return task.create_fresh_copy
+            end
+
+            planner = replan(old_planner = task.planning_task)
+            planned = task.create_fresh_copy
+            planned.abstract = true
+            planned.planned_by planner
+            replace(task, planned)
+            planned
+        end
+
         
         # The set of blocks that should be called to check the structure of the
-        # plan. See also Plan.structure_checks.
+        # plan.
+        #
+        # @yieldparam [Plan] the plan
+        # @yieldreturn [Array<(#to_execution_exception,Array<Task>)>] a list
+        #   of exceptions, and the tasks toward which these exceptions
+        #   should be propagated. If the list of tasks is nil, all parents
+        #   of the exception's origin will be selected
         attr_reader :structure_checks
 
         @structure_checks = Array.new
         class << self
             # A set of structure checking procedures that must be performed on all plans
+            #
+            # @yieldparam [Plan] the plan
+            # @yieldreturn [Array<(#to_execution_exception,Array<Task>)>] a list
+            #   of exceptions, and the tasks toward which these exceptions
+            #   should be propagated. If the list of tasks is nil, all parents
+            #   of the exception's origin will be selected
             attr_reader :structure_checks
         end
 
         # Get all missions that have failed
         def self.check_failed_missions(plan)
-            result = []
-            for task in plan.missions
+            result = Array.new
+            for task in plan.mission_tasks
                 result << MissionFailedError.new(task) if task.failed?
             end
+            for task in plan.permanent_tasks
+                result << PermanentTaskError.new(task) if task.failed?
+            end
             result
         end
         structure_checks << method(:check_failed_missions)
         
-        # Perform the structure checking step by calling the procs registered
-        # in #structure_checks and Plan.structure_checks. These procs are
-        # supposed to return a collection of exception objects, or nil if no
-        # error has been found
-	def check_structure
-	    # Do structure checking and gather the raised exceptions
-	    exceptions = {}
-	    for prc in (Plan.structure_checks + structure_checks)
-		begin
-		    new_exceptions = prc.call(self)
-		rescue Exception => e
-                    if engine
-                        engine.add_framework_error(e, 'structure checking')
-                    else
-                        raise
+        # @api private
+        #
+        # Normalize the value returned by one of the {#structure_checks}, by
+        # computing the list of propagation parents if they were not specified
+        # in the return value
+        #
+        # @param [Hash] result
+        # @param [Array,Hash] new
+        def format_exception_set(result, new)
+            [*new].each do |error, tasks|
+                roby_exception = error.to_execution_exception
+                if !tasks
+                    if error.kind_of?(RelationFailedError)
+                        tasks = [error.parent]
                     end
-		end
-		next unless new_exceptions
+                end
+                result[roby_exception] = tasks
+            end
+            result
+        end
+
+        def call_structure_check_handler(handler)
+            handler.call(self)
+        end
+
+        # Perform the structure checking step by calling the procs registered
+        # in {#structure_checks} and {Plan.structure_checks}
+        #
+        # @return [Hash<ExecutionException,Array<Roby::Task>,nil>
+        def check_structure
+            # Do structure checking and gather the raised exceptions
+            exceptions = Hash.new
+            for prc in (Plan.structure_checks + structure_checks)
+                new_exceptions = call_structure_check_handler(prc)
+                next unless new_exceptions
+
+                format_exception_set(exceptions, new_exceptions)
+            end
+            exceptions
+        end
+
+        # Run a garbage collection pass. This is 'static', as it does not care
+        # about the task's state: it will simply remove *from the plan* any task
+        # that is not useful *in the context of the plan*.
+        #
+        # This is mainly useful for static tests, and for transactions
+        #
+        # Do *not* use it on executed plans.
+        def static_garbage_collect
+            if block_given?
+                for t in unneeded_tasks
+                    yield(t)
+                end
+            else
+                for t in unneeded_tasks
+                    remove_task(t)
+                end
+            end
+        end
+
+        # Finds a single difference between this plan and the other plan, using
+        # the provided mappings to map objects from self to object in other_plan
+        def find_plan_difference(other_plan, mappings)
+            all_self_objects  = tasks | free_events | task_events
+            all_other_objects = (other_plan.tasks | other_plan.free_events | other_plan.task_events)
 
-		[*new_exceptions].each do |e, tasks|
-		    e = ExecutionEngine.to_execution_exception(e)
-		    exceptions[e] = tasks
-		end
-	    end
-	    exceptions
-	end
+            all_mapped_objects = all_self_objects.map do |obj|
+                if !mappings.has_key?(obj)
+                    return [:new_object, obj]
+                end
+                mappings[obj]
+            end.to_set
+
+            if all_mapped_objects != all_other_objects
+                return [:removed_objects, all_other_objects - all_mapped_objects]
+            elsif mission_tasks.map { |m| mappings[m] }.to_set != other_plan.mission_tasks
+                return [:missions_differ]
+            elsif permanent_tasks.map { |p| mappings[p] }.to_set != other_plan.permanent_tasks
+                return [:permanent_tasks_differ]
+            elsif permanent_events.map { |p| mappings[p] }.to_set != other_plan.permanent_events
+                return [:permanent_events_differ]
+            end
 
+            each_task_relation_graph do |graph|
+                other_graph = other_plan.task_relation_graph_for(graph.class)
+                if diff = graph.find_edge_difference(other_graph, mappings)
+                    return [graph.class] + diff
+                end
+            end
 
-        include Roby::ExceptionHandlingObject
+            each_event_relation_graph do |graph|
+                other_graph = other_plan.event_relation_graph_for(graph.class)
+                if diff = graph.find_edge_difference(other_graph, mappings)
+                    return [graph.class] + diff
+                end
+            end
+            nil
+        end
 
-        attr_reader :exception_handlers
-        def each_exception_handler(&iterator); exception_handlers.each(&iterator) end
-        def on_exception(*matchers, &handler)
-            check_arity(handler, 2)
-            exception_handlers.unshift [matchers, handler]
+        # Compares this plan to +other_plan+, mappings providing the mapping
+        # from task/Events in +self+ to task/events in other_plan
+        def same_plan?(other_plan, mappings)
+            !find_plan_difference(other_plan, mappings)
+        end
+
+        # Returns a Query object that applies on this plan.
+        #
+        # This is equivalent to
+        #
+        #   Roby::Query.new(self)
+        #
+        # Additionally, the +model+ and +args+ options are passed to
+        # Query#which_fullfills. For example:
+        #
+        #   plan.find_tasks(Tasks::SimpleTask, id: 20)
+        #
+        # is equivalent to
+        #
+        #   Roby::Query.new(self).which_fullfills(Tasks::SimpleTask, id: 20)
+        #
+        # The returned query is applied on the global scope by default. This
+        # means that, if it is applied on a transaction, it will match tasks
+        # that are in the underlying plans but not yet in the transaction,
+        # import the matches in the transaction and return the new proxies.
+        #
+        # See #find_local_tasks for a local query.
+        def find_tasks(model = nil, args = nil)
+            q = Queries::Query.new(self)
+            if model || args
+                q.which_fullfills(model, args)
+            end
+            q
+        end
+
+        # Starts a local query on this plan.
+        #
+        # Unlike #find_tasks, when applied on a transaction, it will only match
+        # tasks that are already in the transaction.
+        #
+        # See #find_global_tasks for a local query.
+        def find_local_tasks(*args, &block)
+            query = find_tasks(*args, &block)
+            query.local_scope
+            query
+        end
+
+        # Called by TaskMatcher#result_set and Query#result_set to get the set
+        # of tasks matching +matcher+
+        def query_result_set(matcher) # :nodoc:
+            filtered = matcher.filter(tasks, task_index, initial_is_complete: true)
+
+            if matcher.indexed_query?
+                filtered
+            else
+                result = Set.new
+                for task in filtered
+                    result << task if matcher === task
+                end
+                result
+            end
+        end
+
+        # Called by TaskMatcher#each and Query#each to return the result of
+        # this query on +self+
+        def query_each(result_set, &block) # :nodoc:
+            for task in result_set
+                yield(task)
+            end
+        end
+
+        def root_in_query?(result_set, task, graph)
+            graph.depth_first_visit(task) do |v|
+                return false if v != task && result_set.include?(v)
+            end
+            true
+        end
+
+        # Given the result set of +query+, returns the subset of tasks which
+        # have no parent in +query+
+        def query_roots(result_set, relation) # :nodoc:
+            graph = task_relation_graph_for(relation).reverse
+            result_set.find_all do |task|
+                root_in_query?(result_set, task, graph)
+            end
+        end
+
+        # The list of fault response tables that are currently globally active
+        # on this plan
+        attr_reader :active_fault_response_tables
+
+        # Enables a fault response table on this plan
+        #
+        # @param [Model<Coordination::FaultResponseTable>] table_model the fault
+        #   response table model
+        # @param [Hash] arguments the arguments that should be passed to the
+        #   created table
+        # @return [Coordination::FaultResponseTable] the fault response table
+        #   that got added to this plan. It can be removed using
+        #   {#remove_fault_response_table}
+        # @return [void]
+        # @see remove_fault_response_table
+        def use_fault_response_table(table_model, arguments = Hash.new)
+            table = table_model.new(self, arguments)
+            table.attach_to(self)
+            active_fault_response_tables << table
+            table
+        end
+
+        # Remove a fault response table that has been added with
+        # {#use_fault_response_table}
+        #
+        # @overload remove_fault_response_table(table)
+        #   @param [Coordination::FaultResponseTable] table the table that
+        #     should be removed. This is the return value of
+        #     {#use_fault_response_table}
+        #
+        # @overload remove_fault_response_table(table_model)
+        #   Removes all the tables whose model is the given table model
+        #
+        #   @param [Model<Coordination::FaultResponseTable>] table_model
+        #
+        # @return [void]
+        # @see use_fault_response_table
+        def remove_fault_response_table(table_model)
+            active_fault_response_tables.delete_if do |t|
+                if (table_model.kind_of?(Class) && t.kind_of?(table_model)) || t == table_model
+                    t.removed!
+                    true
+                end
+            end
+        end
+
+        # Tests whether a task is useful for another one task
+        #
+        # It is O(N) where N is the number of edges in the combined task
+        # relation graphs. If you have to do a lot of tests with the same task,
+        # compute the set of useful tasks with {Plan#compute_useful_tasks}
+        #
+        # @param reference_task the reference task
+        # @param task the task whose usefulness is being tested
+        # @return [Boolean]
+        def in_useful_subplan?(reference_task, task)
+            compute_useful_tasks([task]) do |useful_t|
+                if useful_t == self
+                    return true
+                end
+            end
+            return false
         end
-    end
 
-    class << self
-        # Returns the main plan
-        attr_reader :plan
+        # Enumerate object identities along the transaction stack
+        #
+        # The enumeration starts with the deepest transaction and stops at the
+        # topmost plan where the object is not a transaction proxy.
+        #
+        # @param [PlanObject] object
+        # @yieldparam [PlanObject] object the object's identity at the
+        #   given level of the stack. Note that the last element is guaranteed
+        #   to not be a transaction proxy.
+        def each_object_in_transaction_stack(object)
+            return enum_for(__method__, object) if !block_given?
+            current_plan = self
+            while true
+                yield(current_plan, object)
+
+                return if !object.transaction_proxy?
+                current_plan = current_plan.plan
+                object = object.__getobj__
+            end
+            nil
+        end
     end
-    
-    # Defines a global exception handler on the main plan.
-    # See also Plan#on_exception
-    def self.on_exception(*matchers, &handler); Roby.plan.on_exception(*matchers, &handler) end
 end