fix(profiling): don't report sibling-instrument records as malformed

jax_compile/ hosts export_probe.py and trace_profile.py, which append their
own schema into the SAME results/<hardware>/ tree probe.py writes to. Their
records have no hardware/dataset_class/instrument because they are a different
record kind, not because they are corrupt -- so the 4 the mode was reporting
as malformed would have sent someone to fix two files that work correctly.

Split the two: missing the whole identity triple is a sibling instrument
(reported per file, under its own bucket); missing only some key fields is
genuine corruption and stays malformed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L4STU81pQP1GkMzZVvsMsv

Author: claude

agents/conductors/profiling/AGENTS.md

@@ -57,6 +57,12 @@ Records whose cell is not in the sweep grid (`knn`, `delaunay_matern`, the
 non-tier hardware in an **other-hardware** bucket. Both are real measurements —
 neither counts as grid coverage, and neither is silently dropped.
 
+`jax_compile/` also hosts sibling instruments (`export_probe.py`,
+`trace_profile.py`) that append their own schema into the same
+`results/<hardware>/` tree. Records missing the whole `(hardware, dataset_class,
+instrument)` identity triple are reported as **sibling-instrument** records, not
+as malformed — only a record missing *some* of its key fields is corruption.
+
 ## Fundamental principles
 
 - **The classification is the result** for CPU-unusable cells (the usability

agents/conductors/profiling/_profiling.py

@@ -57,6 +57,9 @@
 
 # Fields a compile record needs before it can be placed on the grid at all.
 COMPILE_KEY_FIELDS = ("hardware", "dataset_class", "model_type", "instrument")
+# Absent *together*, these mark a record written by a sibling instrument sharing
+# the results tree rather than a corrupt probe record.
+COMPILE_IDENTITY_FIELDS = ("hardware", "dataset_class", "instrument")
 
 
 def workspace_root(explicit: str | None = None) -> Path:
@@ -247,16 +250,22 @@ def campaign_compile(ws: Path, tier: str) -> dict[str, Any]:
     covered: set[tuple[tuple[str, str, str | None], str]] = set()
     off_grid: dict[str, int] = {}
     other_hw: dict[str, int] = {}
+    foreign: dict[str, int] = {}
     malformed: list[dict[str, Any]] = []
 
     for rel, idx, rec in load_compile_corpus(ws):
-        if any(rec.get(f) in (None, "") for f in COMPILE_KEY_FIELDS):
+        absent = [f for f in COMPILE_KEY_FIELDS if rec.get(f) in (None, "")]
+        if set(absent) >= set(COMPILE_IDENTITY_FIELDS):
+            # Not corruption: jax_compile/ hosts sibling instruments
+            # (export_probe.py, trace_profile.py) that append their own schema
+            # into the SAME results/<hardware>/ tree. Missing the whole identity
+            # triple means "another instrument's record", and calling that
+            # malformed would send someone to fix a file that is working.
+            foreign[rel] = foreign.get(rel, 0) + 1
+            continue
+        if absent:
             malformed.append(
-                {
-                    "record": f"{rel}[{idx}]",
-                    "missing": [f for f in COMPILE_KEY_FIELDS if rec.get(f) in (None, "")],
-                    "tag": rec.get("tag"),
-                }
+                {"record": f"{rel}[{idx}]", "missing": absent, "tag": rec.get("tag")}
             )
             continue
         rec_tier = compile_tier_of(rec.get("hardware"))
@@ -314,6 +323,7 @@ def campaign_compile(ws: Path, tier: str) -> dict[str, Any]:
         "runs_missing": len(missing),
         "missing": missing,
         "off_grid": [{"cell": c, "records": n} for c, n in sorted(off_grid.items())],
+        "foreign_records": [{"file": f, "records": n} for f, n in sorted(foreign.items())],
         "other_hardware": [{"hardware": h, "records": n} for h, n in sorted(other_hw.items())],
         "malformed": malformed,
         "policy": (
@@ -481,6 +491,10 @@ def emit_human(d: dict[str, Any]) -> None:
             print("Other hardware (neither tier):")
             for o in d["other_hardware"]:
                 print(f"  {o['hardware']}: {o['records']} record(s)")
+        if d["foreign_records"]:
+            print("Sibling-instrument records (not probe.py's schema):")
+            for f in d["foreign_records"]:
+                print(f"  {f['file']}: {f['records']} record(s)")
         if d["malformed"]:
             print(f"Malformed records:    {len(d['malformed'])}")
             for m in d["malformed"][:10]:

tests/test_profiling_conductor.py

@@ -123,19 +123,39 @@ def test_off_grid_records_are_reported_not_dropped(tmp_path):
     assert d["off_grid"] == [{"cell": "imaging/knn/hst", "records": 2}]
 
 
-def test_malformed_records_are_bucketed_with_their_location(tmp_path):
+def test_sibling_instrument_records_are_not_called_malformed(tmp_path):
+    """export_probe.py / trace_profile.py share the results tree with probe.py.
+
+    Their records lack the whole identity triple because they are a different
+    schema, not because they are corrupt — reporting them as malformed would
+    send someone to fix a file that is working correctly.
+    """
     ws = _workspace(tmp_path, {
         "local_cpu/export_probe.json": [
-            {"transform": "jit", "model_type": "mge", "tag": "census"},   # no hardware/class/instrument
-            _record(),
+            {"transform": "jit", "model_type": "mge", "tag": "census"},
+            {"transform": "vag", "model_type": "mge", "tag": "census"},
         ],
+        "local_cpu/mge.json": [_record()],
+    })
+    d = json.loads(_run(["campaign", "--axis", "compile", "--json"], ws).stdout)
+
+    assert d["malformed"] == []
+    assert d["foreign_records"] == [{"file": "local_cpu/export_probe.json", "records": 2}]
+    assert d["runs_done"] == 1, "the real probe record still counts"
+
+
+def test_a_genuinely_incomplete_probe_record_is_still_malformed(tmp_path):
+    """One field missing is corruption; the whole identity triple is a sibling."""
+    ws = _workspace(tmp_path, {
+        "local_cpu/mge.json": [_record(instrument=None), _record()],
     })
     d = json.loads(_run(["campaign", "--axis", "compile", "--json"], ws).stdout)
 
+    assert d["foreign_records"] == []
     assert len(d["malformed"]) == 1
     m = d["malformed"][0]
-    assert m["record"] == "local_cpu/export_probe.json[0]"
-    assert set(m["missing"]) == {"hardware", "dataset_class", "instrument"}
+    assert m["record"] == "local_cpu/mge.json[0]"
+    assert m["missing"] == ["instrument"]
     assert d["runs_done"] == 1, "the well-formed sibling record still counts"