@@ -17,7 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - SimpleCov depends on the `prism` gem. Ruby 3.4 and 4.0 ship Prism as a default gem, so nothing new installs there, but Ruby 4.1 ships it as a bundled gem, which a bundle can load only when something in it depends on Prism. Without it, a project's bundle on Ruby 4.1 silently lost what needs Prism: static branch and method coverage for files the suite never loaded, telling a newly loaded file's load-time lines from its method bodies under `track_tests`, and narrowing `simplecov affected` to the changed methods. Prism still loads lazily, so a Ruby that cannot load it (JRuby on Windows) keeps working without those features.
 - The HTML report keeps a test file's own loading apart from its tests. The tests panel lists the files whose loading ran a line under their own note, and a line only loading ran counts as covered outside tests in the source view and the file list, like other load-time code. See [#1316].
-- `coverage.json` advances to schema 1.4, which changes no shape. It documents that a bare test file path in `contexts`, beside ids pointing into the same file, names that file's own loading rather than a test, now that `track_tests` records it. Schema 1.3 stays frozen for pinned consumers. See [#1316].
+- `coverage.json` advances to schema 1.4. It adds the optional `contexts_dropped` string, saying why a run that tracked tests carries no `contexts`, and documents that a bare test file path in `contexts`, beside ids pointing into the same file, names that file's own loading rather than a test, now that `track_tests` records it. Schema 1.3 stays frozen for pinned consumers. See [#1316].
 - `track_tests` credits a test file with what it runs while it loads, before any of its tests run, under the file's path with no line number (`spec/user_spec.rb`). Code a spec file runs to define its examples, like shared examples or helpers called in `describe` bodies, belonged to no test, so `simplecov affected` fell back to the full suite for a change to it. Files first loaded while a test file loads still belong to no test, and RSpec's `before(:suite)` hooks belong to no test either. `simplecov tests --redundant` never lists a test file's loading as a redundant test, and `simplecov status` does not count it as a recorded test. Watching files load, and parsing each file a test loads first with Prism, cost nothing measurable: on SimpleCov's own suite under Ruby 4.1 (6,172 examples, three runs each), `track_tests` adds 6% to the suite's CPU time, where it added 20% before this release's attribution changes. See [#1316].
 - SimpleCov no longer warns on JRuby that coverage may be inaccurate without `--debug` (full-trace mode). JRuby's coverage no longer depends on it: SimpleCov's own suite on JRuby 10.0.7 reports every line identically with and without `--debug`, so the warning only told JRuby users to slow their test runs down for nothing.
 - The HTML report is usable on phones. On narrow screens the theme toggles shrink to icons, a report with several groups picks them from a dropdown instead of a row of tabs, the file list drops its coverage bars and covered/total counts and wraps long paths, and the source view stacks its header. On small or short screens the source header and footer scroll away with the code instead of staying pinned. Below 960px wide the code font scales so 80 columns fit beside the line numbers and hit counts. See [#1312].
@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `simplecov affected` falls back to the full suite when a changed statement outside any method ran only outside recorded tests, even if recorded tests ran other lines of the file, and names the changed line. A changed or added constant selected only the tests that ran the file's methods, leaving out tests that read the constant. Blank lines, comments, and added methods do not count, and a change to a heredoc's body counts through the statement that opens it. See [#1316].
 - `track_tests` no longer credits a test with the lines a file ran as the test first loaded it. A file's class body, constants, and `def` lines run once on behalf of every later test, but the test that happened to load it was recorded as their only owner, so `simplecov affected` selected that one test for a change to them. The loading test is now credited only with the method body lines it ran, and the rest is left to no test, like a file loaded before the suite ran. See [#1316].
 - A merge keeps the method and branch hits of a process that recorded no line hit for the file. A forked worker inherits the files its parent loaded with their counters cleared, and calling a method whose body shares its `def` line (a short endless method, for instance) then records a method hit and no line hit. The merge took that for a never-loaded file and dropped its hits in favor of the parent's zeroes, so methods the workers exercised were reported as uncovered. A file now counts as executed when any line, method, or branch arm was hit. See [#1310].
+- `simplecov affected`, `simplecov tests`, and `simplecov status` say why a run that tracked tests recorded no test map, instead of telling you to enable `track_tests`, which was already on. A process whose tests ran concurrently in threads (Rails' threaded `parallelize`) drops its map, since per-test coverage cannot tell concurrent tests apart, and so does a merge of results only some of which recorded one. The reason is carried through the resultset into `coverage.json` as `contexts_dropped`. See [#1316].
 - `track_tests` credits a test with a one-line method it called in a file it first loaded, such as `def odd? = (a || b) && c`. The loading test kept only method body lines, and a one-line method's body shares its `def` line, so the method was left to no test while a later test that called it claimed the line. A change to it then selected only that later test. The line is now the loading test's when it ran more often than loading the file accounts for. See [#1316].
 - A later run under the same command name keeps the test map an earlier run recorded for the tests it did not run. Rerunning one test file, or running `simplecov affected --run`, replaced the whole map, so a later `simplecov affected` selected nothing for a change that only the other tests covered, and exited 0. A test recorded again replaces its earlier lines. An earlier test whose file is gone is dropped, and one that touched a source file changed since is credited with every line of that file, since its recorded line numbers no longer hold. See [#1316].
 - The `strict` profile no longer makes JRuby warn that branch and method coverage are not supported. It enabled both on every engine, so `Coverage.start` was asked for criteria JRuby cannot measure. It now enables only the criteria the runtime supports and pins a 100% threshold for each of those.
 
@@ -171,8 +171,10 @@ complete context map. 1.2 added the optional `history` array (the recorded run h
 added the optional `production` section: the window and per-file lines a
 [production coverage store](Production.md) accumulated, present exactly when
 [`production_coverage`](Production.md#seeing-the-cross-in-the-html-and-json-reports) names a readable store at report
-time. 1.4 changed no shape: it documents that a bare test file path in `contexts`, beside ids pointing into the
-same file, is that file's own loading rather than a test. Top-level structure:
+time. 1.4 added the optional `contexts_dropped` string, saying why a run that tracked tests carries no `contexts`
+(tests that ran concurrently in threads, or a merge that mixed results with and without a map), and documents that
+a bare test file path in `contexts`, beside ids pointing into the same file, is that file's own loading rather than
+a test. Top-level structure:
 
 ```jsonc
 {
@@ -181,6 +183,7 @@ same file, is that file's own loading rather than a test. Top-level structure:
   "total":    { /* aggregate stats for lines (and branches / methods when enabled) */ },
   "coverage": { "<project-relative path>": { /* per-file lines, source, branches, methods, contexts, etc. */ } },
   "contexts": [ /* recorded context ids (with track_tests: test definition locations); present only when recorded */ ],
+  "contexts_dropped": "/* why a tracked run carries no contexts; present only when a map was dropped */",
   "history":  [ /* recorded runs, oldest first, this run last; present only when past runs are recorded */ ],
   "production": { /* window + per-file lines and last_seen stamps from a production store; present only when configured */ },
   "groups":   { "<group name>": { /* per-group stats + files */ } },
 
@@ -35,15 +35,20 @@ def error_nil(stderr, message)
 
       def recorded_contexts(document, opts, stderr)
         contexts = document["contexts"]
-        if contexts.nil?
-          return error_nil(stderr, "no test contexts recorded in #{opts.fetch(:input)}. Enable `track_tests` in " \
-                                   "your `SimpleCov.start` block and rerun the suite to record them")
-        end
+        return error_nil(stderr, unrecorded_contexts(document, opts.fetch(:input))) if contexts.nil?
         return contexts if contexts.instance_of?(Array) && contexts.all?(String)
 
         CoverageFile.report_invalid(stderr, command_name, opts.fetch(:input), '"contexts" must be an array of strings')
       end
 
+      def unrecorded_contexts(document, input)
+        dropped = document["contexts_dropped"]
+        return "no test contexts recorded in #{input}: the run dropped them because #{dropped}" if dropped.instance_of?(String)
+
+        "no test contexts recorded in #{input}. Enable `track_tests` in your `SimpleCov.start` block and rerun " \
+          "the suite to record them"
+      end
+
       def common_options(parser, opts)
         parser.on("--input PATH") { |v| opts[:input] = v }
         parser.on("--json") { opts[:json] = true }
 
@@ -36,7 +36,7 @@ def report_lines(facts)
           provenance_words(facts),
           "commit #{commit_words(facts)}",
           (totals_words(facts.fetch(:totals)) unless facts.fetch(:totals).empty?),
-          "tests recorded: #{contexts_words(facts.fetch(:contexts))}"
+          "tests recorded: #{contexts_words(facts.fetch(:contexts), facts.fetch(:contexts_dropped))}"
         ].compact
       end
 
@@ -62,8 +62,11 @@ def totals_words(totals)
         totals.map { |name, percent| "#{name} #{format("%.2f%%", percent)}" }.join(", ")
       end
 
-      def contexts_words(count)
-        count ? "#{count} (track_tests)" : "none (enable track_tests to select and re-run by test)"
+      def contexts_words(count, dropped)
+        return "#{count} (track_tests)" if count
+        return "none (dropped because #{dropped})" if dropped
+
+        "none (enable track_tests to select and re-run by test)"
       end
 
       def print_resultset(facts, stdout)
 
@@ -8,9 +8,11 @@ module Facts
 
         def gather(document, resultset_path)
           contexts = document["contexts"]
+          dropped = document["contexts_dropped"]
           meta_facts(document).merge(
             totals: totals(document["total"]),
             contexts: (tests_recorded(contexts) if contexts.instance_of?(Array)),
+            contexts_dropped: (dropped if dropped.instance_of?(String)),
             resultset_path: resultset_path, resultset: readable_resultset(resultset_path)
           )
         end
 
@@ -29,7 +29,7 @@ def absorb_resultset(resultset)
       def absorb_entry(data)
         @entries += 1
         map = ContextMap.from_hash(data["contexts"])
-        return @complete = false unless map
+        return drop_entry(data["contexts_dropped"]) unless map
 
         @carrying += 1
         @map.absorb(map)
@@ -41,6 +41,7 @@ def absorb_union(other)
         @entries += other.entries
         @carrying += other.carrying
         @complete &&= other.complete?
+        @reason ||= other.reason
         @map.absorb(other.partial_map)
         self
       end
@@ -59,15 +60,36 @@ def map
         warn_about_partial_maps
       end
 
+      # Why the merged result carries no map, for the report to say: the
+      # first reason a merged result gave, or the merge's own when only some
+      # merged results recorded one. nil when nothing was dropped.
+      def dropped
+        return if @complete
+
+        @reason || (partial_reason if @carrying.positive?)
+      end
+
       protected
 
-      # Protected: only another union folding this one in may read it.
+      # Protected: only another union folding this one in may read these.
       def partial_map
         @map
       end
 
+      attr_reader :reason
+
       private
 
+      def drop_entry(reason)
+        @reason ||= reason if reason.instance_of?(String)
+        @complete = false
+      end
+
+      def partial_reason
+        "only #{@carrying} of #{@entries} merged results recorded one, so enable `track_tests` in every suite " \
+          "that should contribute"
+      end
+
       def warn_about_partial_maps
         return unless @carrying.positive? && SimpleCov.print_errors
 
 
@@ -40,6 +40,7 @@ def format(result, include_source: true)
           # and production coverage only when a store is configured and readable.
           def add_optional_sections(document, result)
             document[:contexts] = result.contexts.contexts if result.contexts
+            document[:contexts_dropped] = result.contexts_dropped if result.contexts_dropped
             history = History.entries_with(result)
             document[:history] = history if history.length > 1
             production = ProductionSectionFormatter.call
 
@@ -31,7 +31,8 @@ def merge_results(*file_paths, processes:, ignore_timeout: false)
       return ResultMerger.merge_results(*file_paths, ignore_timeout: ignore_timeout) unless pair
 
       command_names, coverage = pair
-      ResultMerger.create_result(command_names, coverage, tracked_files: tracked_files, contexts: context_maps.map)
+      ResultMerger.create_result(command_names, coverage, tracked_files: tracked_files, contexts: context_maps.map,
+        contexts_dropped: context_maps.dropped)
     end
 
     # Answers nil when the work could not be fanned out and the caller should
 
@@ -29,6 +29,8 @@ class Result
     # carries none: tracking was off, or a merge dropped the map because not
     # every merged result recorded one.
     attr_reader :contexts
+    # Why no map was recorded although `track_tests` was on, or nil.
+    attr_reader :contexts_dropped
 
     # The distinct run names behind this result, set by a merge so presentation
     # can say "A and N other runs" instead of reading the joined
@@ -50,12 +52,13 @@ class Result
     # `tracked_files` accepts any collection that answers `to_a` (the merge
     # passes a Set), and nil for a run that tracked nothing.
     def initialize(original_result, command_name: nil, created_at: nil, not_loaded_files: Set.new,
-      tracked_files: nil, run_id: nil, worker_id: nil, contexts: nil, report: false,
+      tracked_files: nil, run_id: nil, worker_id: nil, contexts: nil, contexts_dropped: nil, report: false,
       filter_config: FilterConfig.new)
       @original_result = original_result.freeze
       @command_name = command_name
       @created_at = created_at
       initialize_resultset_metadata(tracked_files, run_id, worker_id, contexts)
+      @contexts_dropped = contexts_dropped
       @groups_config = filter_config.groups
       builder = SourceFileBuilder.new(original_result, not_loaded_files: not_loaded_files)
       @files = builder.call
@@ -122,7 +125,8 @@ def self.from_hash(hash)
       hash.map do |command_name, data|
         new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data.fetch("timestamp")),
           tracked_files: data["tracked_files"], run_id: data["run_id"],
-          worker_id: data["worker_id"], contexts: ContextMap.from_hash(data["contexts"]))
+          worker_id: data["worker_id"], contexts: ContextMap.from_hash(data["contexts"]),
+          contexts_dropped: data["contexts_dropped"])
       end
     end
 
 
@@ -9,6 +9,7 @@ def to_hash
         data["worker_id"] = worker_id if worker_id
         data["tracked_files"] = tracked_files unless tracked_files.empty?
         append_contexts(data)
+        data["contexts_dropped"] = contexts_dropped if contexts_dropped
         {command_name => data}
       end