ace-test-runner 0.18.1 → 0.25.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97801800374ba4230c6d4821d63ebf69ea2f9376a85173538fe0fd9c96bd66d8
-  data.tar.gz: 447e4b7f920d3e0188e81c56bfe3226c5c6ac1688a72f08b5a3a2bfb3303048e
+  metadata.gz: 4c042607ae93a0d7b8356b17a8d16e2bf6ce34a90ed2c838da6e3d2424e06fa8
+  data.tar.gz: c487ac4faaa171aa7837faf4cec28a61dbc2d2d39a0c169055384155b5be73a8
 SHA512:
-  metadata.gz: 1b0e98327d7a0a312a604750106abb08c9ae498b2c354464ce3c1af31d9b5be1bf60203c19882a00233d6affab895b6f2dc3806fbb7f8013b891dbf34eb0f0aa
-  data.tar.gz: 06257fccd1041208bb10bc6ef7b0ccf22f05468d864ca354e371c88ab0eb1200e6a158766e3a625b46d1d7f1d89d78fa9dcbf0a040a705ad415fe7c56cacbe52
+  metadata.gz: ed4309b9fe5b54c64af419ea13933e5b2bac49ea8b658e960c307c4964aa3c8688ef4c23603000f71876bd65ff6b5b2e569a06e4eb037c5e99d60ab8c16ff16f
+  data.tar.gz: 27f594fd038d9284173e33373f336e533269925a41a1f84a8aaa9962b3e691a599eaf4c49b36c602a263bb0ad410ea17a9cf7a74a262b12552be97c6efea0d57

data/.ace-defaults/test/runner.yml

@@ -20,16 +20,16 @@ test:
 
   # Test file patterns (optional - has good defaults)
   # patterns:
-  #   smoke: "test/*_test.rb"          # Root-level smoke tests
-  #   atoms: "test/atoms/**/*_test.rb"
-  #   molecules: "test/molecules/**/*_test.rb"
-  #   organisms: "test/organisms/**/*_test.rb"
-  #   models: "test/models/**/*_test.rb"
-  #   integration: "test/integration/**/*_test.rb"
-  #   system: "test/system/**/*_test.rb"
+  #   smoke: "test/{fast/,}smoke/**/*_test.rb"
+  #   atoms: "test/{fast/,}atoms/**/*_test.rb"
+  #   molecules: "test/{fast/,}molecules/**/*_test.rb"
+  #   organisms: "test/{fast/,}organisms/**/*_test.rb"
+  #   models: "test/{fast/,}models/**/*_test.rb"
+  #   feat_tests: "test/feat/**/*_test.rb"
   #
   # Test groups (optional - has good defaults)
   # groups:
-  #   unit: [smoke, atoms, molecules, organisms, models]
-  #   all: [unit, integration, system]
+  #   fast: [smoke, atoms, molecules, organisms, models]
+  #   feat: [feat_tests]
+  #   all: [fast, feat]
   #   quick: [atoms, molecules]

data/.ace-defaults/test-runner/config.yml

@@ -10,25 +10,23 @@
 version: 1
 
 # Test file patterns for each category
-# Supports both test/unit/atoms and test/atoms directory structures
 patterns:
-  smoke: "test/{unit/,}smoke/**/*_test.rb"
-  atoms: "test/{unit/,}atoms/**/*_test.rb"
-  molecules: "test/{unit/,}molecules/**/*_test.rb"
-  organisms: "test/{unit/,}organisms/**/*_test.rb"
-  models: "test/{unit/,}models/**/*_test.rb"
-  commands: "test/{unit/,}commands/**/*_test.rb"
-  cli: "test/{unit/,}cli/**/*_test.rb"
-  prompts: "test/{unit/,}prompts/**/*_test.rb"
-  fixtures: "test/{unit/,}fixtures/**/*_test.rb"
-  support: "test/{unit/,}support/**/*_test.rb"
-  edge: "test/{unit/,}edge/**/*_test.rb"
-  integration: "test/integration/**/*_test.rb"
-  system: "test/system/**/*_test.rb"
+  smoke: "test/{fast/,}smoke/**/*_test.rb"
+  atoms: "test/{fast/,}atoms/**/*_test.rb"
+  molecules: "test/{fast/,}molecules/**/*_test.rb"
+  organisms: "test/{fast/,}organisms/**/*_test.rb"
+  models: "test/{fast/,}models/**/*_test.rb"
+  commands: "test/{fast/,}commands/**/*_test.rb"
+  cli: "test/{fast/,}cli/**/*_test.rb"
+  prompts: "test/{fast/,}prompts/**/*_test.rb"
+  fixtures: "test/{fast/,}fixtures/**/*_test.rb"
+  support: "test/{fast/,}support/**/*_test.rb"
+  edge: "test/{fast/,}edge/**/*_test.rb"
+  feat_tests: "test/feat/**/*_test.rb"
 
-# Test groups that combine multiple patterns
-groups:
-  unit:
+# Test targets that combine multiple patterns
+targets:
+  fast:
     - smoke
     - atoms
     - molecules
@@ -39,11 +37,12 @@ groups:
     - prompts
     - fixtures
     - support
+  feat:
+    - feat_tests
     - edge
   all:
-    - unit
-    - integration
-    - system
+    - fast
+    - feat
   quick:
     - atoms
     - molecules
@@ -59,3 +58,8 @@ defaults:
 # Failure display limits
 failure_limits:
   max_display: 7
+
+execution:
+  mode: by-target
+  target_fail_fast: true
+  target_isolation: false

data/CHANGELOG.md

@@ -7,6 +7,131 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.25.5] - 2026-04-19
+
+### Technical
+- Tightened retained suite failure-propagation runner guidance to persist the injected failing-test path before precheck and cleanup steps.
+
+## [0.25.4] - 2026-04-18
+
+### Technical
+- Strengthened retained suite failure-propagation E2E coverage so Goal 2 now proves the injected failing file through a direct `ace-test` precheck before validating `ace-test-suite` aggregate failure propagation.
+
+## [0.25.3] - 2026-04-16
+
+### Technical
+- Reworked retained suite failure-propagation E2E setup to use a deterministic failing fast-test fixture and require non-zero exit evidence tied to the injected failure path.
+
+## [0.25.2] - 2026-04-16
+
+### Technical
+- Updated `TS-TEST-001` and `TS-TEST-002` sandbox setup to source `mise.toml` from `${ACE_E2E_SOURCE_ROOT:-$PROJECT_ROOT_PATH}` so test-runner E2E flows remain compatible with the shared read-only source-root contract.
+
+## [0.25.1] - 2026-04-15
+
+### Fixed
+- Corrected `TS-TEST-002` suite scenario command contracts to run `ace-test-suite` from sandbox `PATH` and aligned verifier expectations with the same public command surface.
+
+## [0.25.0] - 2026-04-15
+
+### Changed
+- Reworked `ace-test-runner` E2E suites to public-surface goal style by removing duplicate TS-TEST-001 group coverage, enforcing canonical TS-TEST-002 suite invocation, and adding suite `--target` pass-through scenario coverage.
+- Updated `docs/usage.md` with canonical `ace-test-e2e ace-test-runner` guidance and explicit suite E2E invocation constraints.
+
+## [0.24.2] - 2026-04-13
+
+### Fixed
+- Relaxed the removed `unit` target regression assertion so it verifies the canonical target set without depending on display order.
+
+## [0.24.1] - 2026-04-13
+
+### Changed
+- Completed the batch i05 migration follow-through for this package and aligned it with the restarted `fast` / `feat` / `e2e` verification model.
+
+### Technical
+- Included in the coordinated assignment-driven patch release for batch i05 package updates.
+
+
+## [0.24.0] - 2026-04-12
+
+### Changed
+- Migrated deterministic package tests to the `test/fast/` and `test/feat/` layout for `ace-test-runner`, including moving former `test/integration/` coverage into `feat`.
+- Updated package defaults, fixture config, E2E scenario coverage references, and usage examples to align with the `fast` / `feat` / `e2e` contract.
+
+### Removed
+- Removed legacy `test/integration/` deterministic test directory from `ace-test-runner`.
+
+## [0.23.0] - 2026-04-11
+
+### Changed
+- Renamed package-level test-scope terminology to `target` across CLI, runtime, docs, and config, with `targets:` replacing `groups:` and `execution.mode: by-target` replacing the old grouped wording.
+- Kept suite package bucketing on `group` so `ace-test-suite --group` continues to mean package selection while `--target` stays package-local test scope.
+
+### Fixed
+- Made `ace-test-suite --target feat` fail closed on current-run subprocess errors instead of reusing stale package summaries, so suite totals now reflect real feat-only execution.
+
+### Technical
+- Renamed sequential-execution and target-model internals to match the public `target` contract and added regression coverage for config loading, resolver cycles, explicit-file execution, and suite summary freshness.
+
+## [0.22.0] - 2026-04-11
+
+### Changed
+- Renamed the public deterministic test contract to `fast` / `feat`, made bare `ace-test` default to `fast`, and made `all` execute `fast` then `feat`.
+- Updated CLI help, configuration defaults, and suite target guidance to teach `ace-test-e2e` as the only scenario E2E entrypoint.
+
+### Technical
+- Kept internal compatibility aliases for `unit` and `integration` during the migration window while updating resolver and config-loader coverage to the new public naming.
+
+## [0.21.0] - 2026-04-10
+
+### Changed
+- Changed bare `ace-test` package runs to default to the `unit` group, added `int` as an alias for `integration`, and narrowed `all` to `unit`, `edge`, and `integration`.
+- Removed legacy `system`, `e2e`, and `all-with-e2e` targets from the CLI/docs surface and directed scenario E2E execution to `ace-test-e2e`.
+
+## [0.20.1] - 2026-04-10
+
+### Fixed
+- Honored an explicitly configured `all` target without widening default package runs into `test/e2e`, restoring the intended non-E2E default selection.
+
+## [0.20.0] - 2026-04-10
+
+### Changed
+- Added a first-class `e2e` target for `ace-test` and `ace-test-suite --target e2e`, while keeping default `all` runs non-E2E.
+- Documented suite-level E2E targeting and updated runner defaults around the restarted deterministic E2E flow.
+
+## [0.19.6] - 2026-04-10
+
+### Fixed
+- Restored suite-enforced `--run-in-single-batch` execution so `ace-test-suite` preserves its package execution contract instead of falling back to grouped runs.
+- Prefer live runtime timeout/failure state over stale `latest/summary.json` data so suite aggregation no longer reports timed-out packages as passed.
+- Detect subprocess-sensitive tests by file content even inside unit directories, preventing single-batch in-process hangs for packages like `ace-test-runner-e2e`.
+
+## [0.19.5] - 2026-04-10
+
+### Fixed
+- Stopped forcing `--run-in-single-batch` in suite package execution so `ace-test-suite` uses the stable grouped package path instead of the hanging single-batch mode.
+- Prefer live runtime timeout/failure state over stale `latest/summary.json` data so suite aggregation no longer reports timed-out packages as passed.
+
+## [0.19.3] - 2026-04-07
+
+### Technical
+- Expanded suite process-monitor timeout coverage for the full-suite integration queue scenario and improved failure-window robustness under concurrent execution.
+
+## [0.19.2] - 2026-04-07
+
+### Technical
+- Stabilized suite process-monitor integration coverage by increasing the timeout budget for the queued-package timeout scenario under full-suite load.
+
+## [0.19.1] - 2026-03-29
+
+### Technical
+- Normalized published gem metadata so RubyGems and Ruby Toolbox use current release information instead of the 1980 fallback date.
+
+### Added
+- **ace-test-runner v0.19.0**: Added suite-level per-package timeout support via `ace-test-suite --timeout` and `test_suite.timeout`, allowing hung package runs to fail and free their worker slot instead of stalling the rest of the suite.
+
+### Fixed
+- **ace-test-runner v0.19.0**: Terminate active package process groups on suite timeout or interrupt so `ace-test-suite` no longer leaves orphaned `ace-test` subprocesses behind after stuck or cancelled runs.
 
 ## [0.18.1] - 2026-03-29
 

data/README.md

@@ -18,11 +18,11 @@
 
 ![ace-test-runner demo](docs/demo/ace-test-runner-getting-started.gif)
 
-`ace-test-runner` wraps [Minitest](https://github.com/minitest/minitest) with smart grouping, cross-package resolution, and persistent reports so both developers and coding agents can run focused checks quickly, diagnose failures with context, and retain searchable execution history. It handles the execution side of testing; use [ace-test](../ace-test) for planning, review, and suite improvement workflows.
+`ace-test-runner` wraps [Minitest](https://github.com/minitest/minitest) with smart target resolution, cross-package execution, and persistent reports so both developers and coding agents can run focused checks quickly, diagnose failures with context, and retain searchable execution history. It handles the execution side of testing; use [ace-test](../ace-test) for planning, review, and suite improvement workflows.
 
 ## How It Works
 
-1. Resolve the target package and test scope from a package name, group (`atoms`, `molecules`, `organisms`, `unit`, `integration`, `system`, `all`, `quick`), or direct `file:line` selector.
+1. Resolve the target package and test scope from a package name, target (`atoms`, `molecules`, `organisms`, `models`, `fast`, `feat`, `all`, `quick`), or direct `file:line` selector.
 2. Execute the matching tests with failure-oriented output and optional profiling of the slowest cases.
 3. Persist structured run reports for historical debugging and searchable triage across runs.
 
@@ -30,11 +30,13 @@
 
 **Run package tests from anywhere in the monorepo** - execute [`ace-test [package]`](docs/usage.md) by name without changing directories, keeping outputs consistent across local and CI environments.
 
-**Target exactly the scope you need** - run by test groups (`ace-test atoms`, `ace-test molecules`) or direct file/line selectors (`ace-test test/file_test.rb:42`) to focus on the code you are changing.
+**Target exactly the scope you need** - run by test targets (`ace-test atoms`, `ace-test molecules`) or direct file/line selectors (`ace-test test/file_test.rb:42`) to focus on the code you are changing.
+
+**Keep fast-loop defaults tight** - run `ace-test <package>` for `fast` coverage by default, then opt into `feat` when you need deterministic feature checks with controlled IO.
 
 **Speed up triage on broken builds** - use failure-oriented output and persisted reports to locate regressions and continue diagnosis without rerunning broad suites.
 
-**Validate the full monorepo before shipping** - run `ace-test-suite` for cross-package execution orchestration that covers every package in one sweep.
+**Validate the full monorepo before shipping** - run `ace-test-suite` for cross-package execution orchestration, and use `ace-test-e2e <package>` when you need scenario E2E coverage.
 
 **Profile slow tests** - run `ace-test molecules --profile 10` to identify the slowest tests and prioritize optimization with [ace-test](../ace-test) performance audit workflows.
 

data/exe/ace-test-suite

@@ -38,6 +38,14 @@ parser = OptionParser.new do |opts|
     options[:group] = group
   end
 
+  opts.on("--target TARGET", "Pass target through to package-level ace-test (e.g. feat)") do |target|
+    options[:target] = target
+  end
+
+  opts.on("-t", "--timeout SEC", Integer, "Per-package timeout in seconds") do |timeout|
+    options[:timeout] = timeout
+  end
+
   opts.on("-v", "--verbose", "Show verbose output") do
     options[:verbose] = true
   end
@@ -57,7 +65,9 @@ parser = OptionParser.new do |opts|
     puts "  $ ace-test-suite                    Run all (simple line-by-line output)"
     puts "  $ ace-test-suite --progress         Show live animated progress bars"
     puts "  $ ace-test-suite --parallel 16      Run with 16 parallel processes"
+    puts "  $ ace-test-suite --timeout 10       Fail packages that run over 10s"
     puts "  $ ace-test-suite --group foundation Run only foundation group"
+    puts "  $ ace-test-suite --target feat        Run feat target in each package"
     puts "  $ ace-test-suite --verbose          Show detailed test output"
     exit 0
   end
@@ -110,6 +120,10 @@ if options[:parallel]
   config["test_suite"]["max_parallel"] = options[:parallel]
 end
 
+if options[:timeout]
+  config["test_suite"]["timeout"] = options[:timeout]
+end
+
 if options[:group]
   config["test_suite"]["packages"].select! { |p| p["group"] == options[:group] }
   if config["test_suite"]["packages"].empty?
@@ -128,6 +142,11 @@ if options[:verbose]
   config["test_suite"]["test_options"]["verbose"] = true
 end
 
+if options[:target]
+  config["test_suite"]["test_options"] ||= {}
+  config["test_suite"]["test_options"]["target"] = options[:target]
+end
+
 if options[:progress]
   config["test_suite"]["progress"] = true
 end

data/lib/ace/test_runner/atoms/test_folder_detector.rb

@@ -11,8 +11,8 @@ module Ace
         # Returns the parent directory of the test folder + "/test-reports"
         #
         # Example:
-        #   files = ["ace-taskflow/test/commands/tasks_command_test.rb"]
-        #   detect_report_dir(files) # => "ace-taskflow/test-reports"
+        #   files = ["ace-task/test/commands/tasks_command_test.rb"]
+        #   detect_report_dir(files) # => "ace-task/test-reports"
         def detect_report_dir(test_files)
           return nil if test_files.nil? || test_files.empty?
 
@@ -31,8 +31,8 @@ module Ace
         # Looks for "/test/" in the path and returns the path up to and including "test"
         #
         # Example:
-        #   find_test_folder("ace-taskflow/test/commands/tasks_command_test.rb")
-        #   # => "ace-taskflow/test"
+        #   find_test_folder("ace-task/test/commands/tasks_command_test.rb")
+        #   # => "ace-task/test"
         def find_test_folder(file_path)
           # Remove line number suffix if present (file:line format)
           file_path = file_path.sub(/:\d+$/, "")

data/lib/ace/test_runner/atoms/test_type_detector.rb

@@ -39,20 +39,24 @@ module Ace
           # Check if explicitly marked as needing isolation
           return true if isolation_directory?(file_path)
 
-          # Check if it's clearly a unit test that doesn't need isolation
+          # Check file content for patterns that require subprocess
+          needs_isolation = check_file_content(file_path)
+          return true if needs_isolation
+
+          # Unit-directory tests default to in-process only when they do not
+          # exercise subprocess-sensitive behavior directly.
           return false if unit_test_directory?(file_path)
 
-          # Check file content for patterns that require subprocess
-          check_file_content(file_path)
+          false
         end
 
         def test_type(file_path)
           if isolation_directory?(file_path)
             :integration
-          elsif unit_test_directory?(file_path)
-            :unit
           elsif check_file_content(file_path)
             :subprocess_required
+          elsif unit_test_directory?(file_path)
+            :unit
           else
             :unit
           end

data/lib/ace/test_runner/cli/commands/test.rb

@@ -30,10 +30,9 @@ module Ace
               molecules   Run molecule tests only
               organisms   Run organism tests only
               models      Run model tests only
-              unit        Run all unit tests (atoms + molecules + organisms + models)
-              integration Run integration tests
-              system      Run system tests
-              all         Run all tests (default)
+              fast        Run the default isolated fast loop
+              feat        Run deterministic feature tests with controlled IO
+              all         Run fast then feat
               quick       Run quick tests (atoms + molecules)
 
             CONFIGURATION:
@@ -53,10 +52,10 @@ module Ace
               ATOM Architecture Test Layers:
               - atoms       -> Pure functions (no side effects)
               - molecules   -> Composed operations (controlled side effects)
-              - organisms   -> Business logic (complex coordination)
+              - organisms   -> Business logic with stubbed boundaries
               - models      -> Data structures (no behavior)
-              - integration -> Cross-component testing
-              - system      -> End-to-end workflows
+              - fast        -> Default isolated package test loop
+              - feat        -> Deterministic feature coverage
           DESC
 
           # Examples shown in help output
@@ -79,7 +78,7 @@ module Ace
           option :fail_fast, type: :boolean, desc: "Stop execution on first failure"
           option :fix_deprecations, type: :boolean, desc: "Auto-fix deprecated test patterns"
           option :filter, type: :string, desc: "Run only tests matching pattern"
-          option :group, type: :string, aliases: %w[-g], desc: "Run specific test group (unit, integration, system, all)"
+          option :target, type: :string, aliases: %w[-g], desc: "Run specific test target (fast, feat, all)"
           option :color, type: :boolean, desc: "Enable/disable colored output (default: enabled)"
           option :config_path, type: :string, aliases: %w[-c], desc: "Configuration file path (default: .ace/test-runner.yml)"
 
@@ -93,7 +92,7 @@ module Ace
           option :per_file, type: :boolean, desc: "Execute each test file separately (slower, for debugging)"
           option :direct, type: :boolean, desc: "Force in-process execution (faster, less isolation)"
           option :subprocess, type: :boolean, desc: "Force subprocess execution (slower, full isolation)"
-          option :run_in_sequence, type: :boolean, aliases: %w[--ris], desc: "Run test groups sequentially (default)"
+          option :run_in_sequence, type: :boolean, aliases: %w[--ris], desc: "Run test targets sequentially (default)"
           option :run_in_single_batch, type: :boolean, aliases: %w[--risb], desc: "Run all tests together in single batch"
 
           # Rake integration options
@@ -125,6 +124,10 @@ module Ace
               options[key] = options[key].to_i if options[key]
             end
 
+            if options[:target] && args.none? { |arg| !arg.start_with?("-") && !File.exist?(arg) }
+              args = [options[:target]] + args
+            end
+
             # Build test options with defaults
             test_options = build_test_options(options)
 
@@ -169,6 +172,7 @@ module Ace
             end
             # Remove the run_in_sequence key as it's only used to set run_in_single_batch
             symbolized_options.delete(:run_in_sequence)
+            symbolized_options.delete(:target)
 
             # Default options - symbolized_options will override these for any explicit values
             {

data/lib/ace/test_runner/formatters/progress_formatter.rb

@@ -185,15 +185,15 @@ module Ace
         end
 
         def on_test_complete(file, success, duration)
-          # Detect group from file path
-          group = detect_group(file)
+          # Detect target from file path
+          target = detect_target(file)
 
-          # Print group header if it's a new group and groups are enabled
-          if @show_groups && group != @current_group
+          # Print target header if it's a new target and target headers are enabled
+          if @show_groups && target != @current_group
             puts unless @test_count == 0
             puts ""
-            puts colorize("═══ #{group.to_s.capitalize} Tests ═══", :cyan)
-            @current_group = group
+            puts colorize("═══ #{target.to_s.capitalize} Tests ═══", :cyan)
+            @current_group = target
             @test_count = 0  # Reset count for new line
           end
 
@@ -207,47 +207,44 @@ module Ace
             puts if @test_count % @line_width == 0
           end
 
-          # Track group counts
-          @group_counts[group] += 1 if @show_groups
+          # Track target counts
+          @group_counts[target] += 1 if @show_groups
         end
 
-        def detect_group(file_path)
+        def detect_target(file_path)
           case file_path
-          when /test\/unit\/atoms\//
+          when /test\/(fast|unit)\/atoms\//
             :atoms
-          when /test\/unit\/molecules\//
+          when /test\/(fast|unit)\/molecules\//
             :molecules
-          when /test\/unit\/organisms\//
+          when /test\/(fast|unit)\/organisms\//
             :organisms
-          when /test\/unit\/models\//
+          when /test\/(fast|unit)\/models\//
             :models
-          when /test\/integration\//
-            :integration
-          when /test\/system\//
-            :system
+          when /test\/feat\//
+            :feat
+          when /test\/edge\//
+            :edge
           else
             :other
           end
         end
 
-        def on_group_start(group_name, file_count)
-          # Print visual separator before group
+        def on_target_start(target_name, file_count)
           puts "" unless @test_count == 0
           puts ""
-          puts "Running #{group_name} (#{file_count} #{(file_count == 1) ? "file" : "files"})..."
+          puts "Running #{target_name} (#{file_count} #{(file_count == 1) ? "file" : "files"})..."
           @test_count = 0
         end
 
-        def on_group_complete(group_name, success, duration, summary)
-          # Ensure we're on a new line after dots
+        def on_target_complete(target_name, success, duration, summary)
           puts unless @test_count == 0 || @test_count % @line_width == 0
 
-          # Show group completion status
           status_icon = success ? "✓" : "✗"
           test_count = summary[:runs] || 0
           failure_count = summary[:failures] || 0
 
-          status_line = "#{status_icon} #{group_name} complete " +
+          status_line = "#{status_icon} #{target_name} complete " +
             "(#{format_duration(duration)}, #{test_count} tests, #{failure_count} failures)"
 
           puts colorize(status_line, success ? :green : :red)
@@ -258,12 +255,12 @@ module Ace
           # Ensure we're on a new line
           puts unless @test_count == 0 || @test_count % @line_width == 0
 
-          # Print group summary if we have groups and groups are enabled
+          # Print target summary if we have target headers enabled
           if @show_groups && @group_counts.any?
             puts ""
-            puts colorize("═══ Group Summary ═══", :cyan)
-            @group_counts.each do |group, count|
-              puts "  #{group.to_s.capitalize}: #{count} #{(count == 1) ? "file" : "files"}"
+            puts colorize("═══ Target Summary ═══", :cyan)
+            @group_counts.each do |target, count|
+              puts "  #{target.to_s.capitalize}: #{count} #{(count == 1) ? "file" : "files"}"
             end
           end
 

data/lib/ace/test_runner/models/test_configuration.rb

@@ -7,7 +7,7 @@ module Ace
       class TestConfiguration
         attr_accessor :format, :report_dir, :save_reports, :fail_fast,
           :verbose, :filter, :fix_deprecations, :patterns,
-          :timeout, :parallel, :color, :per_file, :groups,
+          :timeout, :parallel, :color, :per_file, :targets,
           :target, :config_path, :failure_limits, :profile,
           :execution, :files, :run_in_single_batch
 
@@ -20,13 +20,13 @@ module Ace
           @filter = attributes[:filter]
           @fix_deprecations = attributes[:fix_deprecations] || false
           @patterns = attributes[:patterns] || default_patterns
-          @groups = attributes[:groups] || default_groups
+          @targets = attributes[:targets] || default_targets
           @target = attributes[:target]
           @config_path = attributes[:config_path]
           @timeout = attributes[:timeout]  # In seconds, nil = no timeout
           @parallel = attributes[:parallel] || false
           @color = attributes.fetch(:color, true)
-          @per_file = attributes[:per_file] || false  # Default to grouped execution for performance
+          @per_file = attributes[:per_file] || false  # Default to by-target execution for performance
           @failure_limits = attributes[:failure_limits] || {max_display: 7}
           @profile = attributes[:profile]  # nil means no profiling, number means show N slowest tests
           @execution = attributes[:execution] || {}
@@ -48,8 +48,8 @@ module Ace
           end
 
           # Validate execution_mode if provided
-          if execution_mode && !%w[grouped all-at-once].include?(execution_mode)
-            raise ArgumentError, "Unknown execution_mode '#{execution_mode}'. Valid modes: grouped, all-at-once"
+          if execution_mode && !%w[by-target all-at-once].include?(execution_mode)
+            raise ArgumentError, "Unknown execution_mode '#{execution_mode}'. Valid modes: by-target, all-at-once"
           end
 
           true
@@ -60,11 +60,11 @@ module Ace
           @execution&.[](:mode) || @execution&.dig("mode") || "all-at-once"
         end
 
-        def group_isolation
-          # Default to true for better isolation in grouped mode
+        def target_isolation
+          # Default to true for better isolation in by-target mode
           # Use fetch to handle false values correctly (|| would treat false as falsy)
-          mode = @execution&.[](:group_isolation)
-          mode = @execution&.dig("group_isolation") if mode.nil?
+          mode = @execution&.[](:target_isolation)
+          mode = @execution&.dig("target_isolation") if mode.nil?
           mode.nil? || mode
         end
 
@@ -83,7 +83,7 @@ module Ace
             filter: filter,
             fix_deprecations: fix_deprecations,
             patterns: patterns,
-            groups: groups,
+            targets: targets,
             target: target,
             config_path: config_path,
             timeout: timeout,
@@ -125,20 +125,26 @@ module Ace
 
         def default_patterns
           {
-            atoms: "test/unit/atoms/**/*_test.rb",
-            molecules: "test/unit/molecules/**/*_test.rb",
-            organisms: "test/unit/organisms/**/*_test.rb",
-            models: "test/unit/models/**/*_test.rb",
-            integration: "test/integration/**/*_test.rb",
-            system: "test/system/**/*_test.rb",
-            all: "test/**/*_test.rb"
+            smoke: "test/{fast/,}*_test.rb",
+            atoms: "test/{fast/,}atoms/**/*_test.rb",
+            molecules: "test/{fast/,}molecules/**/*_test.rb",
+            organisms: "test/{fast/,}organisms/**/*_test.rb",
+            models: "test/{fast/,}models/**/*_test.rb",
+            commands: "test/{fast/,}commands/**/*_test.rb",
+            cli: "test/{fast/,}cli/**/*_test.rb",
+            prompts: "test/{fast/,}prompts/**/*_test.rb",
+            fixtures: "test/{fast/,}fixtures/**/*_test.rb",
+            support: "test/{fast/,}support/**/*_test.rb",
+            feat_tests: "test/feat/**/*_test.rb",
+            edge: "test/{fast/,}edge/**/*_test.rb"
           }
         end
 
-        def default_groups
+        def default_targets
           {
-            unit: %w[atoms molecules organisms models],
-            all: %w[unit integration system],
+            fast: %w[smoke atoms molecules organisms models commands cli prompts fixtures support],
+            feat: %w[feat_tests edge],
+            all: %w[fast feat],
             quick: %w[atoms molecules]
           }
         end