ace-assign 0.53.4 → 0.55.0

data/lib/ace/assign/cli/commands/add.rb

@@ -35,11 +35,11 @@ module Ace
             mode = selected_mode(options)
             case mode
             when :yaml
-              handle_yaml_mode(executor, options)
+              handle_yaml_mode(executor, options, target)
             when :step
-              handle_step_mode(executor, options)
+              handle_step_mode(executor, options, target)
             when :task
-              handle_task_mode(executor, options)
+              handle_task_mode(executor, options, target)
             else
               raise Ace::Support::Cli::Error, "Exactly one of --yaml, --step, or --task is required"
             end
@@ -77,20 +77,21 @@ module Ace
             insertion_modes(options).find { |_, value| !value.to_s.strip.empty? }&.first
           end
 
-          def handle_yaml_mode(executor, options)
+          def handle_yaml_mode(executor, options, target)
             yaml_path = options[:yaml].to_s.strip
             steps = load_steps_from_file(yaml_path)
             result = executor.add_batch(
               steps: steps,
               after: options[:after],
               as_child: options[:child],
-              source_file: yaml_path
+              source_file: yaml_path,
+              fork_root: target.scope
             )
             print_yaml_result(result, yaml_path) unless options[:quiet]
             nil
           end
 
-          def handle_step_mode(executor, options)
+          def handle_step_mode(executor, options, target)
             preset_name = resolve_preset_name(executor, options)
             preset = Atoms::PresetLoader.load(preset_name)
             requested = parse_step_names(options[:step])
@@ -111,7 +112,8 @@ module Ace
                 steps: [step],
                 after: options[:child] ? options[:after] : sibling_cursor,
                 as_child: options[:child],
-                source_file: "preset:#{preset_name}"
+                source_file: "preset:#{preset_name}",
+                fork_root: target.scope
               )
 
               inserted_added = Array(inserted[:added])
@@ -126,7 +128,7 @@ module Ace
             nil
           end
 
-          def handle_task_mode(executor, options)
+          def handle_task_mode(executor, options, target)
             preset_name = resolve_preset_name(executor, options)
             preset = Atoms::PresetLoader.load(preset_name)
             task_ref = options[:task].to_s.strip
@@ -139,7 +141,8 @@ module Ace
             end
 
             parent_step = options[:after].to_s.strip
-            parent_step = detect_batch_parent(executor) if parent_step.empty?
+            parent_step = target.scope.to_s.strip if parent_step.empty? && !target.scope.to_s.strip.empty?
+            parent_step = detect_batch_parent(executor, target) if parent_step.empty?
             if parent_step.to_s.strip.empty?
               raise Ace::Support::Cli::Error, "No batch parent found. Pass --after <step> to specify."
             end
@@ -150,7 +153,8 @@ module Ace
               steps: [task_step],
               after: parent_step,
               as_child: insert_as_child,
-              source_file: "preset:#{preset_name}:task:#{task_ref}"
+              source_file: "preset:#{preset_name}:task:#{task_ref}",
+              fork_root: target.scope
             )
 
             print_task_result(result, task_ref, parent_step, as_child: insert_as_child) unless options[:quiet]
@@ -235,8 +239,13 @@ module Ace
             tokens.to_a.sort
           end
 
-          def detect_batch_parent(executor)
+          def detect_batch_parent(executor, target)
             state = executor.status[:state]
+            if target.scope && !target.scope.to_s.strip.empty?
+              scoped_steps = state.subtree_steps(target.scope.strip)
+              scoped_state = Ace::Assign::Models::QueueState.new(steps: scoped_steps, assignment: state.assignment)
+              state = scoped_state
+            end
 
             batch_parent = state.top_level.find { |step| step.name == "batch-tasks" }
             return batch_parent.number if batch_parent

data/lib/ace/assign/cli/commands/assignment_target.rb

@@ -10,18 +10,26 @@ module Ace
         # - <assignment-id>
         # - <assignment-id>@<step-number>
         module AssignmentTarget
+          DEFAULT_TARGET_ENV = "ACE_ASSIGN_DEFAULT_TARGET"
           Target = Struct.new(:assignment_id, :scope, keyword_init: true)
-          View = Struct.new(:assignment, :state, :scoped_state, :current_step, :scope_root, keyword_init: true)
+          View = Struct.new(:assignment, :state, :scoped_state, :active_steps, :next_step, :focus_step, :scope_root, keyword_init: true)
 
           private
 
           def resolve_assignment_target(options)
             assignment_raw = options[:assignment]
-            unless assignment_raw.nil? || assignment_raw.to_s.strip.empty?
-              return parse_assignment_target(assignment_raw)
+            explicit_target = unless assignment_raw.nil? || assignment_raw.to_s.strip.empty?
+              parse_assignment_target(assignment_raw)
             end
 
-            Target.new(assignment_id: nil, scope: nil)
+            env_target = env_assignment_target
+            if explicit_target && env_target && target_identity(explicit_target) != target_identity(env_target)
+              raise Ace::Support::Cli::Error,
+                "Conflicting assignment targets: --assignment #{target_identity(explicit_target)} " \
+                "does not match #{DEFAULT_TARGET_ENV}=#{target_identity(env_target)}"
+            end
+
+            explicit_target || env_target || Target.new(assignment_id: nil, scope: nil)
           end
 
           def parse_assignment_target(raw)
@@ -38,6 +46,22 @@ module Ace
             Target.new(assignment_id: assignment_id, scope: scope)
           end
 
+          def env_assignment_target
+            raw = ENV[DEFAULT_TARGET_ENV].to_s.strip
+            return nil if raw.empty?
+
+            parse_assignment_target(raw)
+          end
+
+          def target_identity(target)
+            return "" unless target
+
+            scope = target.scope.to_s.strip
+            return target.assignment_id.to_s if scope.empty?
+
+            "#{target.assignment_id}@#{scope}"
+          end
+
           def build_executor_for_target(target)
             return Organisms::AssignmentExecutor.new unless target.assignment_id
 
@@ -60,45 +84,52 @@ module Ace
               assignment: result[:assignment],
               state: state,
               scoped_state: scoped[:state],
-              current_step: scoped[:current],
+              active_steps: scoped[:active_steps],
+              next_step: scoped[:next_step],
+              focus_step: scoped[:focus_step],
               scope_root: scoped[:root]
             )
           end
 
           def scoped_status_view(state, scope)
-            return {state: state, current: state.current || state.next_workable, root: nil} if scope.nil? || scope.strip.empty?
+            if scope.nil? || scope.strip.empty?
+              active_steps = state.active_steps
+              next_step = active_steps.empty? ? state.next_workable : nil
+              return {state: state, active_steps: active_steps, next_step: next_step, focus_step: state.current || next_step, root: nil}
+            end
 
             root = state.find_by_number(scope.strip)
             raise StepErrors::NotFound, "Step #{scope} not found in queue" unless root
 
             scoped_steps = state.subtree_steps(root.number)
             scoped_state = Models::QueueState.new(steps: scoped_steps, assignment: state.assignment)
-            current = scoped_state.current || scoped_state.next_workable
+            active_steps = scoped_state.active_steps
+            next_step = active_steps.empty? ? state.next_workable_in_subtree(root.number) : nil
 
-            {state: scoped_state, current: current, root: root.number}
+            {state: scoped_state, active_steps: active_steps, next_step: next_step, focus_step: scoped_state.current || next_step, root: root.number}
           end
 
-          def fork_scope_root(state, current_step)
-            return nil unless current_step
-            return current_step if current_step.fork?
+          def fork_scope_root(state, step)
+            return nil unless step
+            return step if step.fork?
 
-            state.nearest_fork_ancestor(current_step.number)
+            state.nearest_fork_ancestor(step.number)
           end
 
-          def scoped_fork_metadata_step(state, current_step, scope, scope_root)
-            return nil unless current_step
+          def scoped_fork_metadata_step(state, step, scope, scope_root)
+            return nil unless step
 
             if scope && !scope.strip.empty?
               return state.find_by_number(scope_root || scope.strip)
             end
 
-            fork_scope_root(state, current_step)
+            fork_scope_root(state, step)
           end
 
-          def effective_fork_provider_for(current_step, scoped_fork_step)
-            return nil unless current_step
+          def effective_fork_provider_for(step, scoped_fork_step)
+            return nil unless step
 
-            provider = current_step.fork_provider || scoped_fork_step&.fork_provider
+            provider = step.fork_provider || scoped_fork_step&.fork_provider
             provider.to_s.strip.empty? ? nil : provider
           end
         end

data/lib/ace/assign/cli/commands/create.rb

@@ -32,7 +32,7 @@ module Ace
             unless options[:quiet]
               print_terminal_skip_summary(result[:skipped_terminal])
               print_assignment_header(result[:assignment])
-              print_step_instructions(result[:current])
+              print_step_instructions(result[:current] || result[:state]&.next_workable)
             end
           end
 

data/lib/ace/assign/cli/commands/fail.rb

@@ -21,7 +21,7 @@ module Ace
 
             target = resolve_assignment_target(options)
             executor = build_executor_for_target(target)
-            result = executor.fail(message)
+            result = executor.fail(message, fork_root: target.scope)
 
             unless options[:quiet]
               failed = result[:failed]

data/lib/ace/assign/cli/commands/finish.rb

@@ -4,12 +4,12 @@ module Ace
   module Assign
     module CLI
       module Commands
-        # Complete in-progress step with report content
+        # Complete active step with report content
         class Finish < Ace::Support::Cli::Command
           include Ace::Support::Cli::Base
           include AssignmentTarget
 
-          desc "Complete in-progress step with report content"
+          desc "Complete active step with report content"
 
           argument :step, required: false, desc: "Step number to finish (active assignment only)"
           option :message, aliases: ["-m"], desc: "Report content: string, file path, or pipe stdin"
@@ -41,9 +41,23 @@ module Ace
             report_path = File.join(assignment.reports_dir, report_filename)
             puts "Report saved to: #{report_path}"
 
-            if result[:current]
-              puts "Advancing to step #{result[:current].number}: #{result[:current].name}"
-              puts "Next: ace-assign step#{step_target_suffix(result[:current].number, options[:assignment])}"
+            scoped_state = if target.scope && !target.scope.to_s.strip.empty?
+              Ace::Assign::Models::QueueState.new(
+                steps: result[:state].subtree_steps(target.scope.strip),
+                assignment: assignment
+              )
+            else
+              result[:state]
+            end
+
+            active_steps = scoped_state.active_steps
+            if active_steps.any?
+              focused = scoped_state.current
+              puts "Active steps remaining: #{active_steps.map { |step| "#{step.number} #{step.name}" }.join(', ')}"
+              puts "Next: ace-assign step#{step_target_suffix(focused.number, options[:assignment])}" if focused
+            elsif (next_step = next_pending_step(result[:state], scoped_state, target.scope))
+              puts "No active step selected."
+              puts "Next pending step: #{next_step.number} - #{next_step.name}"
             else
               fork_root = target.scope&.strip
               if fork_root && result[:state].subtree_complete?(fork_root)
@@ -84,6 +98,13 @@ module Ace
 
             %( #{step_number} --assignment "#{assignment_target}")
           end
+
+          def next_pending_step(state, scoped_state, scope_root)
+            scope_ref = scope_root.to_s.strip
+            return scoped_state.next_workable if scope_ref.empty?
+
+            state.next_workable_in_subtree(scope_ref)
+          end
         end
       end
     end

data/lib/ace/assign/cli/commands/fork_run.rb

@@ -22,6 +22,7 @@ module Ace
           option :cli_args, desc: "Extra CLI args for provider process"
           option :timeout, type: :integer, desc: "Execution timeout in seconds"
           option :launch_mode, desc: "Launch mode: auto, headless, or tmux"
+          option :callback, type: :boolean, default: false, desc: "Capture the origin tmux pane and let the forked agent send a final callback message there"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
 
@@ -41,36 +42,35 @@ module Ace
             root_step = resolve_root_step(state, current, options[:root], target.scope)
             ensure_root_is_fork!(root_step)
             resolved_provider = resolved_provider_for(root_step, options[:provider])
+            resolved_launch_mode = resolved_launch_mode_for(root_step, options[:launch_mode])
+            callback_pane = resolve_callback_pane(options[:callback], resolved_launch_mode)
 
             if state.subtree_complete?(root_step.number)
               puts "Subtree #{root_step.number} is already complete." unless options[:quiet]
               return
             end
 
+            ensure_not_same_scoped_refork!(assignment_id: assignment.id, fork_root: root_step.number)
+
             unless options[:quiet]
               next_step = state.next_workable_in_subtree(root_step.number)
               puts "Starting fork subtree execution: #{root_step.number} - #{root_step.name}"
               puts "Assignment: #{assignment.id}"
               puts "Provider: #{resolved_provider}"
-              puts "Launch mode: #{options[:launch_mode] || Molecules::ForkSessionLauncher::DEFAULT_LAUNCH_MODE}"
+              puts "Launch mode: #{resolved_launch_mode}"
+              puts "Callback pane: #{callback_pane}" if callback_pane
               puts "Timeout: #{options[:timeout] || Ace::Assign.config.dig("execution", "timeout") || Molecules::ForkSessionLauncher::DEFAULT_TIMEOUT}s"
               puts "Next step: #{next_step.number} - #{next_step.name}" if next_step
             end
 
-            active_in_subtree = state.in_progress_in_subtree(root_step.number)
-            if active_in_subtree.size > 1
-              active_refs = active_in_subtree.map { |step| "#{step.number}(#{step.name})" }.join(", ")
-              raise StepErrors::InvalidState, "Cannot fork-run subtree #{root_step.number}: multiple steps are already in progress (#{active_refs})."
+            if state.active_branch_conflict_in_subtree?(root_step.number)
+              active_refs = state.active_in_subtree(root_step.number).map { |step| "#{step.number}(#{step.name})" }.join(", ")
+              raise StepErrors::InvalidState, "Cannot fork-run subtree #{root_step.number}: multiple active branches already exist (#{active_refs})."
             end
 
-            # Mark the next workable step as in_progress only when no subtree step is active.
-            # For leaf fork roots, this activates the root itself.
-            if active_in_subtree.empty?
-              first_workable = state.next_workable_in_subtree(root_step.number)
-              if first_workable
-                step_writer = Molecules::StepWriter.new
-                step_writer.mark_in_progress(first_workable.file_path)
-              end
+            if root_step.status == :pending
+              step_writer = Molecules::StepWriter.new
+              step_writer.mark_active(root_step.file_path)
             end
 
             launch_result = launcher.launch(
@@ -80,10 +80,16 @@ module Ace
               cli_args: options[:cli_args],
               timeout: options[:timeout],
               cache_dir: assignment.cache_dir,
-              launch_mode: options[:launch_mode]
+              launch_mode: resolved_launch_mode,
+              callback_pane: callback_pane
             )
             record_fork_pid_info(root_step, launch_result)
 
+            if callback_pane
+              puts "Fork subtree #{root_step.number} launched in callback mode." unless options[:quiet]
+              return
+            end
+
             refreshed = executor.status
             refreshed_state = refreshed[:state]
 
@@ -94,7 +100,7 @@ module Ace
             end
 
             unless refreshed_state.subtree_complete?(root_step.number)
-              active = refreshed_state.in_progress_in_subtree(root_step.number).first || refreshed_state.current
+              active = refreshed_state.current_in_subtree(root_step.number) || refreshed_state.current
               active_msg = active ? " Current step: #{active.number} (#{active.name})." : ""
               last_msg = read_last_message(assignment.cache_dir, root_step.number)
               stall_reason = build_stall_reason(last_msg)
@@ -176,10 +182,10 @@ module Ace
             end
 
             # Fallback for legacy behavior when no root is explicitly scoped.
-            raise Error, "No current step. Use --root <step-number> or --assignment <id>@<step-number>." unless current
+            raise Error, "No active step. Use --root <step-number> or --assignment <id>@<step-number>." unless current
 
             root = state.nearest_fork_ancestor(current.number)
-            raise Error, "Current step is not in a forked subtree. Provide --root or --assignment <id>@<step-number>." unless root
+            raise Error, "Active step is not in a forked subtree. Provide --root or --assignment <id>@<step-number>." unless root
 
             root
           end
@@ -197,6 +203,39 @@ module Ace
             root_step.fork_provider || Ace::Assign.config.dig("execution", "provider") || Molecules::ForkSessionLauncher::DEFAULT_PROVIDER
           end
 
+          def ensure_not_same_scoped_refork!(assignment_id:, fork_root:)
+            return unless Molecules::ForkSessionLauncher.same_scoped_refork?(
+              assignment_id: assignment_id,
+              fork_root: fork_root
+            )
+
+            raise Error,
+              "Cannot fork-run subtree #{assignment_id}@#{fork_root}: already running inside that scoped subtree. Continue inline instead of calling fork-run again."
+          end
+
+          def resolved_launch_mode_for(root_step, cli_launch_mode)
+            explicit = cli_launch_mode&.to_s&.strip
+            return explicit unless explicit.nil? || explicit.empty?
+
+            root_step.fork_mode ||
+              Ace::Assign.config.dig("execution", "launch_mode") ||
+              Molecules::ForkSessionLauncher::DEFAULT_LAUNCH_MODE
+          end
+
+          def resolve_callback_pane(callback_enabled, launch_mode)
+            return nil unless callback_enabled
+
+            unless launch_mode == "tmux"
+              raise Error, "--callback requires tmux launch mode so the origin pane can be addressed."
+            end
+
+            pane = launcher.respond_to?(:callback_pane) ? launcher.callback_pane : nil
+            pane = pane.to_s.strip
+            raise Error, "--callback requires a resolvable origin tmux pane." if pane.empty?
+
+            pane
+          end
+
           def record_fork_pid_info(root_step, launch_result)
             pid_info = launch_result.is_a?(Hash) ? launch_result[:fork_pid_info] : nil
             return unless pid_info

data/lib/ace/assign/cli/commands/list.rb

@@ -93,7 +93,7 @@ module Ace
             # Header
             puts format(
               "%-#{COL_ID}s %-#{COL_NAME}s %-#{COL_STATUS}s %-#{COL_PROGRESS}s %-#{COL_STEP}s %s",
-              "ID", "NAME", "STATUS", "PROGRESS", "CURRENT STEP", "UPDATED"
+              "ID", "NAME", "STATUS", "PROGRESS", "ACTIVE/NEXT", "UPDATED"
             )
             puts "-" * 95
 
@@ -104,7 +104,7 @@ module Ace
 
               name_display = truncate(info.name.to_s, COL_NAME - 1)
               state_display = STATE_LABELS[info.state] || info.state.to_s
-              step_display = truncate(info.current_step, COL_STEP - 1)
+              step_display = truncate(info.step_focus, COL_STEP - 1)
               updated_display = format_relative_time(info.updated_at)
 
               puts format(
@@ -130,7 +130,8 @@ module Ace
                 name: info.name,
                 state: info.state.to_s,
                 progress: info.progress,
-                current_step: info.current_step,
+                active_steps: info.active_steps.map(&:name),
+                next_step: info.next_step&.name,
                 updated_at: info.updated_at.iso8601,
                 is_current: info.id == current_id
               }

data/lib/ace/assign/cli/commands/retry_cmd.rb

@@ -19,7 +19,7 @@ module Ace
           def call(step_ref:, **options)
             target = resolve_assignment_target(options)
             executor = build_executor_for_target(target)
-            result = executor.retry_step(step_ref)
+            result = executor.retry_step(step_ref, fork_root: target.scope)
 
             unless options[:quiet]
               retry_step = result[:retry]

data/lib/ace/assign/cli/commands/status.rb

@@ -13,7 +13,7 @@ module Ace
 
           STATUS_ICONS = {
             done: "✓ Done",
-            in_progress: "▶ Active",
+            active: "▶ Active",
             pending: "○ Pending",
             failed: "✗ Failed"
           }.freeze
@@ -51,9 +51,8 @@ module Ace
             return if options[:quiet]
 
             if options[:format] == "json"
-              scoped_fork_step = scoped_fork_metadata_step(view.state, view.current_step, target.scope, view.scope_root)
               puts JSON.pretty_generate(
-                status_to_h(view.assignment, view.scoped_state, view.current_step, scoped_fork_step: scoped_fork_step)
+                status_to_h(view.assignment, view.scoped_state, view.active_steps, view.next_step, target: target, scope_root: view.scope_root)
               )
               return
             end
@@ -64,7 +63,7 @@ module Ace
 
             case mode
             when "progress"
-              puts progress_summary_line(view.assignment, view.scoped_state, view.current_step)
+              puts progress_summary_line(view.assignment, view.scoped_state, view.active_steps, view.next_step)
             when "full"
               print_full_status(view, target, flat: options[:flat], include_completed: options[:all])
             else
@@ -83,20 +82,20 @@ module Ace
             mode
           end
 
-          def status_to_h(assignment, state, current_step, scoped_fork_step: nil)
-            {
+          def status_to_h(assignment, state, active_steps, next_step, target:, scope_root:)
+            payload = {
               assignment: {
                 id: assignment.id,
                 name: assignment.name,
                 state: state.assignment_state.to_s
               },
               steps: state.steps.map { |step| step_to_h(step) },
-              current_step: step_to_h(
-                current_step,
-                effective_fork_provider: effective_fork_provider_for(current_step, scoped_fork_step)
-              ),
+              active_steps: active_steps.map { |step| step_to_h(step, effective_fork_provider: effective_fork_provider_for(step, scoped_fork_metadata_step(state, step, target.scope, scope_root))) },
               progress: "#{state.done.size}/#{state.size} done"
             }
+
+            payload[:next_step] = step_to_h(next_step, effective_fork_provider: effective_fork_provider_for(next_step, scoped_fork_metadata_step(state, next_step, target.scope, scope_root))) if active_steps.empty? && next_step
+            payload
           end
 
           def step_to_h(step, effective_fork_provider: nil)
@@ -120,7 +119,7 @@ module Ace
 
           def print_compact_status(view, target, include_completed:)
             lines = []
-            lines.concat(compact_summary_lines(view.assignment, view.scoped_state, view.current_step))
+            lines.concat(compact_summary_lines(view.assignment, view.scoped_state, view.active_steps, view.next_step))
 
             unless target.assignment_id
               other_line = compact_other_assignments_line(view.assignment.id, include_completed: include_completed)
@@ -130,9 +129,9 @@ module Ace
             puts lines.take(10).join("\n")
           end
 
-          def compact_summary_lines(assignment, state, current_step)
+          def compact_summary_lines(assignment, state, active_steps, next_step)
             lines = [
-              compact_assignment_line(assignment, state, current_step),
+              compact_assignment_line(assignment, state, active_steps, next_step),
               compact_last_done_line(state)
             ]
 
@@ -148,14 +147,16 @@ module Ace
             lines
           end
 
-          def progress_summary_line(assignment, state, current_step)
+          def progress_summary_line(assignment, state, active_steps, next_step)
             state_label = STATE_LABELS[state.assignment_state] || state.assignment_state.to_s
             details = ["State: #{state_label}", "Progress: #{state.done.size}/#{state.size} done"]
 
-            if current_step
-              details << "Current: #{current_step.number} #{current_step.name}"
+            if active_steps.any?
+              details << "Active: #{step_refs(active_steps)}"
+            elsif next_step
+              details << "Next: #{next_step.number} #{next_step.name}"
             elsif state.complete?
-              details << "Current: complete"
+              details << "Next: complete"
             end
 
             if state.last_done
@@ -165,12 +166,14 @@ module Ace
             details.join(" | ")
           end
 
-          def compact_assignment_line(assignment, state, current_step)
+          def compact_assignment_line(assignment, state, active_steps, next_step)
             state_label = STATE_LABELS[state.assignment_state] || state.assignment_state.to_s
             details = ["Assignment: #{assignment.id}  #{compact_assignment_name(assignment.name)}", "Status: #{state_label}"]
 
-            if current_step
-              details << "Current: #{current_step.number} #{current_step.name}"
+            if active_steps.any?
+              details << "Active: #{step_refs(active_steps)}"
+            elsif next_step
+              details << "Next: #{next_step.number} #{next_step.name}"
             end
             details.join(" | ")
           end
@@ -191,7 +194,7 @@ module Ace
           end
 
           def compact_preview(state)
-            active_or_pending = state.steps.select { |step| %i[in_progress pending].include?(step.status) }.first(PREVIEW_LIMIT)
+            active_or_pending = state.steps.select { |step| %i[active pending].include?(step.status) }.first(PREVIEW_LIMIT)
             return ["Pending steps:", active_or_pending] unless active_or_pending.empty?
 
             failed_preview = state.failed.first(PREVIEW_LIMIT)
@@ -202,7 +205,7 @@ module Ace
 
           def preview_step_line(step)
             status = case step.status
-            when :in_progress then "active"
+            when :active then "active"
             when :pending then "next"
             when :failed then "failed"
             else step.status.to_s
@@ -229,21 +232,43 @@ module Ace
             "other assignments: #{others.size} total | active: #{active} paused: #{pending} failed: #{failed}"
           end
 
+          def step_refs(steps, limit: 3)
+            refs = steps.first(limit).map { |step| "#{step.number} #{step.name}" }
+            refs << "+#{steps.size - limit} more" if steps.size > limit
+            refs.join(" | ")
+          end
+
           def print_full_status(view, target, flat:, include_completed:)
             print_queue_status(view.assignment, view.scoped_state, flat: flat, root_number: view.scope_root)
 
-            if view.current_step
-              scoped_fork_step = scoped_fork_metadata_step(view.state, view.current_step, target.scope, view.scope_root)
+            if view.active_steps.any?
+              puts
+              puts "Active Steps:"
+              view.active_steps.each do |step|
+                puts "  #{step.number} - #{step.name}"
+              end
+
+              if view.focus_step
+                scoped_fork_step = scoped_fork_metadata_step(view.state, view.focus_step, target.scope, view.scope_root)
+
+                puts
+                puts "Focused Step: #{view.focus_step.number} - #{view.focus_step.name}"
+                puts "Focused Status: #{view.focus_step.status}"
+                print_stall_details(view.focus_step)
+                puts "Workflow: #{view.focus_step.workflow}" if view.focus_step.workflow
+                puts "Skill: #{view.focus_step.skill}" if !view.focus_step.workflow && view.focus_step.skill
+                puts "Context: #{view.focus_step.context}" if view.focus_step.context
+
+                effective_fork_provider = effective_fork_provider_for(view.focus_step, scoped_fork_step)
+                puts "Fork Provider: #{effective_fork_provider}" if effective_fork_provider
+                print_scoped_fork_pid_info(scoped_fork_step)
+              end
+            elsif view.next_step
+              scoped_fork_step = scoped_fork_metadata_step(view.state, view.next_step, target.scope, view.scope_root)
 
               puts
-              puts "Current Step: #{view.current_step.number} - #{view.current_step.name}"
-              puts "Current Status: #{view.current_step.status}"
-              print_stall_details(view.current_step)
-              puts "Workflow: #{view.current_step.workflow}" if view.current_step.workflow
-              puts "Skill: #{view.current_step.skill}" if !view.current_step.workflow && view.current_step.skill
-              puts "Context: #{view.current_step.context}" if view.current_step.context
-
-              effective_fork_provider = effective_fork_provider_for(view.current_step, scoped_fork_step)
+              puts "Next Step: #{view.next_step.number} - #{view.next_step.name}"
+              effective_fork_provider = effective_fork_provider_for(view.next_step, scoped_fork_step)
               puts "Fork Provider: #{effective_fork_provider}" if effective_fork_provider
               print_scoped_fork_pid_info(scoped_fork_step)
             elsif view.scoped_state.complete?
@@ -397,12 +422,13 @@ module Ace
             col_progress = 10
             col_step = 20
             puts format("%-#{col_id}s %-#{col_status}s %-#{col_progress}s %-#{col_step}s %s",
-              "ASSIGNMENT", "STATUS", "PROGRESS", "CURRENT STEP", "UPDATED")
+              "ASSIGNMENT", "STATUS", "PROGRESS", "ACTIVE/NEXT", "UPDATED")
 
             others.each do |info|
               state_label = STATE_LABELS[info.state] || info.state.to_s
               updated = format_relative_time(info.updated_at)
-              step = info.current_step.length > col_step ? "#{info.current_step[0..col_step - 4]}..." : info.current_step
+              step = info.step_focus
+              step = step.length > col_step ? "#{step[0..col_step - 4]}..." : step
               puts format("%-#{col_id}s %-#{col_status}s %-#{col_progress}s %-#{col_step}s %s",
                 info.id, state_label, info.progress, step, updated)
             end