ace-assign 0.41.10 → 0.53.4

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

@@ -12,15 +12,40 @@ module Ace
       # start → advance → complete (with fail/add/retry branches)
       class AssignmentExecutor
         DEFAULT_DYNAMIC_STEP_INSTRUCTIONS = "Complete this step and finish with: ace-assign finish --message report.md".freeze
+        PROJECT_ROOT_SIGNAL = "project_root".freeze
+        CATALOG_SIGNAL = "catalog".freeze
 
         attr_reader :assignment_manager, :queue_scanner, :step_writer, :step_renumberer, :skill_source_resolver
 
-        def initialize(cache_base: nil)
+        class << self
+          def clear_caches!
+            @cache_store = { step_catalog_cache: {} }
+          end
+
+          def cache_store
+            @cache_store ||= { step_catalog_cache: {} }
+          end
+
+          private
+
+          def cached_value(store_key, key)
+            cache_store[store_key][key]
+          end
+
+          def store_cached_value(store_key, key, value)
+            cache_store[store_key][key] = value
+          end
+        end
+
+        def initialize(cache_base: nil, skill_source_resolver: nil, step_catalog: nil)
           @assignment_manager = Molecules::AssignmentManager.new(cache_base: cache_base)
           @queue_scanner = Molecules::QueueScanner.new
           @step_writer = Molecules::StepWriter.new
-          @skill_source_resolver = Molecules::SkillAssignSourceResolver.new
+          @skill_source_resolver = skill_source_resolver || Molecules::SkillAssignSourceResolver.new
           @step_catalog = nil
+          @step_catalog_from_fixture = step_catalog
+          @step_catalog_from_fixture_set = !step_catalog.nil?
+          @step_catalog_loaded = false
           @step_renumberer = Molecules::StepRenumberer.new(
             step_writer: @step_writer,
             queue_scanner: @queue_scanner
@@ -479,7 +504,11 @@ module Ace
             next step unless step.is_a?(Hash)
 
             sub_steps = step["sub_steps"] || step["sub-steps"]
-            next step if sub_steps.is_a?(Array) && sub_steps.any?
+            if sub_steps.is_a?(Array) && sub_steps.any?
+              explicit = step.dup
+              explicit["sub_steps_origin"] ||= "explicit"
+              next explicit
+            end
 
             assign_config = resolve_step_assign_config(step)
             next step unless assign_config
@@ -487,7 +516,10 @@ module Ace
             resolved_sub_steps = assign_config[:sub_steps]
             next step unless resolved_sub_steps.is_a?(Array) && resolved_sub_steps.any?
 
-            enriched = step.merge("sub_steps" => resolved_sub_steps)
+            enriched = step.merge(
+              "sub_steps" => resolved_sub_steps,
+              "sub_steps_origin" => "inferred"
+            )
             enriched["context"] ||= assign_config[:context] if assign_config[:context]
             enriched
           end
@@ -523,6 +555,7 @@ module Ace
               # Create split parent orchestration node
               parent_context = step["context"] || "fork"
               parent_instructions = step["instructions"]
+              sub_steps_origin = step["sub_steps_origin"] || "explicit"
               parent_step = build_split_parent_step(
                 step: step,
                 parent_number: parent_number,
@@ -540,7 +573,8 @@ module Ace
                   parent_number: parent_number,
                   parent_step: step,
                   parent_instructions: parent_instructions,
-                  parent_context: parent_context
+                  parent_context: parent_context,
+                  sub_steps_origin: sub_steps_origin
                 )
               end
             else
@@ -564,7 +598,10 @@ module Ace
         # @param sub_steps [Array<String>] Declared sub-step names
         # @return [Hash] Parent step config for runtime queue
         def build_split_parent_step(step:, parent_number:, parent_context:, sub_steps:)
-          source_skill = step["skill"]
+          source_skill = step["source_skill"] || step["skill"]
+          if (source_skill.nil? || source_skill.to_s.strip.empty?) && step["source"].to_s.start_with?("skill://")
+            source_skill = step["source"].to_s.delete_prefix("skill://").strip
+          end
           original_text = normalize_instructions(step["instructions"]).strip
           definition = find_step_definition("split-subtree-root") || {}
 
@@ -591,6 +628,7 @@ module Ace
           )
           parent_step.delete("sub_steps")
           parent_step.delete("sub-steps")
+          parent_step.delete("source")
           parent_step.delete("skill")
           parent_step.delete("workflow")
           parent_step["source_skill"] = source_skill if source_skill
@@ -680,8 +718,9 @@ module Ace
         # @param parent_step [Hash] Parent step config
         # @param parent_instructions [String, Array<String>, nil] Parent instructions
         # @param parent_context [String, nil] Parent execution context
+        # @param sub_steps_origin [String] Whether the subtree was declared explicitly or inferred
         # @return [Hash] Child step config
-        def build_child_sub_step(sub_name:, child_number:, parent_number:, parent_step:, parent_instructions:, parent_context:)
+        def build_child_sub_step(sub_name:, child_number:, parent_number:, parent_step:, parent_instructions:, parent_context:, sub_steps_origin: "inferred")
           step_def = find_step_definition(sub_name)
           parent_task_ref = extract_parent_taskref(parent_step, parent_instructions)
           instructions = if step_def&.dig("skill")
@@ -693,16 +732,25 @@ module Ace
             "number" => child_number,
             "name" => sub_name,
             "instructions" => instructions,
-            "parent" => parent_number
+            "parent" => parent_number,
+            "sub_steps_origin" => sub_steps_origin
           }
           child["taskref"] = parent_task_ref if parent_task_ref
 
           if step_def
             child["workflow"] = step_def["workflow"] if step_def["workflow"]
-            child["skill"] = step_def["skill"] if step_def["skill"] && !step_def["workflow"]
+            preserve_explicit_skill = (sub_steps_origin == "explicit")
+            child["skill"] = step_def["skill"] if step_def["skill"] && (preserve_explicit_skill || !step_def["workflow"])
+            child["source"] = if step_def["source"]
+              step_def["source"]
+            elsif step_def["workflow"]
+              step_def["workflow"]
+            elsif step_def["skill"]
+              "skill://#{step_def["skill"]}"
+            end
 
             context_default = step_def.dig("context", "default")
-            child["context"] = context_default if context_default && parent_context != "fork"
+            child["context"] = context_default if context_default && !fork_context_value?(parent_context)
             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.
@@ -799,14 +847,9 @@ module Ace
           when "pre-commit-review"
             pre_commit_review_action_instructions(task_hint: task_hint)
           when "verify-test"
-            "- Identify modified packages#{task_hint}.\n- For each modified package, run: cd <package> && ace-test --profile 6\n- If no package-level code changes are present, mark this step skipped with a clear reason."
+            "- Identify modified packages#{task_hint}.\n- For each modified package, run: cd <package> && ace-test all --profile 6\n- This subtree step verifies modified packages only; do not run the monorepo suite here.\n- If no package-level code changes are present, mark this step skipped with a clear reason."
           when /\Arelease(?:-.+)?\z/
             "- Release all modified packages and update both package and root changelogs.\n- Follow semantic versioning expectations for this step.\n- When auto-detecting packages, include `git diff origin/main...HEAD --name-only` in addition to working-tree state — prior steps may have already committed changes."
-          when "verify-e2e"
-            "- Check change scope: run `git diff origin/main --name-only` to list modified files.\n" \
-            "- **Skip criteria**: If ALL modified files match `*.md`, `*.yml` (non-CI config), `.ace-tasks/**`, or `.ace-retros/**`, skip E2E verification — mark step done with \"skipped: docs/task-spec only changes, no runnable code affected\".\n" \
-            "- Otherwise: detect modified packages, run E2E scenarios for each package with `test/e2e/` scenarios#{task_hint}.\n" \
-            "- If no modified package has E2E scenarios, mark step done with \"skipped: no E2E scenarios for modified packages\"."
           else
             "- Execute the #{sub_name} step."
           end
@@ -849,25 +892,52 @@ 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
+          resolved_source = resolved_step_source(step, rendering)
+          materialized["source"] = resolved_source if resolved_source && !resolved_source.empty?
+          unless split_child_without_explicit_fork?(step)
+            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
           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")
+          materialized.delete("skill") unless preserve_explicit_child_skill?(step)
           materialized
         end
 
         def resolve_step_rendering(step)
+          explicit_source = step["source"]&.to_s&.strip
+          if explicit_source && !explicit_source.empty?
+            canonical_step = find_step_definition_with_source_fallback(step, explicit_source: explicit_source)
+            if canonical_step && split_child_without_explicit_fork?(step)
+              canonical_step = canonical_step.dup
+              canonical_step.delete("context")
+              canonical_step.delete("fork")
+            end
+            source_skill = step["source_skill"]&.to_s&.strip
+            source_skill = canonical_step&.dig("source_skill") if source_skill.nil? || source_skill.empty?
+            rendering = skill_source_resolver.resolve_source_rendering(
+              explicit_source,
+              step_name: step["name"]&.to_s,
+              source_skill: source_skill
+            )
+            return canonical_step ? canonical_step.merge(rendering || {}) : rendering if rendering
+          end
+
           explicit_workflow = step["workflow"]&.to_s&.strip
           if explicit_workflow && !explicit_workflow.empty?
             canonical_step = find_step_definition(step["name"]&.to_s)
+            if canonical_step && split_child_without_explicit_fork?(step)
+              canonical_step = canonical_step.dup
+              canonical_step.delete("context")
+              canonical_step.delete("fork")
+            end
             source_skill = step["source_skill"]&.to_s&.strip
             source_skill = canonical_step&.dig("source_skill") if source_skill.nil? || source_skill.empty?
             rendering = skill_source_resolver.resolve_workflow_rendering(
@@ -893,6 +963,20 @@ module Ace
           skill_source_resolver.resolve_step_rendering(step["name"]&.to_s)
         end
 
+        def split_child_without_explicit_fork?(step)
+          step["parent"] && !step.key?("context") && !step.key?("fork")
+        end
+
+        def preserve_explicit_child_skill?(step)
+          step["parent"] && step["sub_steps_origin"] == "explicit"
+        end
+
+        def fork_context_value?(value)
+          normalized = value.to_s.strip.downcase
+          normalized = normalized.delete_prefix(":")
+          normalized == "fork"
+        end
+
         def render_skill_backed_step_instructions(step:, rendering:)
           if step_render_mode(rendering) == "step_template"
             return render_step_template_instructions(step: step, rendering: rendering)
@@ -1006,6 +1090,15 @@ module Ace
         end
 
         def resolve_step_assign_config(step)
+          source_ref = step["source"]&.to_s&.strip
+          if source_ref && !source_ref.empty?
+            return skill_source_resolver.resolve_source_assign_config(
+              source_ref,
+              step_name: step["name"]&.to_s,
+              source_skill: step["source_skill"]&.to_s
+            )
+          end
+
           explicit_workflow = step["workflow"]&.to_s&.strip
           if explicit_workflow && !explicit_workflow.empty?
             return skill_source_resolver.resolve_workflow_assign_config(
@@ -1086,30 +1179,120 @@ module Ace
           Atoms::CatalogLoader.find_by_name(step_catalog, step_name)
         end
 
+        def find_step_definition_with_source_fallback(step, explicit_source:)
+          step_name = step["name"]&.to_s
+          canonical_step = find_step_definition(step_name)
+          return canonical_step if canonical_step
+
+          source = explicit_source.to_s.strip
+          return nil if source.empty?
+
+          source_skill = step["source_skill"]&.to_s&.strip
+          source_skill = source.delete_prefix("skill://").strip if source_skill.to_s.empty? && source.start_with?("skill://")
+
+          step_catalog.find do |entry|
+            next unless entry.is_a?(Hash)
+
+            entry_source = entry["source"]&.to_s&.strip
+            entry_workflow = entry["workflow"]&.to_s&.strip
+            entry_source_skill = entry["source_skill"]&.to_s&.strip
+            entry_skill = entry["skill"]&.to_s&.strip
+
+            next true if entry_source == source || entry_workflow == source
+            next true if !source_skill.to_s.empty? && (entry_source_skill == source_skill || entry_skill == source_skill)
+
+            false
+          end
+        end
+
         # Load step catalog from project override or gem defaults.
         #
         # @return [Array<Hash>] Loaded step definitions
         def step_catalog
-          @step_catalog ||= begin
-            project_root = Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
-            gem_root = Gem.loaded_specs["ace-assign"]&.gem_dir || File.expand_path("../../../..", __dir__)
+          return @step_catalog if @step_catalog_loaded
 
-            project_catalog = File.join(project_root, ".ace", "assign", "catalog", "steps")
-            default_catalog = File.join(gem_root, ".ace-defaults", "assign", "catalog", "steps")
+          if @step_catalog_from_fixture_set
+            @step_catalog_loaded = true
+            @step_catalog = @step_catalog_from_fixture
+            return @step_catalog
+          end
 
-            default_steps = Atoms::CatalogLoader.load_all(default_catalog)
-            base_catalog = if File.directory?(project_catalog)
-              project_steps = Atoms::CatalogLoader.load_all(project_catalog)
-              merge_step_catalog(default_steps, project_steps)
-            else
-              default_steps
-            end
+          cached = self.class.send(:cached_value, :step_catalog_cache, step_catalog_signature)
+          return @step_catalog = cached if cached
+
+          @step_catalog_loaded = true
+          @step_catalog = load_step_catalog
+          self.class.send(:store_cached_value, :step_catalog_cache, step_catalog_signature, @step_catalog)
+          @step_catalog
+        end
+
+        def step_catalog_signature
+          [
+            PROJECT_ROOT_SIGNAL,
+            project_catalog_signature,
+            default_catalog_signature,
+            step_catalog_cache_token,
+            CATALOG_SIGNAL
+          ].join("|")
+        end
+
+        def project_catalog_signature
+          @project_catalog_signature ||= catalog_signature(File.join(project_root, ".ace", "assign", "catalog", "steps"))
+        end
 
-            canonical_steps = skill_source_resolver.assign_step_catalog
-            merge_step_catalog(base_catalog, canonical_steps)
+        def default_catalog_signature
+          @default_catalog_signature ||= catalog_signature(File.join(gem_root, ".ace-defaults", "assign", "catalog", "steps"))
+        end
+
+        def load_step_catalog
+          project_catalog = File.join(project_root, ".ace", "assign", "catalog", "steps")
+          default_catalog = File.join(gem_root, ".ace-defaults", "assign", "catalog", "steps")
+
+          canonical_steps = @skill_source_resolver.assign_step_catalog
+          default_steps = Atoms::CatalogLoader.load_all(default_catalog, canonical_steps: false)
+          base_catalog = merge_step_catalog(default_steps, canonical_steps)
+
+          if File.directory?(project_catalog)
+            project_steps = Atoms::CatalogLoader.load_all(project_catalog, canonical_steps: false)
+            merge_step_catalog(base_catalog, project_steps)
+          else
+            base_catalog
           end
         end
 
+        def catalog_signature(catalog_dir)
+          return "missing" unless File.directory?(catalog_dir)
+
+          Dir.glob(File.join(catalog_dir, "*.step.yml")).sort.map do |path|
+            "#{path}:#{file_signature(path)}"
+          end.join("|")
+        end
+
+        def file_signature(path)
+          stat = File.stat(path)
+          "#{stat.mtime.to_f}:#{stat.size}"
+        rescue
+          "missing"
+        end
+
+        def step_catalog_cache_token
+          token = if @skill_source_resolver.respond_to?(:cache_signature)
+            @skill_source_resolver.cache_signature
+          else
+            "resolver:#{@skill_source_resolver.object_id}"
+          end
+
+          "resolver:#{token}"
+        end
+
+        def project_root
+          @project_root ||= Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+        end
+
+        def gem_root
+          @gem_root ||= Gem.loaded_specs["ace-assign"]&.gem_dir || File.expand_path("../../../..", __dir__)
+        end
+
         # Merge default and project step catalogs by step name.
         # Later definitions override earlier ones with matching names.
         #
@@ -1145,6 +1328,11 @@ module Ace
 
           merged = base.dup
           override.each do |key, value|
+            if runtime_binding_override_key?(key, base, override)
+              merged[key] = base[key]
+              next
+            end
+
             merged[key] =
               if merged[key].is_a?(Hash) && value.is_a?(Hash)
                 deep_merge_step_definition(merged[key], value)
@@ -1155,6 +1343,33 @@ module Ace
           merged
         end
 
+        def runtime_binding_override_key?(key, base, override)
+          return false unless %w[source workflow skill source_skill].include?(key)
+          return false unless local_runtime_binding_present?(base)
+          canonical_binding_present?(override)
+        end
+
+        def local_runtime_binding_present?(entry)
+          entry.is_a?(Hash) && (
+            present_string?(entry["source"]) ||
+            present_string?(entry["workflow"]) ||
+            present_string?(entry["skill"])
+          )
+        end
+
+        def canonical_binding_present?(entry)
+          entry.is_a?(Hash) && (
+            present_string?(entry["source"]) ||
+            present_string?(entry["workflow"]) ||
+            present_string?(entry["skill"]) ||
+            present_string?(entry["source_skill"])
+          )
+        end
+
+        def present_string?(value)
+          value.is_a?(String) && !value.strip.empty?
+        end
+
         # Archive source config into the task's jobs/ directory.
         # If config is already in a jobs/ or steps/ directory, keeps it in place.
         # Otherwise moves job.yaml to <task>/jobs/<assignment_id>-job.yml for provenance.
@@ -1201,6 +1416,7 @@ module Ace
 
         def insert_batch_step_tree(step_config, after:, as_child:, added_by:, location:)
           normalized = normalize_batch_step_hash(step_config, location: location)
+          normalized = apply_inferred_parent_for_sibling_insert(normalized, after: after, as_child: as_child)
 
           if canonical_batch_insert_requested?(normalized)
             canonical_inserted = insert_canonical_batch_step_tree(
@@ -1247,10 +1463,27 @@ module Ace
         def canonical_batch_insert_requested?(step_config)
           raw_sub_steps = step_config["sub_steps"] || step_config["sub-steps"]
           has_declared_sub_steps = raw_sub_steps.is_a?(Array) && raw_sub_steps.any?
+          has_source = !step_config["source"].to_s.strip.empty?
           has_workflow = !step_config["workflow"].to_s.strip.empty?
           has_skill = !step_config["skill"].to_s.strip.empty?
 
-          has_declared_sub_steps || has_workflow || has_skill
+          has_declared_sub_steps || has_source || has_workflow || has_skill
+        end
+
+        def resolved_step_source(step, rendering)
+          explicit_source = step["source"]&.to_s&.strip
+          return explicit_source unless explicit_source.nil? || explicit_source.empty?
+
+          rendered_source = rendering["source"]&.to_s&.strip
+          return rendered_source unless rendered_source.nil? || rendered_source.empty?
+
+          workflow_source = rendering["workflow"]&.to_s&.strip
+          return workflow_source unless workflow_source.nil? || workflow_source.empty?
+
+          skill_name = rendering["skill"]&.to_s&.strip
+          return nil if skill_name.nil? || skill_name.empty?
+
+          "skill://#{skill_name}"
         end
 
         def insert_canonical_batch_step_tree(step_config, after:, as_child:, added_by:, location:)
@@ -1456,6 +1689,27 @@ module Ace
           end
         end
 
+        def apply_inferred_parent_for_sibling_insert(step_config, after:, as_child:)
+          return step_config unless step_config.is_a?(Hash)
+          return step_config if as_child
+          return step_config if after.nil? || after.to_s.strip.empty?
+          return step_config if step_config.key?("parent")
+
+          inferred_parent = infer_parent_from_anchor(after)
+          return step_config if inferred_parent.nil? || inferred_parent.to_s.strip.empty?
+
+          step_config.merge("parent" => inferred_parent)
+        end
+
+        def infer_parent_from_anchor(anchor_number)
+          assignment = assignment_manager.find_active
+          return nil unless assignment
+
+          state = queue_scanner.scan(assignment.steps_dir, assignment: assignment)
+          anchor = state.find_by_number(anchor_number.to_s.strip)
+          anchor&.parent
+        end
+
         def default_dynamic_step_instructions
           DEFAULT_DYNAMIC_STEP_INSTRUCTIONS
         end

data/lib/ace/assign/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Assign
-    VERSION = "0.41.10"
+    VERSION = '0.53.4'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-assign
 version: !ruby/object:Gem::Version
-  version: 0.41.10
+  version: 0.53.4
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.34'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.34'
 - !ruby/object:Gem::Dependency
   name: ace-task
   requirement: !ruby/object:Gem::Requirement
@@ -206,7 +206,6 @@ files:
 - ".ace-defaults/assign/catalog/steps/task-load.step.yml"
 - ".ace-defaults/assign/catalog/steps/update-docs.step.yml"
 - ".ace-defaults/assign/catalog/steps/update-pr-desc.step.yml"
-- ".ace-defaults/assign/catalog/steps/verify-e2e.step.yml"
 - ".ace-defaults/assign/catalog/steps/verify-test-suite.step.yml"
 - ".ace-defaults/assign/catalog/steps/verify-test.step.yml"
 - ".ace-defaults/assign/catalog/steps/work-on-task.step.yml"
@@ -221,6 +220,11 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
+- docs/demo/canonical-skill-source.gif
+- docs/demo/canonical-skill-source.tape.yml
+- docs/demo/fork-provider.cast
+- docs/demo/fork-provider.gif
+- docs/demo/fork-provider.recording.json
 - docs/demo/fork-provider.tape.yml
 - docs/exit-codes.md
 - docs/getting-started.md
@@ -236,14 +240,23 @@ files:
 - handbook/skills/as-assign-recover-fork/SKILL.md
 - handbook/skills/as-assign-run-in-batches/SKILL.md
 - handbook/skills/as-assign-start/SKILL.md
+- handbook/skills/as-create-retro-internal/SKILL.md
+- handbook/skills/as-mark-task-done-internal/SKILL.md
+- handbook/skills/as-reflect-and-refactor-internal/SKILL.md
+- handbook/skills/as-task-load-internal/SKILL.md
 - handbook/workflow-instructions/assign/add-task.wf.md
 - handbook/workflow-instructions/assign/compose.wf.md
+- handbook/workflow-instructions/assign/create-retro-internal.wf.md
 - handbook/workflow-instructions/assign/create.wf.md
 - handbook/workflow-instructions/assign/drive.wf.md
+- handbook/workflow-instructions/assign/mark-task-done-internal.wf.md
 - handbook/workflow-instructions/assign/prepare.wf.md
 - handbook/workflow-instructions/assign/recover-fork.wf.md
+- handbook/workflow-instructions/assign/reflect-and-refactor-internal.wf.md
 - handbook/workflow-instructions/assign/run-in-batches.wf.md
 - handbook/workflow-instructions/assign/start.wf.md
+- handbook/workflow-instructions/assign/task-load-internal.wf.md
+- handbook/workflow-instructions/assign/verify-test-suite.wf.md
 - lib/ace/assign.rb
 - lib/ace/assign/atoms/assign_frontmatter_parser.rb
 - lib/ace/assign/atoms/catalog_loader.rb
@@ -263,11 +276,13 @@ files:
 - lib/ace/assign/cli/commands/fail.rb
 - lib/ace/assign/cli/commands/finish.rb
 - lib/ace/assign/cli/commands/fork_run.rb
+- lib/ace/assign/cli/commands/fork_session.rb
 - lib/ace/assign/cli/commands/list.rb
 - lib/ace/assign/cli/commands/retry_cmd.rb
 - lib/ace/assign/cli/commands/select.rb
 - lib/ace/assign/cli/commands/start.rb
 - lib/ace/assign/cli/commands/status.rb
+- lib/ace/assign/cli/commands/step.rb
 - lib/ace/assign/models/assignment.rb
 - lib/ace/assign/models/assignment_info.rb
 - lib/ace/assign/models/queue_state.rb
@@ -280,6 +295,7 @@ files:
 - lib/ace/assign/molecules/skill_assign_source_resolver.rb
 - lib/ace/assign/molecules/step_renumberer.rb
 - lib/ace/assign/molecules/step_writer.rb
+- lib/ace/assign/molecules/tmux_fork_runner.rb
 - lib/ace/assign/organisms/assignment_executor.rb
 - lib/ace/assign/organisms/task_assignment_creator.rb
 - lib/ace/assign/version.rb

data/.ace-defaults/assign/catalog/steps/verify-e2e.step.yml

@@ -1,42 +0,0 @@
-name: verify-e2e
-skill: as-e2e-review
-render: step_template
-description: Review E2E coverage for modified packages and run targeted scenarios
-
-prerequisites:
-  - name: work-on-task
-    strength: required
-    reason: "Must have implementation to test"
-  - name: verify-test-suite
-    strength: recommended
-    reason: "Unit tests should pass before running E2E"
-
-produces: [e2e-results, coverage-matrix]
-consumes: [code-changes]
-
-context:
-  default: null
-  reason: "E2E review and execution run in the project environment"
-
-when_to_skip:
-  - "No public CLI API changes (internal-only refactoring)"
-  - "Package has no E2E test scenarios and no coverage gaps identified"
-  - "All modified files are docs-only (*.md, *.yml non-config, task specs, retros)"
-
-effort: medium
-tags: [testing, e2e, verification]
-
-steps:
-  - name: review-coverage
-    description: "Run /as-e2e-review for each heavily modified package to get coverage matrix"
-    tool: "ace-e2e-review <package>"
-    note: "Identify gaps, overlaps, and which TCs need updating before running"
-
-  - name: update-if-needed
-    description: "If coverage matrix shows gaps or stale TCs, update or create E2E tests"
-    conditional: "coverage-matrix shows gaps or outdated TCs"
-
-  - name: run-targeted
-    description: "Run ace-test-e2e-suite for each heavily modified package (not full suite)"
-    tool: "ace-test-e2e-suite <package>"
-    note: "Pass package name(s) of heavily modified packages only"