ace-overseer 0.17.0 → 0.18.2

data/lib/ace/overseer/organisms/prune_orchestrator.rb

@@ -1,21 +1,41 @@
 # frozen_string_literal: true
 
+require "open3"
+
 module Ace
   module Overseer
     module Organisms
+      # Enforces the prune-safety contract on actual destructive paths.
+      #
+      # Preview is read-only: it classifies candidates but never mutates
+      # worktree metadata or state. Apply holds the durable lifecycle
+      # exclusion exclusively per candidate from its final evidence reads
+      # through removal, recomputes the full safety classification under the
+      # exclusion, removes the worktree without force or untracked
+      # suppression, deletes the branch only after re-verifying its tip and
+      # preservation, and records the removal so later starts fail closed.
+      #
+      # --force never bypasses preservation, dirtiness, lifecycle or
+      # revalidation blocks; it only suppresses the interactive confirmation
+      # for already-safe candidates.
       class PruneOrchestrator
         def initialize(worktree_manager: nil, prune_checker: nil, tmux_executor: nil, config: nil,
-          assignment_prune_checker: nil, assignment_manager: nil)
+          assignment_prune_checker: nil, assignment_manager: nil, lifecycle_exclusion: nil,
+          preservation_manifest_loader: nil)
           @worktree_manager = worktree_manager || Ace::Git::Worktree::Organisms::WorktreeManager.new
           @prune_checker = prune_checker || Molecules::PruneSafetyChecker.new
           @tmux_executor = tmux_executor || Ace::Tmux::Molecules::TmuxExecutor.new
           @config = config || Ace::Overseer.config
           @assignment_prune_checker = assignment_prune_checker || Molecules::AssignmentPruneSafetyChecker.new
           @assignment_manager = assignment_manager || Ace::Assign::Molecules::AssignmentManager.new
+          @lifecycle_exclusion = lifecycle_exclusion
+          @preservation_manifest_loader = preservation_manifest_loader || ->(path) {
+            Molecules::PreservationManifest.load(path)
+          }
         end
 
         def call(dry_run:, yes:, force: false, targets: [], assignment_id: nil,
-          input: $stdin, output: $stdout, on_progress: nil)
+          preservation_manifest: nil, input: $stdin, output: $stdout, on_progress: nil)
           if assignment_id
             return prune_assignment(assignment_id: assignment_id, dry_run: dry_run,
               yes: yes, force: force, input: input, output: output,
@@ -25,69 +45,160 @@ module Ace
           progress = on_progress || ->(_msg) {}
 
           progress.call("Scanning worktrees...")
-          prune_stale_metadata(progress)
           result = @worktree_manager.list_all(show_tasks: true)
           raise Error, result[:error] || "Failed to list worktrees" unless result[:success]
 
           all_worktrees = Array(result[:worktrees]).reject(&:bare)
-          worktrees = if targets.any?
-            filter_by_targets(all_worktrees, targets)
+          selection = if targets.any?
+            select_by_targets(all_worktrees, targets)
           else
             all_worktrees.select(&:task_associated?)
           end
 
-          progress.call("Checking #{worktrees.length} worktree(s)...")
-          checked = worktrees.map { |worktree| check_candidate(worktree) }
+          manifest = load_manifest(preservation_manifest, selection)
 
+          progress.call("Checking #{selection.length} worktree(s)...")
+          accepted_base = accepted_base_for(selection)
+          checked = selection.map do |worktree|
+            check_candidate(worktree, manifest: manifest, accepted_base: accepted_base)
+          end
           safe = checked.select(&:safe_to_prune?)
           unsafe = checked.reject(&:safe_to_prune?)
-          forced = force ? unsafe : []
 
           if dry_run
-            return {dry_run: true, safe: safe, unsafe: unsafe, forced: forced, pruned: [], failed: []}
+            return {dry_run: true, safe: safe, unsafe: unsafe, forced: [], pruned: [], failed: [], blocked: []}
           end
 
-          print_candidates(safe, unsafe, force, output)
+          print_candidates(safe, unsafe, output)
 
-          to_prune = safe + forced
-          unless yes
+          # --force suppresses only the convenience confirmation for
+          # already-safe candidates; every safety block still applies.
+          unless yes || force
             output.print("Continue? [y/N] ")
             answer = input.gets.to_s.strip.downcase
             unless %w[y yes].include?(answer)
-              return {dry_run: false, safe: safe, unsafe: unsafe, forced: forced, pruned: [], failed: [], aborted: true}
+              return {dry_run: false, safe: safe, unsafe: unsafe, forced: [], pruned: [],
+                      failed: [], blocked: [], aborted: true}
             end
           end
 
+          prune_stale_metadata(progress)
+          apply_removals(safe, accepted_base: accepted_base, manifest: manifest, progress: progress)
+            .merge(safe: safe, unsafe: unsafe, forced: [], aborted: false, dry_run: false)
+        end
+
+        private
+
+        # Remove each safe candidate independently under its exclusion: a
+        # blocked candidate never stops other safe candidates from
+        # completing.
+        def apply_removals(safe, accepted_base:, manifest:, progress:)
           pruned = []
           failed = []
+          blocked = []
+
+          safe.each do |candidate|
+            exclusion.with_exclusive(identity_key(candidate)) do
+              # Re-resolve the surviving base inside the exclusion: a base
+              # branch reset after preview must not authorize removal against
+              # its stale tip, and an unresolvable base cannot re-verify
+              # preservation at all.
+              fresh_base = accepted_base_for([candidate_worktree(candidate)])
+              recheck = check_candidate(
+                candidate_worktree(candidate), manifest: manifest, accepted_base: fresh_base
+              )
+              unless recheck.safe_to_prune?
+                blocked << {candidate: candidate, reasons: recheck.reasons}
+                progress.call("Blocked after recheck: task.#{candidate.task_id} — #{recheck.reasons.join(", ")}")
+                next
+              end
 
-          to_prune.each do |candidate|
-            remove_result = @worktree_manager.remove(
-              candidate.worktree_path,
-              force: force,
-              ignore_untracked: true,
-              delete_branch: true
-            )
-            if remove_result[:success]
-              close_tmux_window(candidate.worktree_path)
-              pruned << candidate
+              removal = remove_worktree(
+                candidate,
+                verified_head: recheck.verified_head,
+                verified_branch: recheck.verified_branch
+              )
+              if removal[:success]
+                pruned << candidate
+                record_removed(candidate)
+              else
+                failed << {candidate: candidate, error: removal[:error]}
+              end
+            end
+          rescue => e
+            failed << {candidate: candidate, error: e.message}
+          end
+
+          {pruned: pruned, failed: failed, blocked: blocked}
+        end
+
+        def remove_worktree(candidate, verified_head:, verified_branch: nil)
+          # Bind both identities the recheck proved to the removal: a HEAD
+          # move or a branch switch after the recheck must not let the
+          # worktree disappear or an unproven ref be deleted. Unreadable
+          # identities are left to the removal itself, which fails closed.
+          head_now = candidate_head(candidate.worktree_path)
+          branch_now = candidate_branch(candidate.worktree_path)
+          if verified_head && head_now && head_now != verified_head
+            return {success: false, error: "HEAD changed after recheck (#{head_now[0, 12]}); preserving"}
+          end
+          # Compare branch identities in BOTH directions, including nil: a
+          # detach after the recheck preserves the candidate instead of
+          # deleting the verified branch, and attaching after a detached
+          # recheck preserves the candidate instead of deleting a branch
+          # that was never proven.
+          if verified_branch != branch_now
+            detail = if verified_branch.nil?
+              "worktree attached to #{branch_now} after recheck"
+            elsif branch_now.to_s.empty?
+              "worktree detached after recheck"
             else
-              failed << {candidate: candidate, error: remove_result[:error]}
+              "branch switched to #{branch_now} after recheck"
             end
+            return {success: false, error: "#{detail}; preserving"}
           end
 
-          {
-            dry_run: false,
-            safe: safe,
-            unsafe: unsafe,
-            forced: forced,
-            pruned: pruned,
-            failed: failed,
-            aborted: false
-          }
+          repo = candidate_repo(candidate.worktree_path)
+
+          remove_result = @worktree_manager.remove(
+            candidate.worktree_path,
+            force: false,
+            ignore_untracked: false,
+            delete_branch: false
+          )
+          return remove_result unless remove_result[:success]
+
+          close_tmux_window(candidate.worktree_path)
+          # Only the branch the recheck verified is deletable — never a
+          # freshly observed branch name.
+          branch_result = delete_branch(repo, branch: verified_branch, head: verified_head)
+          return branch_result unless branch_result[:success]
+
+          remove_result
         end
 
-        private
+        # The branch deletion boundary: the ref is deleted by compare-and-swap
+        # against the exact HEAD whose preservation the recheck just proved —
+        # never a freshly re-read commit that was itself never proven, and a
+        # branch advanced concurrently is preserved, not force-deleted.
+        def delete_branch(repo, branch:, head:)
+          return {success: true} if branch.nil? || branch.empty?
+          if head.nil?
+            return {success: false, error: "recheck did not verify a candidate HEAD; preserving branch #{branch}"}
+          end
+          return {success: false, error: "cannot resolve common repository for branch deletion"} if repo.nil?
+
+          _out, status = Open3.capture2(
+            "git", "-C", repo, "update-ref", "-d", "refs/heads/#{branch}", head
+          )
+          if status.success?
+            {success: true}
+          else
+            tip = rev_parse(repo, "--verify", "refs/heads/#{branch}")
+            {success: false,
+             error: "branch #{branch} changed after preview (tip #{tip ? tip[0, 12] : "missing"}); preserving"}
+          end
+        end
 
         def prune_assignment(assignment_id:, dry_run:, yes:, force:, input:, output:, on_progress:)
           progress = on_progress || ->(_msg) {}
@@ -96,73 +207,114 @@ module Ace
           candidate = @assignment_prune_checker.check(assignment_id: assignment_id)
 
           if dry_run
-            return {dry_run: true, assignment_candidate: candidate, pruned_assignments: []}
+            return {dry_run: true, assignment_candidate: candidate, pruned_assignments: [], blocked: false}
           end
 
-          unless candidate.safe_to_prune? || force
+          unless candidate.safe_to_prune?
             output.puts("Cannot prune assignment #{assignment_id}: #{candidate.reasons.join(", ")}")
             return {dry_run: false, assignment_candidate: candidate, pruned_assignments: [], blocked: true}
           end
 
-          print_assignment_candidate(candidate, force, output)
+          print_assignment_candidate(candidate, output)
 
           unless yes
             output.print("Continue? [y/N] ")
             answer = input.gets.to_s.strip.downcase
             unless %w[y yes].include?(answer)
-              return {dry_run: false, assignment_candidate: candidate, pruned_assignments: [], aborted: true}
+              return {dry_run: false, assignment_candidate: candidate, pruned_assignments: [],
+                      blocked: false, aborted: true}
             end
           end
 
-          deleted = @assignment_manager.delete(assignment_id)
-          pruned = deleted ? [candidate] : []
+          deleted = false
+          exclusion.with_exclusive(exclusion.assignment_key(assignment_id)) do
+            recheck = @assignment_prune_checker.check(assignment_id: assignment_id)
+            unless recheck.safe_to_prune?
+              output.puts("Blocked after recheck: assignment #{assignment_id}: #{recheck.reasons.join(", ")}")
+              return {dry_run: false, assignment_candidate: recheck, pruned_assignments: [], blocked: true}
+            end
+
+            deleted = @assignment_manager.delete(assignment_id)
+            # The removed marker records a completed deletion only: a failed
+            # delete must keep admitting starts against the surviving cache.
+            exclusion.record_removed!(exclusion.assignment_key(assignment_id)) if deleted
+          end
 
-          {dry_run: false, assignment_candidate: candidate, pruned_assignments: pruned}
+          pruned = deleted ? [candidate] : []
+          {dry_run: false, assignment_candidate: candidate, pruned_assignments: pruned,
+           blocked: false, deleted: deleted}
         end
 
-        def print_assignment_candidate(candidate, force, output)
-          label = if candidate.safe_to_prune?
-            "Safe to prune"
-          else
-            (force ? "Force removing" : "Blocked")
-          end
-          output.puts("#{label}: assignment #{candidate.assignment_id} (#{candidate.assignment_name})")
+        def print_assignment_candidate(candidate, output)
+          output.puts("Safe to prune: assignment #{candidate.assignment_id} (#{candidate.assignment_name})")
           output.puts("  State: #{candidate.assignment_state}")
           output.puts("  Reasons: #{candidate.reasons.join(", ")}") if candidate.reasons.any?
         end
 
-        def filter_by_targets(worktrees, targets)
-          worktrees.select do |wt|
+        def select_by_targets(worktrees, targets)
+          selected = worktrees.select do |wt|
             targets.any? { |t| wt.task_id.to_s == t.to_s || wt.path.include?(t.to_s) }
           end
-        end
+          if selected.empty?
+            raise Error, "no worktree matches target(s): #{targets.join(", ")}"
+          end
 
-        def print_candidates(safe, unsafe, force, output)
-          if safe.any?
-            output.puts("Safe to prune (#{safe.length}):")
-            safe.each { |c| output.puts("  task.#{c.task_id} — #{c.worktree_path}") }
-          else
-            output.puts("No worktrees safe to prune.")
+          unmatched = targets.reject do |t|
+            selected.any? { |wt| wt.task_id.to_s == t.to_s || wt.path.include?(t.to_s) }
           end
-          if unsafe.any?
-            if force
-              output.puts("Force removing (#{unsafe.length}):")
-              unsafe.each { |c| output.puts("  task.#{c.task_id} — #{c.reasons.join(", ")}") }
-            else
-              output.puts("Skipping (#{unsafe.length}):")
-              unsafe.each { |c| output.puts("  task.#{c.task_id} — #{c.reasons.join(", ")}") }
-            end
+          unless unmatched.empty?
+            raise Error, "no worktree matches target(s): #{unmatched.join(", ")}"
           end
+
+          selected
         end
 
-        def check_candidate(worktree)
-          @prune_checker.check(worktree_path: worktree.path, task_ref: worktree.task_id)
+        def load_manifest(preservation_manifest, selection)
+          return nil if preservation_manifest.nil?
+
+          manifest = @preservation_manifest_loader.call(preservation_manifest)
+          manifest.ensure_all_match!(selection.map(&:path))
+          manifest
+        rescue Molecules::PreservationManifest::Invalid => e
+          raise Error, e.message
+        end
+
+        def accepted_base_for(selection)
+          sample = selection.first
+          return nil if sample.nil?
+
+          repo = candidate_repo(sample.path)
+          return nil if repo.nil?
+
+          branch = rev_parse(repo, "--abbrev-ref", "HEAD")
+          head = rev_parse(repo, "--verify", "HEAD")
+          return nil if branch.nil? || head.nil? || branch == "HEAD"
+
+          base = {branch: branch, head: head}
+          @cached_accepted_base = base
+          base
+        end
+
+        def check_candidate(worktree, manifest:, accepted_base:)
+          record = manifest&.for_worktree(worktree.path)
+          @prune_checker.check(
+            worktree_path: worktree.path,
+            task_ref: worktree.task_id,
+            manifest_record: record,
+            accepted_base: accepted_base
+          )
         rescue Errno::ENOENT, Errno::ENOTDIR
           unsafe_candidate(worktree, "worktree directory missing")
         rescue => e
           unsafe_candidate(worktree, "prune safety check failed: #{e.message}")
         end
 
+        # A recheck needs a worktree-shaped object; the candidate model
+        # carries both path and task id.
+        def candidate_worktree(candidate)
+          Struct.new(:path, :task_id).new(candidate.worktree_path, candidate.task_id)
+        end
+
         def unsafe_candidate(worktree, reason)
           Models::PruneCandidate.new(
             task_id: worktree.task_id || "unknown",
@@ -170,10 +322,60 @@ module Ace
             assignment_complete: false,
             task_done: false,
             git_clean: false,
+            attempts_terminal: false,
+            preserved: false,
             reasons: [reason]
           )
         end
 
+        def identity_key(candidate)
+          if candidate.task_id.to_s == "" || candidate.task_id.to_s == "unknown"
+            exclusion.worktree_key(candidate.worktree_path)
+          else
+            exclusion.task_key(candidate.task_id)
+          end
+        end
+
+        def record_removed(candidate)
+          exclusion.record_removed!(identity_key(candidate))
+        end
+
+        def exclusion
+          @lifecycle_exclusion ||= Ace::Assign::Molecules::LifecycleExclusion.new
+        end
+
+        def candidate_head(worktree_path)
+          rev_parse(worktree_path, "--verify", "HEAD")
+        end
+
+        def candidate_branch(worktree_path)
+          branch = rev_parse(worktree_path, "--abbrev-ref", "HEAD")
+          branch == "HEAD" ? nil : branch
+        end
+
+        def candidate_repo(worktree_path)
+          common_dir = rev_parse(worktree_path, "--path-format=absolute", "--git-common-dir")
+          common_dir.nil? || common_dir.empty? ? nil : File.dirname(common_dir)
+        end
+
+        def rev_parse(repo, *args)
+          stdout, _stderr, status = Open3.capture3("git", "-C", repo, "rev-parse", *args)
+          status.success? ? stdout.to_s.strip : nil
+        end
+
+        def print_candidates(safe, unsafe, output)
+          if safe.any?
+            output.puts("Safe to prune (#{safe.length}):")
+            safe.each { |c| output.puts("  task.#{c.task_id} — #{c.worktree_path}") }
+          else
+            output.puts("No worktrees safe to prune.")
+          end
+          if unsafe.any?
+            output.puts("Skipping (#{unsafe.length}):")
+            unsafe.each { |c| output.puts("  task.#{c.task_id} — #{c.reasons.join(", ")}") }
+          end
+        end
+
         def prune_stale_metadata(progress)
           result = @worktree_manager.prune
           return if result.nil? || result[:success]

data/lib/ace/overseer/organisms/work_on_orchestrator.rb

@@ -8,13 +8,14 @@ module Ace
         SUBTASK_PATTERN = /^[0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}\.[a-z0-9]$/
 
         def initialize(worktree_provisioner: nil, tmux_window_opener: nil, assignment_launcher: nil,
-          task_loader: nil, config: nil, assignment_detector: nil)
+          task_loader: nil, config: nil, assignment_detector: nil, lifecycle_exclusion: nil)
           @worktree_provisioner = worktree_provisioner || Molecules::WorktreeProvisioner.new
           @tmux_window_opener = tmux_window_opener || Molecules::TmuxWindowOpener.new
           @task_manager = task_loader || Ace::Task::Organisms::TaskManager.new
           @assignment_launcher = assignment_launcher || Molecules::AssignmentLauncher.new(task_manager: @task_manager)
           @config = config || Ace::Overseer.config
           @assignment_detector = assignment_detector
+          @lifecycle_exclusion = lifecycle_exclusion
         end
 
         def call(task_ref:, task_refs: nil, cli_preset: nil, on_progress: nil)
@@ -48,57 +49,70 @@ module Ace
           primary_subtask_refs = extract_subtask_refs(primary_task)
           tmux_preset = @config.dig("tmux_window_presets", preset_name)
 
+          # Participate in prune exclusion for the whole start: provisioning,
+          # runtime window and assignment launch all hold the shared side of
+          # the task identity, so a worktree prune cannot interleave with a
+          # writer starting into the same task. Provisioning a fresh worktree
+          # for a task whose previous worktree was pruned clears the removed
+          # marker explicitly.
           progress.call("Provisioning worktree...")
-          worktree = @worktree_provisioner.provision(primary_ref)
-          if worktree[:created]
-            progress.call("Worktree created at #{worktree[:worktree_path]}")
-          else
-            progress.call("Worktree exists at #{worktree[:worktree_path]}")
-          end
-
-          progress.call("Opening tmux window...")
-          @tmux_window_opener.open(
-            worktree_path: worktree[:worktree_path],
-            preset: tmux_preset
-          )
+          outcome = nil
+          lifecycle_exclusion.with_shared(
+            lifecycle_exclusion.task_key(primary_ref), reset_removed: true
+          ) do
+            worktree = @worktree_provisioner.provision(primary_ref)
+            if worktree[:created]
+              progress.call("Worktree created at #{worktree[:worktree_path]}")
+            else
+              progress.call("Worktree exists at #{worktree[:worktree_path]}")
+            end
 
-          progress.call("Checking assignment status...")
-          existing = if @assignment_detector
-            @assignment_detector.call(worktree[:worktree_path])
-          else
-            existing_assignment(worktree[:worktree_path])
-          end
-          assignment_result = if existing
-            progress.call("Assignment already active: #{existing.dig("assignment", "id")}")
-            focused_step = existing.dig("focus_step", "number") || existing.dig("next_step", "number")
-            {
-              assignment_id: existing.dig("assignment", "id"),
-              first_step: focused_step,
-              created: false
-            }
-          else
-            progress.call("Launching assignment (preset: #{preset_name})...")
-            launched = @assignment_launcher.launch(
+            progress.call("Opening tmux window...")
+            @tmux_window_opener.open(
               worktree_path: worktree[:worktree_path],
-              preset_name: preset_name,
-              task_ref: primary_ref.to_s,
-              subtask_refs: primary_subtask_refs,
-              task_refs: expanded_taskrefs
+              preset: tmux_preset
             )
-            launched.merge(created: true)
+
+            progress.call("Checking assignment status...")
+            existing = if @assignment_detector
+              @assignment_detector.call(worktree[:worktree_path])
+            else
+              existing_assignment(worktree[:worktree_path])
+            end
+            assignment_result = if existing
+              progress.call("Assignment already active: #{existing.dig("assignment", "id")}")
+              focused_step = existing.dig("focus_step", "number") || existing.dig("next_step", "number")
+              {
+                assignment_id: existing.dig("assignment", "id"),
+                first_step: focused_step,
+                created: false
+              }
+            else
+              progress.call("Launching assignment (preset: #{preset_name})...")
+              launched = @assignment_launcher.launch(
+                worktree_path: worktree[:worktree_path],
+                preset_name: preset_name,
+                task_ref: primary_ref.to_s,
+                subtask_refs: primary_subtask_refs,
+                task_refs: expanded_taskrefs
+              )
+              launched.merge(created: true)
+            end
+
+            outcome = {
+              task_ref: primary_ref.to_s,
+              task_refs: expanded_taskrefs,
+              preset: preset_name,
+              worktree_path: worktree[:worktree_path],
+              branch: worktree[:branch],
+              worktree_created: worktree[:created],
+              assignment_id: assignment_result[:assignment_id],
+              first_step: assignment_result[:first_step],
+              assignment_created: assignment_result[:created]
+            }
           end
 
-          {
-            task_ref: primary_ref.to_s,
-            task_refs: expanded_taskrefs,
-            preset: preset_name,
-            worktree_path: worktree[:worktree_path],
-            branch: worktree[:branch],
-            worktree_created: worktree[:created],
-            assignment_id: assignment_result[:assignment_id],
-            first_step: assignment_result[:first_step],
-            assignment_created: assignment_result[:created]
-          }
+          outcome
         end
 
         private
@@ -111,6 +125,10 @@ module Ace
           active.any? ? active.map(&:id) : nil
         end
 
+        def lifecycle_exclusion
+          @lifecycle_exclusion ||= Ace::Assign::Molecules::LifecycleExclusion.new
+        end
+
         def normalize_requested_refs(task_ref, task_refs)
           raw = (task_refs && !task_refs.empty?) ? task_refs : [task_ref]
           raw

data/lib/ace/overseer/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Overseer
-    VERSION = "0.17.0"
+    VERSION = "0.18.2"
   end
 end

data/lib/ace/overseer.rb

@@ -8,10 +8,17 @@ require "ace/git/worktree"
 require "ace/task"
 require "ace/tmux"
 
+module Ace
+  module Overseer
+    class Error < StandardError; end
+  end
+end
+
 require_relative "overseer/version"
 require_relative "overseer/models/work_context"
 require_relative "overseer/models/prune_candidate"
 require_relative "overseer/models/assignment_prune_candidate"
+require_relative "overseer/models/preservation_proof"
 require_relative "overseer/atoms/repo_guard"
 require_relative "overseer/atoms/preset_resolver"
 require_relative "overseer/atoms/status_formatter"
@@ -20,8 +27,11 @@ require_relative "overseer/molecules/lab_client"
 require_relative "overseer/molecules/tmux_window_opener"
 require_relative "overseer/molecules/assignment_launcher"
 require_relative "overseer/molecules/worktree_context_collector"
+require_relative "overseer/molecules/preservation_manifest"
+require_relative "overseer/molecules/git_preservation_checker"
 require_relative "overseer/molecules/prune_safety_checker"
 require_relative "overseer/molecules/assignment_prune_safety_checker"
+require_relative "overseer/molecules/lab_prune_safety_checker"
 require_relative "overseer/organisms/work_on_orchestrator"
 require_relative "overseer/organisms/status_collector"
 require_relative "overseer/organisms/prune_orchestrator"
@@ -29,8 +39,6 @@ require_relative "overseer/cli"
 
 module Ace
   module Overseer
-    class Error < StandardError; end
-
     @config_mutex = Mutex.new
     @gem_root_mutex = Mutex.new