FIX: serialize numpy trial_scores in ScorerMetrics.to_json

[fei (feiiiiii5)]

Description

Closes #2710.

ScorerMetrics.to_json() documents itself as "the canonical serialization entry point for
ScorerMetrics and its subclasses", paired with from_json_file() for round-trip
(de)serialization. It raises TypeError: Object of type ndarray is not JSON serializable for
every metrics object ScorerEvaluator hands back, because the evaluator attaches trial_scores
as a numpy array immediately before returning, with an in-source comment telling callers to use
that returned object for detailed analysis (scorer_evaluator.py:448-450).

Two changes, both inside that documented pair:

• to_json() passes a default= hook that encodes numpy arrays and numpy scalars with
  .tolist(). It still raises TypeError for anything that is neither JSON nor numpy, so the
  fix cannot degrade into silent stringification of a bad value.
• from_json_file() decodes trial_scores back into an np.ndarray, so the round trip returns
  the type the field is declared with instead of a nested list.

np.float64 fields (mean_absolute_error, mae_standard_error, accuracy_standard_error) were
never the failing field: np.float64 subclasses float, so json.dumps already accepts them and
default= is not consulted for them — their output is unchanged. ndarray, np.int64 and
np.bool_ are the numpy types json refuses (checked against numpy 2.4.4), which is why the hook
covers np.generic as well as np.ndarray.

Round-trip fidelity, stated precisely: to_json() writes .tolist(), so the loaded array's dtype
and shape follow the stored lists rather than the original array. Measured on this branch:

stored array	after to_json() + from_json_file()
float64 2×2 (what HarmScorerEvaluator returns)	identical dtype, shape, values
bool 3×2 (what ObjectiveScorerEvaluator returns)	identical dtype, shape, values
float32 1×2	widens to float64, values exact
np.zeros((0, 3))	shape collapses to (0,)
masked array	masked cells become JSON null, loads as object dtype
object array holding ragged lists	to_json() fine, decode raises ValueError

The last four are not reachable from ScorerEvaluator, which always assigns a rectangular
float64 or bool array (np.array(all_model_scores_list)), but they are the honest boundary of
"round trip". from_json_file() decodes only when the stored value is a list, so a hand-written
non-list trial_scores passes through unchanged instead of raising inside np.array().

Deliberately not changed:

• _metrics_to_registry_dict() in scorer_metrics_io.py still excludes trial_scores, so JSONL
  registry files keep their current shape; test_metrics_to_registry_dict_excludes_trial_scores
  still passes untouched.
• == between two array-carrying metrics still raises
  ValueError: The truth value of an array with more than one element is ambiguous, because the
  dataclass compares the ndarray field elementwise. Whether trial_scores should participate in
  equality is a semantics decision rather than a bug fix, so I raised it separately in the issue
  instead of smuggling compare=False in here. It is also why the new tests assert per field
  rather than reusing the assert loaded == metrics oracle of the two existing round-trip tests.

Tests and Documentation

Three tests added to TestScorerMetricsSerialization in
tests/unit/score/test_scorer_metrics.py:

• test_harm_metrics_to_json_serializes_trial_scores — the reported failure: to_json() on
  HarmScorerMetrics holding a 2×2 float64 array, then a file round trip through
  from_json_file() that comes back as an ndarray with the same shape and values.
• test_objective_metrics_round_trip_keeps_every_serializable_field — a bool-dtype array (what
  a true/false evaluation produces) plus every other field compared through
  dataclasses.asdict() with trial_scores popped on both sides.
• test_to_json_rejects_values_that_are_not_numpy_or_json — pins that the new hook still raises
  for a value that is neither JSON-serializable nor numpy.

The first two fail on the base commit and pass with the patch; the third passes on both by design
(it constrains how the fix is implemented). No documentation example or in-tree caller invokes
metrics.to_json() today, which is why the existing suite stayed green — so there are no doc/
changes and no JupyText run for this diff.

Verification

Environment for everything below: macOS 27 arm64, Python 3.14.5, numpy 2.4.4, dependencies
resolved by uv sync --frozen --extra all from this branch's own uv.lock (the same dependency
set CI resolves). Every command was run with cwd inside the PR worktree unless stated.

Old behavior vs new, same test file both sides (-p no:randomly on both so the runs are
comparable):

tree	command target	result
base 5172897 (detached worktree, this PR's test file copied in, source untouched)	pytest tests/unit/score/test_scorer_metrics.py	2 failed, 20 passed — TypeError: Object of type ndarray is not JSON serializable / when serializing dict item 'trial_scores' in test_harm_metrics_to_json_serializes_trial_scores and test_objective_metrics_round_trip_keeps_every_serializable_field
head	same command	22 passed

test_to_json_rejects_values_that_are_not_numpy_or_json passes on both sides on purpose; it is a
guard on how the fix is implemented, not evidence about the bug.

Project checks on the head commit:

• uv run --frozen --extra all python -m pytest -n 4 --dist=loadfile --cov=pyrit --cov-fail-under=78 tests/unit --cov-report xml --cov-report term -q → 18181 passed, 11 skipped, Required test coverage of 78% reached. Total coverage: 95.07%
• uv run --frozen --extra all python -m diff_cover.diff_cover_tool coverage.xml --compare-branch=origin/main --diff-range-notation=.. --fail-under=90 → pyrit/score/scorer_evaluation/scorer_metrics.py (100%), Total: 10 lines Missing: 0 lines Coverage: 100%
• uv run --frozen --extra all pre-commit run --files pyrit/score/scorer_evaluation/scorer_metrics.py tests/unit/score/test_scorer_metrics.py → all hooks Passed, including ruff-format, ruff-check, ty (type check), Reject Sphinx reST cross-reference roles and Enforce _async Suffix on async def
• uv run --frozen --extra all python -m pytest tests/unit/score tests/unit/cli/test_import_guards.py -q → 1980 passed. The import-guard tests are included because they are what would object to import numpy moving out of the if TYPE_CHECKING: block; scorer_evaluator.py and krippendorff.py already import numpy at module level, so this matches the package.

Reachability check outside the unit tests (a one-off script, deliberately not added to the suite):
driving the real HarmScorerEvaluator.evaluate_dataset_async(...) with the mocked-scorer recipe of
tests/unit/score/test_scorer_evaluator.py:75 — on base the returned metrics raise the
TypeError from to_json(); on this branch the same call returns
... "trial_scores": [[0.2, 0.4], [0.2, 0.4]], .... The round-trip table under Description comes
from the same script, run against this branch.

Not verified here: CI on Windows/macOS runners and the notebook-based docs examples. No doc/
file is touched, and per the description above no in-tree caller or docs example reaches
metrics.to_json(), so JupyText was not re-run. I will report what the workflow checks show once
they are permitted to run for this fork.