Add evaluation code

evaluation/action_metrics.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""Compare action types, coordinates, numeric inputs, and control sequences."""
+
+from decimal import Decimal, InvalidOperation
+import json
+import math
+import re
+
+
+TYPE_NUMBER_PATTERN = re.compile(
+    r"[+-]?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)"
+)
+
+
+def numeric_type_signature(value):
+    """Normalize numeric spelling while preserving all keyboard controls."""
+    if not isinstance(value, str):
+        return None
+    normalized = value.replace("\r\n", "\n").replace("\r", "\n")
+    matches = list(TYPE_NUMBER_PATTERN.finditer(normalized))
+    if not matches:
+        return None
+    numbers = []
+    separators = []
+    cursor = 0
+    try:
+        for match in matches:
+            separators.append(normalized[cursor:match.start()])
+            number = Decimal(match.group(0))
+            if not number.is_finite():
+                return None
+            numbers.append(number)
+            cursor = match.end()
+    except InvalidOperation:
+        return None
+    separators.append(normalized[cursor:])
+    return tuple(numbers), tuple(separators)
+
+
+def parameter_coordinates(value):
+    """Decode a coordinate pair independently of the predicted action tag."""
+    candidate = value
+    if isinstance(candidate, str):
+        try:
+            candidate = json.loads(candidate.strip())
+        except Exception:
+            return None
+    if not isinstance(candidate, (list, tuple)) or len(candidate) != 2:
+        return None
+    try:
+        result = [float(candidate[0]), float(candidate[1])]
+    except (TypeError, ValueError):
+        return None
+    if not all(math.isfinite(item) for item in result):
+        return None
+    return result
+
+
+def compare_to_reference(generated, expected, record=None,
+                         screen_size=(1920, 1080)):
+    """Compare two parsed actions using the canonical CAD-Drawer protocol."""
+    result = {
+        "action_match": generated.action == expected.action,
+        "parameter_match": False,
+        "step_success": False,
+        "full_match": False,
+    }
+
+    # Parameters use the reference action schema. Thus click and double_click
+    # at the same target can have Parameter=1 while Action=0 and Step=0.
+    if expected.action in ("click", "double_click"):
+        generated_coordinates = parameter_coordinates(generated.parameters)
+        if generated_coordinates is None:
+            return result
+        dx = generated_coordinates[0] - expected.parameters[0]
+        dy = generated_coordinates[1] - expected.parameters[1]
+        result["normalized_l2"] = round(math.hypot(dx, dy), 8)
+        result["pixel_l2_at_1920x1080"] = round(math.hypot(
+            dx * float(screen_size[0]), dy * float(screen_size[1])), 3)
+
+        bounds = None
+        if record is not None:
+            values = [record.get(name) for name in (
+                "x_min_norm", "x_max_norm", "y_min_norm", "y_max_norm")]
+            if all(value is not None for value in values):
+                bounds = [float(value) for value in values]
+        if bounds is not None:
+            x_min, x_max, y_min, y_max = bounds
+            result["parameter_match"] = (
+                x_min <= generated_coordinates[0] <= x_max and
+                y_min <= generated_coordinates[1] <= y_max
+            )
+            result["target_bbox_norm"] = bounds
+        else:
+            result["parameter_match"] = math.hypot(
+                dx * float(screen_size[0]),
+                dy * float(screen_size[1]),
+            ) <= 5.0
+    elif expected.action == "type":
+        generated_signature = numeric_type_signature(generated.parameters)
+        expected_signature = numeric_type_signature(expected.parameters)
+        if generated_signature is not None and expected_signature is not None:
+            result["parameter_match"] = (
+                generated_signature == expected_signature)
+            result["parameter_match_mode"] = (
+                "numeric_value_and_control_sequence")
+        else:
+            generated_text = (
+                generated.parameters.replace("\r\n", "\n").replace("\r", "\n")
+                if isinstance(generated.parameters, str) else None)
+            expected_text = (
+                expected.parameters.replace("\r\n", "\n").replace("\r", "\n")
+                if isinstance(expected.parameters, str) else None)
+            result["parameter_match"] = generated_text == expected_text
+            result["parameter_match_mode"] = "exact_control_text"
+    else:
+        result["parameter_match"] = (
+            generated.parameters == expected.parameters)
+
+    result["step_success"] = (
+        result["action_match"] and result["parameter_match"])
+    result["full_match"] = result["step_success"]
+    return result

evaluation/action_parser.py

@@ -0,0 +1,114 @@
+"""Parse model action responses and dataset reference actions."""
+
+import ast
+import json
+import math
+import re
+
+
+EXPECTED_SCREEN = (1920, 1080)
+
+
+ALLOWED_ACTIONS = {"click", "double_click", "type", "finish"}
+
+
+class RunnerError(RuntimeError):
+    pass
+
+
+class ParsedAction(object):
+    def __init__(self, action, parameters, reasoning="", raw=""):
+        self.action = action
+        self.parameters = parameters
+        self.reasoning = reasoning
+        self.raw = raw
+
+    def as_dict(self):
+        return {
+            "action": self.action,
+            "parameters": self.parameters,
+            "reasoning": self.reasoning,
+        }
+
+
+def _tag_body(text, tag, preserve_payload=False, required=True):
+    pattern = r"<%s\b[^>]*>(.*?)</%s>" % (re.escape(tag), re.escape(tag))
+    match = re.search(pattern, text, flags=re.IGNORECASE | re.DOTALL)
+    if not match:
+        if required:
+            raise RunnerError("Missing <%s>...</%s> block" % (tag, tag))
+        return ""
+
+    body = match.group(1)
+    if not preserve_payload:
+        return body.strip()
+
+    # Remove exactly the formatting newline after the opening tag and before
+    # the closing tag. A second trailing newline belongs to the type payload
+    # and means Enter in the SFT schema.
+    if body.startswith("\r\n"):
+        body = body[2:]
+    elif body.startswith("\n"):
+        body = body[1:]
+    if body.endswith("\r\n"):
+        body = body[:-2]
+    elif body.endswith("\n"):
+        body = body[:-1]
+    return body
+
+
+def _decode_type_payload(payload):
+    # Some serving stacks return literal backslash escapes instead of actual
+    # control characters. Decode only the control sequences used by this data.
+    if "\\t" in payload:
+        payload = payload.replace("\\t", "\t")
+    if "\\r\\n" in payload:
+        payload = payload.replace("\\r\\n", "\n")
+    if "\\n" in payload:
+        payload = payload.replace("\\n", "\n")
+    return payload
+
+
+def parse_model_output(text):
+    if not isinstance(text, str) or not text.strip():
+        raise RunnerError("Model output is empty")
+
+    action = _tag_body(text, "action").lower().replace("-", "_")
+    if action not in ALLOWED_ACTIONS:
+        raise RunnerError("Unsupported action: %r" % action)
+
+    payload = _tag_body(text, "parameters", preserve_payload=True)
+    reasoning = _tag_body(text, "ui_reasoning", required=False)
+
+    if action in ("click", "double_click"):
+        value = payload.strip()
+        try:
+            params = json.loads(value)
+        except Exception:
+            try:
+                params = ast.literal_eval(value)
+            except Exception as exc:
+                raise RunnerError("Invalid click parameters: %r" % value) from exc
+        if not isinstance(params, (list, tuple)) or len(params) != 2:
+            raise RunnerError("Click parameters must be [x_norm, y_norm]")
+        try:
+            params = [float(params[0]), float(params[1])]
+        except Exception as exc:
+            raise RunnerError("Click coordinates must be numeric") from exc
+        if not all(math.isfinite(v) and 0.0 <= v <= 1.0 for v in params):
+            raise RunnerError("Normalized click coordinates must be in [0, 1]")
+    elif action == "type":
+        params = _decode_type_payload(payload)
+        if not params:
+            raise RunnerError("Type payload is empty")
+    else:
+        params = []
+
+    return ParsedAction(action, params, reasoning=reasoning, raw=text)
+
+
+def assistant_text(row):
+    for message in row.get("messages", []):
+        if message.get("role") == "assistant":
+            return message.get("content", "")
+    raise RunnerError("JSONL row has no assistant message")

evaluation/evaluate.py

@@ -0,0 +1,58 @@
+"""Evaluate saved GUI action predictions against dataset references.
+
+Prediction records contain a zero-based `_idx` and the model response in
+`prediction`. The response uses <action> and <parameters> tags, with an optional
+<ui_reasoning> block. An `error` field records an inference failure.
+"""
+import argparse
+from pathlib import Path
+
+if __package__:
+    from .metrics import ScoringError, score_predictions, write_json, write_jsonl
+else:
+    from metrics import ScoringError, score_predictions, write_json, write_jsonl
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate CAD GUI action predictions.')
+    parser.add_argument(
+        '--dataset', type=Path,
+        default=Path(__file__).resolve().parent.parent / 'GUI/annotations/test_final.jsonl.gz',
+        help='Reference dataset in JSONL or JSONL.GZ format.',
+    )
+    parser.add_argument('--predictions', type=Path, required=True,
+                        help='JSONL or JSONL.GZ records with _idx and prediction fields.')
+    parser.add_argument('--output-dir', type=Path, required=True,
+                        help='Directory for metrics.json and details.jsonl.')
+    parser.add_argument('--start-index', type=int, default=0)
+    parser.add_argument('--limit', type=int, default=0, help='Maximum reference rows. Zero selects all remaining rows.')
+    parser.add_argument('--num-shards', type=int, default=1)
+    parser.add_argument('--shard-index', type=int, default=0)
+    args = parser.parse_args()
+
+    try:
+        summary, details = score_predictions(
+            args.dataset, args.predictions, start_index=args.start_index,
+            limit=args.limit, num_shards=args.num_shards, shard_index=args.shard_index,
+        )
+        write_json(args.output_dir / 'metrics.json', summary)
+        write_jsonl(args.output_dir / 'details.jsonl', details)
+    except (ScoringError, OSError) as error:
+        parser.exit(1, f'Evaluation failed: {error}\n')
+
+    by_action = summary['by_gt_action']
+    main_metrics = [
+        ('Action Acc.', summary['metrics']['action_accuracy']),
+        ('Click Param. Acc.', by_action.get('click', {}).get('parameter_accuracy')),
+        ('Double-click Param. Acc.', by_action.get('double_click', {}).get('parameter_accuracy')),
+        ('Input Param. Acc.', by_action.get('type', {}).get('parameter_accuracy')),
+        ('Step Acc.', summary['metrics']['step_accuracy']),
+    ]
+    for label, value in main_metrics:
+        displayed = 'N/A' if value is None else f'{value * 100:.2f}%'
+        print(f'{label:<25} {displayed}')
+    print(f'Results saved to {args.output_dir.resolve()}')
+
+
+if __name__ == '__main__':
+    main()

evaluation/metrics.py

@@ -0,0 +1,823 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Action, parameter, step, subtask, and part metrics for CAD-Drawer.
+
+The dataset is the sole source of ground truth. Prediction artifacts contribute
+only a global row index (_idx) and raw model text (prediction).
+Missing/unparseable/error rows remain in the fixed reference denominator.
+"""
+
+from collections import Counter, defaultdict
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+
+
+if __package__:
+    from . import action_metrics, action_parser as action_runner
+else:
+    import action_metrics
+    import action_parser as action_runner
+
+
+CANONICAL_TEST_FINAL_SHA256 = (
+    "a0a9c3bd89641b33b4c45237157374f0db0e64711d6cf6a1260a419c47bdda7d"
+)
+CANONICAL_TEST_FINAL_SLOTS = 29239
+STRATIFIED_TEST_50_SHA256 = (
+    "ca1c3b0764f4774dca7b51d0b2bb9fd6660224d6e97e201974645895a45c5a32"
+)
+STRATIFIED_TEST_50_SLOTS = 3352
+HELDOUT_TEST_364_SHA256 = (
+    "991983a4945c1124ce067a521810ad7f04ef8fd65f8c5a6fc8ca1d2f95d8e9ec"
+)
+HELDOUT_TEST_364_SLOTS = 25887
+
+
+REGISTERED_DATASET_CONTRACTS = {
+    "canonical_test_final_414": {
+        "sha256": CANONICAL_TEST_FINAL_SHA256,
+        "slots": CANONICAL_TEST_FINAL_SLOTS,
+        "parts": 414,
+        "canonical_full_test": True,
+    },
+    "stratified_test_50_seed42": {
+        "sha256": STRATIFIED_TEST_50_SHA256,
+        "slots": STRATIFIED_TEST_50_SLOTS,
+        "parts": 50,
+        "canonical_full_test": False,
+    },
+    "heldout_test_364_seed42_complement": {
+        "sha256": HELDOUT_TEST_364_SHA256,
+        "slots": HELDOUT_TEST_364_SLOTS,
+        "parts": 364,
+        "canonical_full_test": False,
+        "model_selection_heldout": True,
+        "complement_of": "stratified_test_50_seed42",
+    },
+}
+
+
+class ScoringError(RuntimeError):
+    """Prediction artifact or reference contract is invalid."""
+
+
+def identify_dataset_contract(records, dataset_hash):
+    """Return a registered immutable benchmark contract, if one matches."""
+    part_count = len({
+        record.get("part_id") for record in records
+        if record.get("part_id") is not None
+    })
+    for name, contract in REGISTERED_DATASET_CONTRACTS.items():
+        if (
+            len(records) == contract["slots"] and
+            part_count == contract["parts"] and
+            dataset_hash == contract["sha256"]
+        ):
+            return {"name": name, **contract}
+    return None
+
+
+def dataset_sha256(path, chunk_size=1024 * 1024):
+    digest = hashlib.sha256()
+    opener = gzip.open if Path(path).suffix.lower() == ".gz" else open
+    with opener(path, "rb") as handle:
+        while True:
+            block = handle.read(chunk_size)
+            if not block:
+                break
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def read_jsonl(path):
+    rows = []
+    opener = gzip.open if Path(path).suffix.lower() == ".gz" else open
+    with opener(path, "rt", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ScoringError(
+                    "%s:%d is invalid JSON: %s" %
+                    (path, line_number, exc)) from exc
+            if not isinstance(value, dict):
+                raise ScoringError(
+                    "%s:%d must contain a JSON object" %
+                    (path, line_number))
+            rows.append(value)
+    return rows
+
+
+def reference_slice(records, start_index=0, limit=0):
+    if isinstance(start_index, bool) or start_index < 0:
+        raise ScoringError("start_index must be a non-negative integer")
+    if isinstance(limit, bool) or limit < 0:
+        raise ScoringError("limit must be a non-negative integer")
+    if start_index > len(records):
+        raise ScoringError(
+            "start_index %d exceeds dataset size %d" %
+            (start_index, len(records)))
+    end_index = len(records)
+    if limit:
+        end_index = min(end_index, start_index + limit)
+    return range(start_index, end_index)
+
+
+def reference_indices(records, start_index=0, limit=0,
+                      num_shards=1, shard_index=0):
+    """Select a deterministic modulo shard from a canonical reference slice."""
+    if isinstance(num_shards, bool) or num_shards <= 0:
+        raise ScoringError("num_shards must be a positive integer")
+    if (
+        isinstance(shard_index, bool) or shard_index < 0 or
+        shard_index >= num_shards
+    ):
+        raise ScoringError(
+            "shard_index must be in [0, %d)" % num_shards)
+    base = reference_slice(
+        records, start_index=start_index, limit=limit)
+    return [
+        index for index in base
+        if index % num_shards == shard_index
+    ]
+
+
+def load_prediction_map(path, allowed_indices):
+    allowed = set(allowed_indices)
+    predictions = {}
+    for line_number, row in enumerate(read_jsonl(path), 1):
+        if "_idx" not in row:
+            raise ScoringError(
+                "prediction record %d has no _idx" % line_number)
+        index = row["_idx"]
+        if isinstance(index, bool) or not isinstance(index, int):
+            raise ScoringError(
+                "prediction record %d has non-integer _idx=%r" %
+                (line_number, index))
+        if index not in allowed:
+            raise ScoringError(
+                "prediction record %d has out-of-slice _idx=%d" %
+                (line_number, index))
+        if index in predictions:
+            raise ScoringError(
+                "duplicate prediction _idx=%d (record %d)" %
+                (index, line_number))
+        predictions[index] = row
+    return predictions
+
+
+FORMAT_PATTERN = re.compile(
+    r"^\s*<ui_reasoning\b[^>]*>.*?</ui_reasoning>\s*"
+    r"<action\b[^>]*>.*?</action>\s*"
+    r"<parameters\b[^>]*>.*?</parameters>\s*$",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+
+def is_format_compliant(text):
+    if not isinstance(text, str):
+        return False
+    if not FORMAT_PATTERN.fullmatch(text):
+        return False
+    lowered = text.lower()
+    return all(lowered.count("<%s" % tag) == 1 for tag in (
+        "ui_reasoning", "action", "parameters"))
+
+
+def _empty_counts():
+    return {
+        "slots": 0,
+        "parseable": 0,
+        "format_compliant": 0,
+        "action_correct": 0,
+        "parameter_correct": 0,
+        "step_correct": 0,
+    }
+
+
+def _with_rates(counts):
+    result = dict(counts)
+    denominator = counts["slots"]
+    for numerator, rate_name in (
+        ("parseable", "parse_rate"),
+        ("format_compliant", "format_compliance_rate"),
+        ("action_correct", "action_accuracy"),
+        ("parameter_correct", "parameter_accuracy"),
+        ("step_correct", "step_accuracy"),
+    ):
+        result[rate_name] = (
+            counts[numerator] / denominator if denominator else None)
+    return result
+
+def _record_part_fields(record):
+    """Return the canonical identity fields for a complete part trajectory."""
+    return {
+        "part_key": (
+            record.get("source_part_relpath") or record.get("part_id")),
+        "part_id": record.get("part_id"),
+    }
+
+
+def _record_subtask_fields(record):
+    """Return the canonical fields needed to identify and order a subtask."""
+    present_task = record.get("present_task")
+    if not isinstance(present_task, dict):
+        present_task = {}
+    task_progress = record.get("task_progress")
+    if not isinstance(task_progress, dict):
+        task_progress = {}
+    return {
+        "part_key": _record_part_fields(record)["part_key"],
+        "task_id": (
+            present_task.get("task_id") or record.get("task_id")),
+        "action_index_in_task": task_progress.get("action_index_in_task"),
+        "total_actions_in_task": task_progress.get("total_actions_in_task"),
+    }
+
+
+def build_subtask_contract(records):
+    """Validate canonical subtask grouping and ordering for a dataset.
+
+    A subtask is scoped by ``(part_key, task_id)``. ``part_key`` prefers the
+    source-relative part path because task IDs restart for every part. This
+    function does not inspect predictions; it validates only dataset metadata.
+    Invalid metadata disables subtask-level metrics without changing slot-level
+    Action/Parameter/Step scoring.
+    """
+    groups = defaultdict(list)
+    index_to_key = {}
+    errors = []
+
+    for index, record in enumerate(records):
+        present_task = record.get("present_task")
+        nested_task_id = (
+            present_task.get("task_id")
+            if isinstance(present_task, dict) else None)
+        top_task_id = record.get("task_id")
+        if (
+            nested_task_id is not None and top_task_id is not None and
+            str(nested_task_id) != str(top_task_id)
+        ):
+            errors.append(
+                "_idx=%d has conflicting nested/top-level task_id (%r/%r)" % (
+                    index, nested_task_id, top_task_id))
+            continue
+        fields = _record_subtask_fields(record)
+        missing = [
+            name for name, value in fields.items()
+            if value is None or value == ""
+        ]
+        if missing:
+            errors.append(
+                "_idx=%d missing %s" % (index, ",".join(missing)))
+            continue
+        action_index = fields["action_index_in_task"]
+        total_actions = fields["total_actions_in_task"]
+        if (
+            isinstance(action_index, bool) or
+            not isinstance(action_index, int) or action_index <= 0 or
+            isinstance(total_actions, bool) or
+            not isinstance(total_actions, int) or total_actions <= 0
+        ):
+            errors.append(
+                "_idx=%d has invalid task progress (%r/%r)" % (
+                    index, action_index, total_actions))
+            continue
+        key = (str(fields["part_key"]), str(fields["task_id"]))
+        groups[key].append({
+            "_idx": index,
+            "action_index_in_task": action_index,
+            "total_actions_in_task": total_actions,
+        })
+        index_to_key[index] = key
+
+    for key, rows in sorted(groups.items()):
+        rows.sort(key=lambda item: item["_idx"])
+        declared_totals = {
+            item["total_actions_in_task"] for item in rows}
+        if len(declared_totals) != 1:
+            errors.append(
+                "subtask %r has inconsistent total_actions_in_task=%r" % (
+                    key, sorted(declared_totals)))
+            continue
+        declared_total = next(iter(declared_totals))
+        observed_order = [
+            item["action_index_in_task"] for item in rows]
+        expected_order = list(range(1, declared_total + 1))
+        if len(rows) != declared_total or observed_order != expected_order:
+            errors.append(
+                "subtask %r expected ordered actions %r but observed %r" % (
+                    key, expected_order, observed_order))
+        global_indices = [item["_idx"] for item in rows]
+        if global_indices != list(range(
+                global_indices[0], global_indices[-1] + 1)):
+            errors.append(
+                "subtask %r is not contiguous in the dataset" % (key,))
+
+    return {
+        "valid": not errors,
+        "groups": groups,
+        "index_to_key": index_to_key,
+        "error_count": len(errors),
+        "errors_preview": errors[:50],
+    }
+
+
+def build_part_contract(records):
+    """Validate canonical part grouping and global trajectory ordering."""
+    groups = defaultdict(list)
+    index_to_key = {}
+    errors = []
+
+    for index, record in enumerate(records):
+        fields = _record_part_fields(record)
+        part_key = fields["part_key"]
+        if part_key is None or part_key == "":
+            errors.append("_idx=%d missing part identity" % index)
+            continue
+        key = str(part_key)
+        groups[key].append({
+            "_idx": index,
+            "part_id": fields["part_id"],
+        })
+        index_to_key[index] = key
+
+    for key, rows in sorted(groups.items()):
+        rows.sort(key=lambda item: item["_idx"])
+        global_indices = [item["_idx"] for item in rows]
+        if global_indices != list(range(
+                global_indices[0], global_indices[-1] + 1)):
+            errors.append(
+                "part %r is not contiguous in the dataset" % key)
+
+    return {
+        "valid": not errors,
+        "groups": groups,
+        "index_to_key": index_to_key,
+        "error_count": len(errors),
+        "errors_preview": errors[:50],
+    }
+
+
+def _empty_subtask_metrics():
+    return {
+        "subtasks_touched": 0,
+        "complete_subtasks": 0,
+        "partial_subtasks_excluded": 0,
+        "successful_subtasks": 0,
+        "subtask_exact_match": None,
+        "prefix_correct_steps": 0,
+        "complete_subtask_steps": 0,
+        "subtask_prefix_completion_macro": None,
+        "subtask_prefix_step_accuracy": None,
+        "subtask_metrics_complete": False,
+    }
+
+
+def _empty_part_metrics():
+    return {
+        "parts_touched": 0,
+        "complete_parts": 0,
+        "partial_parts_excluded": 0,
+        "successful_parts": 0,
+        "part_exact_match": None,
+        "step_correct_steps": 0,
+        "prefix_correct_steps": 0,
+        "complete_part_steps": 0,
+        "part_step_accuracy_macro": None,
+        "part_step_accuracy_micro": None,
+        "part_prefix_completion_macro": None,
+        "part_prefix_step_accuracy": None,
+        "part_metrics_complete": False,
+    }
+
+
+def _validate_reference(index, record):
+    try:
+        expected = action_runner.parse_model_output(
+            action_runner.assistant_text(record))
+    except Exception as exc:
+        raise ScoringError(
+            "canonical reference _idx=%d cannot be parsed: %s" %
+            (index, exc)) from exc
+    label = record.get("label_action_type")
+    if label is not None and label != expected.action:
+        raise ScoringError(
+            "canonical reference _idx=%d action label %r != parsed %r" %
+            (index, label, expected.action))
+    return expected
+
+def _score_subtask_metrics(contract, selected_indices, details):
+    """Aggregate per-slot step success into complete subtasks."""
+    result = _empty_subtask_metrics()
+    result.update({
+        "subtask_contract_valid": contract["valid"],
+        "subtask_contract_error_count": contract["error_count"],
+        "subtask_contract_errors_preview": contract["errors_preview"],
+    })
+    selected = set(selected_indices)
+    detail_by_index = {item["_idx"]: item for item in details}
+    complete_groups = []
+    partial_groups = []
+
+    for key, rows in contract["groups"].items():
+        group_indices = [item["_idx"] for item in rows]
+        overlap = selected.intersection(group_indices)
+        if not overlap:
+            continue
+        result["subtasks_touched"] += 1
+        if len(overlap) == len(group_indices):
+            complete_groups.append((key, rows))
+        else:
+            partial_groups.append((key, rows))
+            for index in overlap:
+                detail_by_index[index]["subtask_metric_included"] = False
+                detail_by_index[index]["subtask_partial_in_slice"] = True
+
+    result["complete_subtasks"] = len(complete_groups)
+    result["partial_subtasks_excluded"] = len(partial_groups)
+    result["subtask_metrics_complete"] = (
+        contract["valid"] and not partial_groups)
+
+    if not contract["valid"]:
+        return result
+
+    macro_prefix_sum = 0.0
+    for key, rows in complete_groups:
+        flags = [
+            bool(detail_by_index[item["_idx"]]["step_success"])
+            for item in rows
+        ]
+        prefix_correct = 0
+        for flag in flags:
+            if not flag:
+                break
+            prefix_correct += 1
+        successful = all(flags)
+        total_steps = len(flags)
+        prefix_fraction = (
+            prefix_correct / total_steps if total_steps else 0.0)
+        result["successful_subtasks"] += int(successful)
+        result["prefix_correct_steps"] += prefix_correct
+        result["complete_subtask_steps"] += total_steps
+        macro_prefix_sum += prefix_fraction
+
+        for item in rows:
+            detail = detail_by_index[item["_idx"]]
+            detail.update({
+                "subtask_metric_included": True,
+                "subtask_partial_in_slice": False,
+                "subtask_success": successful,
+                "subtask_prefix_correct_steps": prefix_correct,
+                "subtask_prefix_completion": prefix_fraction,
+            })
+
+    denominator = result["complete_subtasks"]
+    if denominator:
+        result["subtask_exact_match"] = (
+            result["successful_subtasks"] / denominator)
+        result["subtask_prefix_completion_macro"] = (
+            macro_prefix_sum / denominator)
+    step_denominator = result["complete_subtask_steps"]
+    if step_denominator:
+        result["subtask_prefix_step_accuracy"] = (
+            result["prefix_correct_steps"] / step_denominator)
+    return result
+
+
+def _score_part_metrics(contract, selected_indices, details):
+    """Aggregate per-slot correctness into complete part trajectories."""
+    result = _empty_part_metrics()
+    result.update({
+        "part_contract_valid": contract["valid"],
+        "part_contract_error_count": contract["error_count"],
+        "part_contract_errors_preview": contract["errors_preview"],
+    })
+    selected = set(selected_indices)
+    detail_by_index = {item["_idx"]: item for item in details}
+    complete_groups = []
+    partial_groups = []
+
+    for key, rows in contract["groups"].items():
+        group_indices = [item["_idx"] for item in rows]
+        overlap = selected.intersection(group_indices)
+        if not overlap:
+            continue
+        result["parts_touched"] += 1
+        if len(overlap) == len(group_indices):
+            complete_groups.append((key, rows))
+        else:
+            partial_groups.append((key, rows))
+            for index in overlap:
+                detail_by_index[index]["part_metric_included"] = False
+                detail_by_index[index]["part_partial_in_slice"] = True
+
+    result["complete_parts"] = len(complete_groups)
+    result["partial_parts_excluded"] = len(partial_groups)
+    result["part_metrics_complete"] = (
+        contract["valid"] and not partial_groups)
+
+    if not contract["valid"]:
+        return result
+
+    macro_step_sum = 0.0
+    macro_prefix_sum = 0.0
+    for key, rows in complete_groups:
+        flags = [
+            bool(detail_by_index[item["_idx"]]["step_success"])
+            for item in rows
+        ]
+        correct_steps = sum(flags)
+        prefix_correct = 0
+        for flag in flags:
+            if not flag:
+                break
+            prefix_correct += 1
+        successful = all(flags)
+        total_steps = len(flags)
+        step_fraction = (
+            correct_steps / total_steps if total_steps else 0.0)
+        prefix_fraction = (
+            prefix_correct / total_steps if total_steps else 0.0)
+
+        result["successful_parts"] += int(successful)
+        result["step_correct_steps"] += correct_steps
+        result["prefix_correct_steps"] += prefix_correct
+        result["complete_part_steps"] += total_steps
+        macro_step_sum += step_fraction
+        macro_prefix_sum += prefix_fraction
+
+        for item in rows:
+            detail = detail_by_index[item["_idx"]]
+            detail.update({
+                "part_metric_included": True,
+                "part_partial_in_slice": False,
+                "part_success": successful,
+                "part_total_steps": total_steps,
+                "part_step_correct_steps": correct_steps,
+                "part_step_accuracy": step_fraction,
+                "part_prefix_correct_steps": prefix_correct,
+                "part_prefix_completion": prefix_fraction,
+            })
+
+    part_denominator = result["complete_parts"]
+    if part_denominator:
+        result["part_exact_match"] = (
+            result["successful_parts"] / part_denominator)
+        result["part_step_accuracy_macro"] = (
+            macro_step_sum / part_denominator)
+        result["part_prefix_completion_macro"] = (
+            macro_prefix_sum / part_denominator)
+
+    step_denominator = result["complete_part_steps"]
+    if step_denominator:
+        result["part_step_accuracy_micro"] = (
+            result["step_correct_steps"] / step_denominator)
+        result["part_prefix_step_accuracy"] = (
+            result["prefix_correct_steps"] / step_denominator)
+    return result
+
+
+def score_predictions(dataset_path, prediction_path, start_index=0, limit=0,
+                      num_shards=1, shard_index=0):
+    """Score a prediction JSONL against a fixed canonical reference slice."""
+    dataset_path = Path(dataset_path).resolve()
+    prediction_path = Path(prediction_path).resolve()
+    records = read_jsonl(dataset_path)
+    subtask_contract = build_subtask_contract(records)
+    part_contract = build_part_contract(records)
+    index_list = reference_indices(
+        records,
+        start_index=start_index,
+        limit=limit,
+        num_shards=num_shards,
+        shard_index=shard_index,
+    )
+    predictions = load_prediction_map(prediction_path, index_list)
+
+    overall = _empty_counts()
+    by_action = defaultdict(_empty_counts)
+    confusion = defaultdict(Counter)
+    details = []
+    missing_indices = []
+    inference_error_slots = 0
+
+    for index in index_list:
+        record = records[index]
+        task_fields = _record_subtask_fields(record)
+        expected = _validate_reference(index, record)
+        action_name = expected.action
+        overall["slots"] += 1
+        by_action[action_name]["slots"] += 1
+
+        prediction_row = predictions.get(index)
+        prediction_text = (
+            prediction_row.get("prediction")
+            if prediction_row is not None else None)
+        if prediction_row is None:
+            missing_indices.append(index)
+            parse_error = "missing_prediction_record"
+            generated = None
+        else:
+            inference_error = prediction_row.get("error")
+            if inference_error:
+                inference_error_slots += 1
+                prediction_text = None
+                generated = None
+                parse_error = "inference_error: %s" % inference_error
+            else:
+                parse_error = None
+                try:
+                    generated = action_runner.parse_model_output(
+                        prediction_text)
+                except Exception as exc:
+                    generated = None
+                    parse_error = str(exc)
+
+        comparison = {
+            "action_match": False,
+            "parameter_match": False,
+            "step_success": False,
+        }
+        pred_action = "<missing>" if prediction_row is None else "<parse_error>"
+        if generated is not None:
+            overall["parseable"] += 1
+            by_action[action_name]["parseable"] += 1
+            pred_action = generated.action
+            comparison = action_metrics.compare_to_reference(
+                generated, expected, record=record,
+                screen_size=action_runner.EXPECTED_SCREEN)
+        format_compliant = is_format_compliant(prediction_text)
+        if format_compliant:
+            overall["format_compliant"] += 1
+            by_action[action_name]["format_compliant"] += 1
+
+        for key, metric_name in (
+            ("action_match", "action_correct"),
+            ("parameter_match", "parameter_correct"),
+            ("step_success", "step_correct"),
+        ):
+            if comparison[key]:
+                overall[metric_name] += 1
+                by_action[action_name][metric_name] += 1
+        confusion[action_name][pred_action] += 1
+        details.append({
+            "_idx": index,
+            "part_id": record.get("part_id"),
+            "part_key": task_fields["part_key"],
+            "task_id": task_fields["task_id"],
+            "action_index_in_task": task_fields["action_index_in_task"],
+            "total_actions_in_task": task_fields["total_actions_in_task"],
+            "gt_action": action_name,
+            "pred_action": pred_action,
+            "prediction_present": prediction_row is not None,
+            "parse_ok": generated is not None,
+            "parse_error": parse_error,
+            "format_compliant": format_compliant,
+            "action_match": comparison["action_match"],
+            "parameter_match": comparison["parameter_match"],
+            "step_success": comparison["step_success"],
+        })
+
+    subtask_metrics = _score_subtask_metrics(
+        subtask_contract, index_list, details)
+    part_metrics = _score_part_metrics(
+        part_contract, index_list, details)
+    dataset_hash = dataset_sha256(dataset_path)
+    coverage_complete = len(predictions) == len(index_list)
+    full_dataset = (
+        start_index == 0 and limit == 0 and num_shards == 1 and
+        len(index_list) == len(records))
+    dataset_contract = identify_dataset_contract(records, dataset_hash)
+    dataset_contract_name = (
+        dataset_contract["name"] if dataset_contract else None)
+    canonical_contract = bool(
+        dataset_contract and dataset_contract["canonical_full_test"])
+    stratified_test_50_contract = (
+        dataset_contract_name == "stratified_test_50_seed42")
+    heldout_test_364_contract = (
+        dataset_contract_name == "heldout_test_364_seed42_complement")
+    registered_benchmark_metrics_valid = (
+        coverage_complete and full_dataset and dataset_contract is not None and
+        inference_error_slots == 0 and
+        subtask_metrics["subtask_metrics_complete"] and
+        part_metrics["part_metrics_complete"])
+    summary = {
+        "protocol": "cad_drawer_evaluation_v1",
+        "metric_suite_version": "cad_drawer_l1_metrics_v4",
+        "dataset": str(dataset_path),
+        "dataset_sha256": dataset_hash,
+        "prediction_file": str(prediction_path),
+        "dataset_total_slots": len(records),
+        "slice_start_index": start_index,
+        "slice_end_index_exclusive": (
+            index_list[-1] + 1 if index_list else start_index),
+        "reference_slots": len(index_list),
+        "num_shards": num_shards,
+        "shard_index": shard_index,
+        "prediction_records": len(predictions),
+        "missing_slots": len(missing_indices),
+        "missing_indices_preview": missing_indices[:50],
+        "inference_error_slots": inference_error_slots,
+        "coverage_complete": coverage_complete,
+        "evaluation_slice_complete": coverage_complete,
+        "registered_dataset_contract": dataset_contract_name,
+        "registered_dataset_contract_details": dataset_contract,
+        "canonical_test_final_contract": canonical_contract,
+        "stratified_test_50_contract": stratified_test_50_contract,
+        "heldout_test_364_contract": heldout_test_364_contract,
+        "inference_clean": inference_error_slots == 0,
+        "registered_benchmark_metrics_valid": (
+            registered_benchmark_metrics_valid),
+        "official_full_test_metrics_valid": (
+            registered_benchmark_metrics_valid and canonical_contract),
+        "official_test_50_metrics_valid": (
+            registered_benchmark_metrics_valid and
+            stratified_test_50_contract),
+        "official_test_364_metrics_valid": (
+            registered_benchmark_metrics_valid and
+            heldout_test_364_contract),
+        "metrics": _with_rates(overall),
+        "subtask_metrics": subtask_metrics,
+        "part_metrics": part_metrics,
+        "by_gt_action": {
+            name: _with_rates(counts)
+            for name, counts in sorted(by_action.items())
+        },
+        "action_confusion": {
+            expected: dict(sorted(predicted.items()))
+            for expected, predicted in sorted(confusion.items())
+        },
+        "definitions": {
+            "action_accuracy": "predicted action equals the GT action",
+            "parameter_accuracy": (
+                "parameters match under the GT action schema; independent "
+                "from predicted action correctness"),
+            "step_accuracy": (
+                "per-slot conjunction of action_match and parameter_match"),
+            "subtask_exact_match": (
+                "fraction of complete reference subtasks whose every "
+                "step is correct"),
+            "subtask_prefix_completion_macro": (
+                "mean, with equal weight per complete subtask, of the "
+                "consecutive correct prefix length divided by task length"),
+            "subtask_prefix_step_accuracy": (
+                "total consecutive correct prefix slots divided by all slots "
+                "in complete subtasks; longer subtasks receive more weight"),
+            "subtask_scope": (
+                "subtasks are grouped by part identity and task_id; partial "
+                "subtasks at a requested slice boundary are excluded and make "
+                "subtask_metrics_complete false"),
+            "part_step_accuracy_macro": (
+                "mean per-part fraction of independently correct reference "
+                "steps; every complete part has equal weight"),
+            "part_step_accuracy_micro": (
+                "total correct steps divided by all steps in complete parts; "
+                "equivalent to overall step accuracy on a complete full run"),
+            "part_prefix_completion_macro": (
+                "mean per-part fraction of consecutive correct steps before "
+                "the first failure; every complete part has equal weight"),
+            "part_prefix_step_accuracy": (
+                "total consecutive correct prefix steps divided by all steps "
+                "in complete parts; longer parts receive more weight"),
+            "part_exact_match": (
+                "fraction of complete reference part trajectories whose "
+                "every step is correct"),
+            "part_scope": (
+                "parts are grouped by source-relative part identity and must "
+                "be contiguous; partial parts are excluded"),
+            "parse_rate": (
+                "canonical FreeCAD action parser accepts the model output"),
+            "denominator": (
+                "all canonical reference slots in the requested slice; "
+                "missing, inference-error, and parse-error slots score zero"),
+        },
+    }
+    return summary, details
+
+
+def write_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(
+        path.name + ".tmp.%d" % os.getpid())
+    with temporary.open("w", encoding="utf-8") as handle:
+        json.dump(value, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+        handle.flush()
+        os.fsync(handle.fileno())
+    os.replace(temporary, path)
+
+
+def write_jsonl(path, rows):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")