Unify forward-pass iteration measurements (#7)

- Unify forward-pass iteration measurements (945f92e8e21b2ab4fb57292fb0397b79787d7ce2)
- Clarify measurement grouping methods (ef5d1b56b18b410e7acf06e9028d726dd8640aa1)
- Align synchronized iteration provenance (1f40833972a1d55f541b1fdd37d9ceb4cfb6711c)
- Require listener join evidence per rank (e0bb6ccaa82b9aaf65e79d609f72fd8774120114)
- Model synchronized DP rank latency explicitly (5306df84733acb87c44ef92ae5d196221a4e2890)

README.md

@@ -91,10 +91,24 @@ coordinates, row order, and row count. Each affected sidecar records the
 
 Usable measurement bundles declare one of two semantic protocols:
 
-- `forward-pass-measurement-v1` contains exact scheduler observations and
-  measured wall time. Rank streams and synchronized iteration groups are two
-  representations of this protocol, not separate protocols. See
-  [`schemas/forward-pass-measurement-v1.schema.json`](schemas/forward-pass-measurement-v1.schema.json).
+- `forward-pass-measurement-v1`:
+
+  - Normalizes exact scheduler observations into one synchronized iteration.
+  - Retains one measurement for every contributing rank and caches
+    `max_rank_wall_time` as the default complete-iteration truth. Consumers may
+    derive another latency policy from the authoritative rank measurements.
+  - Distinguishes two source kinds:
+    - `self_benchmark`: a benchmark producer groups ranks by `benchmark_id`.
+    - `rank_event_stream`: rank-local events are either evaluated directly for
+      one rank or joined using a declared corrected receive-time window.
+  - `producer` identifies the component that creates rank-local FPM records.
+    Optional `collector` provenance identifies a separate capture component;
+    it is required when grouping by `listener_receive_time_window`.
+  - `grouping` records the membership method and its authority. Rank-local
+    counters, file position, and exact timestamp equality are never cross-rank
+    join keys.
+  - Schema:
+    [`forward-pass-measurement-v1.schema.json`](schemas/forward-pass-measurement-v1.schema.json).
 - `forward-pass-record-v1` contains a reduced, self-contained point:
   scheduled batch/token coordinates plus observed latency. The current
   DSV4-Pro derived CSV files use this protocol because their raw streams are
@@ -163,8 +177,8 @@ references or filtering `catalog/index.parquet` by `snapshot_status`.
 - Consumers verify every recorded SHA-256 before loading data.
 - FPM Gym records the pinned dataset commit and AISim commit for each evaluation.
 - Missing or invalid measurement evidence remains visible as a gap; it is never scored.
-- Raw logs, reproduction scripts, reports, per-rank duplicates, and wholesale
-  prediction directories are not mirrored.
+- Raw logs, reproduction scripts, reports, redundant copies of rank streams,
+  and wholesale prediction directories are not mirrored.
 
 The repository must remain private. Retained provenance contains internal paths
 and network metadata, and the source has no approved redistribution license.

docs/measurement-protocols.md

@@ -20,35 +20,74 @@ unknown protocol is an incompatible contract and must fail validation.
 
 ## `forward-pass-measurement-v1`
 
-This protocol retains the captured scheduler state. Its core rank record stores
-the worker and rank identity, counter, wall time, scheduled requests, and queued
-requests.
+This protocol retains captured scheduler state and rank-local latency. Its
+canonical record is `synchronizedIteration`: one evaluation target containing
+every contributing `rankObservation` in `rank_measurements`. A rank observation
+stores the worker and rank identity, rank-local counter and wall time, scheduled
+requests, and queued requests.
 
-It has two source representations:
+The canonical record separates who emitted a measurement from how its ranks
+were synchronized:
 
-- Observation streams store one rank record per JSONL line. The dataset uses
-  rank 0 as the representative record because rank-local counters do not prove
-  that records from different ranks belong to the same engine iteration.
-- Synchronized benchmark files store `iteration_groups`. Each complete group
-  declares the expected DP ranks and contains exactly one rank record for each
-  rank. The iteration latency is the maximum rank wall time.
+| Field | Meaning |
+| --- | --- |
+| `source_kind` | `self_benchmark` or `rank_event_stream`. |
+| `producer` | Component that created the rank-local FPM measurements. |
+| `collector` | Optional separate capture component. Required for a listener receive-time-window join. |
+| `grouping` | Iteration membership method, authority, and source evidence. |
 
-These are representations of one protocol, not separate protocols. Both
-normalize to one forward-pass iteration containing one or more rank records.
-Zero-time records and empty scheduler heartbeats may remain in a source stream,
-but consumers exclude them from measured points.
+The `grouping.method` records how the ranks became one iteration:
+
+| Method | Purpose | Required source evidence |
+| --- | --- | --- |
+| `single_rank` | Normalize a rank-event iteration with one attention-DP rank. | One rank observation; producer authority. |
+| `benchmark_id` | Normalize ranks grouped by a self-benchmark producer. | `benchmark_id`, benchmark `point`, and producer authority. |
+| `listener_receive_time_window` | Reconstruct an iteration from separately received rank events. | Engine role, raw `_recv_ts`, clock-group offsets, corrected window start and size, collector provenance, and derived authority. |
+
+All methods produce the same canonical measurement. For a complete iteration,
+`rank_measurements` contains exactly the declared `expected_dp_ranks`, sorted by
+`dp_rank`, and `max_rank_wall_time` caches the maximum rank-local `wall_time` as
+the default scoring latency. Consumers may derive another latency policy from
+the retained, authoritative rank measurements. A consumer records the policy it
+uses in its own result provenance. Incomplete groups retain their available
+ranks with `max_rank_wall_time: null`.
+
+Physical source files may remain in their producer formats:
+
+- Rank observation streams store one `rankObservation` per JSONL line. A
+  standalone row is directly evaluable only when the configuration has one
+  attention-DP rank. Multi-rank streams require raw listener receive timestamps,
+  explicit clock correction, and a declared time window. File order, exact
+  timestamp equality, and rank-local `counter_id` are not join keys.
+- Self-benchmark files store `iteration_groups`. Their
+  `rank_results[].fpms[0]` records normalize to canonical
+  `rank_measurements[]` with `source_kind: self_benchmark` and
+  `grouping.method: benchmark_id`; the source `wall_time` normalizes to
+  `max_rank_wall_time` after validation against the nested ranks.
+- Canonical iteration streams store one `synchronizedIteration` per
+  JSONL line.
+
+Listener `_recv_ts` values are assigned independently when each rank event is
+received, so equal timestamps must not be expected. A dataset importer may use
+`listener_receive_time_window` only when the source preserves `_recv_ts` and
+the grouping provenance declares reproducible clock offsets and window rules.
+The GLM DEP16 campaign corrects its four node clocks, then groups distinct ranks
+within an 8 ms half-open window.
+
+Zero-time observations and empty scheduler heartbeats may remain in source
+evidence, but consumers exclude them from measured points.
 
 Request metrics use the following fields. Missing metrics normalize to zero.
 
 | Field | Meaning |
 | --- | --- |
 | `num_prefill_requests` | Scheduled or queued prefill request count. |
-| `sum_prefill_tokens` | Total new prefill tokens. |
-| `sum_prefill_kv_tokens` | Total KV-cache tokens read by prefill requests. |
+| `sum_prefill_tokens` | New prefill tokens computed in the iteration. |
+| `sum_prefill_kv_tokens` | Previously computed prefix or prior-chunk tokens read from KV cache by prefill requests. |
 | `num_decode_requests` | Scheduled or queued decode request count. |
-| `sum_decode_kv_tokens` | Total KV-cache tokens read by decode requests. |
-| `var_prefill_length` | Variance of prefill lengths when recorded. |
-| `var_decode_kv_tokens` | Variance of decode KV lengths when recorded. |
+| `sum_decode_kv_tokens` | Total KV context length across decode requests. |
+| `var_prefill_length` | Population variance of full prompt lengths across prefill requests. |
+| `var_decode_kv_tokens` | Population variance of KV context lengths across decode requests. |
 
 Workload kind is derived from scheduled request metrics. It is not encoded in
 the protocol ID.

schemas/forward-pass-measurement-v1.schema.json

@@ -3,26 +3,62 @@
   "$id": "https://huggingface.co/datasets/nvidia/aisimulate-fpm-dataset/raw/main/schemas/forward-pass-measurement-v1.schema.json",
   "x-protocol-id": "forward-pass-measurement-v1",
   "title": "Forward-pass measurement v1 record",
-  "description": "One physical record from the full forward-pass measurement protocol. A JSONL line is a rank measurement; an iteration_groups entry is a synchronized iteration.",
+  "description": "A canonical synchronized forward-pass iteration or one of its supported physical source records.",
   "oneOf": [
-    {"$ref": "#/$defs/rankMeasurement"},
-    {"$ref": "#/$defs/synchronizedIteration"}
+    {"$ref": "#/$defs/synchronizedIteration"},
+    {"$ref": "#/$defs/rankObservation"},
+    {"$ref": "#/$defs/selfBenchmarkIterationSource"}
   ],
   "$defs": {
     "requestMetrics": {
       "type": "object",
       "properties": {
-        "num_prefill_requests": {"type": "integer", "minimum": 0, "default": 0},
-        "sum_prefill_tokens": {"type": "integer", "minimum": 0, "default": 0},
-        "var_prefill_length": {"type": "number", "minimum": 0, "default": 0},
-        "sum_prefill_kv_tokens": {"type": "integer", "minimum": 0, "default": 0},
-        "num_decode_requests": {"type": "integer", "minimum": 0, "default": 0},
-        "sum_decode_kv_tokens": {"type": "integer", "minimum": 0, "default": 0},
-        "var_decode_kv_tokens": {"type": "number", "minimum": 0, "default": 0}
+        "num_prefill_requests": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0,
+          "description": "Number of prefill requests."
+        },
+        "sum_prefill_tokens": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0,
+          "description": "New prefill tokens computed in this iteration."
+        },
+        "var_prefill_length": {
+          "type": "number",
+          "minimum": 0,
+          "default": 0,
+          "description": "Population variance of full prompt lengths across prefill requests."
+        },
+        "sum_prefill_kv_tokens": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0,
+          "description": "Previously computed prefix or prior-chunk tokens read from KV cache for prefill requests."
+        },
+        "num_decode_requests": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0,
+          "description": "Number of decode requests."
+        },
+        "sum_decode_kv_tokens": {
+          "type": "integer",
+          "minimum": 0,
+          "default": 0,
+          "description": "Total KV context length across decode requests."
+        },
+        "var_decode_kv_tokens": {
+          "type": "number",
+          "minimum": 0,
+          "default": 0,
+          "description": "Population variance of KV context lengths across decode requests."
+        }
       },
       "additionalProperties": true
     },
-    "rankMeasurement": {
+    "rankObservation": {
       "type": "object",
       "required": [
         "version",
@@ -37,14 +73,61 @@
         "version": {"const": 1},
         "worker_id": {"type": "string", "minLength": 1},
         "dp_rank": {"type": "integer", "minimum": 0},
-        "counter_id": {"type": "integer", "minimum": 0},
-        "wall_time": {"type": "number", "minimum": 0, "description": "Rank-local wall time in seconds. Zero-time records are retained evidence but are not usable measurements."},
+        "counter_id": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Monotonic sequence number local to one worker and DP rank. It is not a cross-rank iteration key."
+        },
+        "wall_time": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Rank-local wall time in seconds. Zero-time records are retained evidence but are not usable measurements."
+        },
         "observed_at_unix_ms": {"type": "number", "minimum": 0},
+        "_recv_ts": {
+          "type": ["number", "string"],
+          "description": "Raw listener receive timestamp from a physical rank-event stream. A normalizer must preserve the captured value when it uses corrected receive time to join ranks."
+        },
         "scheduled_requests": {"$ref": "#/$defs/requestMetrics"},
         "queued_requests": {"$ref": "#/$defs/requestMetrics"}
       },
       "additionalProperties": true
     },
+    "producer": {
+      "type": "object",
+      "required": ["component"],
+      "properties": {
+        "component": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Component that produced the rank-local FPM measurements."
+        },
+        "version": {"type": "string", "minLength": 1},
+        "source_revision": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": true
+    },
+    "collector": {
+      "type": "object",
+      "required": ["kind"],
+      "properties": {
+        "kind": {"enum": ["custom_script", "service"]},
+        "component": {"type": "string", "minLength": 1},
+        "path": {"type": "string", "minLength": 1},
+        "source_revision": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": true
+    },
+    "singleRankGrouping": {
+      "type": "object",
+      "required": ["method", "authority"],
+      "properties": {
+        "method": {"const": "single_rank"},
+        "authority": {"const": "producer"},
+        "key": {"type": "string", "minLength": 1}
+      },
+      "additionalProperties": true
+    },
     "benchmarkPoint": {
       "type": "object",
       "required": [
@@ -63,7 +146,285 @@
       },
       "additionalProperties": true
     },
-    "rankResult": {
+    "benchmarkIdGrouping": {
+      "type": "object",
+      "required": ["method", "authority", "key", "benchmark_id", "point"],
+      "properties": {
+        "method": {"const": "benchmark_id"},
+        "authority": {"const": "producer"},
+        "key": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Canonical string form of benchmark_id."
+        },
+        "benchmark_id": {"type": "integer", "minimum": 0},
+        "point": {"$ref": "#/$defs/benchmarkPoint"}
+      },
+      "x-semantic-constraints": [
+        "key must equal the canonical decimal string form of benchmark_id.",
+        "benchmark_id must equal point.benchmark_id."
+      ],
+      "additionalProperties": true
+    },
+    "clockCorrectionGroup": {
+      "type": "object",
+      "required": ["clock_id", "dp_ranks", "offset"],
+      "properties": {
+        "clock_id": {"type": "string", "minLength": 1},
+        "dp_ranks": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {"type": "integer", "minimum": 0}
+        },
+        "offset": {
+          "type": "number",
+          "description": "Signed value added to each raw receive timestamp in this clock group before window grouping."
+        }
+      },
+      "additionalProperties": true
+    },
+    "clockCorrection": {
+      "type": "object",
+      "required": [
+        "method",
+        "reference_clock_id",
+        "offset_unit",
+        "groups"
+      ],
+      "properties": {
+        "method": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Stable identifier for the clock-correction procedure."
+        },
+        "reference_clock_id": {"type": "string", "minLength": 1},
+        "offset_unit": {"enum": ["s", "ms", "us", "ns"]},
+        "groups": {
+          "type": "array",
+          "minItems": 1,
+          "items": {"$ref": "#/$defs/clockCorrectionGroup"}
+        }
+      },
+      "x-semantic-constraints": [
+        "clock_id values must be unique.",
+        "groups[].dp_ranks must partition expected_dp_ranks without duplicates or omissions.",
+        "The group named by reference_clock_id must exist and have offset 0."
+      ],
+      "additionalProperties": true
+    },
+    "receiveTimeWindow": {
+      "type": "object",
+      "required": ["size", "unit", "anchor", "boundary", "distinct_by"],
+      "properties": {
+        "size": {"type": "number", "exclusiveMinimum": 0},
+        "unit": {"enum": ["s", "ms", "us", "ns"]},
+        "anchor": {"const": "earliest_corrected_receive_timestamp"},
+        "boundary": {"const": "half_open"},
+        "distinct_by": {"const": "dp_rank"}
+      },
+      "additionalProperties": true
+    },
+    "listenerReceiveTimeWindowGrouping": {
+      "type": "object",
+      "required": [
+        "method",
+        "authority",
+        "performed_by",
+        "key",
+        "engine_role",
+        "source_field",
+        "source_unit",
+        "clock_correction",
+        "window",
+        "window_start"
+      ],
+      "properties": {
+        "method": {"const": "listener_receive_time_window"},
+        "authority": {"const": "derived"},
+        "performed_by": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Component that derived the synchronized group."
+        },
+        "key": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Stable identity for the engine-role-local corrected receive-time window."
+        },
+        "engine_role": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Source engine role. This is collection topology, not the derived workload kind."
+        },
+        "source_field": {"const": "_recv_ts"},
+        "source_unit": {"enum": ["s", "ms", "us", "ns"]},
+        "clock_correction": {"$ref": "#/$defs/clockCorrection"},
+        "window": {"$ref": "#/$defs/receiveTimeWindow"},
+        "window_start": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^[0-9]+(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$",
+          "description": "Earliest corrected receive timestamp in source_unit, serialized as a string."
+        }
+      },
+      "x-semantic-constraints": [
+        "Add the declared clock-group offset to every raw _recv_ts before grouping.",
+        "Within one engine_role, sort by corrected receive time and form half-open windows anchored at the earliest ungrouped record.",
+        "A window member must have corrected receive time minus window_start strictly less than window.size after unit conversion.",
+        "A window may contain at most one record per dp_rank; a repeated rank starts a new window.",
+        "key must be derived deterministically from engine_role, window_start, source_unit, and window.",
+        "counter_id and file position must not be used as cross-rank iteration keys."
+      ],
+      "additionalProperties": true
+    },
+    "grouping": {
+      "oneOf": [
+        {"$ref": "#/$defs/singleRankGrouping"},
+        {"$ref": "#/$defs/benchmarkIdGrouping"},
+        {"$ref": "#/$defs/listenerReceiveTimeWindowGrouping"}
+      ]
+    },
+    "synchronizedIteration": {
+      "type": "object",
+      "required": [
+        "version",
+        "source_kind",
+        "iteration_id",
+        "producer",
+        "grouping",
+        "expected_dp_ranks",
+        "complete",
+        "max_rank_wall_time",
+        "rank_measurements"
+      ],
+      "properties": {
+        "version": {"const": 1},
+        "source_kind": {"enum": ["self_benchmark", "rank_event_stream"]},
+        "iteration_id": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Stable iteration identity within the physical file."
+        },
+        "producer": {"$ref": "#/$defs/producer"},
+        "collector": {"$ref": "#/$defs/collector"},
+        "grouping": {"$ref": "#/$defs/grouping"},
+        "expected_dp_ranks": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {"type": "integer", "minimum": 0}
+        },
+        "complete": {"type": "boolean"},
+        "max_rank_wall_time": {
+          "type": ["number", "null"],
+          "minimum": 0,
+          "description": "Cached default scoring latency in seconds. For a complete iteration, this equals the maximum rank-local wall time; consumers may derive another policy from rank_measurements."
+        },
+        "rank_measurements": {
+          "type": "array",
+          "items": {"$ref": "#/$defs/rankObservation"}
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {"complete": {"const": true}},
+            "required": ["complete"]
+          },
+          "then": {
+            "properties": {
+              "max_rank_wall_time": {"type": "number", "minimum": 0},
+              "rank_measurements": {"minItems": 1}
+            }
+          },
+          "else": {
+            "properties": {
+              "max_rank_wall_time": {"type": "null"}
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {"source_kind": {"const": "self_benchmark"}},
+            "required": ["source_kind"]
+          },
+          "then": {
+            "properties": {
+              "grouping": {"$ref": "#/$defs/benchmarkIdGrouping"}
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {"source_kind": {"const": "rank_event_stream"}},
+            "required": ["source_kind"]
+          },
+          "then": {
+            "properties": {
+              "grouping": {
+                "oneOf": [
+                  {"$ref": "#/$defs/singleRankGrouping"},
+                  {"$ref": "#/$defs/listenerReceiveTimeWindowGrouping"}
+                ]
+              }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "grouping": {
+                "properties": {"method": {"const": "single_rank"}},
+                "required": ["method"]
+              }
+            },
+            "required": ["grouping"]
+          },
+          "then": {
+            "properties": {
+              "expected_dp_ranks": {"maxItems": 1},
+              "rank_measurements": {"minItems": 1, "maxItems": 1}
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "grouping": {
+                "properties": {
+                  "method": {"const": "listener_receive_time_window"}
+                },
+                "required": ["method"]
+              }
+            },
+            "required": ["grouping"]
+          },
+          "then": {
+            "required": ["collector"],
+            "properties": {
+              "rank_measurements": {
+                "items": {
+                  "required": ["_recv_ts"]
+                }
+              }
+            }
+          }
+        }
+      ],
+      "x-semantic-constraints": [
+        "rank_measurements must be ordered by ascending dp_rank.",
+        "rank_measurements must not contain duplicate dp_rank values.",
+        "For complete=true, rank_measurements dp_rank values must exactly equal expected_dp_ranks.",
+        "For complete=true, max_rank_wall_time must equal max(rank_measurements[*].wall_time).",
+        "For complete=false, available rank measurements are retained and max_rank_wall_time must be null.",
+        "For grouping.method=single_rank, expected_dp_ranks and rank_measurements must each contain exactly one matching rank.",
+        "collector is optional except when grouping.method=listener_receive_time_window.",
+        "For grouping.method=listener_receive_time_window, every rank measurement must retain its raw _recv_ts value."
+      ],
+      "additionalProperties": true
+    },
+    "selfBenchmarkRankResult": {
       "type": "object",
       "required": ["dp_rank", "fpms"],
       "properties": {
@@ -72,12 +433,12 @@
           "type": "array",
           "minItems": 1,
           "maxItems": 1,
-          "items": {"$ref": "#/$defs/rankMeasurement"}
+          "items": {"$ref": "#/$defs/rankObservation"}
         }
       },
       "additionalProperties": true
     },
-    "synchronizedIteration": {
+    "selfBenchmarkIterationSource": {
       "type": "object",
       "required": [
         "benchmark_id",
@@ -97,11 +458,15 @@
           "items": {"type": "integer", "minimum": 0}
         },
         "complete": {"const": true},
-        "wall_time": {"type": "number", "exclusiveMinimum": 0, "description": "Observed iteration wall time in seconds; equal to the maximum rank wall time."},
+        "wall_time": {
+          "type": "number",
+          "exclusiveMinimum": 0,
+          "description": "Observed iteration wall time in seconds; equal to the maximum rank wall time."
+        },
         "rank_results": {
           "type": "array",
           "minItems": 1,
-          "items": {"$ref": "#/$defs/rankResult"}
+          "items": {"$ref": "#/$defs/selfBenchmarkRankResult"}
         }
       },
       "additionalProperties": true
@@ -109,15 +474,34 @@
   },
   "x-source-representations": [
     {
-      "name": "observation_stream",
+      "name": "rank_event_stream",
       "file_extensions": [".jsonl", ".jsonl.gz"],
-      "record_schema": "#/$defs/rankMeasurement"
+      "record_schema": "#/$defs/rankObservation",
+      "normalizes_to": "#/$defs/synchronizedIteration",
+      "source_kind": "rank_event_stream",
+      "grouping_methods": ["single_rank", "listener_receive_time_window"]
     },
     {
-      "name": "synchronized_iteration",
+      "name": "self_benchmark",
       "file_extensions": [".json", ".json.gz"],
       "record_path": "iteration_groups[]",
+      "record_schema": "#/$defs/selfBenchmarkIterationSource",
+      "normalizes_to": "#/$defs/synchronizedIteration",
+      "source_kind": "self_benchmark",
+      "grouping_method": "benchmark_id"
+    },
+    {
+      "name": "canonical_iteration_stream",
+      "file_extensions": [".jsonl", ".jsonl.gz"],
       "record_schema": "#/$defs/synchronizedIteration"
     }
+  ],
+  "x-semantic-constraints": [
+    "producer identifies the component that created rank-local FPM measurements.",
+    "collector identifies a separate capture component and is otherwise omitted.",
+    "A standalone rankObservation is directly evaluable only when attention_dp_size is 1.",
+    "For attention_dp_size greater than 1, truth requires a complete synchronizedIteration.",
+    "A listener receive-time-window join requires raw _recv_ts evidence, explicit clock corrections, and an explicit window rule; exact timestamp equality, file order, and rank-local counter_id are not cross-rank identities.",
+    "Zero-time and empty-heartbeat observations may be retained but are excluded from measured evaluation points."
   ]
 }