diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5fc609a3..56fcd63b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -144,8 +144,8 @@ uv run usersim smoke        # offline self-check; no API key, no network
 ```
 
 `smoke` is the fastest way to confirm an install is sound. It resolves the
-model catalog, every probe's assets, and the plugin entry points without
-making a single model call.
+model catalog, runs each probe's check of the assets it ships, and loads the
+plugin entry points without making a single model call.
 
 ### Choosing models and providers
 
diff --git a/architecture/assets.md b/architecture/assets.md
index 707de136..8986f98c 100644
--- a/architecture/assets.md
+++ b/architecture/assets.md
@@ -62,6 +62,16 @@ Without this, a missing bank surfaces from inside a loader partway through a
 run, after the other probes in the mix have already been paid for, while
 `--dry-run` would report the plan and exit 0.
 
+## Install check
+
+`usersim smoke` runs each registered probe's `asset_problems` classmethod,
+which checks the assets the probe ships without a model call. For example,
+`sov_ai_facts` and `sov_ai_dynamic` look for a bank in every shipped locale,
+`financial_services` loads its `en_US` bank and that bank's dynamic-tier
+taxonomy, and `identity_disclosure` loads its spec through every layer. A probe
+from another package is checked the same way, and `assert_probe_conforms`
+reports what its check finds.
+
 ## Generating a bank
 
 `usersim gen-assets --domain <d>` generates one; `validate-assets` vets it
diff --git a/architecture/evaluator.md b/architecture/evaluator.md
index e499c6df..12f1034e 100644
--- a/architecture/evaluator.md
+++ b/architecture/evaluator.md
@@ -13,7 +13,9 @@ ensemble never rests on one model family. A single judge is allowed.
 
 **Scorers** are per-probe functions over stored columns, each returning a
 structured verdict rather than a free-form opinion. Three are fully
-deterministic (`language_compliance`, `refusal_basics`, `response_shape`); the
+deterministic (`language_compliance`, `refusal_basics`, `response_shape`) and
+register with `deterministic=True`, which is what lets `usersim rescore`
+recompute them on a stored evaluation; the
 other nine call a model to reach a judgment the stored columns cannot settle on
 their own, such as whether a retrieved fact is actually supported or what a
 free-form turn actually disclosed (`health_disclosure_concealment`, which falls
@@ -35,8 +37,12 @@ Twelve ship:
 | `response_shape` | structural expectations |
 | `refusal_basics` | refusal presence and form |
 
-Scorers are opt-in per run. A capability whose scorer was not dispatched
-renders as *untested* rather than as a failure, and
+Scorers are opt-in per run. `usersim eval --scorers auto` runs the three
+deterministic scorers, which apply to every probe, plus the `default_scorers`
+each probe in the run declares, found by the `probe_family` its rows are stored
+under; `auto` combines with scorer names. Over a run holding every built-in
+probe it runs every scorer the capability report reads. A capability whose
+scorer was not dispatched renders as *untested* rather than as a failure, and
 `capabilities_missing_scorer()` exists so a run can warn about that instead
 of silently producing an empty column.
 
@@ -62,6 +68,8 @@ Scorers register through `register_scorer` at import, and are discovered
 out-of-tree through the `usersim.scorers` entry point. A scorer receives the
 trajectory row as a dict in which every empty cell is `None`, apart from
 `conversation_messages`, `persona`, `probe_family`, `locale` and `language`,
-which the evaluator always fills. `usersim.testing` publishes a conformance
+which the evaluator always fills: `probe_family` is an empty string for a row
+that names no probe, and the judges score such a row only on the axes every
+probe shares. `usersim.testing` publishes a conformance
 check, including that a scorer tolerates a row missing any given field, since
 the evaluator calls it on incomplete trajectories. See [plugins.md](plugins.md).
diff --git a/architecture/plugins.md b/architecture/plugins.md
index 5ca16fab..a6127447 100644
--- a/architecture/plugins.md
+++ b/architecture/plugins.md
@@ -133,7 +133,8 @@ failing later inside a run.
 The row a scorer receives holds every column of the trajectory, and an empty
 cell arrives as `None` whichever way pandas held it. The evaluator fills
 `conversation_messages` (a list), `persona` (a dict), `probe_family`, `locale`
-and `language` itself, so those are never `None`. A default passed to
+and `language` itself, so those are never `None`; `probe_family` is an empty
+string for a row that names no probe. A default passed to
 `row.get(key, default)` covers only an absent key, so pass a row shaped like
 your probe's trajectories to the check as well:
 `assert_scorer_conforms("my_scorer", sample_row=row)` also scores that row with
diff --git a/architecture/probes.md b/architecture/probes.md
index 7f9bddfb..908dc9ae 100644
--- a/architecture/probes.md
+++ b/architecture/probes.md
@@ -54,7 +54,11 @@ required; the rest have working defaults on `BaseProbe`.
 | `build_result_extras` | adding probe-specific columns to the trajectory, each declared in the class's `output_columns` |
 
 Anything a probe does not override inherits a default, so a new probe declares
-only what is specific to it.
+only what is specific to it. Its `description`, a paragraph on what it tests, is
+what the per-row preview and the capability report show with its rows, and its
+`preview_fields` are what the preview's Probe Inputs panel shows about the bank
+entry or theme each row drew. Its `default_scorers` are the scorers
+`usersim eval --scorers auto` runs when a run holds its rows.
 
 A probe's own columns are the one part of this that is declared twice. Whatever
 `build_result_extras` returns is written only if the name is a core column or
@@ -115,7 +119,10 @@ instance). Those probes declare a `locale_bank_check` on the class, which the
 pre-flight calls on the bank the class's `bank_locale` names. The refusal names
 the probe, the locale and the locales that can run, rather than failing from
 inside a loader mid-run. `simulate` and its `--dry-run`, `--materialize-inputs`,
-`--inputs` and notebook 01 all run the check. See [assets.md](assets.md).
+`--inputs` and notebook 01 all run the check. A probe's `asset_problems`
+classmethod checks the assets it ships without a model call: `usersim smoke`
+runs it for each registered probe, and `assert_probe_conforms` reports what it
+finds. See [assets.md](assets.md).
 
 A probe whose conversations vary by topic lists its themes in a `themes`
 classmethod, read under its asset folder. A run draws one per row into the
diff --git a/docs/engine/AUTHORING_A_PROBE.md b/docs/engine/AUTHORING_A_PROBE.md
index 5e753a7f..58d3d75c 100644
--- a/docs/engine/AUTHORING_A_PROBE.md
+++ b/docs/engine/AUTHORING_A_PROBE.md
@@ -206,6 +206,32 @@ warnings a probe adds with `add_warning` take the same prefixed form, such as
 
 For `BaseProbe`-only subclasses, just `label` is required.
 
+Every probe also sets `description`, a paragraph on what it tests. The per-row
+preview and the capability report's evidence show it with each of the probe's
+rows:
+
+```python
+class MyProbe(BaseProbe):
+    label = "my_probe"
+    description = "Tests whether the assistant ..."
+```
+
+A probe whose rows draw from a bank also lists, in `preview_fields`, what the
+per-row preview's Probe Inputs panel shows about the entry each row drew. A
+`PreviewField` names a column of the row, or with `from_metadata=True` a key
+the probe writes to `state.metadata`, and the label it is shown with. The panel
+leaves out a field whose value is empty, and is left out when every field is:
+
+```python
+from usersim.engine.core.probes import PreviewField
+
+class MyProbe(BankBackedProbe):
+    preview_fields = (
+        PreviewField("my_probe_item_id", "Item id"),
+        PreviewField("item_category", "Category", from_metadata=True),
+    )
+```
+
 A probe shipped in its own package, rather than in this repository, also
 sets `assets_root` to the directory that holds its `<label>/` asset folder,
 so it finds its banks wherever the package is installed:
@@ -352,6 +378,29 @@ class MyProbe(BankVerbatimMixin, BankBackedProbe):
   for another locale. The refusal links it when a run asks for a locale the
   probe has no bank for.
 
+### Check the assets you ship
+
+`usersim smoke` runs each registered probe's `asset_problems` classmethod, and
+`assert_probe_conforms` reports what it finds, so an install that is missing a
+bank fails a check rather than a run. Return one string per problem, or an
+empty list, and read what your loaders read without calling a model:
+
+```python
+class MyProbe(BankVerbatimMixin, BankBackedProbe):
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        problems = []
+        for locale in ("en_US", "fr_FR"):
+            try:
+                _check_locale_bank(cls.assets_dir() / locale)
+            except Exception as error:
+                problems.append(f"{locale}: {type(error).__name__}: {error}")
+        return problems
+```
+
+The default checks nothing. An exception the check raises is reported like a
+problem it returns.
+
 ### Give each row a theme
 
 A probe whose conversations vary by topic lists the topics in a `themes`
@@ -551,6 +600,9 @@ is the most likely cause. If it shows up but `family missing` fires, the
 `@register_probe` decorator didn't run (check for an import-time
 exception in your module).
 
+A probe that checks its assets is named on the `probe assets` line, which
+fails with the first problems its `asset_problems` finds.
+
 For a probe in its own package, the `extensions` line names the package and
 fails with the reason when an entry point contributes nothing, such as an
 import error or a name another package already uses.
@@ -1078,7 +1130,10 @@ register_scorer("your_probe", score_your_probe_trajectory)
 
 `register_scorer` takes the name and the function; it is not a decorator.
 Give it a name no other scorer uses: a different function under a taken name
-raises `ScorerRegistrationError`. The
+raises `ScorerRegistrationError`. A scorer that never calls or looks up a model
+also passes `deterministic=True`, so `usersim rescore` can recompute it on a
+stored evaluation; `assert_scorer_conforms` reports one that looks up a model
+anyway. The
 `trajectory` argument carries every top-level column your
 `build_result_extras` surfaced, because `TrajectoryEvaluatorGenerator` merges
 the full row dict into it, so any side-channel column you set is visible. A
@@ -1089,10 +1144,22 @@ when you pass it a `sample_row`.
 Add the module path to
 [`evaluator/scorers/__init__.py::DEFAULT_SCORER_MODULES`](../../src/usersim/engine/evaluator/scorers/__init__.py)
 so the auto-load path picks it up. After that, name it at evaluation time
-(`usersim eval --scorers your_probe`). The evaluator calls each named scorer on
-every row, so return early for rows from other probes, for example when your
-probe's join key is missing, as the `safety_agentic` scorer does with
-`action_request_id`.
+(`usersim eval --scorers your_probe`), or list it in the probe's
+`default_scorers`:
+
+```python
+class MyProbe(BaseProbe):
+    label = "my_probe"
+    default_scorers = ("your_probe",)
+```
+
+`usersim eval --scorers auto` then runs it whenever the run holds the probe's
+rows, beside the rule-based `language_compliance`, `refusal_basics` and
+`response_shape`, which `auto` runs for every probe. `assert_probe_conforms`
+reports a name in `default_scorers` that no registered scorer holds. The
+evaluator calls each scorer it runs on every row, so return early for rows from
+other probes, for example when your probe's join key is missing, as the
+`safety_agentic` scorer does with `action_request_id`.
 
 The scorer is its own design exercise (axis definition, rubric
 authoring, threshold gating). See
diff --git a/docs/engine/README.md b/docs/engine/README.md
index 2eeb77fe..aae70237 100644
--- a/docs/engine/README.md
+++ b/docs/engine/README.md
@@ -419,9 +419,10 @@ Quick orientation:
    discarded on the way to storage (with a warning in the log), and the
    scorer that reads it back reports nothing to score; see the
    authoring guide's step 6.
-7. Run `usersim smoke` to confirm registration; copy
-   `templates/probe/test_probe.py.template` for the per-probe
-   regression test.
+7. Run `usersim smoke` to confirm registration and, when your probe
+   checks its banks in an `asset_problems` classmethod, that they are
+   found; copy `templates/probe/test_probe.py.template` for the
+   per-probe regression test.
 
 For the substrate's API surface (every class, every mixin, every
 hook), see the source-of-truth docstrings in
@@ -432,7 +433,8 @@ hook), see the source-of-truth docstrings in
 new axes to `evaluator/axes.py::PROBE_SCORES` if needed; add a
 scorer under `evaluator/scorers/your_probe.py` and include it in
 `DEFAULT_SCORER_MODULES` to register it on import; name it in `--scorers` to
-run it.
+run it, or list it in the probe's `default_scorers` so `--scorers auto` runs
+it.
 
 ## Scope
 
diff --git a/docs/extensions.md b/docs/extensions.md
index 9f51b214..a8c1ce1f 100644
--- a/docs/extensions.md
+++ b/docs/extensions.md
@@ -96,7 +96,7 @@ from pathlib import Path
 import yaml
 
 from usersim.engine.core.identity import persona_uuid
-from usersim.engine.core.probes import BankBackedProbe, register_probe
+from usersim.engine.core.probes import BankBackedProbe, PreviewField, register_probe
 
 
 @dataclass(frozen=True)
@@ -126,12 +126,23 @@ def load_recipe_bank(locale: str) -> RecipeBank:
 @register_probe(family="acme_recipes", prompt_version="v1.0", variants=("default",))
 class RecipeProbe(BankBackedProbe):
     label = "acme_recipes"
+    description = "Tests cooking help: a home cook asks about a recipe from the bank."
+    preview_fields = (PreviewField("acme_recipe_id", "Recipe id"),)
+    default_scorers = ("acme_recipes",)
     assets_root = Path(__file__).parent / "assets"
     bank_loader = staticmethod(load_recipe_bank)
     locale_bank_check = staticmethod(read_recipe_bank)
     placeholder_warning_kind = "acme_used_placeholder_recipe"
     output_columns = ("acme_recipe_id",)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        try:
+            read_recipe_bank(cls.assets_dir() / "en_US")
+        except Exception as error:
+            return [f"en_US: {type(error).__name__}: {error}"]
+        return []
+
     def derive_task(self, persona, bank, *, cfg):
         rng = random.Random(f"{persona_uuid(persona)}:{bank.bank_version}:{cfg.random_seed}")
         return rng.choice(bank.recipes)
@@ -146,6 +157,12 @@ class RecipeProbe(BankBackedProbe):
         return {**super().build_result_extras(state), "acme_recipe_id": self._task.id}
 ```
 
+- **`description`** is what the per-row preview and the capability report
+  show about the probe.
+- **`preview_fields`** puts the row's recipe id in the per-row preview's Probe
+  Inputs panel.
+- **`default_scorers`** names the package's scorer, so
+  `usersim eval --scorers auto` runs it whenever a run holds the probe's rows.
 - **`assets_root`** is the absolute directory holding `acme_recipes/`, so the
   probe finds its banks wherever the package is installed.
 - **`load_recipe_bank`** reads under `RecipeProbe.assets_dir()`, the probe's
@@ -153,6 +170,8 @@ class RecipeProbe(BankBackedProbe):
   `USERSIM_ASSET_PATH` names reaches it too.
 - **`locale_bank_check`** reads one locale's bank, so a run in a locale with no
   bank that loads stops before any model call rather than failing every row.
+- **`asset_problems`** reads the bank the package ships, so `usersim smoke` and
+  `assert_probe_conforms` report an install that is missing it.
 - **`placeholder_warning_kind`** is the warning a row records when its recipe
   is marked `placeholder: true`. Its `<prefix>_used_placeholder_<thing>` form is
   what the capability report counts as placeholder content.
@@ -189,12 +208,14 @@ async def score(row, models):
     return {"acme_recipe_grounded": 1.0 if row.get("acme_recipe_id") else 0.0}
 
 
-register_scorer("acme_recipes", score)
+register_scorer("acme_recipes", score, deterministic=True)
 ```
 
 The evaluator awaits a scorer once per trajectory, with the row and the
 models, and merges the mapping it returns into the row's evaluation. A field
-the row holds empty arrives as `None`.
+the row holds empty arrives as `None`. `deterministic=True` says the scorer
+never calls a model, so `usersim rescore` can recompute it on a stored
+evaluation.
 
 ## Tests
 
diff --git a/src/usersim/cli/evaluate.py b/src/usersim/cli/evaluate.py
index 01f7ca29..392ac004 100644
--- a/src/usersim/cli/evaluate.py
+++ b/src/usersim/cli/evaluate.py
@@ -112,7 +112,9 @@ def register(subparsers: argparse._SubParsersAction) -> None:
             "Comma-separated scorer names to run beside the judges, for "
             "example tool_use,language_compliance. Most scorers use an LLM "
             "judge; language_compliance, response_shape and refusal_basics "
-            "are rule-based. Default: none."
+            "are rule-based. 'auto' stands for those three plus the "
+            "default_scorers of each probe in the run, and combines with "
+            "names. Default: none."
         ),
     )
     p.add_argument(
@@ -179,6 +181,36 @@ def _parse_csv_or_none(spec: str | None) -> list[str] | None:
     return items or None
 
 
+def _resolve_scorers(requested: list[str], families: Iterable[str]) -> list[str]:
+    """``requested`` with ``auto`` replaced by the generic scorers and the ``default_scorers`` of the run's probes.
+
+    ``families`` are the ``probe_family`` values of the rows being evaluated.
+    Each name appears once, where it first occurs. A family no installed probe
+    stores its rows under adds no scorer of its own, and a warning names it. A
+    blank family names no probe, so it adds none and goes unnamed.
+    """
+    from usersim.engine.core.probes import default_scorers_by_family
+    from usersim.engine.evaluator.scorers import AUTO_SCORERS, GENERIC_SCORERS
+
+    if AUTO_SCORERS not in requested:
+        return requested
+    by_family = default_scorers_by_family()
+    present = {family for family in families if family}
+    unclaimed = sorted(present - set(by_family))
+    if unclaimed:
+        logger.warning(
+            "no installed probe stores its rows under probe_family %s, so --scorers %s adds none of "
+            "its scorers for those rows.",
+            ", ".join(unclaimed),
+            AUTO_SCORERS,
+        )
+    auto = [*GENERIC_SCORERS, *(name for family, names in by_family.items() if family in present for name in names)]
+    resolved: dict[str, None] = {}
+    for name in requested:
+        resolved.update(dict.fromkeys(auto if name == AUTO_SCORERS else (name,)))
+    return list(resolved)
+
+
 def _choose_rows(args: argparse.Namespace, seed_path: Path) -> tuple[Any, Any, int, dict[str, Any]]:
     """The trajectory rows this pass evaluates, and how they were chosen.
 
@@ -350,6 +382,11 @@ def run(args: argparse.Namespace) -> int:
             temp_sample_seed = seed_source_path = Path(tmp.name)
             sampled.to_parquet(temp_sample_seed, index=False)
 
+        resolved = _resolve_scorers(scorers, seed_df["probe_family"].head(num_records).dropna().astype(str))
+        if resolved != scorers:
+            print(f"  scorers:       {', '.join(resolved)}")
+        scorers = resolved
+
         data_designer, builder = build_evaluator_config_builder(
             models=models,
             trajectory_parquet=seed_source_path,
diff --git a/src/usersim/cli/rescore.py b/src/usersim/cli/rescore.py
index 7caaa821..ec780e74 100644
--- a/src/usersim/cli/rescore.py
+++ b/src/usersim/cli/rescore.py
@@ -24,11 +24,12 @@
   envelope here would make the next full eval re-judge every patched row at full
   LLM cost. The envelope keeps describing the run that produced the judge axes,
   which is what it is for.
-- **Only genuinely model-free scorers are allowed.** ``financial_services`` and
-  ``safety_agentic`` look deterministic (they emit mechanical axes) but branch
-  into an LLM judge on some rows — ``task_tier == "dynamic"`` and certain
-  ``sub_protocol`` values. Passing them here would silently spend money, so
-  they are refused by name rather than trusted to behave.
+- **Only scorers registered as deterministic are allowed**
+  (``register_scorer(..., deterministic=True)``). ``financial_services`` and
+  ``safety_agentic`` emit mechanical axes but call an LLM judge on some rows
+  (``task_tier == "dynamic"`` and certain ``sub_protocol`` values), so they are
+  not registered as deterministic, and rescore refuses them rather than spend
+  money.
 
 The scorers' inputs come from the TRAJECTORY frame, not the eval frame: the eval
 parquet carries only ``assistant_eval`` plus the three key columns, so
@@ -47,23 +48,6 @@
 
 _ROOT = Path(__file__).resolve().parents[1]
 
-# Scorers that provably issue no LLM call: the only three whose envelopes carry
-# ``scorer_kind="deterministic"``. Kept as an explicit allowlist rather than
-# derived from that field, because the field is absent on the hybrids and a
-# missing marker must not read as "safe".
-DETERMINISTIC_SCORERS: tuple[str, ...] = (
-    "language_compliance",
-    "refusal_basics",
-    "response_shape",
-)
-
-# Hybrids, named so the error can say WHY instead of "unknown scorer".
-_HYBRID_SCORERS: dict[str, str] = {
-    "financial_services": "calls an LLM judge on dynamic-tier rows",
-    "safety_agentic": "calls an LLM judge on some sub-protocols",
-    "health_disclosure_concealment": ("runs an LLM realized-behavior audit whenever a judge model is wired"),
-}
-
 
 def register(subparsers: argparse._SubParsersAction) -> None:
     p = subparsers.add_parser(
@@ -97,7 +81,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
         "--scorers",
         nargs="+",
         required=True,
-        help=("Deterministic scorers to recompute. One or more of: " + ", ".join(DETERMINISTIC_SCORERS)),
+        help="Scorers to recompute: any scorer registered as deterministic, such as language_compliance.",
     )
     p.add_argument(
         "--eval-column",
@@ -113,17 +97,23 @@ def register(subparsers: argparse._SubParsersAction) -> None:
 
 
 def _validate_scorers(names: list[str]) -> list[str]:
-    """Reject anything that might reach an LLM, with a reason."""
+    """Reject any scorer not registered as deterministic, with a reason: rescore calls no model."""
+    from usersim.engine.evaluator.scorers import deterministic_scorers, list_scorers
+
+    allowed = deterministic_scorers()
+    known = set(list_scorers())
     bad: list[str] = []
     for name in names:
-        if name in DETERMINISTIC_SCORERS:
+        if name in allowed:
             continue
-        if name in _HYBRID_SCORERS:
-            bad.append(f"{name!r} ({_HYBRID_SCORERS[name]}) — refused: rescore is LLM-free")
+        if name in known:
+            bad.append(
+                f"{name!r} is not registered as deterministic, so it may call a model; refused: rescore is LLM-free"
+            )
         else:
-            bad.append(f"{name!r} — not a known deterministic scorer")
+            bad.append(f"{name!r} is not a known deterministic scorer")
     if bad:
-        raise SystemExit("cannot rescore:\n  " + "\n  ".join(bad) + "\n\nallowed: " + ", ".join(DETERMINISTIC_SCORERS))
+        raise SystemExit("cannot rescore:\n  " + "\n  ".join(bad) + "\n\nallowed: " + ", ".join(allowed))
     return list(dict.fromkeys(names))
 
 
diff --git a/src/usersim/cli/smoke.py b/src/usersim/cli/smoke.py
index e60004f3..393e62e7 100644
--- a/src/usersim/cli/smoke.py
+++ b/src/usersim/cli/smoke.py
@@ -26,12 +26,10 @@
    ``usersim.engine.core.probes.known_probes()`` resolves
    to a class that carries ``family`` / ``prompt_version`` /
    ``variants`` metadata.
-8. **asset paths** — every shipped probe's default asset path
-   (``probe_assets_dir(probe) / ...``) resolves to a real file on
-   disk for every supported locale. Catches the regression class
-   where a default-path constant points at a non-existent directory
-   (the sort of half-rename bug that ships at notebook-run time
-   instead of install time).
+8. **probe assets** — every registered probe's ``asset_problems()``
+   comes back empty: each probe checks the assets it ships, such as a
+   bank per locale, so a default path pointing at a missing directory
+   fails at install time rather than partway through a run.
 9. **reporting bundles** — both bundles build from a tiny synthetic
    trajectory + evaluator frame and produce non-empty HTML.
 10. **extensions** — what each installed extension package contributes.
@@ -143,7 +141,7 @@ def run(args: argparse.Namespace) -> int:
     _check_evaluator_config(report)
     _check_scorer_registry(report)
     _check_probe_registry(report)
-    _check_asset_paths(report)
+    _check_probe_assets(report)
     _check_dry_runs(report)
     fixtures_path = _check_capability_dashboard(
         report,
@@ -439,164 +437,43 @@ def _check_probe_registry(report: SmokeReport) -> None:
     )
 
 
-def _check_asset_paths(report: SmokeReport) -> None:
-    """Verify every shipped probe's default asset path exists + loads.
+def _check_probe_assets(report: SmokeReport) -> None:
+    """Run every registered probe's ``asset_problems`` check.
 
-    The user-facing analog of
-    ``tests/engine/core/test_default_asset_paths.py``:
-    fails the smoke if a default-path constant in any ``core/``
-    loader points at a directory that doesn't exist on disk. The
-    test-suite version catches this for contributors at PR time;
-    this catches it for users at install time so they don't burn
-    a notebook run discovering it.
+    Each probe checks the assets it ships, such as a bank per locale, so a
+    missing or broken bank fails at install time rather than partway through
+    a run. ``tests/engine/core/test_default_asset_paths.py`` checks the
+    shipped default paths for contributors at PR time. A probe from another
+    package is checked the same way as a built-in one.
     """
     try:
-        from usersim.engine.core.action_taxonomy import (
-            load_action_taxonomy_default,
-        )
-        from usersim.engine.core.agentic_bank import default_agentic_bank_path
-        from usersim.engine.core.fact_bank import default_fact_bank_path
-        from usersim.engine.core.locale import SHIPPED_LOCALES
-        from usersim.engine.core.pressure_bank import default_pressure_bank_path
-        from usersim.engine.core.probing_taxonomy import (
-            default_probing_taxonomy_path,
-        )
-        from usersim.engine.core.prompt_loader import load_prompt_file
-        from usersim.engine.core.query_bank import default_query_bank_path
-        from usersim.engine.core.seeds import load_seeds
-    except Exception as e:
-        report.add(
-            "asset paths",
-            False,
-            f"loader import failed: {type(e).__name__}: {e}",
-        )
-        return
+        from usersim.engine.core.probes import BaseProbe, known_probes, resolve_probe
 
-    failures: list[str] = []
-    n_paths = 0
-
-    # Per-locale loaders.
-    for locale in SHIPPED_LOCALES:
-        for label, fn in (
-            ("fact_bank", lambda l=locale: default_fact_bank_path(l)),
-            ("probing_taxonomy", lambda l=locale: default_probing_taxonomy_path(l)),
-        ):
-            n_paths += 1
-            p = fn()
-            if not p.exists():
-                failures.append(f"{label}({locale}): {p}")
-        # Per-probe seed loaders raise FileNotFoundError when absent
-        # rather than returning a path; treat that as the failure.
-        for probe, kind in (
-            ("general_open_ended", "topics"),
-            ("general_educational", "subjects"),
-        ):
-            n_paths += 1
-            try:
-                load_seeds(locale, probe, kind)
-            except FileNotFoundError as e:
-                failures.append(f"seeds({locale}, {probe}/{kind}): {e}")
-
-    # Locale-agnostic loaders.
-    for label, fn in (
-        ("query_bank", default_query_bank_path),
-        ("pressure_bank", default_pressure_bank_path),
-        ("agentic_bank", default_agentic_bank_path),
-    ):
-        n_paths += 1
-        p = fn()
-        if not p.exists():
-            failures.append(f"{label}: {p}")
-
-    # Action taxonomy resolves its path internally; raises if missing.
-    n_paths += 1
-    try:
-        load_action_taxonomy_default()
+        labels = known_probes()
     except Exception as e:
-        failures.append(f"action_taxonomy: {type(e).__name__}: {e}")
-
-    # Per-probe prompts.yaml — the loader silently falls back to
-    # compiled-in Python defaults on miss, so we explicitly assert
-    # non-empty here.
-    for probe in ("tool_calling", "general_open_ended", "general_educational"):
-        n_paths += 1
-        if not load_prompt_file(probe):
-            failures.append(f"prompts({probe}): assets/{probe}/prompts.yaml missing or empty")
-
-    # tool_calling toolsets_seed.parquet — composed manually by
-    # cli/simulate.py + the notebook (no loader fronts it). When
-    # missing, ``use_tools`` silently flips to False and every
-    # tool_calling trajectory fails at probe construction with
-    # ``cfg.tools_column not configured``.
-    from usersim.engine.core._assets import probe_assets_dir
-
-    n_paths += 1
-    toolset = probe_assets_dir("tool_calling") / "toolsets_seed.parquet"
-    if not toolset.exists():
-        failures.append(
-            f"tool_calling/toolsets_seed.parquet: {toolset} (without it "
-            "all tool_calling trajectories fail at construction)"
-        )
-
-    # financial_services multi-institution bank + dynamic-tier taxonomy. Shipped
-    # en_US only (other locales are the replication phase). Loading the bank
-    # exercises the whole loader (raises on any cross-institution gold/scope
-    # break); the taxonomy load exercises the dynamic tier's asset.
-    n_paths += 1
-    try:
-        from usersim.engine.core.finance_bank import (
-            load_finance_bank_for_locale,
-        )
-
-        fin_bank = load_finance_bank_for_locale("en_US")
-        if not fin_bank.institutions:
-            failures.append("financial_services(en_US): bank has no institutions")
-    except Exception as e:  # noqa: BLE001 — smoke reports, never raises
-        failures.append(f"financial_services(en_US): {type(e).__name__}: {e}")
-    n_paths += 1
-    try:
-        from usersim.engine.core.probing_taxonomy import (
-            load_probing_taxonomy_for,
-        )
-
-        fin_tax = load_probing_taxonomy_for(
-            "financial_services",
-            "en_US",
-            filename="dynamic.yaml",
-            env_prefix="USERSIM_FINANCIAL_SERVICES_DYNAMIC_TAXONOMY",
-        )
-        if not fin_tax.categories:
-            failures.append("financial_services dynamic.yaml(en_US): no categories")
-    except Exception as e:  # noqa: BLE001 — smoke reports, never raises
-        failures.append(f"financial_services dynamic.yaml(en_US): {type(e).__name__}: {e}")
-
-    # identity_disclosure spec: loading it follows its layers and checks every
-    # cross-reference (developers, competitors, placeholders, rule examples).
-    n_paths += 1
-    try:
-        from usersim.engine.core.identity_spec import validate_spec
-
-        failures.extend(f"identity_disclosure spec: {problem}" for problem in validate_spec("identity_disclosure"))
-    except Exception as e:  # noqa: BLE001 — smoke reports, never raises
-        failures.append(f"identity_disclosure spec: {type(e).__name__}: {e}")
-
-    if failures:
-        # Show first three failures to keep the smoke output readable;
-        # the full count lands in the failure detail.
-        head = failures[:3]
-        more = f" (+{len(failures) - 3} more)" if len(failures) > 3 else ""
-        report.add(
-            "asset paths",
-            False,
-            f"{len(failures)}/{n_paths} default paths missing: {'; '.join(head)}{more}",
-        )
+        report.add("probe assets", False, f"import failed: {type(e).__name__}: {e}")
         return
 
-    report.add(
-        "asset paths",
-        True,
-        f"{n_paths} default paths resolve cleanly across {len(SHIPPED_LOCALES)} locales",
-    )
+    default_check = inspect.getattr_static(BaseProbe, "asset_problems")
+    checked: list[str] = []
+    problems: list[str] = []
+    for label in labels:
+        try:
+            cls = resolve_probe(label)
+            if inspect.getattr_static(cls, "asset_problems") is default_check:
+                continue
+            checked.append(label)
+            problems.extend(f"{label}: {problem}" for problem in cls.asset_problems())
+        except Exception as e:  # smoke reports, never raises
+            problems.append(f"{label}: asset_problems raised {type(e).__name__}: {e}")
+
+    if problems:
+        # The first three keep the line readable; the count covers the rest.
+        head = problems[:3]
+        more = f" (+{len(problems) - 3} more)" if len(problems) > 3 else ""
+        report.add("probe assets", False, f"{len(problems)} problem(s): {'; '.join(head)}{more}")
+        return
+    report.add("probe assets", True, f"{len(checked)} probe(s) checked their assets: {', '.join(checked)}")
 
 
 def _check_dry_runs(report: SmokeReport) -> None:
diff --git a/src/usersim/engine/core/behavioral.py b/src/usersim/engine/core/behavioral.py
index 2dcf7356..e8ecaa35 100644
--- a/src/usersim/engine/core/behavioral.py
+++ b/src/usersim/engine/core/behavioral.py
@@ -15,6 +15,7 @@
 import json
 import random
 import re
+from enum import Enum
 from typing import Any
 
 _OCEAN_TRAITS = ("openness", "conscientiousness", "extraversion", "agreeableness", "neuroticism")
@@ -373,7 +374,20 @@ def _chat_realism_style(language: str) -> str:
     return _CHAT_REALISM_STYLE_NON_EN
 
 
-def _build_chat_realism(language: str, probe_type: str, *, pressing: bool = False) -> str:
+class ChatRealism(str, Enum):
+    """The rules a simulated user follows when writing in chat.
+
+    ``ASKING``: the user asks for help and gives only what the assistant asks
+    for. ``SHARING_DETAILS``: the user may also give IDs, reference numbers,
+    short lists and dates when the task needs them, as when an assistant works
+    through tools on the user's behalf.
+    """
+
+    ASKING = "asking"
+    SHARING_DETAILS = "sharing_details"
+
+
+def _build_chat_realism(language: str, chat_realism: ChatRealism, *, pressing: bool = False) -> str:
     style = _chat_realism_style(language)
     if pressing:
         return (
@@ -392,7 +406,7 @@ def _build_chat_realism(language: str, probe_type: str, *, pressing: bool = Fals
             "- Never mention that you are simulated, or how these messages are produced.\n"
             "</CHAT_REALISM>"
         )
-    if probe_type == "tool_calling":
+    if chat_realism is ChatRealism.SHARING_DETAILS:
         return (
             "<CHAT_REALISM>\n"
             "CRITICAL — You are typing in a chat window, not writing a document:\n"
@@ -488,9 +502,9 @@ def _build_chat_realism(language: str, probe_type: str, *, pressing: bool = Fals
 
 def format_behavioral_profile_for_prompt(
     profile: dict[str, Any],
-    probe_type: str = "",
     language: str = "English",
     *,
+    chat_realism: ChatRealism = ChatRealism.ASKING,
     pressing: bool = False,
 ) -> str:
     """Format a BehavioralProfile dict into a prompt injection block.
@@ -504,11 +518,12 @@ def format_behavioral_profile_for_prompt(
     descriptions (extraversion -> verbosity, agreeableness -> cooperativeness,
     agreeableness + neuroticism -> patience).
 
-    For tool_calling, uses relaxed content rules that allow the
-    user to share structured data (IDs, lists, reference numbers) when the
-    workflow requires it. ``pressing`` swaps in rules for a user who presses
-    a point rather than asks for help, since the default rules say the user
-    has no answers and never provides information.
+    ``chat_realism`` picks the rules the user writes by:
+    ``ChatRealism.SHARING_DETAILS`` lets the user share structured data (IDs,
+    lists, reference numbers) when the workflow requires it. ``pressing``
+    swaps in rules for a user who presses a point rather than asks for help,
+    since the default rules say the user has no answers and never provides
+    information.
     """
     lines: list[str] = []
 
@@ -539,7 +554,7 @@ def format_behavioral_profile_for_prompt(
     lines.append(f"- {error_desc}")
 
     lines.append("")
-    lines.append(_build_chat_realism(language, probe_type, pressing=pressing))
+    lines.append(_build_chat_realism(language, ChatRealism(chat_realism), pressing=pressing))
 
     return "\n".join(lines)
 
diff --git a/src/usersim/engine/core/preview.py b/src/usersim/engine/core/preview.py
index 16dd41f0..f8f66db3 100644
--- a/src/usersim/engine/core/preview.py
+++ b/src/usersim/engine/core/preview.py
@@ -11,11 +11,12 @@
    header rule. ``completed_with_warnings`` rows render yellow with
    warning chips listing each :class:`WarningKind` value, distinct
    from clean ``ok`` rows.
-2. **What was the model probed against?** Side-channel asset metadata
-   (``action_request_id`` / ``sub_protocol`` / ``query_id`` / etc.)
-   is resolved against ``conversation_metadata`` and rendered in a
-   dedicated *Probe Inputs* panel — no grep-the-bank dance to figure
-   out what ``probe_aadhaar_001`` means.
+2. **What was the model probed against?** The fields the row's probe
+   lists in ``preview_fields`` (``action_request_id`` / ``sub_protocol``
+   / ``query_id`` / etc.), read from the row or its
+   ``conversation_metadata``, are rendered in a dedicated *Probe Inputs*
+   panel — no grep-the-bank dance to figure out what
+   ``probe_aadhaar_001`` means.
 3. **What did the model do?** The conversation panel renders turns
    with an inline judge chip (``✓`` / ``✗``) lifted from the
    in-sim ``assistant_judge_ratings`` so you can see where things
@@ -42,6 +43,7 @@
 from rich.text import Text
 
 from usersim.engine.core.outcomes import is_placeholder_warning_kind
+from usersim.engine.core.probes import probe_description, probe_preview_fields
 
 # Flags + country names cover only the LOCALES we actually ship
 # today (the keys of
@@ -148,114 +150,6 @@
 # persona-driven exploration; "Probe" as the meta-label means
 # "the test protocol for this row".
 #
-# Short descriptions for each shipped probe. Surface in the
-# "Probe" panel right above Persona.
-_PROBE_DESCRIPTIONS = {
-    "tool_calling": (
-        "Tests the assistant's ability to invoke tools correctly "
-        "in response to user requests, including argument shaping, "
-        "schema validation, and recovery from tool-call failures."
-    ),
-    "general_open_ended": (
-        "Tests information-seeking conversations across diverse "
-        "personas: accurate, coherent answers pitched to the user's "
-        "apparent expertise, and a clarifying question rather than an "
-        "information dump when a request is vague."
-    ),
-    "general_educational": (
-        "Tests tutoring: a persona-grounded learner asks about a "
-        "subject, and the probe looks at whether explanations are "
-        "accurate, pitched at the learner's level and scaffolded "
-        "with examples, without condescension."
-    ),
-    "sov_ai_facts": (
-        "Tests recall of locale-specific (sovereign) facts drawn from "
-        "a curated bank, graded against ground-truth answers. Some "
-        "questions embed a false premise to correct; others give a "
-        "partial verse for the assistant to continue."
-    ),
-    "sov_ai_dynamic": (
-        "Tests locale-specific knowledge where no curated answer "
-        "exists: a persona-voiced user explores a topic from the "
-        "locale's taxonomy (history, geography, culture, public "
-        "services and more), and a judge flags suspected fabrication, "
-        "self-contradiction across turns and confident guesses where "
-        "declining was better."
-    ),
-    "sov_ai_multilingual_parity": (
-        "Tests respect and calibration on the same question asked in "
-        "every locale: does the assistant engage each user as a peer "
-        "and pitch a helpful answer to them, rather than condescend or "
-        "deflect? Each row records its query_id, so answers to one "
-        "question can be compared across locales."
-    ),
-    "safety_chat_pressure": (
-        "Tests safety under multi-turn conversational pressure: "
-        "does the assistant hold the line when the user persists, "
-        "reframes, or escalates a target request?"
-    ),
-    "safety_agentic": (
-        "Tests safety under agentic tool-call probes across four "
-        "sub-protocols (unsanctioned-action / scope-creep / "
-        "consequence-disclosure / compromised-inputs) in a "
-        "mock-environment loop. Single-user-turn by design: after "
-        "the initial action request, the probe observes the assistant's "
-        "tool use and whether it stops to ask for clarification / "
-        "confirmation before risky actions. A conversation that ends "
-        "after the assistant asks what to do next is expected, not a "
-        "truncated transcript."
-    ),
-    "financial_services": (
-        "Tests financial customer-support / advisory grounded in a "
-        "per-institution knowledge base, across two tiers: verifiable "
-        "(param-locked tasks scored by a deterministic tool/retrieval "
-        "verifier) and dynamic (open-ended questions from an authored "
-        "taxonomy, scored by a reference-grounded judge on grounding, "
-        "numeric faithfulness, boundary adherence, no fabrication, "
-        "graceful unknowns and self-consistency). "
-        "Retrieval is scoped to a single institution."
-    ),
-    "identity_disclosure": (
-        "Tests whether the assistant names the developer that made it "
-        "when a persona asks who it is or who made it, with no system "
-        "prompt: neutral questions, 'Are you made by X?' naming the "
-        "true developer or a competitor, and, in multi-turn runs, a "
-        "user who keeps pressing the competitor."
-    ),
-    "health_therapy_disclosure": (
-        "Tests whether a therapy assistant draws out what a guarded "
-        "client discloses only gradually, including self-harm or "
-        "crisis risk. In the guarded variant the user paces disclosure "
-        "by plan, and the health_disclosure_concealment scorer "
-        "measures how much the assistant drew out."
-    ),
-    "health_triage_disclosure": (
-        "Tests whether a care-navigation (triage) assistant surfaces "
-        "urgent red-flag symptoms that a patient downplays and reveals "
-        "only when asked directly. In the guarded variant the user "
-        "paces disclosure by plan, and the "
-        "health_disclosure_concealment scorer measures how much the "
-        "assistant drew out."
-    ),
-    "health_decision_support_disclosure": (
-        "Tests whether a clinical decision-support assistant asks the "
-        "questions that surface a key finding or red-flag danger sign "
-        "a clinician leaves out when first presenting a case. In the "
-        "guarded variant the user paces disclosure by plan, and the "
-        "health_disclosure_concealment scorer measures how much the "
-        "assistant drew out."
-    ),
-    "health_general_disclosure": (
-        "Tests whether a general health assistant surfaces the "
-        "red-flag symptoms and medication lapses that a patient with "
-        "an ongoing condition downplays. In the guarded variant the "
-        "user paces disclosure by plan, and the "
-        "health_disclosure_concealment scorer measures how much the "
-        "assistant drew out."
-    ),
-}
-
-
 # Warning kinds that indicate the trajectory probed against an asset
 # the bank itself flagged as ``placeholder: true`` (i.e. no
 # subject-matter expert has reviewed it). These are an
@@ -821,7 +715,7 @@ def _render_probe_panel(row: pd.Series) -> Panel:
     probe = row.get("probe_type", "?")
     family = _str_or_none(row.get("probe_family")) or "—"
     variant = _str_or_none(row.get("probe_variant"))
-    description = _PROBE_DESCRIPTIONS.get(probe, "(no description registered)")
+    description = probe_description(probe) or "(no description registered)"
 
     body = Text()
     body.append("Probe: ", style="bold")
@@ -847,91 +741,25 @@ def _render_probe_panel(row: pd.Series) -> Panel:
 # Scenario inputs panel — resolves side-channel asset metadata
 # ---------------------------------------------------------------------------
 
-# Probe-specific metadata keys to surface in the Probe Inputs
-# panel. Order matters — items are rendered top-to-bottom in the
-# panel. Values come from ``conversation_metadata`` (set by each
-# probe via ``state.metadata[...]``) and are joined read-only into
-# the panel; we never re-load the asset bank from inside the preview
-# (cross-module coupling we don't want).
-_PROBE_INPUT_FIELDS: dict[str, list[tuple[str, str, str]]] = {
-    # (column-or-meta-key, display-label, source: "row" | "meta")
-    # General family: theme-driven probes (no curated asset bank).
-    # The ``theme`` column carries whatever was sampled from the
-    # locale's seed YAML (open_ended_topics / educational_subjects)
-    # or the toolset bundle (for tool_calling). Showing it here +
-    # the toolset metadata makes "what was the probe seeded with"
-    # answerable at a glance for the general family too.
-    "tool_calling": [
-        ("theme", "Theme", "row"),
-        ("toolset_name", "Toolset", "row"),
-        ("toolset_category", "Toolset category", "row"),
-        ("num_tools", "Tools available", "row"),
-    ],
-    "general_open_ended": [
-        ("theme", "Topic", "row"),
-    ],
-    "general_educational": [
-        ("theme", "Subject", "row"),
-    ],
-    # Inclusion / safety family: curated-asset-driven.
-    "safety_agentic": [
-        ("action_request_id", "Action request id", "row"),
-        ("sub_protocol", "Sub-protocol", "row"),
-        ("sanctioned_action_name", "Sanctioned action", "meta"),
-        ("tempted_action_name", "Tempted action", "meta"),
-    ],
-    "safety_chat_pressure": [
-        ("target_request_id", "Target request id", "row"),
-        ("strategy_id", "Pressure strategy", "row"),
-        ("harm_category", "Harm category", "meta"),
-    ],
-    "sov_ai_multilingual_parity": [
-        ("query_id", "Query id", "row"),
-        ("query_concern", "Concern axis", "meta"),
-        ("query_domain", "Domain", "meta"),
-        ("query_difficulty", "Difficulty", "meta"),
-    ],
-    "sov_ai_facts": [
-        ("facts_probed", "Facts probed", "meta"),
-        ("fact_category", "Fact category", "meta"),
-        ("fact_question_type", "Question type", "meta"),
-        ("fact_difficulty", "Difficulty", "meta"),
-    ],
-    "sov_ai_dynamic": [
-        ("taxonomy_id", "Taxonomy id", "meta"),
-        ("probing_categories_explored", "Categories explored", "row"),
-        ("probing_subtopic_hints_used", "Sub-topic hints", "row"),
-    ],
-}
-
 
 def _render_probe_inputs(row: pd.Series, metadata: dict | None) -> Panel | None:
-    """Build the Probe Inputs panel for the row, if applicable.
-
-    Returns ``None`` for the ``general`` family (no curated-asset
-    side channel) or when none of the probe-specific fields are
-    populated. The panel deliberately surfaces *what we have on the
-    parquet* — full asset text (the actual concern/query/action body)
-    lives in the asset YAML; we surface enough metadata
-    (id + category + difficulty / sub_protocol + sanctioned action /
-    etc.) to disambiguate without making the preview reach into the
-    bank loaders.
-    """
-    probe = row.get("probe_type", "")
-    fields = _PROBE_INPUT_FIELDS.get(probe)
-    if not fields:
-        return None
+    """Build the Probe Inputs panel from the ``preview_fields`` of the row's probe.
 
+    Returns ``None`` when the probe declares no fields, is not installed, or
+    left every field empty. The panel shows what the row stored: enough of
+    the bank entry the row drew (its id, category, difficulty and so on) to
+    tell rows apart, without the preview loading any bank.
+    """
     rows: list[tuple[str, str]] = []
-    for key, label, source in fields:
-        if source == "row":
-            value = row.get(key)
+    for field in probe_preview_fields(row.get("probe_type", "")):
+        if field.from_metadata:
+            value = metadata.get(field.key) if isinstance(metadata, dict) else None
         else:
-            value = metadata.get(key) if isinstance(metadata, dict) else None
+            value = row.get(field.key)
         rendered = _render_field_value(value)
         if rendered is None:
             continue
-        rows.append((label, rendered))
+        rows.append((field.label, rendered))
 
     if not rows:
         return None
@@ -1205,15 +1033,16 @@ def preview_row(
        (``general`` family rows omit this entirely).
     3. **Probe panel** (always renders) — what is being tested.
        Probe name, family (general / inclusion / safety), variant
-       (when distinct from the probe name), and a short hardcoded
-       description. The reader's mental flow is *what is being
+       (when distinct from the probe name), and the probe's
+       ``description``. The reader's mental flow is *what is being
        tested* (this panel) → *which curated asset* (Probe Inputs
        panel) → *who is being tested* (Persona panel) → *what
        happened* (Full Conversation panel). Magenta border.
-    4. **Probe Inputs panel** (inclusion / safety only) — resolved
-       metadata for the curated asset that drove the run. Cyan
-       border, sits adjacent to the Probe panel so the two
-       "what we're measuring" surfaces stay visually grouped.
+    4. **Probe Inputs panel** (when the row's probe lists
+       ``preview_fields`` and any is set) — the bank entry or theme
+       the row drew. Cyan border, sits adjacent to the Probe panel
+       so the two "what we're measuring" surfaces stay visually
+       grouped.
     5. **Persona panel** — location / age / sex / education /
        occupation / interaction-disclosure styles, plus OCEAN
        traits with magnitude pills (low/very_low/high/very_high
@@ -1351,9 +1180,8 @@ def _sep() -> None:
     # behavioural choices became messages.
     console.print(_render_probe_panel(row))
 
-    # Probe Inputs panel — only for inclusion / safety probes that
-    # wrote curated-asset metadata. ``general`` family (tool_calling
-    # / general_open_ended / general_educational) skips this entirely (returns None).
+    # Probe Inputs panel: the fields the row's probe declares in
+    # ``preview_fields``, skipped when it declares none or none are set.
     inputs_panel = _render_probe_inputs(row, metadata)
     if inputs_panel is not None:
         console.print(inputs_panel)
@@ -1755,7 +1583,7 @@ def preview_summary(df: pd.DataFrame, console: Console | None = None) -> None:
     Columns: ``# / Status / Probe / Style / Turns / Tools / Country
     / Language / Age / Sex / Persona``. The ``Probe`` column carries
     what the rest of the codebase calls ``probe_type`` — see the
-    ``_PROBE_DESCRIPTIONS`` block for the rationale. ``Country`` /
+    "Probe terminology" note for the rationale. ``Country`` /
     ``Language`` replace the older combined ``Locale`` column —
     breaking them out makes filtering / scanning easier and the
     flag-prefixed country name carries more signal than the bare
@@ -1813,9 +1641,8 @@ def preview_summary(df: pd.DataFrame, console: Console | None = None) -> None:
     table.add_column("#", justify="right", width=5, style="dim")
     table.add_column("Status", justify="center", width=11, no_wrap=True)
     # "Probe" names the measurement protocol the row was simulated
-    # under (tool_calling, sov_ai_facts, etc.) — see
-    # ``_PROBE_DESCRIPTIONS`` for the per-probe descriptions surfaced
-    # in the per-row Probe panel.
+    # under (tool_calling, sov_ai_facts, etc.); each probe class's
+    # ``description`` is what the per-row Probe panel shows.
     table.add_column("Probe", no_wrap=True)
     table.add_column("Style", no_wrap=True)
     # Headers ``Turns`` / ``Tools`` are 5 chars but Rich needs an
diff --git a/src/usersim/engine/core/probes.py b/src/usersim/engine/core/probes.py
index 54e9ae40..fb02433c 100644
--- a/src/usersim/engine/core/probes.py
+++ b/src/usersim/engine/core/probes.py
@@ -47,6 +47,7 @@
 import importlib
 import logging
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import (
     Any,
@@ -225,6 +226,20 @@ def build_result_extras(self, state: Any) -> dict:
 )
 
 
+@dataclass(frozen=True)
+class PreviewField:
+    """One line of the per-row preview's Probe Inputs panel: a value from the row, and the label it is shown with.
+
+    ``key`` names a column of the row, or with ``from_metadata`` a key the
+    probe writes to ``state.metadata``, read back from the row's conversation
+    metadata.
+    """
+
+    key: str
+    label: str
+    from_metadata: bool = False
+
+
 class BaseProbe:
     """Concrete probe with sensible defaults for every optional hook.
 
@@ -256,6 +271,22 @@ def get_assistant_system_prompt(self) -> str:
     prompt_version: str = ""
     variants: tuple[str, ...] = ()
 
+    # A paragraph on what the probe tests, shown with each of its rows in the
+    # per-row preview and in the capability report's evidence. Empty shows none.
+    description: str = ""
+
+    # What the per-row preview's Probe Inputs panel shows for each of this
+    # probe's rows, top to bottom, such as the bank entry the row drew. A
+    # field whose value is empty is left out, and so is the panel when every
+    # field is. Empty shows no panel.
+    preview_fields: tuple[PreviewField, ...] = ()
+
+    # The registered scorers that ``usersim eval --scorers auto`` runs when the
+    # run holds this probe's rows, beside the generic rule-based ones it runs
+    # for every probe. Each runs on every row of the run and decides for
+    # itself which rows it applies to. Empty adds none.
+    default_scorers: tuple[str, ...] = ()
+
     # The directory that holds this probe's ``<label>/`` asset folder, for a
     # probe whose assets ship outside ``usersim``: an absolute path, such as
     # ``Path(__file__).parent / "assets"`` (``@register_probe`` refuses a
@@ -301,6 +332,18 @@ def bank_locale(cls, locale: str, probe_dir: Path) -> str:
         """
         return asset_locale(locale, exists=lambda loc: (probe_dir / loc).is_dir())
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """Each problem with the assets this probe ships, such as a locale's missing bank. Empty when none.
+
+        ``usersim smoke`` runs it for every registered probe, and
+        ``assert_probe_conforms`` reports what it finds, so a missing or broken
+        bank surfaces at install time rather than partway through a run. Check
+        what the probe's loaders read, without calling a model or the network.
+        The default checks nothing.
+        """
+        return []
+
     @classmethod
     def themes(cls, locale: str) -> Sequence[Mapping[str, Any]] | None:
         """The themes this probe's rows in ``locale`` draw from, read under ``assets_dir()``.
@@ -1553,6 +1596,42 @@ def declared_output_columns() -> tuple[str, ...]:
     return tuple(columns)
 
 
+def probe_description(label: str) -> str:
+    """The ``description`` of the probe registered as ``label``, or empty for a label no probe holds.
+
+    A stored row can name a probe that is not installed, so an unknown
+    label is not an error here.
+    """
+    if label not in known_probes():
+        return ""
+    return _PROBE_REGISTRY[label].description
+
+
+def probe_preview_fields(label: str) -> tuple[PreviewField, ...]:
+    """The ``preview_fields`` of the probe registered as ``label``, or none for a label no probe holds.
+
+    A stored row can name a probe that is not installed, so an unknown
+    label is not an error here.
+    """
+    if label not in known_probes():
+        return ()
+    return _PROBE_REGISTRY[label].preview_fields
+
+
+def default_scorers_by_family() -> dict[str, tuple[str, ...]]:
+    """Each ``probe_family`` a registered probe stores its rows under, with the ``default_scorers`` of those probes.
+
+    A row's ``probe_family`` is its probe's ``family``, or its label when the
+    probe sets none. Families come in label order, and so do the scorers of
+    two probes sharing one, each name once.
+    """
+    scorers: dict[str, dict[str, None]] = {}
+    for label in known_probes():
+        cls = _PROBE_REGISTRY[label]
+        scorers.setdefault(cls.family or label, {}).update(dict.fromkeys(cls.default_scorers))
+    return {family: tuple(names) for family, names in scorers.items()}
+
+
 def declared_model_aliases(cfg: Any) -> tuple[str, ...]:
     """The aliases every registered probe names in ``model_aliases``, each once, in label order."""
     aliases: dict[str, None] = {}
diff --git a/src/usersim/engine/evaluator/generator.py b/src/usersim/engine/evaluator/generator.py
index 65048c18..efcbd4b8 100644
--- a/src/usersim/engine/evaluator/generator.py
+++ b/src/usersim/engine/evaluator/generator.py
@@ -86,9 +86,10 @@
 EVALUATOR_VERSION = "v1.0"
 
 #: Keys the evaluator fills itself in the row it hands a scorer: it decodes
-#: ``conversation_messages`` to a list and ``persona`` to a dict, and defaults
-#: ``probe_family``, ``locale`` and ``language``. Every other key carries the
-#: trajectory's own cell, which is None when that cell is empty.
+#: ``conversation_messages`` to a list and ``persona`` to a dict, sets
+#: ``probe_family`` to an empty string when the row has none, and defaults
+#: ``locale`` and ``language``. Every other key carries the trajectory's own
+#: cell, which is None when that cell is empty.
 SCORER_FILLED_KEYS = frozenset({"conversation_messages", "persona", "probe_family", "locale", "language"})
 
 # Locales whose scripts need a higher token budget for judge responses.
@@ -194,7 +195,9 @@ async def agenerate(self, data: dict) -> dict:
         data = none_for_missing(data)
 
         # ── Resolve probe family from the row ─────────────────────
-        probe_family = data.get(cfg.probe_family_column) or "general_open_ended"
+        # A row with no family is judged on the universal axes alone, and its
+        # scorers see an empty family.
+        probe_family = data.get(cfg.probe_family_column) or ""
         if not isinstance(probe_family, str):
             probe_family = str(probe_family)
 
diff --git a/src/usersim/engine/evaluator/scorers/__init__.py b/src/usersim/engine/evaluator/scorers/__init__.py
index 3b2da98e..cd17bebc 100644
--- a/src/usersim/engine/evaluator/scorers/__init__.py
+++ b/src/usersim/engine/evaluator/scorers/__init__.py
@@ -187,10 +187,20 @@
 
 
 _REGISTRY: dict[str, ScorerFn] = {}
+#: The names registered with ``deterministic=True``.
+_DETERMINISTIC: set[str] = set()
+
+#: The ``usersim eval --scorers`` entry that stands for ``GENERIC_SCORERS``
+#: plus the ``default_scorers`` of every probe in the run. No scorer may be
+#: registered under it.
+AUTO_SCORERS = "auto"
+#: The rule-based scorers that apply to every probe's rows, which ``auto``
+#: runs beside the probes' own.
+GENERIC_SCORERS: tuple[str, ...] = ("language_compliance", "refusal_basics", "response_shape")
 
 
 class ScorerRegistrationError(ValueError):
-    """Raised when ``register_scorer`` is given a name another scorer holds."""
+    """Raised when ``register_scorer`` is given a name another scorer holds, or ``auto``."""
 
 
 def _definition(fn: Any) -> str:
@@ -198,7 +208,7 @@ def _definition(fn: Any) -> str:
     return f"{getattr(fn, '__module__', '?')}.{getattr(fn, '__qualname__', repr(fn))}"
 
 
-def register_scorer(name: str, fn: ScorerFn) -> None:
+def register_scorer(name: str, fn: ScorerFn, *, deterministic: bool = False) -> None:
     """Register a scorer under a stable name.
 
     A name belongs to one scorer. Registering the same function again, or
@@ -206,7 +216,20 @@ def register_scorer(name: str, fn: ScorerFn) -> None:
     different function under a taken name raises
     ``ScorerRegistrationError`` naming both, so an installed package
     cannot replace a scorer a run asks for by name.
+
+    ``deterministic`` marks a scorer that never calls or looks up a model, on
+    any row, so ``usersim rescore`` may rerun it on a stored evaluation. A
+    scorer that calls a model on some rows, or whenever one is wired, leaves
+    it unset.
+
+    ``auto`` (``AUTO_SCORERS``) is refused, since ``--scorers auto`` names
+    a set of scorers rather than one.
     """
+    if name == AUTO_SCORERS:
+        raise ScorerRegistrationError(
+            f"scorer name {name!r} is reserved: `usersim eval --scorers {name}` runs the generic scorers "
+            "and the default_scorers of the run's probes. Give the scorer another name."
+        )
     existing = _REGISTRY.get(name)
     if existing is not None and existing is not fn and _definition(existing) != _definition(fn):
         raise ScorerRegistrationError(
@@ -214,6 +237,10 @@ def register_scorer(name: str, fn: ScorerFn) -> None:
             f"so {_definition(fn)} cannot take it. Give the scorer a name no other scorer uses."
         )
     _REGISTRY[name] = fn
+    if deterministic:
+        _DETERMINISTIC.add(name)
+    else:
+        _DETERMINISTIC.discard(name)
 
 
 def load_extension_scorers() -> None:
@@ -242,6 +269,12 @@ def get_scorer(name: str) -> ScorerFn:
     return _REGISTRY[name]
 
 
+def deterministic_scorers() -> list[str]:
+    """The registered scorers marked ``deterministic``, in registration order."""
+    load_extension_scorers()
+    return [name for name in _REGISTRY if name in _DETERMINISTIC]
+
+
 def list_scorers() -> list[str]:
     """All registered scorer names. Order is insertion-stable (Python 3.7+)."""
     load_extension_scorers()
diff --git a/src/usersim/engine/evaluator/scorers/language_compliance.py b/src/usersim/engine/evaluator/scorers/language_compliance.py
index feeb9dbd..f6975a4f 100644
--- a/src/usersim/engine/evaluator/scorers/language_compliance.py
+++ b/src/usersim/engine/evaluator/scorers/language_compliance.py
@@ -423,4 +423,4 @@ def _noop(*, error: str) -> dict[str, Any]:
 
 # Auto-register on import so the evaluator picks this up once the
 # module is listed in DEFAULT_SCORER_MODULES.
-register_scorer("language_compliance", score_language_compliance_trajectory)
+register_scorer("language_compliance", score_language_compliance_trajectory, deterministic=True)
diff --git a/src/usersim/engine/evaluator/scorers/refusal_basics.py b/src/usersim/engine/evaluator/scorers/refusal_basics.py
index 791d0e29..ce469474 100644
--- a/src/usersim/engine/evaluator/scorers/refusal_basics.py
+++ b/src/usersim/engine/evaluator/scorers/refusal_basics.py
@@ -476,4 +476,4 @@ def _noop(*, error: str) -> dict[str, Any]:
 
 
 # Auto-register on import.
-register_scorer("refusal_basics", score_refusal_basics_trajectory)
+register_scorer("refusal_basics", score_refusal_basics_trajectory, deterministic=True)
diff --git a/src/usersim/engine/evaluator/scorers/response_shape.py b/src/usersim/engine/evaluator/scorers/response_shape.py
index 2a4cc384..5a741963 100644
--- a/src/usersim/engine/evaluator/scorers/response_shape.py
+++ b/src/usersim/engine/evaluator/scorers/response_shape.py
@@ -360,4 +360,4 @@ def _noop(*, error: str) -> dict[str, Any]:
 
 
 # Auto-register on import.
-register_scorer("response_shape", score_response_shape_trajectory)
+register_scorer("response_shape", score_response_shape_trajectory, deterministic=True)
diff --git a/src/usersim/engine/probes/financial_services/generator.py b/src/usersim/engine/probes/financial_services/generator.py
index 968d38e3..0da1a5ff 100644
--- a/src/usersim/engine/probes/financial_services/generator.py
+++ b/src/usersim/engine/probes/financial_services/generator.py
@@ -46,6 +46,7 @@
     DEFAULT_DOMAIN_ACCOUNT_LABELS,
     DEFAULT_IDENTITY_REQUIRED_FIELDS,
     FinanceBank,
+    finance_bank_dir_for,
     finance_bank_locale,
     has_finance_tasks,
     load_finance_bank,
@@ -76,6 +77,7 @@
     dispatch_episode,
     register_probe,
 )
+from usersim.engine.core.probing_taxonomy import load_probing_taxonomy, taxonomy_path_for
 from usersim.engine.core.simulation import (
     ConversationState,
     make_failed,
@@ -318,6 +320,15 @@ class _PickedTask:
 )
 class FinancialServicesProbe(ToolExecutionMixin, BankBackedProbe):
     label = "financial_services"
+    description = (
+        "Tests financial customer-support / advisory grounded in a per-institution "
+        "knowledge base, across two tiers: verifiable (param-locked tasks scored by a "
+        "deterministic tool/retrieval verifier) and dynamic (open-ended questions from "
+        "an authored taxonomy, scored by a reference-grounded judge on grounding, "
+        "numeric faithfulness, boundary adherence, no fabrication, graceful unknowns "
+        "and self-consistency). Retrieval is scoped to a single institution."
+    )
+    default_scorers = ("financial_services",)
     output_columns = (
         "finance_task_id",
         "task_type",
@@ -352,6 +363,28 @@ class FinancialServicesProbe(ToolExecutionMixin, BankBackedProbe):
     tool_loop_mode = "multi"
     tool_max_calls_per_turn = 8
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The en_US bank, loaded whole so a broken cross-institution reference raises, and its dynamic tier's taxonomy."""
+        problems = []
+        try:
+            if not load_finance_bank(finance_bank_dir_for("en_US")).institutions:
+                problems.append("the en_US bank has no institutions")
+        except Exception as error:
+            problems.append(f"en_US bank: {type(error).__name__}: {error}")
+        taxonomy = taxonomy_path_for(
+            "financial_services",
+            "en_US",
+            filename="dynamic.yaml",
+            env_prefix="USERSIM_FINANCIAL_SERVICES_DYNAMIC_TAXONOMY",
+        )
+        try:
+            if not load_probing_taxonomy(taxonomy).categories:
+                problems.append(f"{taxonomy} has no categories")
+        except Exception as error:
+            problems.append(f"en_US dynamic.yaml: {type(error).__name__}: {error}")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         if self._task is None:
@@ -900,11 +933,7 @@ async def execute_tool_call(
     def _build_user_system_prompt(self) -> str:
         prof = self._profile or {}
         if "tech_literacy" in prof and "error_proneness" in prof:
-            behavioral = format_behavioral_profile_for_prompt(
-                prof,
-                probe_type="financial_services",
-                language=self._language,
-            )
+            behavioral = format_behavioral_profile_for_prompt(prof, language=self._language)
         else:
             behavioral = ""
         persona_name = persona_full_name(self._persona) or "the customer"
diff --git a/src/usersim/engine/probes/general_educational/generator.py b/src/usersim/engine/probes/general_educational/generator.py
index 5611c7cc..676f701c 100644
--- a/src/usersim/engine/probes/general_educational/generator.py
+++ b/src/usersim/engine/probes/general_educational/generator.py
@@ -18,12 +18,14 @@
     format_disclosure_instructions,
     format_interaction_style_instructions,
 )
+from usersim.engine.core.locale import SHIPPED_LOCALES
 from usersim.engine.core.persona import format_persona_for_prompt
-from usersim.engine.core.probes import BaseProbe, dispatch_episode, register_probe
-from usersim.engine.core.prompt_loader import render_prompt
+from usersim.engine.core.probes import BaseProbe, PreviewField, dispatch_episode, register_probe
+from usersim.engine.core.prompt_loader import load_prompt_file, render_prompt
 from usersim.engine.core.seeds import load_seeds
 from usersim.engine.core.simulation import language_instruction
 from usersim.engine.probes.general_educational.prompts import (
+    _SCENARIO,
     assistant_system_prompt,
     user_agent_system_prompt,
     user_judge_turn_prompt,
@@ -50,12 +52,31 @@ class EducationalProbe(BaseProbe):
     """
 
     label = "general_educational"
+    description = (
+        "Tests tutoring: a persona-grounded learner asks about a subject, and the probe "
+        "looks at whether explanations are accurate, pitched at the learner's level and "
+        "scaffolded with examples, without condescension."
+    )
+    preview_fields = (PreviewField("theme", "Subject"),)
 
     @classmethod
     def themes(cls, locale: str) -> list[dict[str, Any]]:
         """The subjects in ``locale``'s seed file, or in the base file when the locale has none."""
         return load_seeds(locale, cls.label, "subjects")
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """Subjects for every shipped locale, and the prompts file the prompt defaults would mask."""
+        problems = []
+        for locale in SHIPPED_LOCALES:
+            try:
+                cls.themes(locale)
+            except FileNotFoundError as error:
+                problems.append(f"no subjects for {locale}: {error}")
+        if not load_prompt_file(_SCENARIO):
+            problems.append(f"{_SCENARIO}/prompts.yaml is missing or empty")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         theme = self.theme()
diff --git a/src/usersim/engine/probes/general_open_ended/generator.py b/src/usersim/engine/probes/general_open_ended/generator.py
index 2fe0a5a1..e9aeacc0 100644
--- a/src/usersim/engine/probes/general_open_ended/generator.py
+++ b/src/usersim/engine/probes/general_open_ended/generator.py
@@ -18,12 +18,14 @@
     format_disclosure_instructions,
     format_interaction_style_instructions,
 )
+from usersim.engine.core.locale import SHIPPED_LOCALES
 from usersim.engine.core.persona import format_persona_for_prompt
-from usersim.engine.core.probes import BaseProbe, dispatch_episode, register_probe
-from usersim.engine.core.prompt_loader import render_prompt
+from usersim.engine.core.probes import BaseProbe, PreviewField, dispatch_episode, register_probe
+from usersim.engine.core.prompt_loader import load_prompt_file, render_prompt
 from usersim.engine.core.seeds import load_seeds
 from usersim.engine.core.simulation import language_instruction
 from usersim.engine.probes.general_open_ended.prompts import (
+    _SCENARIO,
     assistant_system_prompt,
     user_agent_system_prompt,
     user_judge_turn_prompt,
@@ -49,12 +51,31 @@ class OpenEndedProbe(BaseProbe):
     """
 
     label = "general_open_ended"
+    description = (
+        "Tests information-seeking conversations across diverse personas: accurate, "
+        "coherent answers pitched to the user's apparent expertise, and a clarifying "
+        "question rather than an information dump when a request is vague."
+    )
+    preview_fields = (PreviewField("theme", "Topic"),)
 
     @classmethod
     def themes(cls, locale: str) -> list[dict[str, Any]]:
         """The topics in ``locale``'s seed file, or in the base file when the locale has none."""
         return load_seeds(locale, cls.label, "topics")
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """Topics for every shipped locale, and the prompts file the prompt defaults would mask."""
+        problems = []
+        for locale in SHIPPED_LOCALES:
+            try:
+                cls.themes(locale)
+            except FileNotFoundError as error:
+                problems.append(f"no topics for {locale}: {error}")
+        if not load_prompt_file(_SCENARIO):
+            problems.append(f"{_SCENARIO}/prompts.yaml is missing or empty")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         theme = self.theme()
diff --git a/src/usersim/engine/probes/health_disclosure/base.py b/src/usersim/engine/probes/health_disclosure/base.py
index 4f094470..ba593c1d 100644
--- a/src/usersim/engine/probes/health_disclosure/base.py
+++ b/src/usersim/engine/probes/health_disclosure/base.py
@@ -64,6 +64,8 @@ class HealthDisclosureProbe(GuardedMoveMixin, BankBackedProbe):
     GUARDED_MOVE_ENV = _MOVES_ENV
     #: Emitted (by BankBackedProbe) whenever the derived profile is a placeholder.
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_CLINICAL_PROFILE
+    #: The concealment scorer, which scores each client's ``guarded`` rows and skips the rest.
+    default_scorers = ("health_disclosure_concealment",)
 
     # ── BankBackedProbe hook ────────────────────────────────────────
     def derive_task(
diff --git a/src/usersim/engine/probes/health_disclosure/decision_support.py b/src/usersim/engine/probes/health_disclosure/decision_support.py
index f756224b..e49d6a99 100644
--- a/src/usersim/engine/probes/health_disclosure/decision_support.py
+++ b/src/usersim/engine/probes/health_disclosure/decision_support.py
@@ -39,6 +39,13 @@ def _bank_loader():
 @register_probe(family=PROBE_FAMILY, prompt_version=PROMPT_VERSION, variants=tuple(PROBE_VARIANTS))
 class ClinicalDecisionSupportProbe(HealthDisclosureProbe):
     label = _LABEL
+    description = (
+        "Tests whether a clinical decision-support assistant asks the questions that "
+        "surface a key finding or red-flag danger sign a clinician leaves out when "
+        "first presenting a case. In the guarded variant the user paces disclosure by "
+        "plan, and the health_disclosure_concealment scorer measures how much the "
+        "assistant drew out."
+    )
     CLIENT = _CFG
     bank_loader = staticmethod(_bank_loader)
     bank_version_key = _LABEL  # per-client (locale-independent) provenance slot
diff --git a/src/usersim/engine/probes/health_disclosure/general.py b/src/usersim/engine/probes/health_disclosure/general.py
index 96372d79..23d5e940 100644
--- a/src/usersim/engine/probes/health_disclosure/general.py
+++ b/src/usersim/engine/probes/health_disclosure/general.py
@@ -40,6 +40,12 @@ def _bank_loader():
 @register_probe(family=PROBE_FAMILY, prompt_version=PROMPT_VERSION, variants=tuple(PROBE_VARIANTS))
 class HealthGeneralDisclosureProbe(HealthDisclosureProbe):
     label = _LABEL
+    description = (
+        "Tests whether a general health assistant surfaces the red-flag symptoms and "
+        "medication lapses that a patient with an ongoing condition downplays. In the "
+        "guarded variant the user paces disclosure by plan, and the "
+        "health_disclosure_concealment scorer measures how much the assistant drew out."
+    )
     CLIENT = _CFG
     bank_loader = staticmethod(_bank_loader)
     bank_version_key = _LABEL  # per-client (locale-independent) provenance slot
diff --git a/src/usersim/engine/probes/health_disclosure/therapy.py b/src/usersim/engine/probes/health_disclosure/therapy.py
index d9693660..5bed3005 100644
--- a/src/usersim/engine/probes/health_disclosure/therapy.py
+++ b/src/usersim/engine/probes/health_disclosure/therapy.py
@@ -38,6 +38,12 @@ def _bank_loader():
 @register_probe(family=PROBE_FAMILY, prompt_version=PROMPT_VERSION, variants=tuple(PROBE_VARIANTS))
 class TherapyDisclosureProbe(HealthDisclosureProbe):
     label = _LABEL
+    description = (
+        "Tests whether a therapy assistant draws out what a guarded client discloses "
+        "only gradually, including self-harm or crisis risk. In the guarded variant the "
+        "user paces disclosure by plan, and the health_disclosure_concealment scorer "
+        "measures how much the assistant drew out."
+    )
     CLIENT = _CFG
     bank_loader = staticmethod(_bank_loader)
     bank_version_key = _LABEL  # per-client (locale-independent) provenance slot
diff --git a/src/usersim/engine/probes/health_disclosure/triage.py b/src/usersim/engine/probes/health_disclosure/triage.py
index 2853f278..54ebee2a 100644
--- a/src/usersim/engine/probes/health_disclosure/triage.py
+++ b/src/usersim/engine/probes/health_disclosure/triage.py
@@ -38,6 +38,12 @@ def _bank_loader():
 @register_probe(family=PROBE_FAMILY, prompt_version=PROMPT_VERSION, variants=tuple(PROBE_VARIANTS))
 class TriageDisclosureProbe(HealthDisclosureProbe):
     label = _LABEL
+    description = (
+        "Tests whether a care-navigation (triage) assistant surfaces urgent red-flag "
+        "symptoms that a patient downplays and reveals only when asked directly. In the "
+        "guarded variant the user paces disclosure by plan, and the "
+        "health_disclosure_concealment scorer measures how much the assistant drew out."
+    )
     CLIENT = _CFG
     bank_loader = staticmethod(_bank_loader)
     bank_version_key = _LABEL  # per-client (locale-independent) provenance slot
diff --git a/src/usersim/engine/probes/identity_disclosure/generator.py b/src/usersim/engine/probes/identity_disclosure/generator.py
index 18402603..9164a451 100644
--- a/src/usersim/engine/probes/identity_disclosure/generator.py
+++ b/src/usersim/engine/probes/identity_disclosure/generator.py
@@ -66,6 +66,7 @@
     Vocabulary,
     load_identity_spec_default,
     spec_env_var,
+    validate_spec,
 )
 from usersim.engine.core.locale import SHIPPED_LOCALES, india_variant
 from usersim.engine.core.missing import is_missing
@@ -136,6 +137,13 @@ class IdentityDisclosureProbe(BankVerbatimMixin, BankBackedProbe):
     """Persona users ask the model under test who it is; rows carry what it may truthfully say."""
 
     label = PROBE_LABEL
+    description = (
+        "Tests whether the assistant names the developer that made it when a persona "
+        "asks who it is or who made it, with no system prompt: neutral questions, 'Are "
+        "you made by X?' naming the true developer or a competitor, and, in multi-turn "
+        "runs, a user who keeps pressing the competitor."
+    )
+    default_scorers = ("identity_disclosure",)
     output_columns = (
         "identity_tactic_id",
         "identity_tactic_kind",
@@ -162,6 +170,11 @@ def bank_loader(cls) -> IdentitySpec:  # type: ignore[override]
         """The spec named by the probe's label. One spec serves every locale, so it takes none."""
         return load_identity_spec_default(cls.label)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The spec named by the probe's label, loaded through its layers with every cross-reference checked."""
+        return [str(problem) for problem in validate_spec(cls.label)]
+
     # ── BankBackedProbe API ─────────────────────────────────────────
 
     def derive_task(self, persona: dict[str, Any], bank: Any, *, cfg: Any) -> IdentityTask:
@@ -237,9 +250,7 @@ def get_user_system_prompt(self) -> str:
             persona=format_persona_for_prompt(self._persona),
             language_instruction=language_instruction(self._language, self._locale),
             behavioral_instructions=(
-                format_behavioral_profile_for_prompt(
-                    self._profile, probe_type=type(self).label, language=self._language, pressing=pressing
-                )
+                format_behavioral_profile_for_prompt(self._profile, language=self._language, pressing=pressing)
                 if self._profile
                 else ""
             ),
diff --git a/src/usersim/engine/probes/safety_agentic/generator.py b/src/usersim/engine/probes/safety_agentic/generator.py
index 4e186747..672fd37e 100644
--- a/src/usersim/engine/probes/safety_agentic/generator.py
+++ b/src/usersim/engine/probes/safety_agentic/generator.py
@@ -86,9 +86,11 @@
 from dataclasses import dataclass
 from typing import Any, Iterable
 
+from usersim.engine.core.action_taxonomy import load_action_taxonomy_default
 from usersim.engine.core.agentic_bank import (
     ActionRequest,
     ToolSpec,
+    default_agentic_bank_path,
     load_agentic_bank_default,
     reset_agentic_bank_cache,
 )
@@ -105,6 +107,7 @@
 from usersim.engine.core.probes import (
     AgenticMixin,
     BankBackedProbe,
+    PreviewField,
     assistant_message,
     dispatch_episode,
     register_probe,
@@ -203,11 +206,40 @@ class SafetyAgenticProbe(AgenticMixin, BankBackedProbe):
     """
 
     label = "safety_agentic"
+    description = (
+        "Tests safety under agentic tool-call probes across four sub-protocols "
+        "(unsanctioned-action / scope-creep / consequence-disclosure / "
+        "compromised-inputs) in a mock-environment loop. Single-user-turn by design: "
+        "after the initial action request, the probe observes the assistant's tool use "
+        "and whether it stops to ask for clarification / confirmation before risky "
+        "actions. A conversation that ends after the assistant asks what to do next is "
+        "expected, not a truncated transcript."
+    )
+    default_scorers = ("safety_agentic",)
+    preview_fields = (
+        PreviewField("action_request_id", "Action request id"),
+        PreviewField("sub_protocol", "Sub-protocol"),
+        PreviewField("sanctioned_action_name", "Sanctioned action", from_metadata=True),
+        PreviewField("tempted_action_name", "Tempted action", from_metadata=True),
+    )
     output_columns = ("action_request_id", "sub_protocol")
     bank_loader = staticmethod(_bank_loader)
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_AGENTIC_ACTION
     bank_version_key = _BANK_VERSION_KEY  # "agentic" — non-locale
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The agentic-action bank, and the action taxonomy its scorer grades against."""
+        problems = []
+        path = default_agentic_bank_path()
+        if not path.exists():
+            problems.append(f"no agentic-action bank at {path}")
+        try:
+            load_action_taxonomy_default()
+        except Exception as error:
+            problems.append(f"action taxonomy: {type(error).__name__}: {error}")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         if self._task is None:
diff --git a/src/usersim/engine/probes/safety_chat_pressure/generator.py b/src/usersim/engine/probes/safety_chat_pressure/generator.py
index 0de5d283..0a3eb5c9 100644
--- a/src/usersim/engine/probes/safety_chat_pressure/generator.py
+++ b/src/usersim/engine/probes/safety_chat_pressure/generator.py
@@ -68,12 +68,14 @@
 from usersim.engine.core.pressure_bank import (
     Strategy,
     TargetRequest,
+    default_pressure_bank_path,
     load_pressure_bank_default,
     reset_pressure_bank_cache,
 )
 from usersim.engine.core.probes import (
     BankBackedProbe,
     BankReframingMixin,
+    PreviewField,
     dispatch_episode,
     register_probe,
 )
@@ -238,11 +240,27 @@ class SafetyChatPressureProbe(BankReframingMixin, BankBackedProbe):
     """
 
     label = "safety_chat_pressure"
+    description = (
+        "Tests safety under multi-turn conversational pressure: does the assistant hold "
+        "the line when the user persists, reframes, or escalates a target request?"
+    )
+    default_scorers = ("safety_chat_pressure",)
+    preview_fields = (
+        PreviewField("target_request_id", "Target request id"),
+        PreviewField("strategy_id", "Pressure strategy"),
+        PreviewField("harm_category", "Harm category", from_metadata=True),
+    )
     output_columns = ("target_request_id", "strategy_id", "reframings_used", "capitulation_checks")
     bank_loader = staticmethod(_bank_loader)
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_TARGET
     bank_version_key = _BANK_VERSION_KEY  # "safety" — not locale-keyed
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The pressure bank, which serves every locale."""
+        path = default_pressure_bank_path()
+        return [] if path.exists() else [f"no pressure bank at {path}"]
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         if self._task is None:
diff --git a/src/usersim/engine/probes/sov_ai_dynamic/generator.py b/src/usersim/engine/probes/sov_ai_dynamic/generator.py
index 0ca01f64..9f9245f4 100644
--- a/src/usersim/engine/probes/sov_ai_dynamic/generator.py
+++ b/src/usersim/engine/probes/sov_ai_dynamic/generator.py
@@ -55,15 +55,18 @@
 from typing import Any
 
 from usersim.engine.core.behavioral import get_conversation_language
+from usersim.engine.core.locale import SHIPPED_LOCALES
 from usersim.engine.core.outcomes import WarningKind
 from usersim.engine.core.persona import format_persona_for_prompt
 from usersim.engine.core.probes import (
     BankBackedProbe,
+    PreviewField,
     dispatch_episode,
     register_probe,
 )
 from usersim.engine.core.probing_taxonomy import (
     Category,
+    default_probing_taxonomy_path,
     load_probing_taxonomy,
     load_probing_taxonomy_for_locale,
     reset_probing_taxonomy_cache,
@@ -180,12 +183,35 @@ class SovAiDynamicProbe(BankBackedProbe):
     """
 
     label = "sov_ai_dynamic"
+    description = (
+        "Tests locale-specific knowledge where no curated answer exists: a "
+        "persona-voiced user explores a topic from the locale's taxonomy (history, "
+        "geography, culture, public services and more), and a judge flags suspected "
+        "fabrication, self-contradiction across turns and confident guesses where "
+        "declining was better."
+    )
+    default_scorers = ("sov_ai_dynamic",)
+    preview_fields = (
+        PreviewField("taxonomy_id", "Taxonomy id", from_metadata=True),
+        PreviewField("probing_categories_explored", "Categories explored"),
+        PreviewField("probing_subtopic_hints_used", "Sub-topic hints"),
+    )
     output_columns = ("probing_categories_explored", "probing_subtopic_hints_used")
     bank_loader = staticmethod(_bank_loader)
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_TAXONOMY
     bank_version_key = None  # locale-keyed (the inclusion convention)
     locale_bank_check = staticmethod(_check_locale_bank)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """A probing taxonomy for every shipped locale."""
+        problems = []
+        for locale in SHIPPED_LOCALES:
+            path = default_probing_taxonomy_path(locale)
+            if not path.exists():
+                problems.append(f"no probing taxonomy for {locale} at {path}")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         # Fail-fast contract: ``derive_probe`` returns None when every
diff --git a/src/usersim/engine/probes/sov_ai_facts/generator.py b/src/usersim/engine/probes/sov_ai_facts/generator.py
index 6579b4ca..495cd1bf 100644
--- a/src/usersim/engine/probes/sov_ai_facts/generator.py
+++ b/src/usersim/engine/probes/sov_ai_facts/generator.py
@@ -53,15 +53,18 @@
 
 from usersim.engine.core.fact_bank import (
     Fact,
+    default_fact_bank_path,
     load_fact_bank,
     load_fact_bank_for_locale,
     reset_fact_bank_cache,
 )
+from usersim.engine.core.locale import SHIPPED_LOCALES
 from usersim.engine.core.outcomes import WarningKind
 from usersim.engine.core.persona import format_persona_for_prompt
 from usersim.engine.core.probes import (
     BankBackedProbe,
     BankVerbatimMixin,
+    PreviewField,
     dispatch_episode,
     register_probe,
 )
@@ -162,12 +165,34 @@ class SovAiFactsProbe(BankVerbatimMixin, BankBackedProbe):
     """
 
     label = "sov_ai_facts"
+    description = (
+        "Tests recall of locale-specific (sovereign) facts drawn from a curated bank, "
+        "graded against ground-truth answers. Some questions embed a false premise to "
+        "correct; others give a partial verse for the assistant to continue."
+    )
+    default_scorers = ("sov_ai_facts",)
+    preview_fields = (
+        PreviewField("facts_probed", "Facts probed", from_metadata=True),
+        PreviewField("fact_category", "Fact category", from_metadata=True),
+        PreviewField("fact_question_type", "Question type", from_metadata=True),
+        PreviewField("fact_difficulty", "Difficulty", from_metadata=True),
+    )
     output_columns = ("sovereign_facts_probed",)
     bank_loader = staticmethod(_bank_loader)
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_FACT
     bank_version_key = None  # locale-keyed (the inclusion convention)
     locale_bank_check = staticmethod(_check_locale_bank)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """A fact bank for every shipped locale."""
+        problems = []
+        for locale in SHIPPED_LOCALES:
+            path = default_fact_bank_path(locale)
+            if not path.exists():
+                problems.append(f"no fact bank for {locale} at {path}")
+        return problems
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         # Fail-fast contract: ``derive_task`` returns None when the
diff --git a/src/usersim/engine/probes/sov_ai_multilingual_parity/generator.py b/src/usersim/engine/probes/sov_ai_multilingual_parity/generator.py
index 11480471..7740594c 100644
--- a/src/usersim/engine/probes/sov_ai_multilingual_parity/generator.py
+++ b/src/usersim/engine/probes/sov_ai_multilingual_parity/generator.py
@@ -45,11 +45,13 @@
 from usersim.engine.core.probes import (
     BankBackedProbe,
     BankVerbatimMixin,
+    PreviewField,
     dispatch_episode,
     register_probe,
 )
 from usersim.engine.core.query_bank import (
     Query,
+    default_query_bank_path,
     load_query_bank_default,
     reset_query_bank_cache,
 )
@@ -143,6 +145,19 @@ class SovAiMultilingualParityProbe(BankVerbatimMixin, BankBackedProbe):
     """
 
     label = "sov_ai_multilingual_parity"
+    description = (
+        "Tests respect and calibration on the same question asked in every locale: does "
+        "the assistant engage each user as a peer and pitch a helpful answer to them, "
+        "rather than condescend or deflect? Each row records its query_id, so answers "
+        "to one question can be compared across locales."
+    )
+    default_scorers = ("sov_ai_multilingual_parity",)
+    preview_fields = (
+        PreviewField("query_id", "Query id"),
+        PreviewField("query_concern", "Concern axis", from_metadata=True),
+        PreviewField("query_domain", "Domain", from_metadata=True),
+        PreviewField("query_difficulty", "Difficulty", from_metadata=True),
+    )
     output_columns = ("query_id",)
     # Routes through the module-level ``_load_bank`` alias so tests
     # that monkeypatch ``_load_bank`` propagate correctly.
@@ -150,6 +165,12 @@ class SovAiMultilingualParityProbe(BankVerbatimMixin, BankBackedProbe):
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_QUERY
     bank_version_key = None  # locale-keyed (the inclusion convention)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The query bank, which serves every locale."""
+        path = default_query_bank_path()
+        return [] if path.exists() else [f"no query bank at {path}"]
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         # Fail-fast contract: ``BankBackedProbe.derive_task`` returns
diff --git a/src/usersim/engine/probes/tool_calling/generator.py b/src/usersim/engine/probes/tool_calling/generator.py
index a85c91a7..7258e6a0 100644
--- a/src/usersim/engine/probes/tool_calling/generator.py
+++ b/src/usersim/engine/probes/tool_calling/generator.py
@@ -26,6 +26,7 @@
 from typing import Any
 
 from usersim.engine.core.behavioral import (
+    ChatRealism,
     format_behavioral_profile_for_prompt,
     format_disclosure_instructions,
     format_interaction_style_instructions,
@@ -43,12 +44,13 @@
 from usersim.engine.core.persona import format_persona_for_prompt
 from usersim.engine.core.probes import (
     BaseProbe,
+    PreviewField,
     ToolCallingMixin,
     ToolExecutionMixin,
     dispatch_episode,
     register_probe,
 )
-from usersim.engine.core.prompt_loader import render_prompt
+from usersim.engine.core.prompt_loader import load_prompt_file, render_prompt
 from usersim.engine.core.simulation import (
     ConversationState,
     make_failed,
@@ -57,6 +59,7 @@
     language_instruction as _language_instruction,
 )
 from usersim.engine.probes.tool_calling.prompts import (
+    _SCENARIO,
     assistant_system_prompt,
     tool_relevance_failure,
     tool_relevance_success,
@@ -239,6 +242,29 @@ class ToolCallingProbe(ToolExecutionMixin, ToolCallingMixin, BaseProbe):
     """
 
     label = "tool_calling"
+    description = (
+        "Tests the assistant's ability to invoke tools correctly in response to user "
+        "requests, including argument shaping, schema validation, and recovery from "
+        "tool-call failures."
+    )
+    default_scorers = ("tool_use",)
+    preview_fields = (
+        PreviewField("theme", "Theme"),
+        PreviewField("toolset_name", "Toolset"),
+        PreviewField("toolset_category", "Toolset category"),
+        PreviewField("num_tools", "Tools available"),
+    )
+
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        """The prompts file the prompt defaults would mask, and the toolset seed rows draw their tools from."""
+        problems = []
+        if not load_prompt_file(_SCENARIO):
+            problems.append(f"{_SCENARIO}/prompts.yaml is missing or empty")
+        toolsets = cls.assets_dir() / "toolsets_seed.parquet"
+        if not toolsets.exists():
+            problems.append(f"no toolset seed at {toolsets}, so every row would fail at construction")
+        return problems
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
@@ -277,8 +303,8 @@ def get_user_system_prompt(self) -> str:
             language_instruction=_language_instruction(self._language, self._locale),
             behavioral_instructions=format_behavioral_profile_for_prompt(
                 self._profile,
-                probe_type="tool_calling",
                 language=self._language,
+                chat_realism=ChatRealism.SHARING_DETAILS,
             ),
             disclosure_instructions=format_disclosure_instructions(
                 self._data.get("disclosure_style", "upfront"),
diff --git a/src/usersim/reporting/capability_report.py b/src/usersim/reporting/capability_report.py
index 4f2aff81..3a0cb0ac 100644
--- a/src/usersim/reporting/capability_report.py
+++ b/src/usersim/reporting/capability_report.py
@@ -24,6 +24,7 @@
 
 from usersim.engine.core.missing import is_missing
 from usersim.engine.core.outcomes import WarningKind, is_placeholder_warning_kind
+from usersim.engine.core.probes import probe_description
 from usersim.engine.core.row_metadata import recorded_value
 from usersim.taxonomy.capabilities import (
     CapabilityDefinition,
@@ -1341,7 +1342,7 @@ def _evidence_snippets(
                 probe_family=_clean_str(row.get("probe_family")) or "",
                 probe_type=probe_type,
                 probe_variant=probe_variant,
-                probe_description=_PROBE_DESCRIPTIONS.get(probe_type, ""),
+                probe_description=probe_description(probe_type),
                 reasoning=_reasoning_summary(row),
                 findings=_build_findings(row, definition),
                 turns=turns,
@@ -1351,100 +1352,6 @@ def _evidence_snippets(
     return out
 
 
-# Mirrors usersim.engine.core.preview._PROBE_DESCRIPTIONS so the
-# dashboard can render the same per-probe explainer the Rich panel in
-# notebooks/01_simulate.ipynb shows. Inlined here (rather than imported)
-# to avoid pulling Rich + the rest of the preview module into the
-# reporting layer's import graph.
-_PROBE_DESCRIPTIONS: dict[str, str] = {
-    "tool_calling": (
-        "Tests the assistant's ability to invoke tools correctly in response to user "
-        "requests, including argument shaping, schema validation, and recovery from "
-        "tool-call failures."
-    ),
-    "general_open_ended": (
-        "Tests information-seeking conversations across diverse personas: accurate, "
-        "coherent answers pitched to the user's apparent expertise, and a clarifying "
-        "question rather than an information dump when a request is vague."
-    ),
-    "general_educational": (
-        "Tests tutoring: a persona-grounded learner asks about a subject, and the probe "
-        "looks at whether explanations are accurate, pitched at the learner's level and "
-        "scaffolded with examples, without condescension."
-    ),
-    "sov_ai_facts": (
-        "Tests recall of locale-specific (sovereign) facts drawn from a curated bank, "
-        "graded against ground-truth answers. Some questions embed a false premise to "
-        "correct; others give a partial verse for the assistant to continue."
-    ),
-    "sov_ai_dynamic": (
-        "Tests locale-specific knowledge where no curated answer exists: a persona-voiced "
-        "user explores a topic from the locale's taxonomy (history, geography, culture, "
-        "public services and more), and a judge flags suspected fabrication, "
-        "self-contradiction across turns and confident guesses where declining was "
-        "better."
-    ),
-    "sov_ai_multilingual_parity": (
-        "Tests respect and calibration on the same question asked in every locale: does "
-        "the assistant engage each user as a peer and pitch a helpful answer to them, "
-        "rather than condescend or deflect? Each row records its query_id, so answers "
-        "to one question can be compared across locales."
-    ),
-    "safety_chat_pressure": (
-        "Tests safety under multi-turn conversational pressure: does the assistant "
-        "hold the line when the user persists, reframes, or escalates a target request?"
-    ),
-    "safety_agentic": (
-        "Tests safety under agentic tool-call probes across four sub-protocols "
-        "(unsanctioned-action / scope-creep / consequence-disclosure / "
-        "compromised-inputs) in a mock-environment loop. Single-user-turn by design: "
-        "after the initial action request, the probe observes the assistant's tool use "
-        "and whether it stops to ask for clarification / confirmation before risky "
-        "actions. A conversation that ends after the assistant asks what to do next is "
-        "expected, not a truncated transcript."
-    ),
-    "financial_services": (
-        "Tests financial customer-support / advisory grounded in a per-institution "
-        "knowledge base, across two tiers: verifiable (param-locked tasks scored by a "
-        "deterministic tool/retrieval verifier) and dynamic (open-ended questions from "
-        "an authored taxonomy, scored by a reference-grounded judge on grounding, "
-        "numeric faithfulness, boundary adherence, no fabrication, graceful unknowns "
-        "and self-consistency). Retrieval is scoped to a single institution."
-    ),
-    "identity_disclosure": (
-        "Tests whether the assistant names the developer that made it when a persona "
-        "asks who it is or who made it, with no system prompt: neutral questions, 'Are "
-        "you made by X?' naming the true developer or a competitor, and, in multi-turn "
-        "runs, a user who keeps pressing the competitor."
-    ),
-    "health_therapy_disclosure": (
-        "Tests whether a therapy assistant draws out what a guarded client discloses "
-        "only gradually, including self-harm or crisis risk. In the guarded variant the "
-        "user paces disclosure by plan, and the health_disclosure_concealment scorer "
-        "measures how much the assistant drew out."
-    ),
-    "health_triage_disclosure": (
-        "Tests whether a care-navigation (triage) assistant surfaces urgent red-flag "
-        "symptoms that a patient downplays and reveals only when asked directly. In the "
-        "guarded variant the user paces disclosure by plan, and the "
-        "health_disclosure_concealment scorer measures how much the assistant drew out."
-    ),
-    "health_decision_support_disclosure": (
-        "Tests whether a clinical decision-support assistant asks the questions that "
-        "surface a key finding or red-flag danger sign a clinician leaves out when first "
-        "presenting a case. In the guarded variant the user paces disclosure by plan, "
-        "and the health_disclosure_concealment scorer measures how much the assistant "
-        "drew out."
-    ),
-    "health_general_disclosure": (
-        "Tests whether a general health assistant surfaces the red-flag symptoms and "
-        "medication lapses that a patient with an ongoing condition downplays. In the "
-        "guarded variant the user paces disclosure by plan, and the "
-        "health_disclosure_concealment scorer measures how much the assistant drew out."
-    ),
-}
-
-
 def _per_turn_judge_ratings(raw: Any) -> list[dict[str, Any]]:
     """Pull the in-sim ``assistant_judge_ratings`` off ``conversation_metadata``.
 
diff --git a/src/usersim/testing/__init__.py b/src/usersim/testing/__init__.py
index 321f3791..6fcf942e 100644
--- a/src/usersim/testing/__init__.py
+++ b/src/usersim/testing/__init__.py
@@ -94,6 +94,7 @@ def probe_conformance_problems(probe: str | type) -> list[str]:
     from usersim.engine.core.probes import (
         _PROBE_REGISTRY,
         BaseProbe,
+        PreviewField,
         known_probes,
     )
 
@@ -184,6 +185,20 @@ def probe_conformance_problems(probe: str | type) -> list[str]:
         if kind_problem:
             problems.append(f"{cls.__qualname__}.placeholder_warning_kind {kind_problem}")
 
+    description = getattr(cls, "description", "")
+    if not isinstance(description, str):
+        problems.append(f"{cls.__qualname__}.description must be a string; got {description!r}")
+    fields = getattr(cls, "preview_fields", ())
+    if not isinstance(fields, tuple) or not all(
+        isinstance(field, PreviewField) and all(isinstance(text, str) and text for text in (field.key, field.label))
+        for field in fields
+    ):
+        problems.append(
+            f"{cls.__qualname__}.preview_fields must be a tuple of PreviewField, each with a key and a label; "
+            f"got {fields!r}"
+        )
+    problems.extend(_default_scorers_problems(cls))
+
     # A run reads these on the class, before any row runs.
     check = getattr(cls, "locale_bank_check", None)
     if check is not None and not callable(check):
@@ -191,11 +206,13 @@ def probe_conformance_problems(probe: str | type) -> list[str]:
             f"{cls.__qualname__}.locale_bank_check must be None or a function that loads one "
             f"locale's bank folder; got {check!r}"
         )
-    for hook in ("bank_locale", "themes", "model_aliases"):
+    for hook in ("bank_locale", "themes", "model_aliases", "asset_problems"):
         if not isinstance(inspect.getattr_static(cls, hook, None), classmethod):
             problems.append(f"{cls.__qualname__}.{hook} must be a classmethod; a run calls it on the class.")
     if isinstance(inspect.getattr_static(cls, "model_aliases", None), classmethod):
         problems.extend(_model_aliases_problems(cls))
+    if isinstance(inspect.getattr_static(cls, "asset_problems", None), classmethod):
+        problems.extend(_asset_check_problems(cls))
     guide = getattr(cls, "authoring_guide", None)
     if guide is not None and not (isinstance(guide, str) and guide.startswith("https://")):
         problems.append(
@@ -219,6 +236,24 @@ def probe_conformance_problems(probe: str | type) -> list[str]:
     return problems
 
 
+def _default_scorers_problems(cls: type) -> list[str]:
+    """What is wrong with the scorers ``cls.default_scorers`` names."""
+    from usersim.engine.evaluator.scorers import list_scorers
+
+    names = getattr(cls, "default_scorers", ())
+    if not isinstance(names, tuple) or not all(isinstance(name, str) and name for name in names):
+        return [f"{cls.__qualname__}.default_scorers must be a tuple of scorer names; got {names!r}"]
+    registered = list_scorers()
+    unknown = [name for name in names if name not in registered]
+    if unknown:
+        return [
+            f"{cls.__qualname__}.default_scorers names {unknown}, which no registered scorer holds, so "
+            f"`usersim eval --scorers auto` would record an error in its place on every row. "
+            f"Registered: {', '.join(registered)}"
+        ]
+    return []
+
+
 def _model_aliases_problems(cls: type) -> list[str]:
     """What is wrong with the aliases ``cls.model_aliases`` gives a run with default settings."""
     from usersim.engine.config import ConversationSimulatorConfig
@@ -232,6 +267,17 @@ def _model_aliases_problems(cls: type) -> list[str]:
     return []
 
 
+def _asset_check_problems(cls: type) -> list[str]:
+    """What ``cls.asset_problems`` finds in the probe's shipped assets, or what is wrong with the check itself."""
+    try:
+        found = cls.asset_problems()
+    except Exception as error:
+        return [f"{cls.__qualname__}.asset_problems raised {type(error).__name__}: {error}"]
+    if not isinstance(found, list) or not all(isinstance(problem, str) for problem in found):
+        return [f"{cls.__qualname__}.asset_problems must return a list of strings; got {found!r}"]
+    return [f"{cls.__qualname__}.asset_problems: {problem}" for problem in found]
+
+
 def _reserved_metadata_writes(cls: type) -> list[tuple[str, str]]:
     """``(class, key)`` for each reserved metadata key the probe's own classes write.
 
@@ -303,6 +349,26 @@ def assert_probe_conforms(probe: str | type) -> None:
         raise AssertionError(f"probe {name!r} does not conform:\n  - " + "\n  - ".join(problems))
 
 
+class _ModelLookups(dict):
+    """An empty ``models`` mapping that records each alias a scorer looks up in it."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.asked: list[str] = []
+
+    def get(self, key: Any, default: Any = None) -> Any:
+        self.asked.append(key)
+        return default
+
+    def __getitem__(self, key: Any) -> Any:
+        self.asked.append(key)
+        raise KeyError(key)
+
+    def __contains__(self, key: object) -> bool:
+        self.asked.append(str(key))
+        return False
+
+
 async def scorer_conformance_problems(
     name: str,
     *,
@@ -324,7 +390,7 @@ async def scorer_conformance_problems(
     means awaiting it here too.
     """
     from usersim.engine.evaluator.generator import SCORER_FILLED_KEYS
-    from usersim.engine.evaluator.scorers import _REGISTRY, list_scorers
+    from usersim.engine.evaluator.scorers import _REGISTRY, deterministic_scorers, list_scorers
 
     if name not in _REGISTRY:
         return [
@@ -343,8 +409,9 @@ async def scorer_conformance_problems(
             f"{name!r} is not an async function. The evaluator awaits every scorer, so declare it with 'async def'."
         ]
 
+    models = _ModelLookups()
     try:
-        result = await fn(dict(sample_row or {}), {})
+        result = await fn(dict(sample_row or {}), models)
     except Exception as exc:
         problems.append(
             f"raised {type(exc).__name__} on an empty row: {exc}. The "
@@ -357,6 +424,11 @@ async def scorer_conformance_problems(
         problems.append(
             f"returned {type(result).__name__}, expected a dict the evaluator can merge into the eval cell."
         )
+    if models.asked and name in deterministic_scorers():
+        problems.append(
+            f"{name!r} is registered as deterministic but looked up {', '.join(sorted(set(models.asked)))}. "
+            f"usersim rescore reruns a deterministic scorer on the promise that it calls no model."
+        )
 
     emptied = sorted(key for key in sample_row or {} if key not in SCORER_FILLED_KEYS)
     if emptied:
diff --git a/templates/probe/README.md b/templates/probe/README.md
index 07c29829..0467dfbe 100644
--- a/templates/probe/README.md
+++ b/templates/probe/README.md
@@ -113,6 +113,11 @@ When porting one of the templates into a new module:
 - [ ] Pick a `label` for `@register_probe` that no other probe uses,
       used by `--probe-mix` and the `_PROBE_REGISTRY` lookup.
       Underscores, lowercase.
+- [ ] Set `description`, a paragraph on what the probe tests; the
+      per-row preview and the capability report show it.
+- [ ] List in `preview_fields` the columns or metadata keys the per-row
+      preview's Probe Inputs panel shows, such as the id of the bank
+      entry each row drew.
 - [ ] Pick a `family` (the class attribute the decorator sets).
       The reporting layer stratifies on this.
 - [ ] Bump `prompt_version` on **any** semantic change to the
@@ -125,6 +130,9 @@ When porting one of the templates into a new module:
       by locale also sets `locale_bank_check`, so a run refuses a locale
       whose bank is missing before any model call (step 3 of
       `docs/engine/AUTHORING_A_PROBE.md`).
+- [ ] If the probe ships banks, check them in an `asset_problems`
+      classmethod, so `usersim smoke` reports an install that is missing
+      one (step 3 of `docs/engine/AUTHORING_A_PROBE.md`).
 - [ ] If the probe's conversations vary by topic, list the topics in a
       `themes` classmethod and read the row's with `self.theme()` (step 3
       of `docs/engine/AUTHORING_A_PROBE.md`).
@@ -148,7 +156,10 @@ When porting one of the templates into a new module:
       `docs/engine/AUTHORING_A_PROBE.md`.
 - [ ] Add a scorer under
       `evaluator/scorers/<your_probe>.py` and include the module
-      path in `DEFAULT_SCORER_MODULES`.
+      path in `DEFAULT_SCORER_MODULES`. Register it with
+      `deterministic=True` when it never calls a model, and list it in
+      the class's `default_scorers` so `usersim eval --scorers auto`
+      runs it.
 - [ ] Write tests from `test_probe.py.template`. Its first test runs
       the probe end to end with `usersim.testing.run_episode` and
       scripted models. The standard tests after it control each reply:
diff --git a/tests/conftest.py b/tests/conftest.py
index ee81d201..28e2073b 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -410,16 +410,17 @@ def register_test_probe(monkeypatch) -> Callable[..., type]:
     """Register throwaway ``BaseProbe`` subclasses in a copy of the probe registry.
 
     ``register_test_probe("ext_probe", assets_root=root)`` registers a class
-    labelled ``ext_probe`` with the given class attributes. The registry is
-    restored after the test, so nothing registered here reaches another test.
+    labelled ``ext_probe`` with the given class attributes, in the family
+    ``family`` or, by default, its label's. The registry is restored after
+    the test, so nothing registered here reaches another test.
     """
     from usersim.engine.core import probes
 
     monkeypatch.setattr(probes, "_PROBE_REGISTRY", dict(probes._PROBE_REGISTRY))
 
-    def register(label: str, **attributes: Any) -> type:
+    def register(label: str, *, family: str | None = None, **attributes: Any) -> type:
         cls = type(label, (probes.BaseProbe,), {"label": label, **attributes})
-        return probes.register_probe(family=label, prompt_version="v1.0", variants=("default",))(cls)
+        return probes.register_probe(family=family or label, prompt_version="v1.0", variants=("default",))(cls)
 
     return register
 
diff --git a/tests/engine/core/test_behavioral.py b/tests/engine/core/test_behavioral.py
index ab18785e..17452037 100644
--- a/tests/engine/core/test_behavioral.py
+++ b/tests/engine/core/test_behavioral.py
@@ -4,6 +4,7 @@
 """Tests for core/behavioral.py -- OCEAN->behavioral parameter computation."""
 
 from usersim.engine.core.behavioral import (
+    ChatRealism,
     _education_ordinal,
     _extract_ocean,
     _extract_ocean_metadata,
@@ -222,6 +223,14 @@ def test_no_patience_verbosity_coop_in_prompt(self, full_persona):
         assert "verbose" not in text.lower()
         assert "cooperative" not in text.lower()
 
+    def test_a_user_sharing_details_may_give_structured_data(self, full_persona):
+        """A user an assistant works for through tools gives IDs and dates; an asking user gives only what is asked."""
+        profile = compute_behavioral_profile(full_persona)
+        asking = format_behavioral_profile_for_prompt(profile)
+        sharing = format_behavioral_profile_for_prompt(profile, chat_realism=ChatRealism.SHARING_DETAILS)
+        assert "provide ONLY what was asked" in asking and "share IDs, reference numbers" not in asking
+        assert "share IDs, reference numbers" in sharing and "provide ONLY what was asked" not in sharing
+
     def test_a_pressing_user_may_state_what_it_believes(self, full_persona):
         profile = compute_behavioral_profile(full_persona)
         asking = format_behavioral_profile_for_prompt(profile)
diff --git a/tests/engine/core/test_preview.py b/tests/engine/core/test_preview.py
index b3087f51..5456b41a 100644
--- a/tests/engine/core/test_preview.py
+++ b/tests/engine/core/test_preview.py
@@ -42,6 +42,7 @@
     preview_row,
     preview_summary,
 )
+from usersim.engine.core.probes import PreviewField
 
 
 def _general_row() -> dict[str, Any]:
@@ -631,10 +632,9 @@ def test_probe_variant_in_panel_not_header(self) -> None:
         assert "Variant: factual_recall" in out
 
     def test_unknown_probe_falls_back_gracefully(self) -> None:
-        # Defensive: an unknown ``probe_type`` (e.g. a typo, or
-        # a probe added in code without a corresponding entry in
-        # ``_PROBE_DESCRIPTIONS``) renders the panel with a
-        # placeholder description rather than crashing.
+        # Defensive: an unknown ``probe_type`` (e.g. a typo, or a
+        # stored row from a probe that is not installed) renders
+        # the panel with a placeholder description rather than crashing.
         row = _general_row()
         row["probe_type"] = "tool_calling_v2_renamed"
         out = _record([row])
@@ -701,10 +701,37 @@ def test_multilingual_consistency_inputs_panel(self) -> None:
         assert "Q-HEALTH-001" in out
         assert "respect.condescension" in out
 
+    # ---------------------------------------------------------------------------
+    # 6. Attempted actions table (safety_agentic)
+    # ---------------------------------------------------------------------------
+
+    def test_a_probe_from_another_package_shows_the_fields_it_declares(self, register_test_probe) -> None:
+        register_test_probe(
+            "ext_recipes",
+            preview_fields=(
+                PreviewField("ext_recipe_id", "Recipe id"),
+                PreviewField("ext_cuisine", "Cuisine", from_metadata=True),
+                PreviewField("ext_difficulty", "Recipe difficulty"),
+            ),
+        )
+        row = _general_row()
+        row.update(probe_type="ext_recipes", probe_family="ext_recipes", ext_recipe_id="R-007")
+        row["conversation_metadata"] = json.dumps({"ext_cuisine": "Thai"})
 
-# ---------------------------------------------------------------------------
-# 6. Attempted actions table (safety_agentic)
-# ---------------------------------------------------------------------------
+        out = _record([row])
+
+        assert "Probe Inputs" in out
+        assert out.index("Recipe id: R-007") < out.index("Cuisine: Thai")
+        assert "Recipe difficulty" not in out
+
+    def test_a_row_from_a_probe_that_is_not_installed_has_no_inputs_panel(self) -> None:
+        row = _general_row()
+        row.update(probe_type="retired_probe", probe_family="retired_probe")
+
+        out = _record([row])
+
+        assert "retired_probe" in out
+        assert "Probe Inputs" not in out
 
 
 class TestAttemptedActionsTable:
diff --git a/tests/engine/evaluator/test_evaluator_generator.py b/tests/engine/evaluator/test_evaluator_generator.py
index 1435338d..52bf54ea 100644
--- a/tests/engine/evaluator/test_evaluator_generator.py
+++ b/tests/engine/evaluator/test_evaluator_generator.py
@@ -21,7 +21,7 @@
 import pytest
 
 from usersim.engine.evaluator import scorers as scorers_module
-from usersim.engine.evaluator.axes import select_axes
+from usersim.engine.evaluator.axes import UNIVERSAL_SCORES, select_axes
 from usersim.engine.evaluator.config import (
     JudgeSpecConfig,
     TrajectoryEvaluatorConfig,
@@ -137,6 +137,20 @@ async def _capture(models, judge_alias, prompt, schema_model, max_tokens):
                 f"an anchor of {axis.name} is missing from the judge prompt"
             )
 
+    async def test_a_row_with_no_family_is_judged_on_the_universal_axes_alone(self) -> None:
+        gen = _build_generator(TrajectoryEvaluatorConfig(name="eval_v2", judges=_ok_judges()))
+        row = {
+            "conversation_messages": json.dumps(
+                [{"role": "user", "content": "hi"}, {"role": "assistant", "content": "hello"}]
+            ),
+            "persona": json.dumps({"first_name": "A", "last_name": "B"}),
+            "probe_family": None,
+        }
+
+        cell = json.loads((await gen.agenerate(row))["eval_v2"])
+
+        assert cell["envelope"]["axes"] == [s.name for s in UNIVERSAL_SCORES]
+
 
 class TestNoAssistantMessages:
     async def test_short_circuits_with_skipped_record(self) -> None:
@@ -684,6 +698,14 @@ async def test_empty_cells_reach_the_scorer_as_none(self, empty) -> None:
         assert traj_row["sub_protocol"] is None
         assert traj_row["locale"] == "en_US"
 
+    @pytest.mark.parametrize("empty", [None, float("nan"), pd.NA, ""], ids=["none", "nan", "na", "blank"])
+    async def test_a_row_with_no_family_reaches_the_scorer_with_an_empty_one(self, empty) -> None:
+        """A row that names no probe is attributed to none."""
+        data = self._make_data_with_probe_columns()
+        data["probe_family"] = empty
+
+        assert (await self._scorer_row(data))["probe_family"] == ""
+
 
 class TestEmptyCellsReachAShippedScorer:
     """A shipped scorer's verdict does not depend on how an empty cell was held."""
diff --git a/tests/engine/evaluator/test_evaluator_scorers.py b/tests/engine/evaluator/test_evaluator_scorers.py
index 5c941472..15a2141c 100644
--- a/tests/engine/evaluator/test_evaluator_scorers.py
+++ b/tests/engine/evaluator/test_evaluator_scorers.py
@@ -48,6 +48,12 @@ def b(traj, models):
             scorers_module.register_scorer("x", b)
         assert scorers_module.get_scorer("x") is a
 
+    def test_the_auto_entry_cannot_be_a_scorer_name(self) -> None:
+        """``--scorers auto`` stands for a set of scorers, so no one scorer may answer to it."""
+        with pytest.raises(scorers_module.ScorerRegistrationError, match=r"'auto' is reserved"):
+            scorers_module.register_scorer("auto", lambda t, m: {})
+        assert "auto" not in scorers_module.list_scorers()
+
     def test_registering_the_same_scorer_again_keeps_it(self) -> None:
         def a(traj, models):
             return {"v": 1}
diff --git a/tests/engine/test_conformance_suite.py b/tests/engine/test_conformance_suite.py
index 28eaf165..56c61351 100644
--- a/tests/engine/test_conformance_suite.py
+++ b/tests/engine/test_conformance_suite.py
@@ -17,7 +17,7 @@
 
 import usersim.engine.generator  # noqa: F401  (populates the registry)
 from usersim.engine.core import simulation
-from usersim.engine.core.probes import BaseProbe, known_probes
+from usersim.engine.core.probes import BaseProbe, PreviewField, known_probes
 from usersim.engine.evaluator import scorers
 from usersim.engine.evaluator.generator import SCORER_FILLED_KEYS
 from usersim.engine.evaluator.scorers import list_scorers
@@ -192,19 +192,68 @@ class Mislabelled(BaseProbe):
                 "PreflightProbe.authoring_guide must be None or an https:// URL",
             ),
             ({"themes": lambda self, locale: None}, "PreflightProbe.themes must be a classmethod"),
+            ({"description": ("Tests", "cooking")}, "PreflightProbe.description must be a string"),
+            (
+                {"preview_fields": PreviewField("theme", "Topic")},
+                "PreflightProbe.preview_fields must be a tuple of PreviewField",
+            ),
+            (
+                {"preview_fields": (("theme", "Topic"),)},
+                "PreflightProbe.preview_fields must be a tuple of PreviewField",
+            ),
+            (
+                {"preview_fields": (PreviewField("theme", ""),)},
+                "PreflightProbe.preview_fields must be a tuple of PreviewField, each with a key and a label",
+            ),
+            (
+                {"preview_fields": (PreviewField("theme", 1),)},
+                "PreflightProbe.preview_fields must be a tuple of PreviewField, each with a key and a label",
+            ),
+            (
+                {"default_scorers": "tool_use"},
+                "PreflightProbe.default_scorers must be a tuple of scorer names; got 'tool_use'",
+            ),
+            (
+                {"default_scorers": ("tool_use", "no_such_scorer")},
+                "PreflightProbe.default_scorers names ['no_such_scorer'], which no registered scorer holds",
+            ),
             ({"model_aliases": lambda self, cfg: ()}, "PreflightProbe.model_aliases must be a classmethod"),
             (
                 {"model_aliases": classmethod(lambda cls, cfg: "critic_model")},
                 "PreflightProbe.model_aliases must return a tuple of alias names; got 'critic_model'",
             ),
+            ({"asset_problems": lambda self: []}, "PreflightProbe.asset_problems must be a classmethod"),
+            (
+                {"asset_problems": classmethod(lambda cls: "no bank for fr_FR")},
+                "PreflightProbe.asset_problems must return a list of strings; got 'no bank for fr_FR'",
+            ),
+            (
+                {"asset_problems": classmethod(lambda cls: ["no bank for fr_FR"])},
+                "PreflightProbe.asset_problems: no bank for fr_FR",
+            ),
+            (
+                {"asset_problems": classmethod(lambda cls: {}["fr_FR"])},
+                "PreflightProbe.asset_problems raised KeyError: 'fr_FR'",
+            ),
         ],
         ids=[
             "check-not-callable",
             "bank-locale-not-a-classmethod",
             "relative-guide",
             "themes-not-a-classmethod",
+            "description-not-a-string",
+            "preview-fields-a-bare-field",
+            "preview-fields-plain-tuples",
+            "preview-field-without-a-label",
+            "preview-field-with-a-label-that-is-not-text",
+            "default-scorers-a-bare-string",
+            "default-scorers-naming-no-scorer",
             "model-aliases-not-a-classmethod",
             "model-aliases-a-bare-string",
+            "asset-check-not-a-classmethod",
+            "asset-check-a-bare-string",
+            "asset-check-finding-a-problem",
+            "asset-check-raising",
         ],
     )
     async def test_unusable_preflight_declarations_are_reported(self, attributes, expected) -> None:
@@ -219,6 +268,11 @@ class Declared(BaseProbe):
             label = "declared_probe"
             locale_bank_check = staticmethod(lambda locale_dir: None)
             authoring_guide = "https://example.com/declared-probe/locales"
+            default_scorers = ("tool_use", "language_compliance")
+            preview_fields = (
+                PreviewField("theme", "Topic"),
+                PreviewField("taxonomy_id", "Taxonomy", from_metadata=True),
+            )
 
             @classmethod
             def bank_locale(cls, locale, probe_dir):
@@ -232,7 +286,20 @@ def themes(cls, locale):
             def model_aliases(cls, cfg):
                 return ("critic_model",)
 
-        declarations = ("locale_bank_check", "bank_locale", "authoring_guide", "themes", "model_aliases")
+            @classmethod
+            def asset_problems(cls):
+                return []
+
+        declarations = (
+            "locale_bank_check",
+            "bank_locale",
+            "authoring_guide",
+            "themes",
+            "model_aliases",
+            "default_scorers",
+            "asset_problems",
+            "preview_fields",
+        )
         assert not [p for p in probe_conformance_problems(Declared) if any(d in p for d in declarations)]
 
     @pytest.mark.parametrize(
@@ -289,6 +356,23 @@ async def defaulted(row, models):
         problems = await scorer_conformance_problems("defaulted", sample_row={"sub_protocol": "Triage"})
         assert any("AttributeError" in p and "sub_protocol" in p for p in problems)
 
+    @pytest.mark.parametrize(("deterministic", "reported"), [(True, True), (False, False)])
+    async def test_a_deterministic_scorer_that_looks_up_a_model_is_reported(
+        self, monkeypatch, deterministic, reported
+    ) -> None:
+        """usersim rescore reruns a deterministic scorer with no models, trusting it calls none."""
+
+        async def judged_when_wired(row, models):
+            return {"judged": models.get("judge_model") is not None}
+
+        monkeypatch.setattr(scorers, "_REGISTRY", dict(scorers._REGISTRY))
+        monkeypatch.setattr(scorers, "_DETERMINISTIC", set(scorers._DETERMINISTIC))
+        scorers.register_scorer("judged_when_wired", judged_when_wired, deterministic=deterministic)
+
+        problems = await scorer_conformance_problems("judged_when_wired")
+        expected = "'judged_when_wired' is registered as deterministic but looked up judge_model"
+        assert any(expected in p for p in problems) is reported, problems
+
     async def test_keys_the_evaluator_fills_are_never_emptied(self, monkeypatch) -> None:
         async def relies_on_filled_keys(row, models):
             return {
diff --git a/tests/engine/test_hosted_parity_contract.py b/tests/engine/test_hosted_parity_contract.py
index 8edd8d56..2119a25c 100644
--- a/tests/engine/test_hosted_parity_contract.py
+++ b/tests/engine/test_hosted_parity_contract.py
@@ -84,6 +84,20 @@ async def test_every_registered_probe_runs_to_completion_with_scripted_models(pr
     assert run.prompts and all(prompt["messages"] for prompt in run.prompts)
 
 
+@pytest.mark.parametrize(("probe_type", "shares_details"), [("tool_calling", True), ("general_open_ended", False)])
+async def test_only_the_tool_calling_user_may_share_details(probe_type: str, shares_details: bool) -> None:
+    """Its user hands the assistant the identifiers a tool call needs; an asking user gives only what is asked."""
+    run = await run_episode(
+        probe_type, config=_config(probe_type), persona=_PERSONA, data=_data(probe_type), profile=_PROFILE
+    )
+
+    system = next(
+        m["content"] for p in run.prompts if p["role"] == "user" for m in p["messages"] if m["role"] == "system"
+    )
+    assert ("share IDs, reference numbers" in system) is shares_details
+    assert ("provide ONLY what was asked" in system) is not shares_details
+
+
 async def test_a_model_factory_scripts_the_replies() -> None:
     """A ``ScriptedModel`` subclass answers in place of the default, with nothing patched."""
 
diff --git a/tests/engine/test_probe_asset_problems.py b/tests/engine/test_probe_asset_problems.py
new file mode 100644
index 00000000..01ad11f7
--- /dev/null
+++ b/tests/engine/test_probe_asset_problems.py
@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Each probe that checks its shipped assets reports the ones it cannot find.
+
+``BaseProbe.asset_problems`` is what ``usersim smoke`` and
+``assert_probe_conforms`` run for every registered probe. The shipped assets
+pass every check (``test_conformance_suite.py``); here each check is pointed
+at an empty asset folder and has to say so.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+import pytest
+
+from usersim.engine.core._assets import reset_runtime_assets_dir, set_runtime_assets_dir
+from usersim.engine.core.probes import BaseProbe, known_probes, resolve_probe
+
+
+def _checks_its_assets(label: str) -> bool:
+    check = inspect.getattr_static(resolve_probe(label), "asset_problems")
+    return check is not inspect.getattr_static(BaseProbe, "asset_problems")
+
+
+@pytest.fixture
+def empty_assets(tmp_path):
+    """An asset root, searched first, holding an empty folder for every registered probe."""
+    for label in known_probes():
+        (tmp_path / label).mkdir()
+    token = set_runtime_assets_dir(tmp_path)
+    try:
+        yield tmp_path
+    finally:
+        reset_runtime_assets_dir(token)
+
+
+def test_these_probes_check_their_assets() -> None:
+    probes = (
+        "financial_services",
+        "general_educational",
+        "general_open_ended",
+        "identity_disclosure",
+        "safety_agentic",
+        "safety_chat_pressure",
+        "sov_ai_dynamic",
+        "sov_ai_facts",
+        "sov_ai_multilingual_parity",
+        "tool_calling",
+    )
+
+    assert [label for label in probes if not _checks_its_assets(label)] == []
+
+
+@pytest.mark.parametrize("label", [label for label in known_probes() if _checks_its_assets(label)])
+def test_a_probe_with_an_empty_asset_folder_is_reported(label: str, empty_assets) -> None:
+    problems = resolve_probe(label).asset_problems()
+
+    assert problems
+    assert all(isinstance(problem, str) and problem for problem in problems)
diff --git a/tests/engine/test_probe_default_scorers.py b/tests/engine/test_probe_default_scorers.py
new file mode 100644
index 00000000..55bb54e6
--- /dev/null
+++ b/tests/engine/test_probe_default_scorers.py
@@ -0,0 +1,80 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""What ``usersim eval --scorers auto`` stands for.
+
+``auto`` is the rule-based scorers that apply to every probe plus the
+``default_scorers`` of each probe whose rows the pass evaluates, found by the
+``probe_family`` the rows are stored under.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+from usersim.cli.evaluate import _resolve_scorers
+from usersim.engine.core.probes import known_probes, resolve_probe
+from usersim.engine.evaluator.scorers import GENERIC_SCORERS
+from usersim.taxonomy.capabilities import ALL_PROBES, capabilities_missing_scorer, capability_definitions
+
+
+def test_auto_is_the_generic_scorers_plus_the_run_probes_own() -> None:
+    assert _resolve_scorers(["auto"], ["tool_calling", "general_open_ended"]) == [*GENERIC_SCORERS, "tool_use"]
+
+
+def test_names_beside_auto_are_kept_in_place_each_once() -> None:
+    resolved = _resolve_scorers(["tool_use", "auto", "language_compliance", "my_scorer"], ["tool_calling"])
+
+    assert resolved == ["tool_use", *GENERIC_SCORERS, "my_scorer"]
+
+
+def test_a_list_without_auto_is_passed_on_as_given() -> None:
+    assert _resolve_scorers(["tool_use"], ["financial_services"]) == ["tool_use"]
+
+
+def test_a_family_no_installed_probe_stores_is_named(caplog) -> None:
+    with caplog.at_level(logging.WARNING, logger="usersim.cli.eval"):
+        resolved = _resolve_scorers(["auto"], ["retired_probe", "tool_calling"])
+
+    assert resolved == [*GENERIC_SCORERS, "tool_use"]
+    (warning,) = [r.getMessage() for r in caplog.records]
+    assert "probe_family retired_probe" in warning
+    assert "tool_calling" not in warning
+
+
+def test_a_blank_family_adds_no_scorer_and_no_warning(caplog) -> None:
+    with caplog.at_level(logging.WARNING, logger="usersim.cli.eval"):
+        resolved = _resolve_scorers(["auto"], ["", "tool_calling"])
+
+    assert resolved == [*GENERIC_SCORERS, "tool_use"]
+    assert not caplog.records
+
+
+def test_a_probe_is_found_by_the_family_its_rows_are_stored_under(register_test_probe) -> None:
+    register_test_probe("ext_recipes", family="ext_cooking", default_scorers=("tool_use",))
+
+    assert _resolve_scorers(["auto"], ["ext_cooking"]) == [*GENERIC_SCORERS, "tool_use"]
+    assert _resolve_scorers(["auto"], ["ext_recipes"]) == list(GENERIC_SCORERS)
+
+
+def test_auto_over_every_built_in_probe_runs_every_scorer_the_capability_report_reads() -> None:
+    families = [resolve_probe(label).family or label for label in known_probes()]
+
+    assert capabilities_missing_scorer(_resolve_scorers(["auto"], families)) == {}
+
+
+@pytest.mark.parametrize(
+    ("probe", "scorer"),
+    sorted(
+        {
+            (source.probe, source.scorer)
+            for definition in capability_definitions()
+            for source in definition.sources
+            if source.scorer and source.probe and source.probe != ALL_PROBES
+        }
+    ),
+)
+def test_auto_over_one_probe_runs_the_scorers_its_capabilities_read(probe: str, scorer: str) -> None:
+    assert scorer in _resolve_scorers(["auto"], [resolve_probe(probe).family or probe])
diff --git a/tests/fixtures/extension_package/usersim_extension_fixture/probe.py b/tests/fixtures/extension_package/usersim_extension_fixture/probe.py
index 915973b6..b3ad86d1 100644
--- a/tests/fixtures/extension_package/usersim_extension_fixture/probe.py
+++ b/tests/fixtures/extension_package/usersim_extension_fixture/probe.py
@@ -5,7 +5,7 @@
 
 import yaml
 
-from usersim.engine.core.probes import BaseProbe, register_probe
+from usersim.engine.core.probes import BaseProbe, PreviewField, register_probe
 
 
 def _check_locale_bank(locale_dir: Path) -> None:
@@ -18,6 +18,8 @@ class FixtureProbe(BaseProbe):
     label = "fixture_probe"
     assets_root = Path(__file__).parent / "assets"
     output_columns = ("fixture_probe_marker",)
+    preview_fields = (PreviewField("fixture_probe_marker", "Marker"),)
+    default_scorers = ("fixture_scorer",)
     locale_bank_check = staticmethod(_check_locale_bank)
     authoring_guide = "https://example.com/fixture-probe/locales"
 
@@ -25,6 +27,14 @@ class FixtureProbe(BaseProbe):
     def model_aliases(cls, cfg) -> tuple[str, ...]:
         return ("fixture_critic_model",)
 
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        try:
+            _check_locale_bank(cls.assets_dir() / "en_US")
+        except FileNotFoundError as error:
+            return [str(error)]
+        return []
+
     @classmethod
     def themes(cls, locale: str) -> list[dict]:
         return yaml.safe_load((cls.assets_dir() / locale / "themes.yaml").read_text(encoding="utf-8"))
diff --git a/tests/fixtures/extension_package/usersim_extension_fixture/scorer.py b/tests/fixtures/extension_package/usersim_extension_fixture/scorer.py
index e2dd4df8..93f6512f 100644
--- a/tests/fixtures/extension_package/usersim_extension_fixture/scorer.py
+++ b/tests/fixtures/extension_package/usersim_extension_fixture/scorer.py
@@ -8,4 +8,4 @@ async def score(row, models):
     return {"fixture_axis": 1.0}
 
 
-register_scorer("fixture_scorer", score)
+register_scorer("fixture_scorer", score, deterministic=True)
diff --git a/tests/fixtures/extension_package/verify_seams.py b/tests/fixtures/extension_package/verify_seams.py
index 34b36e86..80e659eb 100644
--- a/tests/fixtures/extension_package/verify_seams.py
+++ b/tests/fixtures/extension_package/verify_seams.py
@@ -44,6 +44,11 @@ def check(seam: str, condition: bool, detail: str = "") -> None:
 
 check("usersim.scorers", "fixture_scorer" in list_scorers())
 
+# A contributed scorer registered as deterministic is one usersim rescore reruns.
+from usersim.cli.rescore import _validate_scorers  # noqa: E402
+
+check("deterministic scorer is rescorable", _validate_scorers(["fixture_scorer"]) == ["fixture_scorer"])
+
 # 3. Asset domain
 from usersim.asset_gen.registry import domain_names  # noqa: E402
 
@@ -140,6 +145,26 @@ def preflight_refusal(locales: list[str]) -> str:
 declared = declared_model_aliases(ConversationSimulatorConfig(name="conversation_messages"))
 check("model_aliases joins the run's models", "fixture_critic_model" in declared, str(declared))
 
+# `usersim eval --scorers auto` adds a contributed probe's default_scorers for
+# the rows stored under its family, which differs from its label.
+from usersim.cli.evaluate import _resolve_scorers  # noqa: E402
+from usersim.engine.evaluator.scorers import GENERIC_SCORERS  # noqa: E402
+
+auto = _resolve_scorers(["auto"], ["fixture"])
+check("default_scorers join --scorers auto", auto == [*GENERIC_SCORERS, "fixture_scorer"], str(auto))
+
+# The per-row preview shows the fields a contributed probe declares.
+import pandas as pd  # noqa: E402
+from rich.console import Console  # noqa: E402
+
+from usersim.engine.core.preview import _render_probe_inputs  # noqa: E402
+
+panel = _render_probe_inputs(pd.Series({"probe_type": "fixture_probe", "fixture_probe_marker": "yes"}), {})
+shown = Console(record=True, width=100)
+if panel is not None:
+    shown.print(panel)
+check("preview_fields reach the preview", "Marker: yes" in shown.export_text(), shown.export_text())
+
 # The published conformance suite must pass for a real external probe.
 from usersim.testing import probe_conformance_problems  # noqa: E402
 
@@ -173,7 +198,7 @@ def preflight_refusal(locales: list[str]) -> str:
 check("identity probe conformance", not identity_problems, str(identity_problems))
 
 # `usersim smoke` names the installed package and finds nothing wrong with it.
-from usersim.cli.smoke import SmokeReport, _check_extensions  # noqa: E402
+from usersim.cli.smoke import SmokeReport, _check_extensions, _check_probe_assets  # noqa: E402
 
 smoke = SmokeReport()
 _check_extensions(smoke)
@@ -184,6 +209,18 @@ def preflight_refusal(locales: list[str]) -> str:
     extensions.detail,
 )
 
+# It also runs the contributed probes' asset checks beside the shipped ones:
+# the fixture probe's own, and the spec check the identity probe inherits.
+assets = SmokeReport()
+_check_probe_assets(assets)
+(probe_assets,) = assets.results
+checked = probe_assets.detail.split(": ", 1)[-1].split(", ")
+check(
+    "usersim smoke runs the contributed asset checks",
+    probe_assets.ok and {"fixture_probe", "fixture_identity", "tool_calling"} <= set(checked),
+    probe_assets.detail,
+)
+
 if failures:
     print(f"\n{len(failures)} seam(s) failed: {', '.join(failures)}")
     sys.exit(1)
diff --git a/tests/test_capability_report.py b/tests/test_capability_report.py
index e6c487da..d79ae83f 100644
--- a/tests/test_capability_report.py
+++ b/tests/test_capability_report.py
@@ -851,13 +851,21 @@ def test_axis_description_is_absent_for_judged_axes():
     assert axis_description("helpfulness") == ""
 
 
-def test_dashboard_probe_descriptions_match_the_preview():
-    """The dashboard keeps its own copy of the preview's probe descriptions so
-    reporting doesn't import Rich; the two copies must say the same thing."""
-    from usersim.engine.core import preview
-    from usersim.reporting import capability_report
+def test_every_built_in_probe_describes_itself():
+    """The preview and the dashboard show each row's probe description from its class."""
+    from usersim.engine.core.probes import known_probes, probe_description
 
-    assert capability_report._PROBE_DESCRIPTIONS == preview._PROBE_DESCRIPTIONS
+    assert [label for label in known_probes() if not probe_description(label)] == []
+
+
+def test_a_probe_description_comes_from_its_class(register_test_probe):
+    """A probe shipped in its own package is described where a built-in is; a label no probe holds has none."""
+    from usersim.engine.core.probes import probe_description
+
+    register_test_probe("ext_described", description="Tests cooking help from a recipe bank.")
+
+    assert probe_description("ext_described") == "Tests cooking help from a recipe bank."
+    assert probe_description("no_such_probe") == ""
 
 
 def test_dashboard_prefers_reasoning_then_description(tmp_path):
diff --git a/tests/test_cli_eval_sampling.py b/tests/test_cli_eval_sampling.py
index 3252c366..07556e94 100644
--- a/tests/test_cli_eval_sampling.py
+++ b/tests/test_cli_eval_sampling.py
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""How ``usersim eval`` sampled a run, and the report label that follows from it."""
+"""The rows and scorers of a ``usersim eval`` pass, and the report label that follows from its sampling."""
 
 from __future__ import annotations
 
@@ -16,6 +16,7 @@
 from usersim.cli import _pipeline
 from usersim.cli._models import bundled_models_path
 from usersim.engine.core.storage import read_partitioned_dataset, run_subroot, write_partitioned_dataset
+from usersim.engine.evaluator.scorers import GENERIC_SCORERS
 from usersim.reporting import EVAL_STORE_MANIFEST_FILENAME, read_eval_sample_manifest, record_eval_sample_pass
 
 RUN_ID = "1700000000"
@@ -28,11 +29,20 @@ def create(self, builder, num_records):
         return SimpleNamespace(load_dataset=lambda: pd.DataFrame({"assistant_eval": ["{}"] * num_records}))
 
 
-def _evaluate(tmp_path, monkeypatch, trajectory_df, *flags):
-    """Run ``usersim eval`` over ``trajectory_df`` and return the evaluations root and its recorded pass."""
+def _evaluate(tmp_path, monkeypatch, trajectory_df, *flags, built=None):
+    """Run ``usersim eval`` over ``trajectory_df`` and return the evaluations root and its recorded pass.
+
+    ``built``, when given, receives the arguments the evaluator is built with.
+    """
     traj_root = tmp_path / "trajectories"
     write_partitioned_dataset(trajectory_df, run_subroot(traj_root, RUN_ID))
-    monkeypatch.setattr(_pipeline, "build_evaluator_config_builder", lambda **_: (_StubDataDesigner(), object()))
+
+    def build(**kwargs):
+        if built is not None:
+            built.update(kwargs)
+        return _StubDataDesigner(), object()
+
+    monkeypatch.setattr(_pipeline, "build_evaluator_config_builder", build)
     out = tmp_path / "evaluations"
     args = ["eval", "--trajectories", str(traj_root), "--out", str(out), "--models", str(bundled_models_path())]
 
@@ -65,6 +75,17 @@ def test_a_per_locale_sample(self, tmp_path, monkeypatch, trajectory_df):
         assert recorded.random_seed == 42
 
 
+def test_auto_scorers_reach_the_evaluator_resolved_for_the_run(tmp_path, monkeypatch, trajectory_df, capsys):
+    """``--scorers auto`` becomes the generic scorers plus the default_scorers of the run's probes."""
+    run = trajectory_df.assign(probe_family=["tool_calling", "financial_services", *["general_open_ended"] * 4])
+    built: dict = {}
+
+    _evaluate(tmp_path, monkeypatch, run, "--scorers", "tool_use,auto", built=built)
+
+    assert built["scorers"] == ["tool_use", *GENERIC_SCORERS, "financial_services"]
+    assert f"scorers:       {', '.join(built['scorers'])}" in capsys.readouterr().out
+
+
 class TestEvalWarnsOnRepeatedIds:
     """One ``trajectory_id`` is one conversation; a run that repeats one would score it more than once."""
 
diff --git a/tests/test_rescore.py b/tests/test_rescore.py
index 5f02fa74..9e715dc5 100644
--- a/tests/test_rescore.py
+++ b/tests/test_rescore.py
@@ -19,7 +19,8 @@
 
 import pytest
 
-from usersim.cli.rescore import DETERMINISTIC_SCORERS, run
+from usersim.cli.rescore import run
+from usersim.engine.evaluator import scorers as scorers_module
 
 
 def _judge_axes():
@@ -110,6 +111,13 @@ def run_on_disk(tmp_path):
     )
 
 
+def _register_for_this_test(monkeypatch, name, fn, *, deterministic=False):
+    """Register ``fn`` in copies of the scorer registry, restored after the test."""
+    monkeypatch.setattr(scorers_module, "_REGISTRY", dict(scorers_module._REGISTRY))
+    monkeypatch.setattr(scorers_module, "_DETERMINISTIC", set(scorers_module._DETERMINISTIC))
+    scorers_module.register_scorer(name, fn, deterministic=deterministic)
+
+
 def _read_cell(evaluations, run_id="1700000000"):
     pytest.importorskip("pandas")
     from usersim.engine.core.storage import read_partitioned_dataset
@@ -183,17 +191,13 @@ def test_empty_cells_reach_the_scorer_as_none(self, run_on_disk, monkeypatch):
         """The store reads an empty cell back as pandas NA, which a scorer's
         falsy fallback cannot test, so it has to arrive as None, as it does
         from the evaluator."""
-        from usersim.cli import rescore
-        from usersim.engine.evaluator import scorers as scorers_module
-
         seen = {}
 
         async def spy(traj, models):
             seen["traj_row"] = traj
             return {"scores": {}}
 
-        monkeypatch.setitem(scorers_module._REGISTRY, "__spy__", spy)
-        monkeypatch.setattr(rescore, "DETERMINISTIC_SCORERS", (*rescore.DETERMINISTIC_SCORERS, "__spy__"))
+        _register_for_this_test(monkeypatch, "__spy__", spy, deterministic=True)
         run_on_disk.scorers = ["__spy__"]
 
         assert run(run_on_disk) == 0
@@ -213,17 +217,29 @@ def test_hybrid_scorers_are_refused(self, run_on_disk, scorer):
         run_on_disk.scorers = [scorer]
         with pytest.raises(SystemExit) as excinfo:
             run(run_on_disk)
-        assert scorer in str(excinfo.value)
+        assert f"{scorer!r} is not registered as deterministic" in str(excinfo.value)
         assert "LLM-free" in str(excinfo.value)
 
+    def test_a_scorer_registered_without_the_flag_is_refused(self, run_on_disk, monkeypatch):
+        """Rescore reruns only what a scorer's registration promises calls no model."""
+
+        async def acme_judged(traj, models):
+            return {"scores": {}}
+
+        _register_for_this_test(monkeypatch, "acme_judged", acme_judged)
+        run_on_disk.scorers = ["acme_judged"]
+        with pytest.raises(SystemExit) as excinfo:
+            run(run_on_disk)
+        assert "'acme_judged' is not registered as deterministic" in str(excinfo.value)
+
     def test_unknown_scorer_is_refused(self, run_on_disk):
         run_on_disk.scorers = ["not_a_scorer"]
         with pytest.raises(SystemExit) as excinfo:
             run(run_on_disk)
         assert "not a known deterministic scorer" in str(excinfo.value)
 
-    def test_allowlist_is_only_the_model_free_scorers(self):
-        assert set(DETERMINISTIC_SCORERS) == {
+    def test_only_the_model_free_scorers_are_registered_as_deterministic(self):
+        assert set(scorers_module.deterministic_scorers()) == {
             "language_compliance",
             "refusal_basics",
             "response_shape",
diff --git a/tests/test_smoke.py b/tests/test_smoke.py
index 8039ab44..48d014f8 100644
--- a/tests/test_smoke.py
+++ b/tests/test_smoke.py
@@ -24,6 +24,7 @@
     _check_extensions,
     _check_imports,
     _check_models_config,
+    _check_probe_assets,
     _check_probe_registry,
     _check_scorer_registry,
     _check_simulator_config,
@@ -157,6 +158,50 @@ def test_all_registered_probes_resolve(self):
             assert probe in detail, f"missing {probe!r} in: {detail}"
 
 
+class TestProbeAssetsCheck:
+    def test_names_each_probe_that_checks_its_assets(self, register_test_probe):
+        register_test_probe("checked_probe", asset_problems=classmethod(lambda cls: []))
+        register_test_probe("unchecked_probe")
+
+        report = SmokeReport()
+        _check_probe_assets(report)
+
+        assert report.all_passed, report.render()
+        named = report.results[-1].detail.split(": ", 1)[1].split(", ")
+        assert "checked_probe" in named
+        assert "unchecked_probe" not in named
+
+    def test_a_problem_a_probe_finds_fails_the_check(self, register_test_probe):
+        register_test_probe("unbanked_probe", asset_problems=classmethod(lambda cls: ["no bank for fr_FR"]))
+
+        report = SmokeReport()
+        _check_probe_assets(report)
+
+        assert not report.all_passed
+        assert report.results[-1].detail == "1 problem(s): unbanked_probe: no bank for fr_FR"
+
+    def test_a_check_that_raises_is_reported(self, register_test_probe):
+        register_test_probe("broken_probe", asset_problems=classmethod(lambda cls: {}["fr_FR"]))
+
+        report = SmokeReport()
+        _check_probe_assets(report)
+
+        assert not report.all_passed
+        assert report.results[-1].detail == "1 problem(s): broken_probe: asset_problems raised KeyError: 'fr_FR'"
+
+    def test_names_the_first_three_problems_and_counts_the_rest(self, register_test_probe):
+        missing = [f"no bank for {locale}" for locale in ("de_DE", "fr_FR", "ja_JP", "ko_KR", "pt_BR")]
+        register_test_probe("unbanked_probe", asset_problems=classmethod(lambda cls: missing))
+
+        report = SmokeReport()
+        _check_probe_assets(report)
+
+        assert report.results[-1].detail == (
+            "5 problem(s): unbanked_probe: no bank for de_DE; unbanked_probe: no bank for fr_FR; "
+            "unbanked_probe: no bank for ja_JP (+2 more)"
+        )
+
+
 class TestDryRunsCheck:
     def test_three_dry_runs_pass(self):
         report = SmokeReport()