ace-assign 0.42.4 → 0.55.0

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

@@ -21,6 +21,8 @@ module Ace
           option :provider, desc: "LLM provider:model override (e.g., codex:gpt-5, claude:sonnet)"
           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"
 
@@ -40,35 +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: #{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(
@@ -77,10 +79,17 @@ module Ace
               provider: resolved_provider,
               cli_args: options[:cli_args],
               timeout: options[:timeout],
-              cache_dir: assignment.cache_dir
+              cache_dir: assignment.cache_dir,
+              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]
 
@@ -91,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)
@@ -173,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
@@ -194,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/fork_session.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        # Internal command used by tmux-backed fork panes to launch the provider session once.
+        class ForkSession < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Run one provider-backed fork session for a subtree"
+
+          option :assignment, required: true, desc: "Target assignment ID"
+          option :root, required: true, desc: "Fork subtree root step number"
+          option :provider, desc: "LLM provider:model override (e.g., codex:gpt-5, claude:sonnet)"
+          option :cli_args, desc: "Extra CLI args for provider process"
+          option :timeout, type: :integer, desc: "Execution timeout in seconds"
+          option :cache_dir, desc: "Assignment cache directory override"
+          option :last_message_file, desc: "Explicit path for fork last-message capture"
+          option :session_meta_file, desc: "Explicit path for fork session metadata"
+
+          def initialize(launcher: nil)
+            super()
+            @launcher = launcher || Molecules::ForkSessionLauncher.new
+          end
+
+          def call(**options)
+            launcher.launch_provider_session(
+              assignment_id: options[:assignment],
+              fork_root: options[:root],
+              provider: options[:provider],
+              cli_args: options[:cli_args],
+              timeout: options[:timeout],
+              cache_dir: options[:cache_dir],
+              last_message_file: options[:last_message_file],
+              session_meta_file: options[:session_meta_file]
+            )
+
+            0
+          rescue Error, Ace::LLM::Error => e
+            warn e.message
+            1
+          end
+
+          private
+
+          attr_reader :launcher
+        end
+      end
+    end
+  end
+end

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/start.rb

@@ -29,9 +29,15 @@ module Ace
 
             started = result[:started]
             puts "Step #{started.number} (#{started.name}) started"
-            puts
-            puts "Instructions:"
-            puts started.instructions
+            puts "Next: ace-assign step#{step_target_suffix(started.number, options[:assignment])}"
+          end
+
+          private
+
+          def step_target_suffix(step_number, assignment_target)
+            return " #{step_number}" if assignment_target.nil? || assignment_target.to_s.strip.empty?
+
+            %( #{step_number} --assignment "#{assignment_target}")
           end
         end
       end