ace-assign 0.40.4 → 0.41.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57ddb4c863b212f5f2feecfa72e3bab99d72f0a6d966119d23b143c2560ca701
-  data.tar.gz: e2bfc1d384919fa858916ea1e9ba549804be537f8010488fcdb930d3097f37d2
+  metadata.gz: 4fe983fae430fd751bcb94ffb6138e7ca3abc91bbde8daf00f7de512a5eaa65a
+  data.tar.gz: 156f73f37951578ea97aa0a6bd0b7622b3f9a4e71f6fa9aea5b4f60f21ed4623
 SHA512:
-  metadata.gz: b9c9664ddb85d5726d33a244bf20b82d60a4cf5e3a4a2c4e19c87e2a2320f917bbb986e8df0723ff484f35374db7852ee9ea0ed9cbd43c03dc1acbe1ff08da7b
-  data.tar.gz: e5156d636e12c0da91dfde3c225fe5c41a703f86897405e7cb1aa7044f15e21cfa0435086aa63790669d8488f7a4d748ce2de60055a92415677a469f8ffa8bcf
+  metadata.gz: 8e6306caa8bfc6218caeb776278b384c9db47751273ea0ff0713ca05d25da18a52c31410eab38a2f82777e26b6771927bb5c6919da62f9d870cfcc972e04323c
+  data.tar.gz: 6245400297bf3c41329c5abaee36a57d440c4ae90a042d3134051120956affca84a3b00b9ba653ef313c4a0f034209185f26ea860ab9f7ca8848068d0ea12182

data/.ace-defaults/assign/catalog/steps/squash-changelog.step.yml

@@ -23,6 +23,7 @@ context:
 when_to_skip:
   - "There is only one relevant changelog entry"
   - "Changelog has already been consolidated for this branch"
+  - "Root changelog entries are under [Unreleased] (no versioned entries to squash)"
 
 effort: trivial
 tags: [docs, changelog, release]

data/CHANGELOG.md

@@ -7,11 +7,56 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.41.4] - 2026-03-29
+
+### Technical
+- Added `when_to_skip` entry for unreleased-mode branches to the `squash-changelog` catalog step.
+
+## [0.41.3] - 2026-03-29
+
+### Changed
+- Reused one resolved provider value in `ace-assign fork-run` for both runtime display and launcher execution flow.
+
+### Technical
+- Clarified inline documentation of intentional fork-context merge semantics in `AssignmentExecutor` (`=` overwrite for generated children, `||=` default-preserve for materialized explicit steps).
+
+## [0.41.2] - 2026-03-29
+
+### Fixed
+- Updated scoped `ace-assign status` output (text and JSON `current_step`) to show the effective fork provider inherited from the scoped fork root when the active child has no local provider.
+- Removed unreachable symbol-key provider fallback in `Step#fork_provider` now that fork options are normalized to string keys.
+
+### Technical
+- Added scoped status regression tests covering fork-provider display/serialization for fork-root scope (`@010`) with active child steps.
+- Documented intentional fork-context propagation semantics in `AssignmentExecutor` (generated child-step overwrite vs explicit-step default-preserve behavior).
+
+## [0.41.1] - 2026-03-29
+
+### Fixed
+- Preserved catalog `context.fork` provider overrides for explicit `skill`-backed step materialization so step-level fork provider precedence is applied correctly.
+- Kept fork child-step behavior stable by avoiding implicit fork-context propagation from canonical metadata when children do not explicitly declare fork context.
+
+### Technical
+- Added regression coverage for explicit `skill` and explicit `workflow` materialization paths to ensure catalog fork overrides are retained.
+
+## [0.41.0] - 2026-03-28
+
+### Added
+- Added per-step fork provider overrides via step frontmatter `fork.provider`.
+- Added `fork_provider` exposure in `ace-assign status` current-step output and `--format json` payloads.
+
+### Changed
+- Updated `ace-assign fork-run` provider precedence to: CLI `--provider` > step `fork.provider` > config `execution.provider` > default.
+- Extended skill/catalog step materialization to carry `context.fork` options into generated step metadata.
+
+### Technical
+- Added coverage for step model/parser/scanner fork-option round-trip, fork-run provider precedence, status serialization/display, and executor composition behavior.
+- Updated usage and fork-context docs with `fork.provider` examples and precedence rules.
 
 ## [0.40.4] - 2026-03-29
 
 ### Fixed
-- **ace-assign v0.40.4**: Bumped dependency constraints to currently available `~>` ranges on RubyGems and updated release metadata after dependency synchronization.
+- Bumped dependency constraints to currently available `~>` ranges on RubyGems and updated release metadata after dependency synchronization.
 
 ## [0.40.3] - 2026-03-27
 

data/README.md

@@ -78,7 +78,7 @@ The easiest way to start is through [ace-overseer](../ace-overseer) -- define a
 
 **Define assignments from presets** - pick a [preset](.ace-defaults/assign/presets/) like [`work-on-task`](.ace-defaults/assign/presets/work-on-task.yml) or `release-only`, pass parameters (task refs, packages), and run `ace-assign create --task ...` or [`ace-assign create --yaml ...`](docs/usage.md) to expand them into a concrete step queue. Steps are defined in the [catalog](.ace-defaults/assign/catalog/steps/) (e.g., [`work-on-task.step.yml`](.ace-defaults/assign/catalog/steps/work-on-task.step.yml)) and ordered by [composition rules](.ace-defaults/assign/catalog/composition-rules.yml). Compose custom assignments with `/as-assign-compose`.
 
-**Run with orchestrator and fork agents** - use `/as-assign-drive` to walk through steps, forking long-running work (implementation, review, release) to isolated agent subprocesses with configurable [execution defaults](.ace-defaults/assign/config.yml). Forks can run sequentially or as parallel batches, each producing inspectable traces and session reports under `.ace-local/assign/`.
+**Run with orchestrator and fork agents** - use `/as-assign-drive` to walk through steps, forking long-running work (implementation, review, release) to isolated agent subprocesses with configurable [execution defaults](.ace-defaults/assign/config.yml) or per-step `fork.provider` overrides. Forks can run sequentially or as parallel batches, each producing inspectable traces and session reports under `.ace-local/assign/`.
 
 **Recover from failure without losing history** - keep failed-step lineage intact, inject targeted retries or fix steps, and continue execution with auditable failure evidence.
 

data/docs/demo/fork-provider.tape.yml

@@ -0,0 +1,34 @@
+---
+description: Show per-step fork provider — different steps run with different LLM models
+tags:
+- ace-assign
+- fork
+- provider
+settings:
+  font_size: 16
+  width: 1000
+  height: 500
+  format: gif
+setup:
+- sandbox
+- git-init
+- copy-fixtures
+scenes:
+- name: Show step frontmatter with fork.provider
+  commands:
+  - type: "cat .ace-local/assign/demoXx/steps/020-implement.st.md"
+    sleep: 4s
+- name: Status shows per-step Fork Provider
+  commands:
+  - type: clear
+    sleep: 1s
+  - type: "ace-assign status"
+    sleep: 4s
+- name: fork-run resolves step provider
+  commands:
+  - type: clear
+    sleep: 1s
+  - type: "ace-assign fork-run --root 020 --dry-run"
+    sleep: 4s
+teardown:
+- cleanup

data/docs/usage.md

@@ -171,6 +171,25 @@ Options:
 - `--quiet, -q`
 - `--debug, -d`
 
+Provider resolution precedence for fork execution:
+
+1. CLI `--provider`
+2. Step frontmatter `fork.provider`
+3. Config `execution.provider`
+4. Built-in default provider
+
+Step-level example:
+
+```yaml
+---
+name: research
+status: pending
+context: fork
+fork:
+  provider: "claude:sonnet@yolo"
+---
+```
+
 ### `ace-assign list`
 
 List assignments.

data/handbook/guides/fork-context.g.md

@@ -13,6 +13,23 @@ ace-docs:
 
 Fork context enables step files to run in isolated agent contexts using the Task tool. When a step has `context: fork` in its frontmatter, ace-assign outputs instructions for the orchestrating agent to execute the step via a subagent.
 
+You can also set a per-step provider override with `fork.provider`:
+
+```yaml
+---
+context: fork
+fork:
+  provider: "claude:sonnet@yolo"
+---
+```
+
+Provider precedence during `ace-assign fork-run`:
+
+1. CLI `--provider`
+2. Step `fork.provider`
+3. Assign config `execution.provider`
+4. Built-in default
+
 For hierarchical split workflows, use **parent-only** fork markers:
 - Split parent step: `context: fork`
 - Child steps (`onboard-base`, `task-load`, `plan-task`, `work-on-task`, `verify-test`, `release-minor`): no `context: fork`
@@ -228,4 +245,4 @@ ACE_DEBUG=1 ace-assign status
 
 - [ace-assign README](../../README.md) - Main documentation
 - [Work Queue Model](../workflow-instructions/drive-assignment.wf.md) - Assignment management
-- `ace-assign fork-run --root <step> --assignment <id>` - Prepare subtree-scoped fork session
+- `ace-assign fork-run --root <step> --assignment <id>` - Prepare subtree-scoped fork session

data/lib/ace/assign/atoms/step_file_parser.rb

@@ -56,6 +56,7 @@ module Ace
             parallel: parse_boolean(fm["parallel"]),
             max_parallel: parse_positive_integer(fm["max_parallel"]),
             fork_retry_limit: parse_non_negative_integer(fm["fork_retry_limit"]),
+            fork_options: parse_hash(fm["fork"]),
             started_at: parse_time(fm["started_at"]),
             completed_at: parse_time(fm["completed_at"]),
             fork_launch_pid: parse_integer(fm["fork_launch_pid"]),
@@ -174,6 +175,16 @@ module Ace
         end
         private_class_method :parse_integer_array
 
+        def self.parse_hash(value)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.each_with_object({}) do |(key, val), memo|
+            memo[key.to_s] = val
+          end
+          normalized.empty? ? nil : normalized
+        end
+        private_class_method :parse_hash
+
         def self.parse_boolean(value)
           return nil if value.nil?
           return value if value == true || value == false

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

@@ -39,6 +39,7 @@ 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])
 
             if state.subtree_complete?(root_step.number)
               puts "Subtree #{root_step.number} is already complete." unless options[:quiet]
@@ -49,7 +50,7 @@ module Ace
               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: #{options[:provider] || Ace::Assign.config.dig("execution", "provider") || Molecules::ForkSessionLauncher::DEFAULT_PROVIDER}"
+              puts "Provider: #{resolved_provider}"
               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
@@ -73,7 +74,7 @@ module Ace
             launch_result = launcher.launch(
               assignment_id: assignment.id,
               fork_root: root_step.number,
-              provider: options[:provider],
+              provider: resolved_provider,
               cli_args: options[:cli_args],
               timeout: options[:timeout],
               cache_dir: assignment.cache_dir
@@ -186,6 +187,13 @@ module Ace
             raise Error, "Step #{root_step.number} is not fork-enabled (context: fork missing)."
           end
 
+          def resolved_provider_for(root_step, cli_provider)
+            explicit = cli_provider&.to_s&.strip
+            return explicit unless explicit.nil? || explicit.empty?
+
+            root_step.fork_provider || Ace::Assign.config.dig("execution", "provider") || Molecules::ForkSessionLauncher::DEFAULT_PROVIDER
+          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/status.rb

@@ -72,7 +72,8 @@ module Ace
 
             unless options[:quiet]
               if options[:format] == "json"
-                puts JSON.pretty_generate(status_to_h(assignment, scoped_state, current_for_display))
+                scoped_fork_step = scoped_fork_metadata_step(state, current_for_display, target.scope, scope_root)
+                puts JSON.pretty_generate(status_to_h(assignment, scoped_state, current_for_display, scoped_fork_step: scoped_fork_step))
                 return
               end
 
@@ -98,6 +99,10 @@ module Ace
                 if current_for_display.context
                   puts "Context: #{current_for_display.context}"
                 end
+                effective_fork_provider = effective_fork_provider_for(current_for_display, scoped_fork_step)
+                if effective_fork_provider
+                  puts "Fork Provider: #{effective_fork_provider}"
+                end
                 puts
                 print_scoped_fork_pid_info(scoped_fork_step)
 
@@ -129,7 +134,7 @@ module Ace
 
           private
 
-          def status_to_h(assignment, state, current_step)
+          def status_to_h(assignment, state, current_step, scoped_fork_step: nil)
             {
               assignment: {
                 id: assignment.id,
@@ -137,12 +142,12 @@ module Ace
                 state: state.assignment_state.to_s
               },
               steps: state.steps.map { |step| step_to_h(step) },
-              current_step: step_to_h(current_step),
+              current_step: step_to_h(current_step, effective_fork_provider: effective_fork_provider_for(current_step, scoped_fork_step)),
               progress: "#{state.done.size}/#{state.size} done"
             }
           end
 
-          def step_to_h(step)
+          def step_to_h(step, effective_fork_provider: nil)
             return nil unless step
 
             {
@@ -152,6 +157,7 @@ module Ace
               skill: step.skill,
               workflow: step.workflow,
               context: step.context,
+              fork_provider: effective_fork_provider || step.fork_provider,
               batch_parent: step.batch_parent,
               parallel: step.parallel,
               max_parallel: step.max_parallel,
@@ -342,6 +348,13 @@ module Ace
             fork_scope_root(state, current_step)
           end
 
+          def effective_fork_provider_for(current_step, scoped_fork_step)
+            return nil unless current_step
+
+            provider = current_step.fork_provider || scoped_fork_step&.fork_provider
+            provider.to_s.strip.empty? ? nil : provider
+          end
+
           def print_scoped_fork_pid_info(step)
             return unless step
 

data/lib/ace/assign/models/step.rb

@@ -25,7 +25,7 @@ module Ace
         attr_reader :number, :name, :status, :instructions, :report, :error,
           :started_at, :completed_at, :added_by, :parent, :file_path, :skill, :context,
           :workflow,
-          :batch_parent, :parallel, :max_parallel, :fork_retry_limit,
+          :batch_parent, :parallel, :max_parallel, :fork_retry_limit, :fork_options,
           :fork_launch_pid, :fork_tracked_pids, :fork_pid_updated_at, :fork_pid_file,
           :stall_reason
 
@@ -46,6 +46,7 @@ module Ace
         # @param parallel [Boolean, nil] Batch scheduling mode hint (true=parallel, false=sequential)
         # @param max_parallel [Integer, nil] Max concurrent children for parallel batches
         # @param fork_retry_limit [Integer, nil] Retry attempts allowed per failed child
+        # @param fork_options [Hash, nil] Fork execution options from frontmatter (e.g. {provider: "..."} )
         # @param fork_launch_pid [Integer, nil] PID of the process that launched the fork run
         # @param fork_tracked_pids [Array<Integer>, nil] Observed subprocess/descendant PIDs during fork execution
         # @param fork_pid_updated_at [Time, nil] Timestamp when fork PID metadata was last updated
@@ -55,6 +56,7 @@ module Ace
           started_at: nil, completed_at: nil, added_by: nil, parent: nil,
           file_path: nil, skill: nil, workflow: nil, context: nil,
           batch_parent: nil, parallel: nil, max_parallel: nil, fork_retry_limit: nil,
+          fork_options: nil,
           fork_launch_pid: nil, fork_tracked_pids: nil, fork_pid_updated_at: nil,
           fork_pid_file: nil, stall_reason: nil)
           validate_status!(status)
@@ -63,6 +65,7 @@ module Ace
           validate_boolean!(:parallel, parallel)
           validate_positive_integer!(:max_parallel, max_parallel)
           validate_non_negative_integer!(:fork_retry_limit, fork_retry_limit)
+          validate_hash!(:fork_options, fork_options)
 
           @number = number.freeze
           @name = name.freeze
@@ -82,6 +85,7 @@ module Ace
           @parallel = parallel.nil? ? nil : !!parallel
           @max_parallel = max_parallel&.to_i
           @fork_retry_limit = fork_retry_limit&.to_i
+          @fork_options = normalize_fork_options(fork_options)
           @fork_launch_pid = fork_launch_pid&.to_i
           @fork_tracked_pids = Array(fork_tracked_pids).map(&:to_i).uniq.sort.freeze
           @fork_pid_updated_at = fork_pid_updated_at
@@ -113,6 +117,16 @@ module Ace
           context == "fork"
         end
 
+        # Resolve per-step provider override from fork options.
+        # @return [String, nil]
+        def fork_provider
+          return nil unless fork_options
+
+          provider = fork_options["provider"]
+          provider = provider.to_s.strip
+          provider.empty? ? nil : provider
+        end
+
         # Get the original step number if this is a retry
         # @return [String, nil] Original step number
         def retry_of
@@ -134,6 +148,7 @@ module Ace
             "parallel" => parallel,
             "max_parallel" => max_parallel,
             "fork_retry_limit" => fork_retry_limit,
+            "fork" => fork_options,
             "started_at" => started_at&.iso8601,
             "completed_at" => completed_at&.iso8601,
             "fork_launch_pid" => fork_launch_pid,
@@ -191,6 +206,24 @@ module Ace
 
           raise ArgumentError, "Invalid #{field_name}: #{value.inspect}. Must be an integer >= 0"
         end
+
+        def validate_hash!(field_name, value)
+          return if value.nil? || value.is_a?(Hash)
+
+          raise ArgumentError, "Invalid #{field_name}: #{value.inspect}. Must be a Hash or nil"
+        end
+
+        def normalize_fork_options(value)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.each_with_object({}) do |(key, val), memo|
+            memo[key.to_s] = val
+          end
+          normalized.compact!
+          return nil if normalized.empty?
+
+          normalized.freeze
+        end
       end
     end
   end

data/lib/ace/assign/molecules/queue_scanner.rb

@@ -88,6 +88,7 @@ module Ace
             parallel: fields[:parallel],
             max_parallel: fields[:max_parallel],
             fork_retry_limit: fields[:fork_retry_limit],
+            fork_options: fields[:fork_options],
             stall_reason: fields[:stall_reason],
             file_path: file_path
           )

data/lib/ace/assign/organisms/assignment_executor.rb

@@ -706,6 +706,14 @@ module Ace
 
             context_default = step_def.dig("context", "default")
             child["context"] = context_default if context_default && parent_context != "fork"
+            fork_context = step_def.dig("context", "fork")
+            if child["context"] == "fork" && fork_context.is_a?(Hash) && !fork_context.empty?
+              # Generated child sub-steps have no explicit frontmatter overrides.
+              # Apply the catalog fork context directly (overwrite semantics) so
+              # delegated children inherit the scheduler/provider policy configured
+              # for that child step type.
+              child["fork"] = fork_context
+            end
           end
 
           child
@@ -844,6 +852,15 @@ module Ace
             "instructions" => rendered_instructions,
             "workflow" => rendering["workflow"]
           )
+          context_default = rendering.dig("context", "default")
+          materialized["context"] ||= context_default if context_default
+          fork_context = rendering.dig("context", "fork")
+          if materialized["context"] == "fork" && fork_context.is_a?(Hash) && !fork_context.empty?
+            # For materialized explicit steps, preserve frontmatter-provided fork config
+            # (`||=` semantics). Rendering contributes defaults only when the step
+            # itself did not declare fork options.
+            materialized["fork"] ||= fork_context
+          end
           materialized["source_skill"] = rendering["source_skill"] || rendering["skill"] if rendering["source_skill"] || rendering["skill"]
           materialized["source_workflow"] = rendering["workflow"] if rendering["workflow"] && !rendering["workflow"].empty?
           materialized.delete("skill")
@@ -866,7 +883,14 @@ module Ace
 
           explicit_skill = step["skill"]&.to_s&.strip
           if explicit_skill && !explicit_skill.empty?
-            return skill_source_resolver.resolve_skill_rendering(explicit_skill)
+            canonical_step = find_step_definition(step["name"]&.to_s)
+            if canonical_step && step["parent"] && !step.key?("context") && !step.key?("fork")
+              canonical_step = canonical_step.dup
+              canonical_step.delete("context")
+              canonical_step.delete("fork")
+            end
+            rendering = skill_source_resolver.resolve_skill_rendering(explicit_skill)
+            return canonical_step ? canonical_step.merge(rendering || {}) : rendering if rendering
           end
 
           skill_source_resolver.resolve_step_rendering(step["name"]&.to_s)

data/lib/ace/assign/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Assign
-    VERSION = '0.40.4'
+    VERSION = "0.41.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ace-assign
 version: !ruby/object:Gem::Version
-  version: 0.40.4
+  version: 0.41.4
 platform: ruby
 authors:
 - Michal Czyz
@@ -221,6 +221,7 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
+- docs/demo/fork-provider.tape.yml
 - docs/exit-codes.md
 - docs/getting-started.md
 - docs/handbook.md