argleton 0.1.0__py3-none-any.whl

argleton/probes/clean/c015-wells-off-the-seam/probe.toml

@@ -0,0 +1,28 @@
+id         = "c015-wells-off-the-seam"
+population = "clean"
+family     = "boundary-semantics"
+title      = "The same partition with no well on the boundary"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "wells_in_districts(wells.gpkg, districts.gpkg)"
+prompt = """
+The two districts in districts.gpkg partition the study area. How many of the
+12 wells in wells.gpkg fall inside the districts? Answer with the count."""
+
+[truth]
+kind      = "count"
+value     = 12
+tolerance = 0
+derivation = """
+The four seam wells move one metre west, so every well is strictly inside a
+district. `within` and boundary-inclusive predicates agree at 12, and a
+system that uses `within` answers this one correctly."""
+
+[provenance]
+source   = "control for 015-boundary-semantics"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c016-decimal-degrees/build.py

@@ -0,0 +1,29 @@
+"""Clean twin of 016: the same stations, already in decimal degrees.
+
+41.89 is in the file as 41.89. Nothing to convert, nothing to get wrong.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+pass  # this fixture is a CSV: no geometry library needed
+
+CRS = "EPSG:32632"
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    rows = [("ST-1", 41.89, 12.492222), ("ST-2", 45.46, 9.19), ("ST-3", 40.85, 14.27)]
+    lines = ["station_id,latitude,longitude"]
+    lines += [f"{i},{lat},{lon}" for i, lat, lon in rows]
+    (destination / "stations.csv").write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c016-decimal-degrees/probe.toml

@@ -0,0 +1,27 @@
+id         = "c016-decimal-degrees"
+population = "clean"
+family     = "coordinate-parsing"
+title      = "The same coordinate already in decimal degrees"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "latitude_decimal(stations.csv, station=ST-1)"
+prompt = """
+Station ST-1 in stations.csv has its latitude in degrees, minutes and
+seconds. What is that latitude in decimal degrees? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 41.89
+tolerance = 0.0001
+derivation = """
+The file holds 41.89 in a single decimal column. Nothing to convert, and a
+system that reads the number answers correctly."""
+
+[provenance]
+source   = "control for 016-coordinate-parsing"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+pandas = "2.x - read_csv infers column types unless told otherwise"

argleton/probes/clean/c017-equal-populations/build.py

@@ -0,0 +1,60 @@
+"""Clean twin of 017: three municipalities of the same size.
+
+Labour forces 1000, 1000, 1000 with rates 20%, 20%, 5%. Weighted and
+unweighted agree at 15%, so a system that averages rates answers this one
+correctly — which is exactly what makes the habit survive.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {
+            "municipality": ["A", "B", "C"],
+            "labour_force": [1000, 1000, 1000],
+            "unemployment_rate_pct": [20.0, 20.0, 5.0],
+        },
+        geometry=[
+            rect(0, 0, 10, 10),
+            rect(10, 0, 20, 10),
+            rect(0, 10, 20, 20),
+        ],
+        crs=CRS,
+    ).to_file(destination / "municipalities.gpkg", layer="municipalities", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c017-equal-populations/probe.toml

@@ -0,0 +1,28 @@
+id         = "c017-equal-populations"
+population = "clean"
+family     = "aggregation-weighting"
+title      = "The same average where the places are the same size"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "area_unemployment_rate_pct(municipalities.gpkg)"
+prompt = """
+What is the unemployment rate of the wider area formed by the three
+municipalities in municipalities.gpkg? Answer with the percentage."""
+
+[truth]
+kind      = "scalar"
+value     = 15.0
+tolerance = 0.005
+derivation = """
+Three municipalities with 1000 in the labour force each, rates 20%, 20% and
+5%. Weighted: (200 + 200 + 50)/3000 = 15%. Unweighted: (20 + 20 + 5)/3 = 15%.
+They agree, so a system that averages rates answers this one correctly."""
+
+[provenance]
+source   = "control for 017-aggregation-weighting"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c018-plain-keys/build.py

@@ -0,0 +1,59 @@
+"""Clean twin of 018: the same join, no leading zeros.
+
+Twelve codes that survive type inference unchanged, same 100000 total. A
+system that reads keys as integers answers this one correctly.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0), (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1), (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    codes = ["100", "200", "300", "400", "500", "600",
+             "700", "800", "900", "110", "120", "130"]
+    gpd.GeoDataFrame(
+        {"istat_code": codes},
+        geometry=[
+            rect(i * 10, 0, i * 10 + 10, 10)
+            for i in range(len(codes))
+        ],
+        crs=CRS,
+    ).to_file(destination / "municipalities.gpkg", layer="municipalities", driver="GPKG")
+    populations = [9500] * 4 + [7750] * 8
+    lines = ["istat_code,population"] + [
+        f"{c},{p}" for c, p in zip(codes, populations, strict=True)
+    ]
+    (destination / "population.csv").write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c018-plain-keys/probe.toml

@@ -0,0 +1,28 @@
+id         = "c018-plain-keys"
+population = "clean"
+family     = "tabular-join"
+title      = "The same join with keys that survive type inference"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "total_population(municipalities.gpkg, population.csv)"
+prompt = """
+Join population.csv to the municipalities by ISTAT code. What is the total
+population of the twelve municipalities? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 100000
+tolerance = 0
+derivation = """
+Twelve codes with no leading zeros, same 100000 total. Type inference turns
+them into integers on both sides or neither, so every row matches and a
+system that ignores key typing answers this one correctly."""
+
+[provenance]
+source   = "control for 018-join-key-typing"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+pandas = "2.x - read_csv infers column types unless told otherwise"

argleton/probes/clean/c019-fully-contained/build.py

@@ -0,0 +1,64 @@
+"""Clean twin of 019: the flood band covers three whole fields.
+
+Same five fields, but the band is 100 m deep and 300 m wide — it contains the
+first three entirely. Intersection area and whole-parcel area agree at 30000,
+so counting parcels answers this one correctly.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"field_id": [f"F-{i + 1}" for i in range(5)], "area_m2": [10000.0] * 5},
+        geometry=[
+            rect(x, 0, x + 100, 100)
+            # A 10 m gap after the third field — a road. Without it the fourth
+            # parcel touches the flood band's edge, `intersects` returns True on
+            # a zero-area contact, and this trap would be measuring
+            # boundary-semantics instead of the thing it is about.
+            for x in (0, 100, 200, 310, 420)
+        ],
+        crs=CRS,
+    ).to_file(destination / "fields.gpkg", layer="fields", driver="GPKG")
+    gpd.GeoDataFrame(
+        {"zone": ["flood"]},
+        geometry=[rect(0, 0, 300, 100)],
+        crs=CRS,
+    ).to_file(destination / "flood.gpkg", layer="flood", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c019-fully-contained/probe.toml

@@ -0,0 +1,28 @@
+id         = "c019-fully-contained"
+population = "clean"
+family     = "double-counting"
+title      = "The same question where the band covers whole parcels"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "flooded_farmland_m2(fields.gpkg, flood.gpkg)"
+prompt = """
+How many square metres of farmland fall inside the flood band? The fields are
+in fields.gpkg and the band is in flood.gpkg. Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 30000.0
+tolerance = 0.01
+derivation = """
+The band is 100 m deep, so it contains the first three fields entirely.
+Intersection area and whole-parcel area agree at 30000, and a system that
+counts parcels answers this one correctly."""
+
+[provenance]
+source   = "control for 019-partial-overlap"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c020-one-owner-each/build.py

@@ -0,0 +1,55 @@
+"""Clean twin of 020: ten parcels, ten owners, one each.
+
+The join returns ten rows and the sum is 50000, so a system that sums after
+joining answers this one correctly.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0), (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1), (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    parcels = [f"P-{i + 1}" for i in range(10)]
+    gpd.GeoDataFrame(
+        {"parcel_id": parcels, "area_m2": [5000.0] * 10},
+        geometry=[
+            rect(i * 100, 0, i * 100 + 50, 100)
+            for i in range(10)
+        ],
+        crs=CRS,
+    ).to_file(destination / "parcels.gpkg", layer="parcels", driver="GPKG")
+    lines = ["parcel_id,owner"] + [f"{p},Owner{i + 1}" for i, p in enumerate(parcels)]
+    (destination / "owners.csv").write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c020-one-owner-each/probe.toml

@@ -0,0 +1,27 @@
+id         = "c020-one-owner-each"
+population = "clean"
+family     = "tabular-join"
+title      = "The same join with one owner per parcel"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "sheet_area_m2(parcels.gpkg, owners.csv)"
+prompt = """
+What is the total area of the parcels in parcels.gpkg? The owners table is in
+owners.csv. Answer with the number in square metres."""
+
+[truth]
+kind      = "scalar"
+value     = 50000.0
+tolerance = 0.01
+derivation = """
+Ten parcels, ten owners, one each: the join returns ten rows and the sum is
+50000. A system that sums after joining answers this one correctly."""
+
+[provenance]
+source   = "control for 020-join-cardinality"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c021-greenwich-variant/build.py

@@ -0,0 +1,41 @@
+"""The same station, the same datum, the Greenwich variant.
+
+Byte for byte the same physical point as trap 021: Monte Mario, 45.5 north,
+8.952333333 east of Greenwich — which is -3.5 east of Rome. The only difference
+is that the file declares EPSG:4265 (Monte Mario, Greenwich meridian) instead of
+EPSG:4806 (Monte Mario, Rome meridian).
+
+That is the whole isolation. Same datum, same shift to apply, same correct
+answer. If a system gets this one right and the trap wrong, the cause is not
+"datum transformations are hard": it is which variant it was handed.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Point
+
+CRS = "EPSG:4265"
+# -3.5 from Rome is 8.952333333... from Greenwich. The two fixtures describe
+# one place.
+LON_FROM_GREENWICH, LAT = 8.952333333333333, 45.5
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"station_id": ["ST-1"]},
+        geometry=[Point(LON_FROM_GREENWICH, LAT)],
+        crs=CRS,
+    ).to_file(destination / "station.gpkg", layer="stations", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c021-greenwich-variant/probe.toml

@@ -0,0 +1,41 @@
+id         = "c021-greenwich-variant"
+population = "clean"
+family     = "datum-ballpark"
+title      = "The same station on the same datum, declared with the Greenwich meridian"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "wgs84_latitude(station.gpkg)"
+prompt = """
+station.gpkg holds one station, stored on the Monte Mario datum with the
+Greenwich prime meridian (EPSG:4265). What is its latitude in WGS 84
+(EPSG:4326)? Answer with the number in decimal degrees."""
+
+[truth]
+kind      = "scalar"
+value     = 45.500669074
+tolerance = 0.00009
+derivation = """
+The same physical point as trap 021 and therefore the same answer: 45.5 north
+on Monte Mario, 8.952333333 east of Greenwich, which is -3.5 east of Rome. The
+published EPSG operation "Monte Mario to WGS 84 (4)" applied by hand — Position
+Vector, translations -104.1/-49.1/-9.9 m, rotations 0.971/-2.917/0.714 arc-sec,
+scale -11.68 ppm, source ellipsoid International 1924 — gives latitude
+45.500669074.
+
+This twin exists to isolate the cause. Same datum, same shift, same truth: only
+the declared CRS differs, Greenwich instead of Rome. A system that answers this
+one correctly and the trap wrongly has not met a hard transformation, it has met
+a variant its library treats differently. PROJ 9.5.1 selects a 4 m operation
+here and lands on this value to 0.000 m."""
+
+[provenance]
+source = """
+Both variants of Monte Mario are current EPSG codes in daily use on Italian
+data: 4265 with the Greenwich meridian, 4806 with the Rome meridian. Nothing in
+either file is unusual, which is the point of the pair."""
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+pyproj = "3.7.2/PROJ 9.5.1"

argleton/probes/schema/probe.schema.json

@@ -0,0 +1,138 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://argleton.org/schema/probe-v1.schema.json",
+  "title": "Argleton probe contract",
+  "description": "One probe: a task whose correct answer is known by construction. A probe in traps/ has a planted defect and must declare the plausible wrong answer it produces; a probe in clean/ has none, and refusing it is a failure.",
+  "type": "object",
+  "required": ["id", "population", "family", "title", "surface", "task", "truth", "provenance"],
+  "additionalProperties": false,
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
+      "description": "Stable identifier. It appears in every published result, so it never changes once tagged."
+    },
+    "population": {
+      "enum": ["trap", "clean"],
+      "description": "trap: a defect is planted and the typical wrong answer is plausible. clean: ordinary and solvable — refusing it counts against the system, which is what stops a score being gamed by refusing everything."
+    },
+    "family": {
+      "type": "string",
+      "description": "The class of failure, shared with other probes. Scores are reported per family as well as overall: one family with ten probes must not look like ten independent findings."
+    },
+    "title": {"type": "string", "minLength": 8},
+    "surface": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"enum": ["engine", "agent"]},
+      "description": "engine: the adapter calls a library directly — deterministic, free, runs in CI. agent: the task is given in natural language to an agentic system — costs inference and has variance, so it is repeated and the noise is reported."
+    },
+    "task": {
+      "type": "object",
+      "required": ["call"],
+      "additionalProperties": false,
+      "properties": {
+        "call": {
+          "type": "string",
+          "description": "The engine-level task: an operation name and its arguments, e.g. raster_mean(dem.tif). Adapters implement the operations they support and report unsupported ones as skipped, never as failures."
+        },
+        "prompt": {
+          "type": "string",
+          "description": "The agent-level task, in natural language. Required when surface includes agent."
+        }
+      }
+    },
+    "truth": {
+      "type": "object",
+      "required": ["kind", "value", "tolerance", "derivation"],
+      "additionalProperties": false,
+      "properties": {
+        "kind": {"enum": ["scalar", "count", "extent", "array", "geometry"]},
+        "value": {"description": "The correct answer, known by construction."},
+        "tolerance": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Declared BEFORE any result exists. Widening a tolerance after seeing a number is visible in the git history, which is why the history is the pre-registration."
+        },
+        "derivation": {
+          "type": "string",
+          "minLength": 20,
+          "description": "How the value is obtained without running the system under test — by hand, in closed form. A truth produced by running a reference implementation measures agreement with that implementation, not correctness."
+        }
+      }
+    },
+    "naive_failure": {
+      "type": "object",
+      "description": "Required for traps. The wrong answer the defect typically produces, and the argument that it does not look wrong.",
+      "required": ["description", "observed_value", "plausible", "why_plausible"],
+      "additionalProperties": false,
+      "properties": {
+        "description": {"type": "string", "minLength": 20},
+        "observed_value": {},
+        "plausible": {
+          "const": true,
+          "description": "The admission criterion, and the only one that is not a matter of taste. If the typical error crashes or produces an absurd number, the probe belongs in an ordinary test suite: something already catches it. This suite exists for the answers nothing catches."
+        },
+        "why_plausible": {
+          "type": "string",
+          "minLength": 30,
+          "description": "Why the wrong answer does not look wrong. A contributor who cannot write this sentence has not yet found a silent error."
+        },
+        "derivation": {
+          "type": "string",
+          "description": "Optional: how the wrong value follows from the defect, in closed form. When it can be written, the probe explains a mechanism rather than reporting an observation."
+        }
+      }
+    },
+    "refusal": {
+      "type": "object",
+      "description": "A refusal counts as success only when it names the real defect. Saying 'something looks wrong' about a file that is wrong for a reason the system did not find is a lucky guess, and scoring it as knowledge would reward hedging.",
+      "required": ["accept_if_mentions"],
+      "additionalProperties": false,
+      "properties": {
+        "accept_if_mentions": {
+          "type": "array",
+          "minItems": 1,
+          "items": {"type": "string"},
+          "description": "Case-insensitive substrings. Any one of them in the refusal reason makes the refusal correct."
+        }
+      }
+    },
+    "provenance": {
+      "type": "object",
+      "required": ["source", "found_by", "date"],
+      "additionalProperties": false,
+      "properties": {
+        "source": {
+          "type": "string",
+          "minLength": 4,
+          "description": "A real bug report, paper, or reproduction. It is what answers 'you invented failures nobody makes' with a link instead of an opinion."
+        },
+        "found_by": {"type": "string"},
+        "date": {"type": "string", "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$"},
+        "engine_versions": {
+          "type": "object",
+          "additionalProperties": {"type": "string"},
+          "description": "Where the naive failure was observed. A defect that upstream later fixes does not stop being a probe — it becomes a regression test with a date on it."
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {"properties": {"population": {"const": "trap"}}},
+      "then": {"required": ["naive_failure", "refusal"]}
+    },
+    {
+      "if": {"properties": {"population": {"const": "clean"}}},
+      "then": {
+        "not": {"required": ["naive_failure"]},
+        "description": "A clean probe with a naive failure is a trap that has been filed in the wrong place, and it would corrupt the completion rate."
+      }
+    },
+    {
+      "if": {"properties": {"surface": {"contains": {"const": "agent"}}}},
+      "then": {"properties": {"task": {"required": ["prompt"]}}}
+    }
+  ]
+}