ace-overseer 0.30.2 → 0.31.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require_relative "../molecules/coworker_launcher"
+require_relative "../molecules/manager_binding"
 
 module Ace
   module Overseer
@@ -41,7 +42,21 @@ module Ace
         #   "start_config"}|nil, legs: [...], dry_run}
         # @raise [Error] when the task or its worktree cannot be
         #   resolved, or the handoff is refused (with every reason)
-        def call(task_ref:, dry_run: false, on_progress: nil, runtime: nil)
+        def call(task_ref:, dry_run: false, on_progress: nil, runtime: nil, manager_ref: nil)
+          arguments = {task_ref: task_ref, dry_run: dry_run, on_progress: on_progress,
+            runtime: runtime, manager_ref: manager_ref}
+          return perform(**arguments) unless manager_ref
+
+          manager = @task_manager.show(manager_ref)
+          raise Error, "Manager not found: #{manager_ref}" unless manager
+          lifecycle_exclusion.with_exclusive("manager:#{manager.id}") do
+            perform(**arguments.merge(manager_ref: manager.id))
+          end
+        end
+
+        private
+
+        def perform(task_ref:, dry_run:, on_progress:, runtime:, manager_ref:)
           progress = on_progress || ->(_msg) {}
 
           task = @task_manager.show(task_ref.to_s)
@@ -62,16 +77,43 @@ module Ace
               progress.call("Reading role-sequence state in #{worktree_path}...")
               state = probe.probe(worktree_path, task_id: task.id.to_s)
 
+              binding = Molecules::ManagerBinding.new(task_manager: @task_manager) if manager_ref
+              if binding
+                roles = state.fetch(:legs).map { |leg| leg.fetch("role") }
+                binding.validate!(manager_ref: manager_ref, task: task, roles: roles)
+                unless dry_run
+                  binding.prepare(manager_ref: manager_ref, task: task, sequence: state.fetch(:legs),
+                    worktree_path: worktree_path,
+                    project_root: Molecules::ProjectRootResolver.new.resolve(cwd: worktree_path))
+                end
+              end
               active = Ace::Coworker::Atoms::ActiveExecutorRule.evaluate(
                 config: state[:executor][:config], assignments: state[:executor][:assignments])
               verdict = Atoms::HandoffReadiness.evaluate(legs: state[:legs], active_executor: active)
 
+              # Recover a launched leg through the launcher's existing identity
+              # check, rather than treating a retry as a new handoff.
+              next_leg = state[:legs].find { |leg| leg["state"] != "completed" }
+              selected = Atoms::RuntimeSetting.normalize(runtime || @config["runtime"]) || ENV["ACE_RUNTIME"]
+              native = selected == "herdr" || selected.to_s.empty? && Ace::Runtime::Atoms::Detector.detect == :herdr
+              if native && next_leg && %w[paused empty running].include?(next_leg["state"]) &&
+                  next_leg["execution"].is_a?(Hash) &&
+                  %w[launching started running resuming resumed].include?(next_leg["execution"]["state"]) &&
+                  (!active[:active] || active.dig(:evidence, "assignment") == next_leg["assignment"])
+                verdict = {status: :ready, next: next_leg}
+              end
               if verdict[:status] == :refused
                 raise Error, "Handoff refused: #{verdict[:reasons].join("; ")}"
               end
 
+              binding&.ready!(manager_ref: manager_ref, assignment: verdict[:next]["assignment"], allow_unbound: dry_run) if verdict[:next]
               outcome = ready_outcome(task: task, worktree_path: worktree_path, branch: found[:branch],
                 verdict: verdict, dry_run: dry_run, runtime: runtime, progress: progress)
+              if binding && outcome[:execution]
+                binding.record_execution(manager_ref: manager_ref,
+                  assignment: outcome.fetch(:next).fetch("assignment"), execution: outcome[:execution])
+              end
+              outcome[:manager_ref] = manager_ref if manager_ref
             end
           end
 

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

@@ -16,7 +16,8 @@ module Ace
       class ReportProcessor
         OUTCOME_STATUSES = %i[success error needs_answer duplicate unmatched].freeze
 
-        def initialize(inbox: nil, task_manager: nil, handoff: nil, work_on: nil, completion_check: nil, owner: "overseer", scope: nil, retire: nil)
+        def initialize(inbox: nil, task_manager: nil, handoff: nil, work_on: nil, completion_check: nil, owner: "overseer", scope: nil, retire: nil, decision_check: nil)
+          @decision_check = decision_check || method(:pending_decision)
           @completion_check = completion_check || Molecules::ReportCompletionCheck.new
           @inbox = inbox || Molecules::HitlInbox.new(owner: owner, scope: scope)
           @task_manager = task_manager || Ace::Task::Organisms::TaskManager.new
@@ -31,25 +32,73 @@ module Ace
         # @return [Hash] {dry_run:, outcomes: [...], counts: {...}}
         def call(dry_run: false, on_progress: nil)
           progress = on_progress || ->(_msg) {}
-          events = @inbox.incoming_events
+          events = timed(progress, "collect reports") { @inbox.incoming_events }
+          @manager_snapshot = timed(progress, "read private tasks") { @task_manager.list(in_folder: "_overseer") }
           progress.call("Incoming ace-hitl events: #{events.size}")
 
           outcomes = events.map do |event|
-            process_event(event, dry_run: dry_run, progress: progress)
+            result = process_event(event, dry_run: dry_run, progress: progress)
+            if result[:acknowledge]
+              receipt = {"key" => result[:key], "revision" => result[:revision],
+                "cleanup" => "complete", "continuation" => "complete",
+                "timings" => result[:timings]}
+              unless @task_manager.update(result[:step_ref], set: {"report_receipt" => receipt})
+                result[:acknowledge] = false
+                result[:continuation] = {action: "blocked", reason: "report receipt could not be recorded"}
+              end
+            end
+            if !dry_run && result[:manager_ref]
+              ref = result[:manager_ref]
+              current = @task_manager.show(ref)
+              @manager_snapshot = @manager_snapshot.reject { |manager| manager.id.to_s == ref }
+              @manager_snapshot << current if current
+            end
+            result
           end
 
           counts = OUTCOME_STATUSES.to_h { |status| [status, outcomes.count { |o| o[:status] == status }] }
-          {dry_run: dry_run, outcomes: outcomes, counts: counts}
+          operation = {
+            completed: outcomes.select { |row| row[:accepted] }.map { |row| row[:event_id] },
+            running: outcomes.filter_map { |row| row.dig(:continuation, :execution, "agent") }.uniq,
+            waiting: outcomes.reject { |row| row[:acknowledge] }.map { |row| row[:event_id] },
+            blocked: outcomes.filter_map { |row| row.dig(:continuation, :reason) if row.dig(:continuation, :action) == "blocked" },
+            evidence: outcomes.map { |row| row.slice(:event_id, :key, :revision, :manager_ref, :step_ref) }}
+          {dry_run: dry_run, outcomes: outcomes, counts: counts, operation: operation}
+        ensure
+          @manager_snapshot = nil
+          @receipt = nil
         end
 
         private
 
         def process_event(event, dry_run:, progress:)
-          verdict = Atoms::ReportInterpretation.evaluate(event: event, managers: private_managers)
+          @receipt = {accepted: false, cleanup: false, timings: {}, dry_run: dry_run}
+          verdict = timed(progress, "match #{event['id']}") do
+            Atoms::ReportInterpretation.evaluate(event: event, managers: private_managers)
+          end
+          if verdict[:status] == :duplicate
+            step = @task_manager.show(verdict[:step_ref])
+            recorded = step&.metadata&.fetch("processed_report_revision", nil)
+            if event["revision"] && recorded != event["revision"]
+              return outcome({status: :unmatched}, event, nil,
+                "accepted report revision is missing or changed; inspect the revision before reconciling")
+            end
+            @receipt[:accepted] = true
+          end
+          if verdict[:status] == :duplicate && (reason = duplicate_identity_error(verdict, event))
+            return outcome({status: :unmatched, reason: reason}, event, nil, reason)
+          end
+          if accepted_closed_report?(verdict, event)
+            progress.call("Event #{event['id']}: accepted closed history; only reconcile executor cleanup")
+            retirement = dry_run ? nil : timed(progress, "retire #{event['id']}") { retire_executor(verdict, event) }
+            return outcome(verdict, event, retirement, retirement ? retirement[:reason] : "closed report already accepted; no continuation")
+          end
 
           if verdict[:status] == :success || (verdict[:status] == :duplicate && verdict[:recorded_result] == "success")
-            refusal = @completion_check.call(event: event,
-              manager: @task_manager.show(verdict[:manager_ref]), step: @task_manager.show(verdict[:step_ref]))
+            refusal = timed(progress, "verify #{event['id']}") do
+              @completion_check.call(event: event,
+                manager: @task_manager.show(verdict[:manager_ref]), step: @task_manager.show(verdict[:step_ref]))
+            end
             verdict = {status: :unmatched, reason: refusal} if refusal
           end
 
@@ -84,7 +133,7 @@ module Ace
         # incomplete executor cleanup. A dry run changes nothing.
         def resume_duplicate_continuation(verdict, event, dry_run:, progress:)
           unless dry_run
-            retirement = retire_executor(verdict, event)
+            retirement = timed(progress, "retire #{event['id']}") { retire_executor(verdict, event) }
             return outcome(verdict, event, retirement, retirement[:reason]) if retirement
           end
           unless verdict[:recorded_result] == Atoms::ReportInterpretation::SUCCESS_RESULT && !dry_run
@@ -93,7 +142,7 @@ module Ace
               "nothing re-run")
           end
 
-          continuation = continue_queue(verdict[:manager_ref], progress: progress)
+          continuation = timed(progress, "continue #{event['id']}") { continue_queue(verdict[:manager_ref], progress: progress) }
           outcome(verdict, event, continuation,
             "report #{event['id']} already recorded on #{verdict[:step_ref]} (result: #{verdict[:recorded_result]}); " \
             "continuation re-checked - #{continuation_description(continuation)}")
@@ -108,14 +157,16 @@ module Ace
             return outcome(verdict, event, nil, message)
           end
 
-          unless @task_manager.update(verdict[:step_ref], set: verdict[:set])
+          verdict[:set] = verdict[:set].merge("processed_report_revision" => event["revision"]) if event["revision"]
+          unless timed(progress, "accept #{event['id']}") { @task_manager.update(verdict[:step_ref], set: verdict[:set]) }
             reason = "task #{verdict[:step_ref]} no longer resolves - moved or archived since the event matched"
             message = "report #{event['id']} not recorded: #{reason}; kept in ace-hitl for clarification"
             progress.call("Event #{event['id']}: #{message}")
             return outcome(verdict, event, {action: "blocked", reason: reason}, message)
           end
+          @receipt[:accepted] = true
           progress.call("Event #{event['id']}: recorded #{verdict[:status]} on #{verdict[:step_ref]}")
-          retirement = retire_executor(verdict, event)
+          retirement = timed(progress, "retire #{event['id']}") { retire_executor(verdict, event) }
           return outcome(verdict, event, retirement, retirement[:reason]) if retirement
 
           if verdict[:status] == :error
@@ -125,7 +176,7 @@ module Ace
             return outcome(verdict, event, nil, message)
           end
 
-          continuation = continue_queue(verdict[:manager_ref], progress: progress)
+          continuation = timed(progress, "continue #{event['id']}") { continue_queue(verdict[:manager_ref], progress: progress) }
           outcome(verdict, event, continuation,
             "step #{verdict[:step_ref]} done (report #{event['id']}); #{continuation_description(continuation)}")
         end
@@ -143,7 +194,17 @@ module Ace
           if next_step.nil?
             active = active_steps(manager)
             reason = if active.empty?
-              "every step of #{manager_ref} is terminal; close the managing task per the queue workflow"
+              required = Array(manager.subtasks)
+              if required.any? { |step| step.status.to_s != "done" }
+                return {action: "blocked", reason: "required steps were cancelled or skipped; manager is not successful"}
+              end
+              if (blocker = @decision_check.call(manager))
+                return {action: "blocked", reason: blocker}
+              end
+              unless @task_manager.update(manager_ref, set: {"status" => "done"})
+                return {action: "blocked", reason: "manager disappeared before closure"}
+              end
+              "managing task #{manager_ref} closed by ace-task after accepted required steps"
             else
               "no unblocked step in #{manager_ref}: #{active.map { |s| blocking_summary(s) }.join(' | ')}"
             end
@@ -159,14 +220,14 @@ module Ace
             if family_worktree(manager)
               project_root = manager.metadata["project_root"].to_s
               result = if @handoff
-                @handoff.call(task_ref: manager.metadata["project_task"].to_s)
+                @handoff.call(task_ref: manager.metadata["project_task"].to_s, manager_ref: manager.id.to_s)
               else
                 Dir.chdir(project_root.empty? ? Dir.pwd : project_root) do
-                  Organisms::HandoffOrchestrator.new.call(task_ref: manager.metadata["project_task"].to_s,
+                  Organisms::HandoffOrchestrator.new(task_loader: @task_manager).call(task_ref: manager.metadata["project_task"].to_s,
+                    manager_ref: manager.id.to_s,
                     runtime: Ace::Support::Cli::Toolchain.installed? ? "herdr" : nil)
                 end
               end
-              record_allocation(next_step, result) if result[:execution]
               {action: "handoff", step_ref: next_step.id.to_s,
                next: result[:next], status: result[:status], worktree_path: result[:worktree_path],
                execution: result[:execution], start_command: start_command_of(result[:next])}
@@ -196,6 +257,20 @@ module Ace
           {action: "blocked", reason: "report recorded; executor retirement failed: #{e.message}"}
         end
 
+        def pending_decision(manager)
+          refs = [manager, *Array(manager.subtasks)].filter_map { |task| task.metadata["hitl_case"] }.uniq
+          refs.each do |ref|
+            shown = Ace::Hitl::Organisms::HitlManager.new.show(ref, scope: "all")
+            event = shown.is_a?(Hash) ? shown[:event] : shown
+            unless event && event.answered? && %w[applied closed].include?(event.metadata.dig("application", "state"))
+              return "decision #{ref} is not applied; manager remains open"
+            end
+          end
+          nil
+        rescue StandardError => error
+          "decision state unavailable: #{error.message}"
+        end
+
         def record_allocation(step, result)
           execution = result.fetch(:execution)
           unless @task_manager.update(step.id, set: {"assignment" => execution.fetch("assignment"),
@@ -247,12 +322,57 @@ module Ace
         end
 
         def private_managers
-          @task_manager.list(in_folder: "_overseer")
+          @manager_snapshot || @task_manager.list(in_folder: "_overseer")
+        end
+
+        def duplicate_identity_error(verdict, event)
+          manager = @task_manager.show(verdict[:manager_ref])
+          step = @task_manager.show(verdict[:step_ref])
+          return "accepted report allocation no longer exists" unless manager && step
+          return "duplicate report task differs from accepted allocation" unless event["task"].to_s == manager.metadata["project_task"].to_s
+          return "duplicate report assignment differs from accepted allocation" unless event["assignment"].to_s == step.metadata["assignment"].to_s
+          return "duplicate report result differs from accepted result" unless event["result"].to_s == verdict[:recorded_result].to_s
+          if !event["role"].to_s.empty? && event["role"] != step.metadata["role"]
+            return "duplicate report role differs from accepted allocation"
+          end
+          nil
+        end
+
+        def accepted_closed_report?(verdict, event)
+          return false unless verdict[:status] == :duplicate && verdict[:recorded_result] == "success"
+          manager = private_managers.find { |candidate| candidate.id.to_s == verdict[:manager_ref] }
+          return false unless manager
+          family = [manager, *Array(manager.subtasks)]
+          step = family.find { |candidate| candidate.id.to_s == verdict[:step_ref] }
+          step && step.metadata["processed_report"] == event["id"] && family.all? do |candidate|
+            Ace::Task::Atoms::TaskValidationRules.terminal_status?(candidate.status.to_s)
+          end
+        end
+
+        def timed(progress, label)
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          progress.call("Starting #{label}")
+          result = yield
+          @receipt[:timings][label] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started if @receipt
+          @receipt[:cleanup] = result.nil? if @receipt && label.start_with?("retire ")
+          progress.call("Completed #{label} (#{format('%.3f', Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)}s)")
+          result
+        rescue StandardError
+          progress.call("Failed #{label} (#{format('%.3f', Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)}s)")
+          raise
         end
 
         def outcome(verdict, event, continuation, message)
           {
             event_id: event["id"],
+            key: event["key"], revision: event["revision"],
+            accepted: @receipt[:accepted], cleanup: @receipt[:cleanup] ? "complete" : "pending",
+            timings: @receipt[:timings].dup,
+            acknowledge: !@receipt[:dry_run] && @receipt[:accepted] && @receipt[:cleanup] &&
+              !!event["key"] && !!event["revision"] && event["type"] == "report" &&
+              (verdict[:status] == :success || verdict[:status] == :duplicate && verdict[:recorded_result] == "success") &&
+              (continuation.nil? || continuation[:action] == "none" ||
+                %w[handoff work-on].include?(continuation[:action]) && !!continuation[:execution]),
             status: verdict[:status],
             manager_ref: verdict[:manager_ref],
             step_ref: verdict[:step_ref],

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

@@ -3,8 +3,10 @@
 require_relative "../atoms/start_contract"
 require_relative "../atoms/observation_sources"
 require_relative "../molecules/project_root_resolver"
+require "pathname"
 require_relative "../molecules/project_bundle"
 require_relative "../molecules/eyes_readiness"
+require_relative "../molecules/eyes_configuration"
 require_relative "../molecules/session_environment"
 require "ace/herdr"
 require "ace/herdr/molecules/installed_pi_extensions"
@@ -103,6 +105,7 @@ module Ace
               "message" => "dry-run: session would start with this plan; nothing was created")
           end
 
+          prepare_eyes(root, plan)
           owner = owner_pane(label)
           if owner
             conflict = owner_conflict(owner, root)
@@ -155,7 +158,13 @@ module Ace
           unless plan["profile"]["harness"] == "pi"
             raise Ace::Overseer::Error, "foreground start requires the configured pi harness"
           end
+          raise Errno::ENOENT, @cwd unless File.directory?(@cwd)
           root = File.realpath(@cwd)
+          # A new lab may not yet be a repository; an existing project/worktree
+          # must resolve through Git to its canonical owner.
+          if Pathname.new(root).ascend.any? { |directory| directory.join(".git").exist? }
+            root = @root_resolver.resolve(cwd: root)
+          end
           source = plan["instructions"]
           guide = if %w[wfi://overseer/lab-start wfi://overseer/start].include?(source)
             filename = source.end_with?("lab-start") ? "lab-start.wf.md" : "start.wf.md"
@@ -169,7 +178,8 @@ module Ace
           thinking = plan["profile"]["thinking"]
           command += ["--thinking", thinking] if thinking
           command += ["--append-system-prompt", guide, Atoms::StartContract::FIRST_TURN_PROMPT]
-          {"status" => dry_run ? "dry_run" : "foreground", "scope" => plan["scope"],
+          eyes_path = dry_run ? nil : prepare_eyes(root, plan)
+          {"eyes_config" => eyes_path, "status" => dry_run ? "dry_run" : "foreground", "scope" => plan["scope"],
             "root" => root, "profile" => plan["profile_name"],
             "instructions" => {"source" => source, "path" => guide},
             "command" => command, "message" => "launch the coordinator in the current terminal"}
@@ -338,6 +348,7 @@ module Ace
         # owner is matched by its cwd directly — never through
         # project-root resolution.
         def boot_lab_session(workspace, plan, instructions_path, lab_root)
+          prepare_eyes(lab_root, plan)
           label = Atoms::StartContract.session_label(lab_root)
           owner = owner_pane(label)
           replaced = nil
@@ -507,10 +518,12 @@ module Ace
           end
           if owners.length > 1
             # A replaced dead owner may retain its tab. Only a single live
-            # agent identifies an unambiguous current owner; never pick the
-            # first of multiple live or dead candidates.
+            # agent identifies an unambiguous current owner. When all agents
+            # exited, keep their panels for diagnostics and create a fresh one;
+            # there is no live owner to choose or take over.
             live = owners.select { |pane| !agent_state(pane[:id]).nil? }
-            unless live.length == 1
+            return nil if live.empty?
+            if live.length > 1
               raise Ace::Overseer::Error,
                 "multiple overseer tabs '#{label}' have no unique live owner; refusing an ambiguous session"
             end
@@ -595,8 +608,11 @@ module Ace
               @executor.pane_run(pane, command)
               @executor.pane_wait_output(pane, pattern: marker, timeout_ms: START_TIMEOUT_MS)
             end
-            @executor.agent_start(name: "#{AGENT_NAME}-#{Digest::SHA256.hexdigest(root)[0, 12]}", kind: plan["profile"]["harness"],
-              pane: pane, timeout_ms: START_TIMEOUT_MS, args: args)
+            Molecules::SessionEnvironment.new(env: @env).with_environment(root: root, role: "project-overseer",
+              eyes_config: prepare_eyes(root, plan)) do |file, _directory, _profile|
+              @executor.agent_start(name: "#{AGENT_NAME}-#{Digest::SHA256.hexdigest(root)[0, 12]}", kind: plan["profile"]["harness"],
+                pane: pane, timeout_ms: START_TIMEOUT_MS, args: args, env_file: file)
+            end
           end
           pane
         rescue Ace::Herdr::WaitTimeoutError => e
@@ -608,9 +624,14 @@ module Ace
         # A failed native start can still have created a process. Close the
         # pane before deleting its credentials; if closure is unconfirmed,
         # preserve the directory and report that recovery is required.
+        def prepare_eyes(root, plan)
+          Molecules::EyesConfiguration.prepare(root: root,
+            recipient: @config["owner"] || (plan["scope"] == "lab" ? "lab-overseer" : "overseer"))
+        end
+
         def start_installed_agent(pane, root, role, plan, args)
           credentials = nil
-          Molecules::SessionEnvironment.new(env: @env).with_environment(root: root, role: role) do |file, directory, _profile|
+          Molecules::SessionEnvironment.new(env: @env).with_environment(root: root, role: role, eyes_config: prepare_eyes(root, plan)) do |file, directory, _profile|
             credentials = directory
             @executor.agent_start(name: "#{AGENT_NAME}-#{Digest::SHA256.hexdigest(root)[0, 12]}", kind: plan["profile"]["harness"],
               pane: pane, timeout_ms: START_TIMEOUT_MS, args: args, env_file: file)

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "set"
 
 module Ace
@@ -38,8 +39,9 @@ module Ace
 
         # @param hitl_events [Proc] -> Array<Hash> incoming ace-hitl
         #   events (the existing HitlInbox molecule, read-only)
-        def initialize(hitl_events: default_hitl_events)
-          @hitl_events = hitl_events
+        def initialize(hitl_events: nil, config: nil)
+          @config = config
+          @hitl_events = hitl_events || default_hitl_events
         end
 
         # @param snapshot [Hash] {sources:, unknown_keys:} as produced by
@@ -74,7 +76,29 @@ module Ace
         end
 
         def default_hitl_events
-          -> { Molecules::HitlInbox.new.incoming_events }
+          -> { Molecules::HitlInbox.new(owner: configured_owner).incoming_events }
+        end
+
+        def configured_owner
+          config = @config || Ace::Overseer.config
+          owner = config["owner"].to_s.strip
+          return owner unless owner.empty?
+
+          scope = config.dig("start", "scope").to_s.strip
+          return "lab-overseer" if scope == "lab"
+          return "overseer" if scope == "project"
+
+          eyes_recipient || "overseer"
+        end
+
+        def eyes_recipient
+          return nil unless File.file?(".ace-local/overseer/eyes.json")
+
+          data = JSON.parse(File.read(".ace-local/overseer/eyes.json"))
+          recipient = data.is_a?(Hash) ? data["recipient"].to_s.strip : ""
+          recipient.empty? ? nil : recipient
+        rescue JSON::ParserError, SystemCallError
+          nil
         end
 
         def fetch_hitl_events

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

@@ -2,6 +2,7 @@
 
 require "json"
 require "open3"
+require "rbconfig"
 
 module Ace
   module Overseer
@@ -22,7 +23,7 @@ module Ace
           @project_root = project_root
           @config = config
           @sources = sources
-          @attention = attention || Organisms::StatusAttention.new
+          @attention = attention || Organisms::StatusAttention.new(config: config)
         end
 
         # Aggregate the configurable status sources (L7.2). Each enabled
@@ -48,6 +49,7 @@ module Ace
           attention = snapshot[:attention]
           {
             sources: snapshot[:sources],
+            operation: operation_summary(snapshot),
             unknown_keys: Array(snapshot[:unknown_keys]),
             # Always the three-array contract (never null), so partial or
             # hand-built snapshots render consistently with the table.
@@ -57,6 +59,24 @@ module Ace
           }
         end
 
+        def operation_summary(snapshot)
+          sources = snapshot[:sources] || {}
+          tasks = %w[project_tasks overseer_tree].flat_map do |name|
+            source = sources[name]
+            next [] unless source && source[:status] == "ok" && source[:data].is_a?(Array)
+
+            source[:data].reject { |row| name == "project_tasks" && !row[:special_folder].to_s.empty? }
+          end
+          coworkers = sources.dig("coworkers", :data)
+          coworkers = [] unless coworkers.is_a?(Array)
+          attention = snapshot[:attention] || {}
+          {completed: tasks.select { |row| row[:status] == "done" }.map { |row| row[:id] }.uniq,
+           running: coworkers.select { |row| row[:active] }.map { |row| row[:worktree] }.uniq,
+           waiting: tasks.reject { |row| %w[done cancelled skipped].include?(row[:status]) }.map { |row| row[:id] }.uniq,
+           blocked: Array(attention[:blockers]) + Array(attention[:failures]) + Array(attention[:missing_data]),
+           evidence: sources.map { |name, source| {source: name, origin: source[:origin], status: source[:status]} }}
+        end
+
         def to_sources_table(snapshot)
           sections = [render_attention(snapshot[:attention])]
           source_sections = STATUS_SOURCE_ORDER.filter_map do |key|
@@ -390,7 +410,7 @@ module Ace
               pipe_read.close
               $stdout.reopen(pipe_write)
               pipe_write.close
-              exec("ruby", "-e", worker_script, worktree.path.to_s)
+              exec(RbConfig.ruby, "-e", worker_script, worktree.path.to_s)
               exit!(1) # unreachable unless exec fails
             end
             pipe_write.close

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require_relative "../molecules/coworker_launcher"
+require_relative "../molecules/manager_binding"
+require "ace/task/molecules/git_ignored_path"
 
 module Ace
   module Overseer
@@ -20,7 +22,7 @@ module Ace
           @coworker_launcher = coworker_launcher
         end
 
-        def call(task_ref:, task_refs: nil, cli_preset: nil, on_progress: nil, runtime: nil)
+        def call(task_ref:, task_refs: nil, cli_preset: nil, on_progress: nil, runtime: nil, manager_ref: nil)
           progress = on_progress || ->(_msg) {}
 
           requested_refs = normalize_requested_refs(task_ref, task_refs)
@@ -43,6 +45,13 @@ module Ace
           guard_dependencies_satisfied!(resolved_refs)
           if native_delegation?(runtime)
             raise Error, "delegate one task per worktree" unless resolved_refs.size == 1
+            if manager_ref
+              manager = @task_manager.show(manager_ref)
+              raise Error, "Manager not found: #{manager_ref}" unless manager
+              return lifecycle_exclusion.with_exclusive("manager:#{manager.id}") do
+                delegate(resolved_refs.first, progress: progress, manager_ref: manager.id)
+              end
+            end
             return delegate(resolved_refs.first, progress: progress)
           end
 
@@ -129,19 +138,34 @@ module Ace
           selected == "herdr" || selected.to_s.empty? && Ace::Runtime::Atoms::Detector.detect == :herdr
         end
 
-        def delegate(entry, progress:)
+        def delegate(entry, progress:, manager_ref: nil)
           launcher = @coworker_launcher || Molecules::CoworkerLauncher.new
-          launcher.ready!
-          ref = entry.fetch(:ref)
           task = entry.fetch(:task)
+          ref = task.id.to_s
+          if Ace::Task::Molecules::GitIgnoredPath.ignored_task?(task)
+            raise Error, "task #{task.id} is Git-ignored coordination state and cannot be loaded in an executor worktree; " \
+              "create a separate project task with the commission, roles and existing hitl_case, pass this private task with --manager"
+          end
+          launcher.ready!
+          roles = task.metadata["roles"] || (task.metadata["role"] && [task.metadata["role"]])
+          unless roles.is_a?(Array) && !roles.empty? && roles.all? { |role| role.is_a?(String) && !role.empty? && role == role.strip } && roles.uniq == roles
+            raise Error, "task #{task.id} requires an explicit nonempty role sequence (roles or role); choose roles for this commission before work-on"
+          end
+          if roles.include?("second-captain") && task.metadata["hitl_case"].to_s.strip.empty?
+            raise Error, "second-captain commission requires hitl_case naming the existing decision; do not create another case on retry"
+          end
           lifecycle_exclusion.with_shared(lifecycle_exclusion.task_key(ref), reset_removed: true) do
             lifecycle_exclusion.with_exclusive("delegate:#{ref}") do
+              binding = Molecules::ManagerBinding.new(task_manager: @task_manager) if manager_ref
+              binding&.validate!(manager_ref: manager_ref, task: task, roles: roles)
               worktree = @worktree_provisioner.provision(ref)
               root = worktree.fetch(:worktree_path)
-              roles = task.metadata["roles"] || (task.metadata["role"] ? [task.metadata["role"]] : %w[worker reviewer integrator])
               sequence = Ace::Coworker::Molecules::RoleSequenceComposer.new(project_root: root).call(task: task.id, roles: roles)
               configs = Ace::Coworker::Organisms::StartConfigWriter.new(worktree_path: root).call(
-                task: task.id, sequence: sequence, overseer: @config["owner"] || launcher.recipient)
+                task: task.id, sequence: sequence, overseer: @config["owner"] || launcher.recipient,
+                hitl_case: task.metadata["hitl_case"])
+              binding&.prepare(manager_ref: manager_ref, task: task, sequence: sequence,
+                worktree_path: root, project_root: Molecules::ProjectRootResolver.new.resolve(cwd: root))
               state = Molecules::HandoffProbe.new.probe(root, task_id: task.id)
               leg = state.fetch(:legs).find { |candidate| candidate["state"] != "completed" }
               raise Error, "all prepared roles are complete; reconcile the task instead of starting again" unless leg
@@ -150,9 +174,11 @@ module Ace
               end
               config = configs.find { |row| row["assignment"] == leg["assignment"] }
               raise Error, "prepared role has no start configuration" unless config
+              binding&.ready!(manager_ref: manager_ref, assignment: leg["assignment"])
               execution = launcher.call(worktree_path: root, config_path: config.fetch("path"))
+              binding&.record_execution(manager_ref: manager_ref, assignment: leg["assignment"], execution: execution)
               progress.call("Executor #{execution['agent']} bound to assignment #{leg['assignment']}")
-              {task_ref: task.id, task_refs: [task.id], worktree_path: root, branch: worktree[:branch],
+              {manager_ref: manager_ref, task_ref: task.id, task_refs: [task.id], worktree_path: root, branch: worktree[:branch],
                worktree_created: worktree[:created], assignment_id: leg["assignment"],
                assignment_created: sequence.find { |row| row["assignment"] == leg["assignment"] }["disposition"] == "created",
                execution: execution}

data/lib/ace/overseer/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Overseer
-    VERSION = "0.30.2"
+    VERSION = "0.31.0"
   end
 end