Validate and normalize benchmark data

BurntSushi_ripgrep_14.1.1_15.0.0/test_results/simple_test/simple_test_classification.json

@@ -1,7 +0,0 @@
-{
-  "stable_classification": {
-    "fail_to_pass": [],
-    "pass_to_pass": [],
-    "none_to_pass": []
-  }
-}

README.md

@@ -28,24 +28,29 @@ This dataset contains the metadata, task specifications (SRS documents), depende
 
 ## Dataset Statistics
 
-SWE-Milestone covers **7 real-world open-source repositories** spanning 5 programming languages, with **98 graded milestones**, **124 dependency edges**, and **48,480 total ΔLoC** in gold patches.
-
-| Repository | Language | Version Range | #Milestones | #Deps | ΔLoC | LoC CV |
-|-----------|----------|---------------|:-----------:|:-----:|-----:|:------:|
-| [go-zero](https://github.com/zeromicro/go-zero) | Go | v1.6.0 → v1.9.3 (750d) | 23 | 25 | 6,403 | 1.29 |
-| [element-web](https://github.com/element-hq/element-web) | TypeScript | v1.11.95 → v1.11.97 (28d) | 18 | 12 | 7,657 | 0.87 |
-| [nushell](https://github.com/nushell/nushell) | Rust | 0.106.0 → 0.108.0 (84d) | 13 | 28 | 15,520 | 1.10 |
-| [dubbo](https://github.com/apache/dubbo) | Java | 3.3.3 → 3.3.6 (284d) | 12 | 9 | 4,154 | 0.76 |
-| [scikit-learn](https://github.com/scikit-learn/scikit-learn) | Python | 1.5.2 → 1.6.0 (89d) | 12 | 29 | 7,372 | 0.84 |
-| [ripgrep](https://github.com/BurntSushi/ripgrep) | Rust | 14.1.1 → 15.0.0 (402d) | 11 | 12 | 1,474 | 0.83 |
-| [navidrome](https://github.com/navidrome/navidrome) | Go | v0.57.0 → v0.58.0 (27d) | 9 | 9 | 5,900 | 1.02 |
-| **Average** | | | **14** | **17.7** | **6,926** | **0.96** |
+<!-- BEGIN GENERATED DATASET STATISTICS -->
+
+SWE-Milestone covers **7 real-world open-source repositories** spanning 5 programming languages, with **98 graded milestones**, **110 active dependency edges** (84 base + 26 additional), and **48,470 total ΔSrcLoC** in graded gold patches.
+
+| Repository | Language | Version Range | #Milestones | #Deps | ΔSrcLoC | Src LoC CV |
+|-----------|----------|---------------|:-----------:|:-----:|---------:|:----------:|
+| [go-zero](https://github.com/zeromicro/go-zero) | Go | v1.6.0 → v1.9.3 (750d) | 23 | 24 | 6,403 | 0.63 |
+| [element-web](https://github.com/element-hq/element-web) | TypeScript | v1.11.95 → v1.11.97 (28d) | 18 | 12 | 7,647 | 0.82 |
+| [nushell](https://github.com/nushell/nushell) | Rust | 0.106.0 → 0.108.0 (84d) | 13 | 29 | 15,520 | 1.01 |
+| [dubbo](https://github.com/apache/dubbo) | Java | 3.3.3 → 3.3.6 (284d) | 12 | 6 | 4,154 | 0.43 |
+| [scikit-learn](https://github.com/scikit-learn/scikit-learn) | Python | 1.5.2 → 1.6.0 (89d) | 12 | 14 | 7,372 | 1.07 |
+| [ripgrep](https://github.com/BurntSushi/ripgrep) | Rust | 14.1.1 → 15.0.0 (402d) | 11 | 16 | 1,474 | 0.54 |
+| [navidrome](https://github.com/navidrome/navidrome) | Go | v0.57.0 → v0.58.0 (27d) | 9 | 9 | 5,900 | 0.83 |
+| **Average** | | | **14** | **15.7** | **6,924** | **0.76** |
 
 **Column definitions:**
-- **#Milestones** --- Number of graded milestones (non-graded milestones excluded from scoring but still part of the DAG).
-- **#Deps** --- Number of dependency edges in the milestone DAG.
-- **ΔLoC** --- Total lines of code changed across all gold patches in the version range.
-- **LoC CV** --- Coefficient of variation of per-milestone LoC, measuring how unevenly work is distributed across milestones (higher = more variable).
+- **#Milestones** - Number of graded milestones: active milestones excluding IDs in `non-graded_milestone_ids.txt`.
+- **#Deps** - Number of unique edges in the active DAG. It combines `dependencies.csv` and `additional_dependencies.csv`, then keeps edges whose two endpoints are active. Non-graded milestones remain part of this DAG because the agent still implements them.
+- **ΔSrcLoC** - Sum of `src_loc` over graded milestones only. `src_loc` equals `src_additions + src_deletions` and excludes test-only changes according to each repository's metadata.
+- **Src LoC CV** - Population coefficient of variation (`pstdev / mean`) of graded milestone `src_loc` values.
+- **Active milestones** - IDs from `selected_milestone_ids.txt` when that file exists; otherwise every ID in `milestones.csv`.
+
+<!-- END GENERATED DATASET STATISTICS -->
 
 ## Dataset Structure
 
@@ -97,6 +102,20 @@ Each milestone in the DAG requires the following components:
 - The **Graded Milestones** count includes only milestones that contribute to the final score. Some repositories include additional **non-graded milestones** (listed in `non-graded_milestone_ids.txt`) that the agent must still implement as part of the dependency DAG but are excluded from scoring, typically because they are trivial tasks (e.g., version bumps, dependency updates) or lack sufficient test coverage for reliable grading. Only 3 milestones across all repositories are non-graded.
 - Each milestone is extracted from the actual commit history of the repository, representing real software evolution between the listed version ranges.
 
+## Validation
+
+Run the dataset contract validator from the repository root:
+
+```bash
+python scripts/validate_data.py
+```
+
+The validator checks the active and graded milestone sets, the effective DAG, SRS and test-classification coverage, classification/filter schemas, and the generated README statistics. It exits non-zero when contract errors are found. After an intentional data change, regenerate the statistics block with:
+
+```bash
+python scripts/validate_data.py --write-readme
+```
+
 ## Usage
 
 ```bash

apache_dubbo_dubbo-3.3.3_dubbo-3.3.6/test_results/M017/M017_filter_list.json

@@ -2,8 +2,6 @@
   "invalid_fail_to_pass": [],
   "invalid_none_to_pass": [
     "dubbo-rpc/dubbo-rpc-triple::org.apache.dubbo.rpc.protocol.tri.rest.support.basic.RestProtocolTest::bean argument test [path: /buy, body: <org.apache.dubbo.rpc.protocol.tri.rest.service.Book@111cba40 name=Dubbo price=0 publishDate=null>, output: Dubbo, #0]",
-    "dubbo-rpc/dubbo-rpc-triple::org.apache.dubbo.rpc.protocol.tri.rest.support.basic.RestProtocolTest::bean argument test [path: /buy2, body: [book:org.apache.dubbo.rpc.protocol.tri.rest.service.Book@4fb57fb3, count:2], output: Dubbo, #3]",
-    "dubbo-rpc/dubbo-rpc-triple::org.apache.dubbo.rpc.protocol.tri.rest.support.basic.RestProtocolTest::bean argument test [path: /buy2, body: [org.apache.dubbo.rpc.protocol.tri.rest.service.Book@336f49a1, 2], output: Dubbo, #2]",
     "dubbo-rpc/dubbo-rpc-triple::org.apache.dubbo.rpc.protocol.tri.rest.support.basic.RestProtocolTest::bean argument post test [path: /beanArgTest, body: [book:org.apache.dubbo.rpc.protocol.tri.rest.service.Book@7ec3a8bd], output: 6, #2]",
     "dubbo-rpc/dubbo-rpc-triple::org.apache.dubbo.rpc.protocol.tri.rest.support.basic.RestProtocolTest::bean argument post test [path: /beanArgTest, body: [book:org.apache.dubbo.rpc.protocol.tri.rest.service.Book@42cf6349, quote:5], output: 5, #3]"
   ],

element-hq_element-web_v1.11.95_v1.11.97/test_results/milestone_seed_56c7fc1_1/milestone_seed_56c7fc1_1_filter_list.json

@@ -1,6 +0,0 @@
-{
-  "invalid_fail_to_pass": [
-    "/testbed/test/unit-tests/components/views/rooms/MessageComposerButtons-test.tsx::MessageComposerButtons Renders other buttons in menu in wide mode"
-  ],
-  "invalid_none_to_pass": []
-}

navidrome_navidrome_v0.57.0_v0.58.0/test_results/milestone_003_sub-01/milestone_003_sub-01_classification.json

@@ -5891,10 +5891,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::sqlRepository > buildSortOrder > single field > forces snake case for field names",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is true > returns the index when PreferSortTags is true and SortArtistName is not empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > roleFilter > validates roles and returns appropriate SQL expressions > albumartist role",
         "end_outcome": "failed"
@@ -6835,10 +6831,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > MBID and Text Search > prevents restricted user from finding artist by MBID when not in accessible library",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is NOT empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::TranscodingRepository > Regular User > fails to create",
         "end_outcome": "passed"
@@ -7027,10 +7019,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::GenreRepository > ReadAll > should return all genres through ReadAll",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Count > returns the number of artists in the DB",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::GenreRepository > Read > should not return non-genre tags",
         "end_outcome": "passed"
@@ -7591,10 +7579,6 @@
         "test_id": "github.com/navidrome/navidrome/model/metadata::Participants > PERFORMER tags > when MUSICBRAINZ_PERFORMERID tag is set > should handle mismatched performer names and MBIDs for sub-roles",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/model::MediaFiles > ToAlbum > Calculated attributes > Comments > when we have only one Comment > sets the correct Comment",
         "end_outcome": "passed"
@@ -8339,10 +8323,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::UserRepository > validateUsernameUnique > allows unique usernames",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when validating library IDs > returns artists when library IDs are provided (admin user sees all content)",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/model/metadata::Metadata > Metadata > Performers > Vorbis > should return the performers",
         "end_outcome": "passed"

navidrome_navidrome_v0.57.0_v0.58.0/test_results/milestone_003_sub-01/milestone_003_sub-01_filter_list.json

@@ -420,7 +420,7 @@
     "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > returns a 'in' condition for multiples 'id' filters",
     "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > returns a 'like' condition for other filters",
     "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > returns nil if filters is empty",
-    "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > returns nil if tries a filter with fullTextExpr(",
+    "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > returns nil if tries a filter with fullTextExpr(\"'\")",
     "github.com/navidrome/navidrome/persistence::sqlRestful > parseRestFilters > uses the custom filter"
   ],
   "invalid_none_to_pass": []

navidrome_navidrome_v0.57.0_v0.58.0/test_results/milestone_003_sub-03/milestone_003_sub-03_classification.json

@@ -5180,10 +5180,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::PlayerRepository > Get > Gets an existing item from another user",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Regular User Operations > when user gains library access > GetAll returns artists after gaining access",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::PlaylistRepository > Put/Exists/Delete",
         "end_outcome": "passed"
@@ -5208,10 +5204,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::sqlRepository > buildSortOrder > single field > forces snake case for field names",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is true > returns the index when PreferSortTags is true and SortArtistName is not empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > roleFilter > validates roles and returns appropriate SQL expressions > albumartist role",
         "end_outcome": "passed"
@@ -5488,10 +5480,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::PlayQueueRepository > Retrieve > retrieves the playqueue with only track IDs (no full MediaFile data)",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Admin User Library Access > sees all artists regardless of library permissions",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::GenreRepository > Library Filtering > Headless Processes (No User Context) > should count all genres from all libraries when no user is in context",
         "end_outcome": "passed"
@@ -5896,10 +5884,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > MBID and Text Search > prevents restricted user from finding artist by MBID when not in accessible library",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is NOT empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::TranscodingRepository > Regular User > fails to create",
         "end_outcome": "passed"
@@ -5960,10 +5944,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::Property Repository > returns a default value if property does not exist",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Regular User Operations > when user gains library access > CountAll returns correct count after gaining access",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/core/agents::Agents > Agents > GetArtistMBID > returns not found if artist is Unknown Artist",
         "end_outcome": "passed"
@@ -6036,10 +6016,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::GenreRepository > ReadAll > should return all genres through ReadAll",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Count > returns the number of artists in the DB",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/core/agents::Agents > Agents > GetArtistBiography > returns not found if artist is Unknown Artist",
         "end_outcome": "passed"
@@ -6424,10 +6400,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::Tag Library Filtering > TagRepository Library Filtering > Admin User > should see all tags regardless of library",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is empty",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::PlayQueueRepository > RetrieveWithMediaFiles > retrieves the playqueue with full MediaFile data",
         "end_outcome": "passed"
@@ -6636,10 +6608,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::MediaRepository > returns songs ordered by lyrics with a specific title/artist",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Missing Artist Handling > missing artists are never returned by search",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::GenreRepository > GetAll > filtering and sorting > should sort by name in ascending order",
         "end_outcome": "passed"
@@ -6700,10 +6668,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > dbArtist mapping > PostScan > parses stats and similar artists correctly",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Regular User Operations > when user gains library access > GetIndex returns artists with proper library filtering",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::AlbumRepository > artistRoleFilter > creates correct SQL expressions for artist roles > composer role",
         "end_outcome": "passed"
@@ -6944,10 +6908,6 @@
         "test_id": "github.com/navidrome/navidrome/persistence::UserRepository > validateUsernameUnique > allows unique usernames",
         "end_outcome": "passed"
       },
-      {
-        "test_id": "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when validating library IDs > returns artists when library IDs are provided (admin user sees all content)",
-        "end_outcome": "passed"
-      },
       {
         "test_id": "github.com/navidrome/navidrome/persistence::PlayerRepository > per context > admin context > Read > can read from other user or fail if not admin",
         "end_outcome": "passed"

navidrome_navidrome_v0.57.0_v0.58.0/test_results/milestone_003_sub-03/milestone_003_sub-03_filter_list.json

@@ -75,13 +75,9 @@
     "github.com/navidrome/navidrome/persistence::AlbumRepository > Get > returns ErrNotFound when the album does not exist",
     "github.com/navidrome/navidrome/persistence::AlbumRepository > Participant Foreign Key Handling > handles complex nested JSON with multiple roles and sub-roles",
     "github.com/navidrome/navidrome/persistence::AlbumRepository > Participant Foreign Key Handling > verifies that participant records are actually inserted into database",
-    "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Count > returns the number of artists in the DB",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Exists > returns false for an artist that is NOT in the DB",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Exists > returns true for an artist that is in the DB",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > Basic Operations > Get > retrieves existing artist data",
-    "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is empty",
-    "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is false > returns the index when SortArtistName is NOT empty",
-    "github.com/navidrome/navidrome/persistence::ArtistRepository > Admin User Operations > GetIndex > when PreferSortTags is true > returns the index when PreferSortTags is true and SortArtistName is not empty",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > dbArtist mapping > PostMapArgs > does not override empty sort_artist_name and mbz_artist_id",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > dbArtist mapping > PostMapArgs > maps empty similar artists correctly",
     "github.com/navidrome/navidrome/persistence::ArtistRepository > Core Functionality > dbArtist mapping > PostMapArgs > maps similar artists and full text correctly",

scikit-learn_scikit-learn_1.5.2_1.6.0/test_results/M12.5/M12.5_filter_list.json

@@ -1,6 +0,0 @@
-{
-  "invalid_fail_to_pass": [],
-  "invalid_none_to_pass": [
-    "test_fixed_threshold_classifier_prefit"
-  ]
-}

scripts/validate_data.py

@@ -0,0 +1,897 @@
+#!/usr/bin/env python3
+"""Validate the SWE-Milestone dataset contract and its README statistics.
+
+The source files are authoritative. README statistics are derived from them:
+
+* catalog = every ID in milestones.csv
+* active = selected_milestone_ids.txt when present, otherwise catalog
+* non-graded = IDs in non-graded_milestone_ids.txt
+* graded = active - non-graded
+* effective DAG = unique base + additional edges with both endpoints active
+
+Milestone count, DeltaSrcLoC, and SrcLoC CV are computed over graded IDs.
+Dependency count is computed over the active DAG because non-graded milestones
+are still implemented by the agent and participate in scheduling.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import statistics
+import sys
+from collections import Counter, deque
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+
+
+TRANSITION_CATEGORIES = (
+    "pass_to_pass",
+    "pass_to_fail",
+    "pass_to_skipped",
+    "fail_to_pass",
+    "fail_to_fail",
+    "fail_to_skipped",
+    "skipped_to_pass",
+    "skipped_to_fail",
+    "skipped_to_skipped",
+    "none_to_pass",
+    "none_to_fail",
+    "none_to_skipped",
+    "pass_to_none",
+    "fail_to_none",
+    "skipped_to_none",
+)
+AGGREGATE_CATEGORIES = ("new_tests", "removed_tests")
+CLASSIFICATION_CATEGORIES = TRANSITION_CATEGORIES + AGGREGATE_CATEGORIES
+FILTER_KEYS = (
+    "invalid_fail_to_pass",
+    "invalid_none_to_pass",
+    "invalid_pass_to_pass",
+)
+REQUIRED_DEPENDENCY_COLUMNS = {
+    "source_id",
+    "target_id",
+    "type",
+    "strength",
+    "rationale",
+    "confidence_score",
+}
+README_BEGIN = "<!-- BEGIN GENERATED DATASET STATISTICS -->"
+README_END = "<!-- END GENERATED DATASET STATISTICS -->"
+
+
+# Display-only metadata. All numeric values are derived from dataset files.
+README_REPO_INFO = {
+    "zeromicro_go-zero_v1.6.0_v1.9.3": (
+        "[go-zero](https://github.com/zeromicro/go-zero)",
+        "Go",
+        "v1.6.0 \u2192 v1.9.3 (750d)",
+    ),
+    "element-hq_element-web_v1.11.95_v1.11.97": (
+        "[element-web](https://github.com/element-hq/element-web)",
+        "TypeScript",
+        "v1.11.95 \u2192 v1.11.97 (28d)",
+    ),
+    "nushell_nushell_0.106.0_0.108.0": (
+        "[nushell](https://github.com/nushell/nushell)",
+        "Rust",
+        "0.106.0 \u2192 0.108.0 (84d)",
+    ),
+    "apache_dubbo_dubbo-3.3.3_dubbo-3.3.6": (
+        "[dubbo](https://github.com/apache/dubbo)",
+        "Java",
+        "3.3.3 \u2192 3.3.6 (284d)",
+    ),
+    "scikit-learn_scikit-learn_1.5.2_1.6.0": (
+        "[scikit-learn](https://github.com/scikit-learn/scikit-learn)",
+        "Python",
+        "1.5.2 \u2192 1.6.0 (89d)",
+    ),
+    "BurntSushi_ripgrep_14.1.1_15.0.0": (
+        "[ripgrep](https://github.com/BurntSushi/ripgrep)",
+        "Rust",
+        "14.1.1 \u2192 15.0.0 (402d)",
+    ),
+    "navidrome_navidrome_v0.57.0_v0.58.0": (
+        "[navidrome](https://github.com/navidrome/navidrome)",
+        "Go",
+        "v0.57.0 \u2192 v0.58.0 (27d)",
+    ),
+}
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    severity: str
+    path: str
+    message: str
+
+
+@dataclass(frozen=True)
+class RepoStats:
+    repo: str
+    catalog_milestones: int
+    active_milestones: int
+    graded_milestones: int
+    non_graded_milestones: int
+    base_active_dependencies: int
+    additional_active_dependencies: int
+    active_dependencies: int
+    strong_dependencies: int
+    weak_dependencies: int
+    graded_src_loc: int
+    graded_src_loc_cv: float
+    roots: int
+    leaves: int
+    max_depth_edges: int
+
+
+class DatasetValidator:
+    def __init__(self, data_root: Path) -> None:
+        self.data_root = data_root.resolve()
+        self.diagnostics: list[Diagnostic] = []
+        self.stats: list[RepoStats] = []
+
+    def error(self, path: Path | str, message: str) -> None:
+        self._add("ERROR", path, message)
+
+    def warning(self, path: Path | str, message: str) -> None:
+        self._add("WARNING", path, message)
+
+    def info(self, path: Path | str, message: str) -> None:
+        self._add("INFO", path, message)
+
+    def _add(self, severity: str, path: Path | str, message: str) -> None:
+        path_obj = Path(path)
+        try:
+            display_path = str(path_obj.resolve().relative_to(self.data_root))
+        except (OSError, ValueError):
+            display_path = str(path)
+        self.diagnostics.append(Diagnostic(severity, display_path, message))
+
+    def validate(self) -> list[RepoStats]:
+        if not self.data_root.is_dir():
+            self.error(self.data_root, "data root does not exist or is not a directory")
+            return []
+
+        repo_dirs = sorted(
+            path
+            for path in self.data_root.iterdir()
+            if path.is_dir() and (path / "metadata.json").is_file()
+        )
+        if not repo_dirs:
+            self.error(self.data_root, "no repository directories containing metadata.json found")
+            return []
+
+        for repo_dir in repo_dirs:
+            stats = self._validate_repo(repo_dir)
+            if stats is not None:
+                self.stats.append(stats)
+        return self.stats
+
+    def _validate_repo(self, repo_dir: Path) -> RepoStats | None:
+        milestone_rows = self._read_csv(
+            repo_dir / "milestones.csv",
+            required_columns={"id", "src_loc", "src_additions", "src_deletions"},
+            required=True,
+        )
+        if milestone_rows is None:
+            return None
+
+        milestones: dict[str, dict[str, str]] = {}
+        for lineno, row in enumerate(milestone_rows, 2):
+            milestone_id = (row.get("id") or "").strip()
+            if not milestone_id:
+                self.error(repo_dir / "milestones.csv", f"line {lineno}: empty milestone ID")
+                continue
+            if milestone_id in milestones:
+                self.error(repo_dir / "milestones.csv", f"duplicate milestone ID {milestone_id!r}")
+                continue
+            milestones[milestone_id] = row
+            self._validate_loc_fields(repo_dir / "milestones.csv", lineno, milestone_id, row)
+
+        catalog = set(milestones)
+        if not catalog:
+            self.error(repo_dir / "milestones.csv", "catalog is empty")
+            return None
+
+        selected_path = repo_dir / "selected_milestone_ids.txt"
+        if selected_path.exists():
+            active_list = self._read_id_file(selected_path)
+            active = set(active_list)
+            if not active:
+                self.error(selected_path, "selected milestone set is empty")
+        else:
+            active = set(catalog)
+            self.info(repo_dir, "selected_milestone_ids.txt absent; active set defaults to catalog")
+
+        unknown_active = active - catalog
+        if unknown_active:
+            self.error(
+                selected_path,
+                f"active IDs missing from milestones.csv: {sorted(unknown_active)}",
+            )
+
+        non_graded_path = repo_dir / "non-graded_milestone_ids.txt"
+        non_graded = set(self._read_id_file(non_graded_path)) if non_graded_path.exists() else set()
+        unknown_non_graded = non_graded - active
+        if unknown_non_graded:
+            self.error(
+                non_graded_path,
+                f"non-graded IDs are not active: {sorted(unknown_non_graded)}",
+            )
+        graded = active - non_graded
+        if not graded:
+            self.error(repo_dir, "graded milestone set is empty")
+
+        self._validate_metadata(repo_dir / "metadata.json", active)
+        self._validate_artifact_directories(repo_dir, catalog)
+
+        classifications: dict[str, dict[str, set[str]]] = {}
+        for milestone_id in sorted(active):
+            self._validate_srs(repo_dir, milestone_id)
+            stable_ids = self._validate_classification(repo_dir, milestone_id)
+            if stable_ids is not None:
+                classifications[milestone_id] = stable_ids
+
+        for milestone_id, stable_ids in classifications.items():
+            self._validate_filter(repo_dir, milestone_id, stable_ids)
+
+        dependency_result = self._validate_dependencies(repo_dir, catalog, active)
+        (
+            base_active_count,
+            additional_active_count,
+            effective_edges,
+            strong_count,
+            weak_count,
+            roots,
+            leaves,
+            max_depth,
+        ) = dependency_result
+
+        src_locs = [
+            self._parse_nonnegative_int(milestones[mid].get("src_loc"))
+            for mid in sorted(graded)
+            if mid in milestones
+        ]
+        valid_src_locs = [value for value in src_locs if value is not None]
+        if len(valid_src_locs) != len(graded):
+            self.error(repo_dir / "milestones.csv", "cannot compute graded src_loc statistics")
+        graded_src_loc = sum(valid_src_locs)
+        graded_src_loc_cv = coefficient_of_variation(valid_src_locs)
+
+        return RepoStats(
+            repo=repo_dir.name,
+            catalog_milestones=len(catalog),
+            active_milestones=len(active),
+            graded_milestones=len(graded),
+            non_graded_milestones=len(non_graded),
+            base_active_dependencies=base_active_count,
+            additional_active_dependencies=additional_active_count,
+            active_dependencies=len(effective_edges),
+            strong_dependencies=strong_count,
+            weak_dependencies=weak_count,
+            graded_src_loc=graded_src_loc,
+            graded_src_loc_cv=graded_src_loc_cv,
+            roots=roots,
+            leaves=leaves,
+            max_depth_edges=max_depth,
+        )
+
+    def _read_csv(
+        self,
+        path: Path,
+        required_columns: set[str],
+        *,
+        required: bool,
+    ) -> list[dict[str, str]] | None:
+        if not path.exists():
+            if required:
+                self.error(path, "required CSV file is missing")
+            return None
+        try:
+            with path.open(newline="", encoding="utf-8-sig") as handle:
+                reader = csv.DictReader(handle)
+                columns = set(reader.fieldnames or [])
+                missing = required_columns - columns
+                if missing:
+                    self.error(path, f"missing required columns: {sorted(missing)}")
+                return [dict(row) for row in reader]
+        except (OSError, UnicodeError, csv.Error) as exc:
+            self.error(path, f"failed to parse CSV: {exc}")
+            return None
+
+    def _read_id_file(self, path: Path) -> list[str]:
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeError) as exc:
+            self.error(path, f"failed to read ID file: {exc}")
+            return []
+        ids = [line.strip() for line in lines if line.strip() and not line.lstrip().startswith("#")]
+        duplicates = sorted(value for value, count in Counter(ids).items() if count > 1)
+        if duplicates:
+            self.error(path, f"duplicate IDs: {duplicates}")
+        return ids
+
+    def _read_json(self, path: Path) -> Any | None:
+        if not path.exists():
+            self.error(path, "required JSON file is missing")
+            return None
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+            self.error(path, f"failed to parse JSON: {exc}")
+            return None
+
+    def _validate_loc_fields(
+        self,
+        path: Path,
+        lineno: int,
+        milestone_id: str,
+        row: dict[str, str],
+    ) -> None:
+        values: dict[str, int] = {}
+        for key in ("src_loc", "src_additions", "src_deletions"):
+            value = self._parse_nonnegative_int(row.get(key))
+            if value is None:
+                self.error(path, f"line {lineno} ({milestone_id}): {key} must be a non-negative integer")
+            else:
+                values[key] = value
+        if len(values) == 3 and values["src_loc"] != values["src_additions"] + values["src_deletions"]:
+            self.error(
+                path,
+                f"line {lineno} ({milestone_id}): src_loc != src_additions + src_deletions",
+            )
+
+    @staticmethod
+    def _parse_nonnegative_int(raw: Any) -> int | None:
+        if isinstance(raw, bool):
+            return None
+        try:
+            value = int(str(raw).strip())
+        except (TypeError, ValueError):
+            return None
+        return value if value >= 0 else None
+
+    def _validate_metadata(self, path: Path, active: set[str]) -> None:
+        metadata = self._read_json(path)
+        if not isinstance(metadata, dict):
+            if metadata is not None:
+                self.error(path, "metadata root must be an object")
+            return
+        raw_milestones = metadata.get("milestones")
+        if not isinstance(raw_milestones, list):
+            self.error(path, "metadata.milestones must be an array")
+            return
+        metadata_ids: list[str] = []
+        for index, item in enumerate(raw_milestones):
+            if not isinstance(item, dict) or not isinstance(item.get("id"), str) or not item["id"].strip():
+                self.error(path, f"metadata.milestones[{index}] must contain a non-empty string ID")
+                continue
+            metadata_ids.append(item["id"].strip())
+        duplicates = sorted(value for value, count in Counter(metadata_ids).items() if count > 1)
+        if duplicates:
+            self.error(path, f"duplicate metadata milestone IDs: {duplicates}")
+        missing_active = active - set(metadata_ids)
+        if missing_active:
+            self.error(path, f"active IDs missing from metadata.milestones: {sorted(missing_active)}")
+        total = metadata.get("total_milestones")
+        if total != len(metadata_ids):
+            self.error(path, f"total_milestones={total!r}, expected {len(metadata_ids)}")
+
+    def _validate_artifact_directories(self, repo_dir: Path, catalog: set[str]) -> None:
+        for dirname in ("srs", "test_results"):
+            root = repo_dir / dirname
+            if not root.is_dir():
+                self.error(root, "required directory is missing")
+                continue
+            unknown = sorted(path.name for path in root.iterdir() if path.is_dir() and path.name not in catalog)
+            if unknown:
+                self.error(root, f"directories reference IDs outside catalog: {unknown}")
+
+    def _validate_srs(self, repo_dir: Path, milestone_id: str) -> None:
+        path = repo_dir / "srs" / milestone_id / "SRS.md"
+        if not path.is_file():
+            self.error(path, "active milestone SRS is missing")
+            return
+        try:
+            if not path.read_text(encoding="utf-8").strip():
+                self.error(path, "SRS is empty")
+        except (OSError, UnicodeError) as exc:
+            self.error(path, f"failed to read SRS: {exc}")
+
+    def _validate_classification(
+        self,
+        repo_dir: Path,
+        milestone_id: str,
+    ) -> dict[str, set[str]] | None:
+        path = repo_dir / "test_results" / milestone_id / f"{milestone_id}_classification.json"
+        payload = self._read_json(path)
+        if not isinstance(payload, dict):
+            if payload is not None:
+                self.error(path, "classification root must be an object")
+            return None
+
+        summary = payload.get("summary")
+        if not isinstance(summary, dict):
+            self.error(path, "summary must be an object")
+        else:
+            for key, value in summary.items():
+                if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                    self.error(path, f"summary.{key} must be a non-negative integer")
+
+        parsed: dict[str, dict[str, set[str]]] = {}
+        for section_name in ("classification", "stable_classification"):
+            section = payload.get(section_name)
+            if not isinstance(section, dict):
+                self.error(path, f"{section_name} must be an object")
+                continue
+            missing = sorted(set(CLASSIFICATION_CATEGORIES) - set(section))
+            if missing:
+                self.error(path, f"{section_name} missing categories: {missing}")
+            section_ids: dict[str, set[str]] = {}
+            for category in CLASSIFICATION_CATEGORIES:
+                values = section.get(category)
+                if not isinstance(values, list):
+                    self.error(path, f"{section_name}.{category} must be an array")
+                    section_ids[category] = set()
+                    continue
+                aggregate = category in AGGREGATE_CATEGORIES
+                ids = self._validate_test_items(path, f"{section_name}.{category}", values, aggregate)
+                section_ids[category] = ids
+            parsed[section_name] = section_ids
+
+        full = parsed.get("classification")
+        stable = parsed.get("stable_classification")
+        if full is None or stable is None:
+            return None
+        for category in CLASSIFICATION_CATEGORIES:
+            outside = stable[category] - full[category]
+            if outside:
+                self.error(
+                    path,
+                    f"stable_classification.{category} contains {len(outside)} IDs absent from classification",
+                )
+
+        expected_new = stable["none_to_pass"] | stable["none_to_fail"] | stable["none_to_skipped"]
+        if stable["new_tests"] != expected_new:
+            self.warning(path, "stable new_tests does not equal the union of stable none_to_* categories")
+        expected_removed = stable["pass_to_none"] | stable["fail_to_none"] | stable["skipped_to_none"]
+        if stable["removed_tests"] != expected_removed:
+            self.warning(path, "stable removed_tests does not equal the union of stable *_to_none categories")
+        return stable
+
+    def _validate_test_items(
+        self,
+        path: Path,
+        label: str,
+        values: list[Any],
+        aggregate: bool,
+    ) -> set[str]:
+        ids: list[str] = []
+        for index, item in enumerate(values):
+            if aggregate:
+                if not isinstance(item, dict):
+                    self.error(path, f"{label}[{index}] must be an object with test_id")
+                    continue
+                test_id = item.get("test_id")
+            else:
+                if not isinstance(item, str):
+                    self.error(path, f"{label}[{index}] must be a string test ID")
+                    continue
+                test_id = item
+            if not isinstance(test_id, str) or not test_id.strip():
+                self.error(path, f"{label}[{index}] has an empty or invalid test_id")
+                continue
+            ids.append(test_id)
+        duplicates = sorted(value for value, count in Counter(ids).items() if count > 1)
+        if duplicates:
+            self.error(path, f"{label} contains {len(duplicates)} duplicate test IDs")
+        return set(ids)
+
+    def _validate_filter(
+        self,
+        repo_dir: Path,
+        milestone_id: str,
+        stable: dict[str, set[str]],
+    ) -> None:
+        path = repo_dir / "test_results" / milestone_id / f"{milestone_id}_filter_list.json"
+        if not path.exists():
+            return
+        payload = self._read_json(path)
+        if not isinstance(payload, dict):
+            if payload is not None:
+                self.error(path, "filter root must be an object")
+            return
+        unknown_keys = sorted(set(payload) - set(FILTER_KEYS))
+        if unknown_keys:
+            self.error(path, f"unknown filter keys: {unknown_keys}")
+        for required_key in FILTER_KEYS[:2]:
+            if required_key not in payload:
+                self.error(path, f"missing required filter key {required_key!r}")
+
+        parsed: dict[str, set[str]] = {}
+        for key in FILTER_KEYS:
+            values = payload.get(key, [])
+            if not isinstance(values, list):
+                self.error(path, f"{key} must be an array, not {type(values).__name__}")
+                parsed[key] = set()
+                continue
+            parsed[key] = self._validate_filter_items(path, key, values)
+
+        functional = parsed["invalid_fail_to_pass"] | parsed["invalid_none_to_pass"]
+        stable_functional = stable["fail_to_pass"] | stable["none_to_pass"]
+        stale_functional = functional - stable_functional
+        if stale_functional:
+            self.error(
+                path,
+                f"{len(stale_functional)} functional filter IDs are absent from stable F2P/N2P",
+            )
+        stale_p2p = parsed["invalid_pass_to_pass"] - stable["pass_to_pass"]
+        if stale_p2p:
+            self.error(path, f"{len(stale_p2p)} P2P filter IDs are absent from stable P2P")
+    def _validate_filter_items(self, path: Path, label: str, values: list[Any]) -> set[str]:
+        ids: list[str] = []
+        for index, item in enumerate(values):
+            if isinstance(item, str):
+                test_id = item
+            elif isinstance(item, dict):
+                test_id = item.get("test_id")
+                reason = item.get("reason")
+                if reason is not None and not isinstance(reason, str):
+                    self.error(path, f"{label}[{index}].reason must be a string when present")
+            else:
+                self.error(path, f"{label}[{index}] must be a string or object")
+                continue
+            if not isinstance(test_id, str) or not test_id.strip():
+                self.error(path, f"{label}[{index}] has an empty or invalid test_id")
+                continue
+            ids.append(test_id)
+        duplicates = sorted(value for value, count in Counter(ids).items() if count > 1)
+        if duplicates:
+            self.error(path, f"{label} contains {len(duplicates)} duplicate test IDs")
+        return set(ids)
+
+    def _validate_dependencies(
+        self,
+        repo_dir: Path,
+        catalog: set[str],
+        active: set[str],
+    ) -> tuple[int, int, dict[tuple[str, str], dict[str, str]], int, int, int, int, int]:
+        base_rows = self._read_csv(
+            repo_dir / "dependencies.csv",
+            required_columns=REQUIRED_DEPENDENCY_COLUMNS,
+            required=True,
+        ) or []
+        additional_rows = self._read_csv(
+            repo_dir / "additional_dependencies.csv",
+            required_columns=REQUIRED_DEPENDENCY_COLUMNS,
+            required=False,
+        ) or []
+
+        effective: dict[tuple[str, str], dict[str, str]] = {}
+        edge_origins: dict[tuple[str, str], str] = {}
+        active_to_inactive_count = 0
+        base_active_count = 0
+        additional_active_count = 0
+        for origin, rows in (("dependencies.csv", base_rows), ("additional_dependencies.csv", additional_rows)):
+            for lineno, row in enumerate(rows, 2):
+                path = repo_dir / origin
+                source = (row.get("source_id") or "").strip()
+                target = (row.get("target_id") or "").strip()
+                if not source or not target:
+                    self.error(path, f"line {lineno}: dependency endpoints must be non-empty")
+                    continue
+                edge = (source, target)
+                if source == target:
+                    self.error(path, f"line {lineno}: self-loop {source!r}")
+                unknown = sorted({source, target} - catalog)
+                if unknown:
+                    self.error(path, f"line {lineno}: endpoints missing from catalog: {unknown}")
+                strength = (row.get("strength") or "").strip().lower()
+                if strength not in {"strong", "weak"}:
+                    self.error(path, f"line {lineno}: strength must be Strong or Weak")
+                confidence_raw = (row.get("confidence_score") or "").strip()
+                try:
+                    confidence = float(confidence_raw)
+                    if not 0.0 <= confidence <= 1.0:
+                        raise ValueError
+                except ValueError:
+                    self.error(path, f"line {lineno}: confidence_score must be in [0, 1]")
+
+                if source not in active and target in active:
+                    self.error(path, f"line {lineno}: inactive prerequisite {source!r} targets active {target!r}")
+                elif source in active and target not in active:
+                    active_to_inactive_count += 1
+
+                if edge in edge_origins:
+                    self.error(
+                        path,
+                        f"line {lineno}: duplicate edge {source!r} -> {target!r}; first seen in {edge_origins[edge]}",
+                    )
+                    continue
+                edge_origins[edge] = f"{origin}:{lineno}"
+
+                if source in active and target in active:
+                    effective[edge] = row
+                    if origin == "dependencies.csv":
+                        base_active_count += 1
+                    else:
+                        additional_active_count += 1
+
+        if active_to_inactive_count:
+            self.info(
+                repo_dir,
+                f"excluded {active_to_inactive_count} active-to-inactive dependency edge(s)",
+            )
+
+        roots, leaves, max_depth = self._validate_active_dag(repo_dir, active, effective)
+        strengths = Counter((row.get("strength") or "").strip().lower() for row in effective.values())
+        return (
+            base_active_count,
+            additional_active_count,
+            effective,
+            strengths["strong"],
+            strengths["weak"],
+            roots,
+            leaves,
+            max_depth,
+        )
+
+    def _validate_active_dag(
+        self,
+        repo_dir: Path,
+        active: set[str],
+        edges: dict[tuple[str, str], dict[str, str]],
+    ) -> tuple[int, int, int]:
+        indegree = {node: 0 for node in active}
+        successors = {node: [] for node in active}
+        for source, target in edges:
+            indegree[target] += 1
+            successors[source].append(target)
+        roots = sorted(node for node, count in indegree.items() if count == 0)
+        leaves = sorted(node for node, targets in successors.items() if not targets)
+        queue = deque(roots)
+        remaining = dict(indegree)
+        depth = {node: 0 for node in active}
+        ordered = 0
+        while queue:
+            node = queue.popleft()
+            ordered += 1
+            for target in successors[node]:
+                depth[target] = max(depth[target], depth[node] + 1)
+                remaining[target] -= 1
+                if remaining[target] == 0:
+                    queue.append(target)
+        if ordered != len(active):
+            cyclic = sorted(node for node, count in remaining.items() if count > 0)
+            self.error(repo_dir, f"effective active DAG contains a cycle involving: {cyclic}")
+        return len(roots), len(leaves), max(depth.values(), default=0)
+
+
+def coefficient_of_variation(values: Sequence[int]) -> float:
+    if not values:
+        return 0.0
+    mean = statistics.fmean(values)
+    if mean == 0:
+        return 0.0
+    return statistics.pstdev(values) / mean
+
+
+def ordered_stats(stats: Iterable[RepoStats]) -> list[RepoStats]:
+    by_repo = {item.repo: item for item in stats}
+    ordered = [by_repo[name] for name in README_REPO_INFO if name in by_repo]
+    ordered.extend(by_repo[name] for name in sorted(set(by_repo) - set(README_REPO_INFO)))
+    return ordered
+
+
+def render_readme_stats(stats: Sequence[RepoStats]) -> str:
+    rows = ordered_stats(stats)
+    repo_count = len(rows)
+    graded_total = sum(row.graded_milestones for row in rows)
+    dependency_total = sum(row.active_dependencies for row in rows)
+    base_total = sum(row.base_active_dependencies for row in rows)
+    additional_total = sum(row.additional_active_dependencies for row in rows)
+    src_loc_total = sum(row.graded_src_loc for row in rows)
+    average_cv = statistics.fmean(row.graded_src_loc_cv for row in rows) if rows else 0.0
+
+    delta = "\u0394"
+    lines = [
+        README_BEGIN,
+        "",
+        (
+            f"SWE-Milestone covers **{repo_count} real-world open-source repositories** spanning "
+            f"5 programming languages, with **{graded_total} graded milestones**, "
+            f"**{dependency_total} active dependency edges** ({base_total} base + "
+            f"{additional_total} additional), and **{src_loc_total:,} total {delta}SrcLoC** "
+            "in graded gold patches."
+        ),
+        "",
+        f"| Repository | Language | Version Range | #Milestones | #Deps | {delta}SrcLoC | Src LoC CV |",
+        "|-----------|----------|---------------|:-----------:|:-----:|---------:|:----------:|",
+    ]
+    for row in rows:
+        display, language, version = README_REPO_INFO.get(row.repo, (f"`{row.repo}`", "-", "-"))
+        lines.append(
+            f"| {display} | {language} | {version} | {row.graded_milestones} | "
+            f"{row.active_dependencies} | {row.graded_src_loc:,} | {row.graded_src_loc_cv:.2f} |"
+        )
+
+    if rows:
+        average_milestones = graded_total / repo_count
+        average_dependencies = dependency_total / repo_count
+        average_src_loc = src_loc_total / repo_count
+    else:
+        average_milestones = average_dependencies = average_src_loc = 0.0
+    milestone_display = (
+        f"{average_milestones:.0f}"
+        if average_milestones.is_integer()
+        else f"{average_milestones:.1f}"
+    )
+    lines.extend(
+        [
+            (
+                f"| **Average** | | | **{milestone_display}** | **{average_dependencies:.1f}** | "
+                f"**{average_src_loc:,.0f}** | **{average_cv:.2f}** |"
+            ),
+            "",
+            "**Column definitions:**",
+            "- **#Milestones** - Number of graded milestones: active milestones excluding IDs in "
+            "`non-graded_milestone_ids.txt`.",
+            "- **#Deps** - Number of unique edges in the active DAG. It combines `dependencies.csv` "
+            "and `additional_dependencies.csv`, then keeps edges whose two endpoints are active. "
+            "Non-graded milestones remain part of this DAG because the agent still implements them.",
+            f"- **{delta}SrcLoC** - Sum of `src_loc` over graded milestones only. `src_loc` equals "
+            "`src_additions + src_deletions` and excludes test-only changes according to each repository's metadata.",
+            "- **Src LoC CV** - Population coefficient of variation (`pstdev / mean`) of graded "
+            "milestone `src_loc` values.",
+            "- **Active milestones** - IDs from `selected_milestone_ids.txt` when that file exists; "
+            "otherwise every ID in `milestones.csv`.",
+            "",
+            README_END,
+        ]
+    )
+    return "\n".join(lines)
+
+
+def update_readme(readme_path: Path, block: str) -> None:
+    text = readme_path.read_text(encoding="utf-8")
+    if README_BEGIN in text and README_END in text:
+        start = text.index(README_BEGIN)
+        end = text.index(README_END, start) + len(README_END)
+        updated = text[:start] + block + text[end:]
+    else:
+        heading = "## Dataset Statistics"
+        next_heading = "## Dataset Structure"
+        heading_pos = text.find(heading)
+        if heading_pos < 0:
+            raise ValueError(f"README is missing {heading!r}")
+        content_start = text.find("\n", heading_pos + len(heading))
+        section_end = text.find(f"\n{next_heading}", content_start)
+        if content_start < 0 or section_end < 0:
+            raise ValueError("could not locate Dataset Statistics section boundaries")
+        updated = text[: content_start + 1] + "\n" + block + "\n" + text[section_end:]
+    if not updated.endswith("\n"):
+        updated += "\n"
+    readme_path.write_text(updated, encoding="utf-8")
+
+
+def check_readme(readme_path: Path, expected_block: str) -> str | None:
+    try:
+        text = readme_path.read_text(encoding="utf-8")
+    except (OSError, UnicodeError) as exc:
+        return f"failed to read README: {exc}"
+    if README_BEGIN not in text or README_END not in text:
+        return "generated statistics markers are missing; run with --write-readme"
+    start = text.index(README_BEGIN)
+    end = text.index(README_END, start) + len(README_END)
+    actual = text[start:end]
+    if actual != expected_block:
+        return "generated statistics are stale; run with --write-readme"
+    return None
+
+
+def build_parser() -> argparse.ArgumentParser:
+    default_root = Path(__file__).resolve().parents[1]
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--data-root",
+        type=Path,
+        default=default_root,
+        help=f"dataset root (default: {default_root})",
+    )
+    parser.add_argument(
+        "--write-readme",
+        action="store_true",
+        help="replace the generated Dataset Statistics block in README.md",
+    )
+    parser.add_argument(
+        "--skip-readme",
+        action="store_true",
+        help="do not check README.md statistics",
+    )
+    parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
+    parser.add_argument(
+        "--strict-warnings",
+        action="store_true",
+        help="return non-zero when warnings are present",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    validator = DatasetValidator(args.data_root)
+    stats = validator.validate()
+    expected_block = render_readme_stats(stats)
+    readme_path = args.data_root.resolve() / "README.md"
+
+    if args.write_readme:
+        try:
+            update_readme(readme_path, expected_block)
+            validator.info(readme_path, "updated generated Dataset Statistics block")
+        except (OSError, UnicodeError, ValueError) as exc:
+            validator.error(readme_path, f"failed to update README: {exc}")
+    elif not args.skip_readme:
+        problem = check_readme(readme_path, expected_block)
+        if problem:
+            validator.error(readme_path, problem)
+
+    counts = Counter(item.severity for item in validator.diagnostics)
+    summary = {
+        "repositories": len(stats),
+        "catalog_milestones": sum(item.catalog_milestones for item in stats),
+        "active_milestones": sum(item.active_milestones for item in stats),
+        "graded_milestones": sum(item.graded_milestones for item in stats),
+        "non_graded_milestones": sum(item.non_graded_milestones for item in stats),
+        "active_dependencies": sum(item.active_dependencies for item in stats),
+        "base_active_dependencies": sum(item.base_active_dependencies for item in stats),
+        "additional_active_dependencies": sum(item.additional_active_dependencies for item in stats),
+        "graded_src_loc": sum(item.graded_src_loc for item in stats),
+        "errors": counts["ERROR"],
+        "warnings": counts["WARNING"],
+        "info": counts["INFO"],
+    }
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "summary": summary,
+                    "repositories": [asdict(item) for item in ordered_stats(stats)],
+                    "diagnostics": [asdict(item) for item in validator.diagnostics],
+                },
+                indent=2,
+                sort_keys=True,
+            )
+        )
+    else:
+        print(
+            "Dataset summary: "
+            f"{summary['repositories']} repos, {summary['catalog_milestones']} catalog, "
+            f"{summary['active_milestones']} active, {summary['graded_milestones']} graded, "
+            f"{summary['active_dependencies']} active dependencies "
+            f"({summary['base_active_dependencies']} base + "
+            f"{summary['additional_active_dependencies']} additional), "
+            f"{summary['graded_src_loc']:,} graded src_loc"
+        )
+        severity_order = {"ERROR": 0, "WARNING": 1, "INFO": 2}
+        for item in sorted(
+            validator.diagnostics,
+            key=lambda value: (severity_order[value.severity], value.path, value.message),
+        ):
+            print(f"{item.severity}: {item.path}: {item.message}")
+        print(
+            f"Validation result: {counts['ERROR']} error(s), "
+            f"{counts['WARNING']} warning(s), {counts['INFO']} info message(s)"
+        )
+
+    failed = counts["ERROR"] > 0 or (args.strict_warnings and counts["WARNING"] > 0)
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M007.1/M007.1_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M007.2/M007.2_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M008/M008_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M009/M009_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M010/M010_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M013/M013_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M014/M014_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M017/M017_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M018/M018_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M019/M019_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M020/M020_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M021/M021_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M022/M022_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M023/M023_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M025/M025_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M026/M026_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M027/M027_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }

zeromicro_go-zero_v1.6.0_v1.9.3/test_results/M028/M028_filter_list.json

@@ -1,4 +1,4 @@
 {
-  "invalid_fail_to_pass": null,
-  "invalid_none_to_pass": null
+  "invalid_fail_to_pass": [],
+  "invalid_none_to_pass": []
 }