Blame for evaluation/metrics.py

#!/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")