diff --git a/architecture/assets.md b/architecture/assets.md
index 79dbada0..71dca6ff 100644
--- a/architecture/assets.md
+++ b/architecture/assets.md
@@ -2,8 +2,8 @@
 
 Probe content (fact banks, query banks, pressure banks, clinical profiles,
 finance corpora, tool catalogs, action taxonomies) ships as **package
-data** under `usersim/engine/assets/<probe>/`, or, for a built-in probe kept
-in its own folder, under that folder's `assets/<probe>/`.
+data** in each built-in probe's own folder, under
+`usersim/engine/probes/<folder>/assets/<probe>/`.
 
 They ship inside the package so a plain `pip install` gives you working
 probes with no extra download step. `make check-dist` fails if the wheel
@@ -12,40 +12,37 @@ Markdown outside the banks.
 
 ## Resolution
 
-Assets resolve along an ordered **search path**, highest priority first:
+Each probe keeps its banks in the `<label>/` folder of the root its class
+declares as `assets_root`. A built-in probe declares its own folder in the
+package, `engine/probes/<folder>/assets/`. A probe shipped in its own package
+points it inside that package, such as `Path(__file__).parent / "assets"`, so
+the probe finds its banks wherever the package is installed, with no
+environment variable to set. Registration refuses a relative root. The lookup
+finds a built-in's folder before the probe's module is imported: a prompt read
+while the module loads, or a scorer in a process that never imports the probe,
+reaches the probe's assets.
+
+Ahead of a probe's own root, assets resolve along an ordered **search path**
+of deliberate overrides, highest priority first:
 
 1. the per-context override set by `set_runtime_assets_dir`
 2. each entry of `$USERSIM_ASSET_PATH` (`os.pathsep`-separated)
 3. `$USERSIM_ASSETS_DIR`
-4. the packaged `usersim/engine/assets/` directory
-
-`probe_assets_dir()` walks that path and takes the first root holding the
-probe. The packaged directory is always last, so prepending a root never
-hides the shipped banks, which is what lets a package contribute one
-probe's assets without restating the rest.
-
-A probe class can also declare `assets_root`, the directory that holds its
-`<label>/` folder. A probe shipped in its own package points it inside that
-package, such as `Path(__file__).parent / "assets"`, so the probe finds its
-banks wherever the package is installed, with no environment variable to
-set. Registration refuses a relative root. That root is searched for that
-probe only, after the first three entries and before the packaged directory,
-so a deliberate override wins over it. A built-in probe kept in its own
-folder declares one too, that folder's `assets/`, and the lookup finds that
-folder before the probe's module is imported: a prompt read while the module
-loads, or a scorer in a process that never imports the probe, reaches the
-probe's assets. A probe's bank loader reads
-under its class's `assets_dir()`, the folder this search finds for the probe,
-and its `prompts.yaml` is read from that folder too.
+
+`probe_assets_dir()` walks those roots, then the probe's own, and takes the
+first that holds the probe. An override without a probe's folder leaves that
+probe's own banks in reach, which is what lets a package contribute one
+probe's assets without restating the rest. A probe's bank loader reads under
+its class's `assets_dir()`, the folder this search finds for the probe, and
+its `prompts.yaml` is read from that folder too.
 
 An explicit `--assets-dir` is **not** part of the search. It pins resolution
 to exactly that directory, for every probe in the run, including one that
 declares `assets_root`, because a user who named a location should be told
-when the assets are not there rather than quietly served another copy.
-Pinning the packaged directory pins the assets that ship with User Sim, so it
-also reaches a built-in probe whose banks are in its own folder.
-`simulate --inputs` pins the folder its rows were stored with: the packaged
-directory, for rows stored by a run that named no folder and set no override.
+when the assets are not there rather than quietly served another copy. A run
+without it records no asset folder. `simulate --inputs` reads stored rows
+from the folder they were stored with, or from each probe's own assets when
+they name none.
 
 There is no fallback to the working directory. Resolving against wherever the
 process happened to start makes a broken install look healthy from a source
diff --git a/architecture/plugins.md b/architecture/plugins.md
index c0b2e011..ccb713d9 100644
--- a/architecture/plugins.md
+++ b/architecture/plugins.md
@@ -171,8 +171,8 @@ class MyProbe(BaseProbe):
 ```
 
 The probe then finds its banks wherever the package is installed. That root
-is searched after `$USERSIM_ASSET_PATH` and before the packaged banks, so a
-deployment can override it and the shipped banks remain reachable.
+is searched after `$USERSIM_ASSET_PATH`, so a deployment can override it, and
+an override without the probe's folder leaves its shipped banks in reach.
 `@register_probe` refuses a relative `assets_root`, which would resolve against
 the working directory. The probe's bank loader reads under `MyProbe.assets_dir()`,
 its folder on that search, so an override reaches the loader too.
diff --git a/architecture/probes.md b/architecture/probes.md
index 591a907d..07a78c28 100644
--- a/architecture/probes.md
+++ b/architecture/probes.md
@@ -129,7 +129,7 @@ than into a branch on its label.
 | `description` | `""` | the per-row preview and the capability report, beside the probe's rows |
 | `preview_fields` | `()` | the per-row preview's Probe Inputs panel |
 | `default_scorers` | `()` | `usersim eval --scorers auto`, for a run that holds the probe's rows |
-| `assets_root` | `None`: the packaged banks | `assets_dir()`, and through it the probe's loaders, the pre-flight and smoke |
+| `assets_root` | `None`: the override roots only | `assets_dir()`, and through it the probe's loaders, the pre-flight and smoke |
 | `locale_bank_check` | `None`: the asset folder holds bank files | the pre-flight, for each run locale |
 | `bank_locale` | an India variant's own bank when it has one, else its base locale's | the pre-flight |
 | `authoring_guide` | `None` | the pre-flight, when a run asks for a locale the probe has no bank for |
@@ -167,9 +167,9 @@ the turn had no side effects.
 
 ## Assets
 
-A probe's content lives at `engine/assets/<label>/`, or, for a probe kept in
-its own folder, at `engine/probes/<folder>/assets/<label>/`, where the folder
-is named after the probe or, as `health_disclosure` is, shared by several. It
+A built-in probe's content lives in its own folder, at
+`engine/probes/<folder>/assets/<label>/`, where the folder is named after the
+probe or, as `health_disclosure` is, shared by several. It
 is resolved through `probe_assets_dir()`. A run fails pre-flight, before any
 model call, if a selected probe's bank is missing or, for the probes whose banks
 are split by locale, doesn't load for a run locale (a finance bank without
diff --git a/docs/engine/AUTHORING_A_PROBE.md b/docs/engine/AUTHORING_A_PROBE.md
index 1327fac4..9fe2c3e3 100644
--- a/docs/engine/AUTHORING_A_PROBE.md
+++ b/docs/engine/AUTHORING_A_PROBE.md
@@ -259,12 +259,11 @@ resolve against the working directory. In this repository the banks are then
 at `src/usersim/engine/probes/<folder>/assets/<label>/`, as for
 `general_educational`, `general_open_ended`, the three `sov_ai_*` probes,
 `safety_chat_pressure`, `safety_agentic`, `identity_disclosure`,
-`financial_services` and the four `health_*` probes, which share the
-`health_disclosure/` folder. They keep their bank loader (`bank.py`,
-`taxonomy.py` for `sov_ai_dynamic`, `spec.py` for `identity_disclosure`) and
-their scorer (`scorer.py`) in that folder too, and their tests in
-`tests/probes/<folder>/`. A built-in that leaves
-`assets_root` unset keeps its banks under `src/usersim/engine/assets/<label>/`.
+`financial_services`, `tool_calling` and the four `health_*` probes, which
+share the `health_disclosure/` folder: every built-in probe. They keep their
+bank loader (`bank.py`, `taxonomy.py` for `sov_ai_dynamic`, `spec.py` for
+`identity_disclosure`) and their scorer (`scorer.py`) in that folder too, and
+their tests in `tests/probes/<folder>/`.
 
 Its bank loader reads under `MyProbe.assets_dir()`, the probe's own folder,
 resolved as the built-in loaders resolve theirs, so a folder `--assets-dir` or
diff --git a/docs/engine/EXTERNAL_PROBE_RUNTIME.md b/docs/engine/EXTERNAL_PROBE_RUNTIME.md
index ab9b3324..c26ce326 100644
--- a/docs/engine/EXTERNAL_PROBE_RUNTIME.md
+++ b/docs/engine/EXTERNAL_PROBE_RUNTIME.md
@@ -109,7 +109,8 @@ print(result.run_id, result.written, result.skipped)
   stored with. The rows in one call must share their settings apart from
   locale, asset folder and that replay setting.
   `--assets-dir` replaces the asset folder the rows were stored with, and is
-  required when that folder doesn't exist on this machine.
+  required when that folder doesn't exist on this machine. Rows stored by a
+  run that named no folder read each probe's own assets.
 - **Concurrent writers.** Writes into `--out` take a lock, so two calls can
   share it. On a filesystem without file locks, or whose locks don't reach
   every node (Lustre mounted without `flock` or with `localflock`, NFS with
diff --git a/docs/engine/README.md b/docs/engine/README.md
index 1860fd64..ef7642fd 100644
--- a/docs/engine/README.md
+++ b/docs/engine/README.md
@@ -589,7 +589,7 @@ The tables describe the main files.
 | `test_locale.py` | `SHIPPED_LOCALES` parity across language-name / display-name / script-range maps; new locales caught at CI time |
 | `test_language_detection.py` | Lazy `lingua` detector loading, `script_compliance_fraction`, `script_dominance` helpers |
 | `test_default_asset_paths.py` | Every shipped probe's default asset path resolves to a real file across every supported locale |
-| `test_assets_discovery.py` | Runtime assets-dir resolution (`set_runtime_assets_dir`, `probe_assets_dir`), env-override precedence, a probe's declared `assets_root`, and every registered probe owning a packaged folder |
+| `test_assets_discovery.py` | Runtime assets-dir resolution (`set_runtime_assets_dir`, `probe_assets_dir`), env-override precedence, a probe's declared `assets_root`, and every registered probe owning a folder in the package |
 | `test_config.py` | `ConversationSimulatorConfig` defaults, optional fields, side-effect-columns contract (the core columns plus every registered probe's `output_columns`) |
 | `test_pipeline.py` | Pipeline-level config validation |
 | `test_generator.py` | Dispatcher failed-result structure, probe-variant resolution, structured `SCENARIO_ABORTED` outcomes |
@@ -603,13 +603,11 @@ The tables describe the main files.
 | `test_analysis.py` | Score extraction, demographic preservation, edge cases used by the deep-dive analysis script |
 | `test_probing_taxonomy.py` | Probing-taxonomy YAML schema validator, loader, lookup helpers, locale-keyed shared cache |
 
-**`tests/engine/probes/`: the probe generators, verifier and invariants**
+**`tests/engine/probes/`: cross-probe invariants**
 
 | Test File | Coverage |
 |-----------|----------|
 | `test_probe_invariants.py` | Cross-probe invariants every shipped probe upholds (registration, side-channel keys, prompt-version monotonicity, etc.) |
-| `test_tool_calling.py` | Tool-calling probe: tool sampling, gate check |
-| `test_verifiers.py` | Tool-call JSON-schema validator |
 
 **`tests/engine/evaluator/`: judges, scorers, registry**
 
@@ -659,3 +657,6 @@ The tables describe the main files.
 | `health_disclosure/test_bank.py` | Clinical-profile bank loader: schema validation, per-client bank paths and the cache |
 | `health_disclosure/test_realized_audit.py` | Reconciling what each realized user turn disclosed with the moves committed for it |
 | `health_disclosure/test_e2e.py` | The probe's real columns through the store to the concealment scorer |
+| `tool_calling/test_probe.py` | `tool_calling` probe: prompt templates, the tool helpers, the simulated API response, the row-derived tool draw, and conversations through the loop with mocked models |
+| `tool_calling/test_verifiers.py` | Tool-call JSON-schema validator |
+| `tool_calling/test_catalog.py` | The shipped tool catalog: every spec is valid JSON Schema that providers accept, with typed items, defaults, examples and enums, and every tool and parameter described |
diff --git a/notebooks/01_simulate.ipynb b/notebooks/01_simulate.ipynb
index 987d8fbd..911db652 100644
--- a/notebooks/01_simulate.ipynb
+++ b/notebooks/01_simulate.ipynb
@@ -97,7 +97,7 @@
     "from usersim.cli._pipeline import build_simulator_config_builder, known_probes, sample_trajectories\n",
     "\n",
     "# --- Engine (asset + storage + preview helpers) ---\n",
-    "from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir\n",
+    "from usersim.engine.core._assets import probe_assets_dir\n",
     "from usersim.engine.core.preview import (\n",
     "    filter_preview_locale,\n",
     "    preview_row,\n",
@@ -128,9 +128,9 @@
     "# Trajectories land as a directory-partitioned dataset rooted at\n",
     "# TRAJECTORY_PATH (Hive-style: locale=X/probe_family=Y/part-N.parquet).\n",
     "REPO_ROOT = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()\n",
-    "# Banks ship inside the installed package, so resolve them from there rather\n",
-    "# than from the checkout. This works the same from a wheel install.\n",
-    "ASSETS_DIR = packaged_assets_dir()\n",
+    "# None reads each probe's banks from its own folder in the installed package,\n",
+    "# the same from a checkout or a wheel. A folder here pins every probe to it.\n",
+    "ASSETS_DIR = None\n",
     "OUTPUT_DIR = REPO_ROOT / \"output\"\n",
     "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n",
     "TRAJECTORY_PATH = OUTPUT_DIR / \"trajectories\"\n",
diff --git a/pyproject.toml b/pyproject.toml
index 28e1667d..5de88484 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -116,7 +116,7 @@ dev = [
     # has only through this backport.
     "exceptiongroup>=1.0; python_version < '3.11'",
     # Validates each tool spec in the tool_calling catalog against the JSON
-    # Schema 2020-12 meta-schema, in tests/engine/probes/test_tool_catalog.py.
+    # Schema 2020-12 meta-schema, in tests/probes/tool_calling/test_catalog.py.
     "jsonschema>=4.0,<5",
 ]
 # Empty on purpose: the gate runs a pinned pip-licenses through `uv tool run`,
@@ -168,15 +168,10 @@ include = ["usersim*"]
     "models_*.toml",
 ]
 "usersim.engine" = [
-    # The asset banks. setuptools ships package data only when it is named,
-    # and a wheel without the banks fails every probe at asset resolution.
-    # `make check-dist` fails if the wheel misses any bank file.
-    "assets/**/*.yaml",
-    "assets/**/*.yml",
-    "assets/**/*.json",
-    "assets/**/*.parquet",
-    "assets/**/*.md",
-    # The banks a probe keeps in its own folder, under probes/<label>/assets/.
+    # The asset banks, each in its probe's own folder, under probes/<folder>/assets/.
+    # setuptools ships package data only when it is named, and a wheel without the
+    # banks fails every probe at asset resolution. `make check-dist` fails if the
+    # wheel misses any bank file.
     "probes/*/assets/**/*.yml",
     "probes/*/assets/**/*.json",
     "probes/*/assets/**/*.parquet",
diff --git a/scripts/check_dist.py b/scripts/check_dist.py
index dd1abe5e..adc29d46 100644
--- a/scripts/check_dist.py
+++ b/scripts/check_dist.py
@@ -36,13 +36,11 @@
 def in_a_bank(path: str) -> bool:
     """Whether a package file is in an asset bank.
 
-    Banks live under ``usersim/engine/assets/``, or in the ``assets/`` folder
-    of a probe kept in its own folder, ``usersim/engine/probes/<label>/assets/``.
+    Banks live in the ``assets/`` folder of each built-in probe's own folder,
+    ``usersim/engine/probes/<folder>/assets/``.
     """
     parts = path.split("/")
-    return path.startswith("usersim/engine/assets/") or (
-        parts[:3] == ["usersim", "engine", "probes"] and parts[4:5] == ["assets"]
-    )
+    return parts[:3] == ["usersim", "engine", "probes"] and parts[4:5] == ["assets"]
 
 
 def ships(path: str) -> bool:
diff --git a/src/usersim/cli/_inputs.py b/src/usersim/cli/_inputs.py
index ad15e8a9..1bf080dc 100644
--- a/src/usersim/cli/_inputs.py
+++ b/src/usersim/cli/_inputs.py
@@ -72,8 +72,8 @@ class EpisodeInputs:
     #: The ``usersim_config`` every row shares, apart from ``_PER_ROW_SETTINGS``
     #: and ``_RUN_SETTINGS``, which the run settles (see :func:`_run_config`).
     config: dict[str, Any]
-    #: The asset root the rows run against.
-    assets_dir: Path
+    #: The asset root the rows run against, or ``None`` to read each probe's own.
+    assets_dir: Path | None
     #: The file the rows came from, when they came from one.
     source: Path | None = None
 
@@ -208,22 +208,29 @@ def setup(row: dict[str, Any]) -> dict[str, Any]:
     return dict(rows[0]["usersim_config"])
 
 
-def _resolve_assets_dir(rows: list[dict[str, Any]], given: str | Path | None) -> Path:
-    """``--assets-dir`` when given, else the one asset root the rows were stored with."""
-    from usersim.engine.core._assets import packaged_assets_dir
+def _resolve_assets_dir(rows: list[dict[str, Any]], given: str | Path | None) -> Path | None:
+    """``--assets-dir`` when given, else the asset root the rows were stored with.
 
+    ``None`` when the rows name none: they were stored by a run that named no
+    folder, so each probe reads its own assets.
+    """
     if given is not None:
         path = Path(given).resolve()
         if not path.is_dir():
             raise ValueError(f"--assets-dir {path} is not a directory")
         return path
     stored = {row["usersim_config"].get("assets_dir") for row in rows}
-    hint = f"pass --assets-dir (the assets that ship with User Sim are at {packaged_assets_dir()})"
-    if len(stored) != 1 or None in stored:
-        raise ValueError(f"the rows do not name one asset folder; {hint}")
-    path = Path(stored.pop())
+    if len(stored) != 1:
+        raise ValueError("the rows were stored with different asset folders; pass --assets-dir to name one")
+    folder = stored.pop()
+    if folder is None:
+        return None
+    path = Path(folder)
     if not path.is_dir():
-        raise ValueError(f"the asset folder the rows were stored with, {path}, does not exist here; {hint}")
+        raise ValueError(
+            f"the asset folder the rows were stored with, {path}, does not exist here; pass --assets-dir to "
+            "name one, or store the rows again without --assets-dir so each probe reads its own assets"
+        )
     return path
 
 
@@ -288,7 +295,7 @@ def _model_settings(models: Any, aliases: list[str]) -> tuple[dict[str, Any], di
     return readable, hashed
 
 
-def _asset_roots_digest(assets_dir: Path) -> list[str]:
+def _asset_roots_digest(assets_dir: Path | None) -> list[str]:
     """The contents of every asset root a run can read, in priority order.
 
     The search path, then the ``assets_root`` each registered probe declares.
@@ -520,7 +527,11 @@ def _column_config(inputs: EpisodeInputs, locale: str, models: Any):
     from usersim.engine.config import ConversationSimulatorConfig
 
     return ConversationSimulatorConfig.model_validate(
-        {**_run_config(inputs, models), "locale": locale, "assets_dir": str(inputs.assets_dir)}
+        {
+            **_run_config(inputs, models),
+            "locale": locale,
+            "assets_dir": str(inputs.assets_dir) if inputs.assets_dir is not None else None,
+        }
     )
 
 
diff --git a/src/usersim/cli/_pipeline.py b/src/usersim/cli/_pipeline.py
index c63736dc..faa8a68f 100644
--- a/src/usersim/cli/_pipeline.py
+++ b/src/usersim/cli/_pipeline.py
@@ -76,11 +76,12 @@
 _NO_THEME_PLACEHOLDER: str = "__not_used__"
 
 
-def _probe_themes(probe: str, locale: str, assets_dir: Path) -> list[str]:
+def _probe_themes(probe: str, locale: str, assets_dir: Path | None) -> list[str]:
     """``probe``'s themes in ``locale``, JSON-encoded for the sampler.
 
     Read with ``assets_dir`` installed as the run installs it for each row, so
-    a probe finds its themes where its rows find their banks. ``ensure_ascii``
+    a probe finds its themes where its rows find their banks. ``None`` reads
+    each probe's own assets. ``ensure_ascii``
     is off so non-Latin descriptions stay readable in the stored column.
     """
     from usersim.engine.core._assets import reset_runtime_assets_dir, set_runtime_assets_dir
@@ -426,11 +427,16 @@ def known_probes() -> tuple[str, ...]:
     return _known()
 
 
+def _recorded_assets_dir(assets_dir: Path | str | None) -> str | None:
+    """The asset root a run's config records: the pinned folder, or ``None`` for each probe's own."""
+    return str(Path(assets_dir).resolve()) if assets_dir is not None else None
+
+
 def build_simulator_config_builder(
     *,
     locale: str,
     models: ModelsConfig,
-    assets_dir: Path,
+    assets_dir: Path | None = None,
     max_turns: int = 5,
     max_assistant_attempts: int = 1,
     store_reasoning: bool = True,
@@ -483,7 +489,7 @@ def build_simulator_config_builder(
             theme_column="theme",
             **toolset_kwargs,
             locale=locale,
-            assets_dir=str(Path(assets_dir).resolve()),
+            assets_dir=_recorded_assets_dir(assets_dir),
             max_turns=max_turns,
             max_assistant_attempts=max_assistant_attempts,
             store_reasoning=store_reasoning,
@@ -506,7 +512,7 @@ def _add_episode_input_columns(
     dd: Any,
     *,
     locale: str,
-    assets_dir: Path,
+    assets_dir: Path | None,
     probe_mix: dict[str, float],
     tool_calling_themes: tuple[str, ...] | None,
     toolset_seed_path: Path | None,
@@ -566,8 +572,8 @@ def materialize_episode_inputs(
     locale: str,
     num_rows: int,
     models: ModelsConfig,
-    assets_dir: Path,
     probe_mix: dict[str, float],
+    assets_dir: Path | None = None,
     random_seed: int | None = None,
     tool_calling_themes: tuple[str, ...] | None = None,
     toolset_seed_path: Path | None = None,
@@ -602,7 +608,7 @@ def materialize_episode_inputs(
     config = ConversationSimulatorConfig(
         name="conversation_messages",
         locale=locale,
-        assets_dir=str(assets_dir.resolve()),
+        assets_dir=_recorded_assets_dir(assets_dir),
         random_seed=random_seed,
         max_turns=max_turns,
         max_assistant_attempts=max_assistant_attempts,
diff --git a/src/usersim/cli/evaluate_assets.py b/src/usersim/cli/evaluate_assets.py
index 35a73e4a..655c0c03 100644
--- a/src/usersim/cli/evaluate_assets.py
+++ b/src/usersim/cli/evaluate_assets.py
@@ -15,7 +15,7 @@
 from pathlib import Path
 
 from usersim.asset_gen.registry import domain_names, get_domain
-from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir
+from usersim.engine.core._assets import shipped_assets_dir
 
 
 def register(subparsers: argparse._SubParsersAction) -> None:
@@ -86,7 +86,7 @@ def run(args: argparse.Namespace) -> int:
     if dom.evaluate is None:
         print(f"  domain {args.domain!r} has no evaluator")
         return 2
-    bank_dir = args.dir or (probe_assets_dir(args.domain, assets_root=packaged_assets_dir()) / args.locale)
+    bank_dir = args.dir or (shipped_assets_dir(args.domain) / args.locale)
     spec_path = args.region_spec or (dom.region_spec_dir / f"{args.locale}.yaml")
 
     print(f"usersim evaluate-assets [{args.domain}] — {args.locale}")
diff --git a/src/usersim/cli/gen_assets.py b/src/usersim/cli/gen_assets.py
index 5a6e1913..047dbe6a 100644
--- a/src/usersim/cli/gen_assets.py
+++ b/src/usersim/cli/gen_assets.py
@@ -15,7 +15,7 @@
 from pathlib import Path
 
 from usersim.asset_gen.registry import domain_names, get_domain
-from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir
+from usersim.engine.core._assets import shipped_assets_dir
 
 
 def register(subparsers: argparse._SubParsersAction) -> None:
@@ -99,7 +99,7 @@ def run(args: argparse.Namespace) -> int:
         print("  (dry run — no assets written)")
         return 0
 
-    out_dir = args.out or (probe_assets_dir(args.domain, assets_root=packaged_assets_dir()) / args.locale)
+    out_dir = args.out or (shipped_assets_dir(args.domain) / args.locale)
     from usersim.cli._models import (
         apply_model_overrides,
         apply_parallel_overrides,
diff --git a/src/usersim/cli/simulate.py b/src/usersim/cli/simulate.py
index 14ecb5e2..d59048ea 100644
--- a/src/usersim/cli/simulate.py
+++ b/src/usersim/cli/simulate.py
@@ -47,6 +47,9 @@
 
 logger = logging.getLogger("usersim.cli.simulate")
 
+#: How a run that pins no asset folder reports where its assets come from.
+_OWN_ASSETS = "each probe's own assets"
+
 
 def register(subparsers: argparse._SubParsersAction) -> None:
     p = subparsers.add_parser(
@@ -120,7 +123,9 @@ def register(subparsers: argparse._SubParsersAction) -> None:
         type=Path,
         default=None,
         help=(
-            "Path to an alternate assets/ tree (seeds + toolsets). Defaults to the banks shipped inside the package."
+            "Read every probe's assets from this folder, which holds a <probe>/ folder per probe. "
+            "Without it, each probe reads the banks it ships with, after any USERSIM_ASSET_PATH or "
+            "USERSIM_ASSETS_DIR override."
         ),
     )
     p.add_argument(
@@ -146,8 +151,8 @@ def register(subparsers: argparse._SubParsersAction) -> None:
             "one row per toolset with columns toolset_source, "
             "toolset_category, toolset_name, num_tools and tools (JSON list "
             "of OpenAI-style function specs) -- see the Schema section of "
-            "assets/tool_calling/README.md. "
-            "Defaults to <assets-dir>/tool_calling/toolsets_seed.{parquet,jsonl}. "
+            "engine/probes/tool_calling/assets/tool_calling/README.md in the package. "
+            "Defaults to toolsets_seed.{parquet,jsonl} in the tool_calling assets, under --assets-dir when given. "
             "Requires tool_calling in --probe-mix; a missing or unsupported "
             "explicit file is an error."
         ),
@@ -354,24 +359,16 @@ def run(args: argparse.Namespace) -> int:
 
     probe_mix = _parse_probe_mix(args.probe_mix)
 
-    # Resolve --assets-dir once, here, so every downstream consumer sees a
-    # real path rather than None.
-    from usersim.engine.core._assets import default_assets_dir
-
-    # Two different questions. ``pinned`` is whether the user named a
-    # directory: if so, resolution stays there and a missing bank is an
-    # error rather than a silent fall-through to the packaged copies.
-    # ``args.assets_dir`` is the single concrete root recorded in the
-    # generator config and the run manifest, which cannot hold a list.
-    pinned_assets_dir = args.assets_dir
-    if args.assets_dir is None:
-        args.assets_dir = default_assets_dir()
-
+    # ``args.assets_dir`` is the folder the user pinned, or None. A pinned run
+    # reads every bank there, and a missing one is an error rather than a
+    # silent fall-through; otherwise each probe reads its own assets.
+    if args.assets_dir is not None:
+        args.assets_dir = args.assets_dir.resolve()
     if args.locale and args.num_rows is None:
         raise SystemExit("--locale requires --num-rows")
 
     if args.materialize_inputs:
-        return _materialize_inputs(args, models, probe_mix, pinned_assets_dir)
+        return _materialize_inputs(args, models, probe_mix)
 
     if args.dry_run:
         run_locales = (
@@ -379,10 +376,10 @@ def run(args: argparse.Namespace) -> int:
         )
         # Resolved before anything is printed so a bad config fails cleanly
         # instead of interleaving with a half-written plan.
-        verify_probe_assets(probe_mix, run_locales, pinned_assets_dir)
+        verify_probe_assets(probe_mix, run_locales, args.assets_dir)
         seed = resolve_toolset_seed_for_mix(
             probe_mix,
-            pinned_assets_dir,
+            args.assets_dir,
             args.toolset_seed_path,
         )
         # Reported, not refused: the offline check a new install runs comes
@@ -403,12 +400,12 @@ def run(args: argparse.Namespace) -> int:
         print(f"  max_assistant_attempts: {args.max_assistant_attempts}")
         print(f"  random_seed:   {args.random_seed}")
         print(f"  models config: {models_path}")
-        if pinned_assets_dir is not None:
+        if args.assets_dir is not None:
             print(f"  assets_dir:    {args.assets_dir}")
         else:
             from usersim.engine.core._assets import asset_search_path
 
-            print(f"  asset path:    {', '.join(str(r) for r in asset_search_path())}")
+            print(f"  asset path:    {', '.join([*map(str, asset_search_path()), _OWN_ASSETS])}")
         print(f"  match_persona_language: {args.match_persona_language}")
         print(f"  toolset_seed_path: {seed or '(not used)'}")
         print(f"  output:        {args.out}")
@@ -430,7 +427,6 @@ def run(args: argparse.Namespace) -> int:
         num_rows=args.num_rows,
         out=args.out,
         assets_dir=args.assets_dir,
-        pinned_assets_dir=pinned_assets_dir,
         match_persona_language=args.match_persona_language,
         toolset_seed_path=args.toolset_seed_path,
         max_turns=args.max_turns,
@@ -471,7 +467,7 @@ def run(args: argparse.Namespace) -> int:
     return status.exit_code or 0
 
 
-def _materialize_inputs(args, models, probe_mix: dict[str, float], pinned_assets_dir) -> int:
+def _materialize_inputs(args, models, probe_mix: dict[str, float]) -> int:
     """CLI adapter for the public no-model-call materialization seam."""
     import json
 
@@ -480,7 +476,7 @@ def _materialize_inputs(args, models, probe_mix: dict[str, float], pinned_assets
     from usersim.cli._pipeline import materialize_episode_inputs
 
     locales = _locales_from_panel(args.panel) if args.panel else list(args.locale or [])
-    verify_probe_assets(probe_mix, locales, pinned_assets_dir)
+    verify_probe_assets(probe_mix, locales, args.assets_dir)
     if (report := persona_dataset_report(locales)) is not None:
         raise ConfigError(report)
     rows = []
@@ -491,7 +487,7 @@ def _materialize_inputs(args, models, probe_mix: dict[str, float], pinned_assets
                 locale=locale,
                 num_rows=count,
                 models=models,
-                assets_dir=Path(args.assets_dir).resolve(),
+                assets_dir=args.assets_dir,
                 probe_mix=probe_mix,
                 random_seed=args.random_seed,
                 toolset_seed_path=args.toolset_seed_path,
@@ -556,7 +552,7 @@ def _run_inputs(args: argparse.Namespace, models, models_path: Path) -> int:
             for key in ("max_turns", "max_assistant_attempts", "random_seed", "store_reasoning")
         )
     )
-    print(f"  assets_dir:    {inputs.assets_dir}")
+    print(f"  assets_dir:    {inputs.assets_dir or _OWN_ASSETS}")
     print(f"  models config: {models_path}")
     print(f"  setup:         {plan.fingerprint[:12]}")
     if plan.matching_run is not None:
@@ -601,7 +597,7 @@ def job() -> int:
         "inputs": str(args.inputs),
         "out": str(args.out),
         "models_path": str(models_path),
-        "assets_dir": str(inputs.assets_dir),
+        "assets_dir": str(inputs.assets_dir) if inputs.assets_dir is not None else None,
         "skip_existing": not args.no_skip_existing,
     }
     handle = backend.submit(JobSpec(name="simulate-inputs", params=params, callable_=job))
@@ -623,7 +619,6 @@ def _simulate_to_parquet(
     num_rows,
     out,
     assets_dir,
-    pinned_assets_dir=None,
     max_turns,
     match_persona_language=False,
     toolset_seed_path=None,
@@ -683,7 +678,7 @@ def _simulate_to_parquet(
     # the exact file used and keeps non-tool runs independent of toolset assets.
     toolset_seed_path = resolve_toolset_seed_for_mix(
         probe_mix,
-        pinned_assets_dir,
+        assets_dir,
         toolset_seed_path,
     )
 
@@ -696,7 +691,7 @@ def _simulate_to_parquet(
 
     # Fail before any model call rather than from inside a loader mid-run.
     # Checked here, where the run executes, since that host holds the datasets.
-    verify_probe_assets(probe_mix, run_locales, pinned_assets_dir)
+    verify_probe_assets(probe_mix, run_locales, assets_dir)
     if (report := persona_dataset_report(run_locales)) is not None:
         raise ConfigError(report)
 
@@ -727,7 +722,7 @@ def _simulate_to_parquet(
         data_designer, builder = build_simulator_config_builder(
             locale=locale,
             models=models,
-            assets_dir=Path(assets_dir).resolve(),
+            assets_dir=assets_dir,
             max_turns=max_turns,
             max_assistant_attempts=max_assistant_attempts,
             store_reasoning=store_reasoning,
@@ -805,7 +800,7 @@ def _simulate_to_parquet(
             tool_calling_themes=DEFAULT_TOOL_CALLING_THEMES,
             toolset_seed_path=toolset_seed_path,
             panel_path=Path(panel) if panel else None,
-            assets_dir=Path(assets_dir).resolve(),
+            assets_dir=Path(assets_dir).resolve() if assets_dir is not None else None,
             trajectories_requested=requested_per_locale,
             persona_language_filters=applied_language_filters,
         )
diff --git a/src/usersim/cli/validate_assets.py b/src/usersim/cli/validate_assets.py
index 506e6fa3..2cd24547 100644
--- a/src/usersim/cli/validate_assets.py
+++ b/src/usersim/cli/validate_assets.py
@@ -15,7 +15,7 @@
 from pathlib import Path
 
 from usersim.asset_gen.registry import domain_names, get_domain
-from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir
+from usersim.engine.core._assets import shipped_assets_dir
 
 
 def register(subparsers: argparse._SubParsersAction) -> None:
@@ -44,7 +44,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
 
 def run(args: argparse.Namespace) -> int:
     dom = get_domain(args.domain)
-    bank_dir = args.dir or (probe_assets_dir(args.domain, assets_root=packaged_assets_dir()) / args.locale)
+    bank_dir = args.dir or (shipped_assets_dir(args.domain) / args.locale)
     spec_path = args.region_spec or (dom.region_spec_dir / f"{args.locale}.yaml")
 
     print(f"usersim validate-assets [{args.domain}] — {args.locale}")
diff --git a/src/usersim/engine/core/_assets.py b/src/usersim/engine/core/_assets.py
index 4c82c964..499a339c 100644
--- a/src/usersim/engine/core/_assets.py
+++ b/src/usersim/engine/core/_assets.py
@@ -1,38 +1,32 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Locate the shipped asset banks.
+"""Locate a probe's asset banks.
 
-The banks are **package data** — they live at
-``usersim/engine/assets/`` and are resolved through
-:mod:`importlib.resources`, so they are found identically whether the
-package is installed editable or from a wheel.
+Each probe keeps its banks in the ``<label>/`` folder of the root its class
+declares as ``assets_root``. A built-in probe declares its folder in this
+package, ``usersim/engine/probes/<folder>/assets/``, read as **package data**
+through :mod:`importlib.resources`, so it is found identically whether the
+package is installed editable or from a wheel. A probe shipped in its own
+package declares a folder inside that package.
 
-Resolution is an ordered **search path**, highest priority first:
+Resolution walks an ordered **search path**, highest priority first:
 
 1. the per-context override set by :func:`set_runtime_assets_dir`;
 2. each entry of ``$USERSIM_ASSET_PATH`` (``os.pathsep``-separated);
 3. ``$USERSIM_ASSETS_DIR``;
-4. the packaged ``usersim/engine/assets/`` directory.
 
-A probe class may also declare ``assets_root``, the root that holds its
-``<label>/`` folder: a probe shipped in its own package does, and so does a
-built-in probe that keeps its banks in its own folder. That root
-is searched for that probe after the first three entries and before the
-packaged directory, so a deliberate override wins over it.
-
-:func:`probe_assets_dir` walks that path and takes the first root that
-actually holds the probe, so a package contributing one probe's banks
-does not have to restate the shipped ones to be usable.
+and then the probe's own root, so a deliberate override wins over it.
+:func:`probe_assets_dir` takes the first root that actually holds the probe,
+so a package contributing one probe's banks does not have to restate the
+others to be usable.
 
 A pinned root -- what ``--assets-dir`` becomes, passed to
 :func:`probe_assets_dir` as ``assets_root`` -- is not part of the search.
 It pins resolution to exactly that directory, for every probe, including
 one whose class declares a root. A user who named a location wants to be
 told when the assets are not there, rather than to be quietly served
-another copy instead. The packaged directory stands for the assets that
-ship with User Sim, so pinning it also reaches a built-in probe whose
-banks are in its own folder.
+another copy instead.
 
 There is deliberately no CWD fallback: resolving against whatever
 directory the process happened to start in makes a broken install look
@@ -69,19 +63,8 @@ def reset_runtime_assets_dir(token: Token[Path | None]) -> None:
     _RUNTIME_ASSETS_DIR.reset(token)
 
 
-def packaged_assets_dir() -> Path:
-    """Return the ``assets/`` directory shipped inside this package.
-
-    Uses :mod:`importlib.resources` so it resolves for both editable and
-    wheel installs. Zip-imported distributions are not supported: the
-    loaders below do ordinary filesystem reads, and the banks have always
-    been read as real files.
-    """
-    return Path(str(resources.files("usersim.engine") / "assets"))
-
-
 #: ``os.pathsep``-separated list of additional asset roots, searched ahead
-#: of the packaged banks.
+#: of each probe's own root.
 ASSET_PATH_ENV_VAR = "USERSIM_ASSET_PATH"
 
 
@@ -105,20 +88,19 @@ def _override_roots() -> list[Path]:
 
 
 def asset_search_path() -> tuple[Path, ...]:
-    """Asset roots in priority order, duplicates removed.
+    """The override roots in priority order, duplicates removed; empty when none is set.
 
-    Always ends with the packaged directory, so the shipped banks remain
+    Each probe's own root comes after these, so a probe's shipped banks stay
     reachable no matter what a deployment prepends.
     """
-    return tuple(dict.fromkeys([*_override_roots(), packaged_assets_dir()]))
+    return tuple(dict.fromkeys(_override_roots()))
 
 
 def declared_assets_roots() -> dict[str, Path]:
     """The ``assets_root`` each registered probe class declares, by label.
 
-    Probes that declare none, such as a built-in whose banks are in the
-    packaged directory, are left out. Reads the registry as it stands, so a
-    probe counts once its module is imported.
+    Probes that declare none are left out. Reads the registry as it stands, so
+    a probe counts once its module is imported.
     """
     return {
         label: Path(cls.assets_root)
@@ -128,7 +110,12 @@ def declared_assets_roots() -> dict[str, Path]:
 
 
 def _builtin_probes_dir() -> Path:
-    """``usersim/engine/probes/``, which holds the built-in probe packages."""
+    """``usersim/engine/probes/``, which holds the built-in probe packages.
+
+    Uses :mod:`importlib.resources` so it resolves for both editable and
+    wheel installs. Zip-imported distributions are not supported: the
+    loaders do ordinary filesystem reads.
+    """
     return Path(str(resources.files("usersim.engine") / "probes"))
 
 
@@ -163,12 +150,10 @@ def _declared_root(probe: str) -> Path | None:
 def probe_asset_roots(probe: str) -> tuple[Path, ...]:
     """The roots searched for ``probe``'s assets, highest priority first.
 
-    The search path, with the root ``probe``'s class declares placed just
-    ahead of the packaged directory.
+    The search path, then the root ``probe``'s class declares.
     """
     declared = _declared_root(probe)
-    roots = [*_override_roots(), *([declared] if declared is not None else []), packaged_assets_dir()]
-    return tuple(dict.fromkeys(roots))
+    return tuple(dict.fromkeys([*_override_roots(), *([declared] if declared is not None else [])]))
 
 
 def asset_roots_in_use() -> tuple[Path, ...]:
@@ -180,16 +165,18 @@ def asset_roots_in_use() -> tuple[Path, ...]:
     return tuple(dict.fromkeys([*asset_search_path(), *declared_assets_roots().values()]))
 
 
-def default_assets_dir() -> Path:
-    """Return the highest-priority asset root.
+def shipped_assets_dir(probe: str) -> Path:
+    """``probe``'s own asset folder, under the root its class declares, whatever the search path holds.
+
+    For a built-in probe, its folder in this package. For the commands that write
+    or check the bank a probe ships, which an override must not redirect.
 
-    For the callers that need a single serializable directory -- the
-    generator config and the run manifest -- rather than a path to search.
-    Per-loader env overrides (``USERSIM_<PROBE>_BANK`` and friends) take
-    precedence at the loader level, so a deployment can redirect a single
-    bank without redirecting the whole tree.
+    Raises ``LookupError`` for a probe that declares no root.
     """
-    return asset_search_path()[0]
+    declared = _declared_root(probe)
+    if declared is None:
+        raise LookupError(f"{probe!r} declares no assets_root, so it has no assets of its own")
+    return declared / probe
 
 
 def probe_assets_dir(
@@ -206,8 +193,8 @@ def probe_assets_dir(
     instead of hard-coding the directory name as a string literal,
     so a probe rename / asset-folder rename is a single-edit
     operation. ``test_assets_discovery.py`` checks that every
-    registered probe resolves to a folder and that every packaged
-    folder belongs to a registered probe.
+    registered probe resolves to a folder and that every built-in
+    probe's folder belongs to a registered probe.
 
     Args:
         probe: A probe label. Its class's ``assets_root``, when declared,
@@ -217,14 +204,12 @@ def probe_assets_dir(
         assets_root: Pin resolution to exactly this directory, skipping
             the search path. This is what ``--assets-dir`` becomes: a
             user who named a location is told when the assets are not
-            there rather than quietly served the packaged copies.
-            Pinning the packaged directory reaches every bank that ships
-            with User Sim, a built-in kept in its own folder included.
+            there rather than quietly served another copy.
             When ``None``, :func:`probe_asset_roots` is walked and the
             first root holding ``probe`` wins.
     """
     if assets_root is not None:
-        return _pinned_probe_dir(probe, Path(assets_root))
+        return Path(assets_root) / probe
 
     roots = probe_asset_roots(probe)
     for root in roots:
@@ -232,25 +217,12 @@ def probe_assets_dir(
         if candidate.is_dir():
             return candidate
     # Nothing matched. Report where a user would most expect it to have
-    # been: the root the probe declares, else the highest-priority root.
-    declared = _declared_root(probe)
-    return (declared if declared is not None else roots[0]) / probe
-
-
-def _pinned_probe_dir(probe: str, root: Path) -> Path:
-    """``probe``'s folder under the pinned ``root``.
-
-    The packaged directory stands for the assets that ship with User Sim, so
-    for a probe it does not hold, pinning it reaches the root the probe's class
-    declares when that root is inside this package. An extension's root is
-    outside it, so the pin stays strict for an extension.
-    """
-    folder = root / probe
-    packaged = packaged_assets_dir().resolve()
-    if folder.is_dir() or root.resolve() != packaged:
-        return folder
+    # been: the root the probe declares, else the highest-priority root,
+    # else where a built-in probe keeps its banks. Never a relative path,
+    # which would resolve against the working directory.
     declared = _declared_root(probe)
-    # ``packaged`` is ``usersim/engine/assets/``, so ``parents[1]`` is the package.
-    if declared is not None and declared.resolve().is_relative_to(packaged.parents[1]):
+    if declared is not None:
         return declared / probe
-    return folder
+    if roots:
+        return roots[0] / probe
+    return _builtin_probes_dir() / probe / "assets" / probe
diff --git a/src/usersim/engine/core/probes.py b/src/usersim/engine/core/probes.py
index b6388b03..656e2e0b 100644
--- a/src/usersim/engine/core/probes.py
+++ b/src/usersim/engine/core/probes.py
@@ -293,13 +293,12 @@ def get_assistant_system_prompt(self) -> str:
     # 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 are outside the packaged banks, in its own package or
-    # its own folder: an absolute path, such as ``Path(__file__).parent /
-    # "assets"`` (``@register_probe`` refuses a relative one). Searched after
-    # the deliberate overrides (the runtime override, ``USERSIM_ASSET_PATH``
-    # and ``USERSIM_ASSETS_DIR``) and before the packaged banks. ``None``
-    # searches the overrides and the packaged banks only.
+    # The directory that holds this probe's ``<label>/`` asset folder, in its own
+    # package or, for a built-in, its own folder: an absolute path, such as
+    # ``Path(__file__).parent / "assets"`` (``@register_probe`` refuses a
+    # relative one). Searched after the deliberate overrides (the runtime
+    # override, ``USERSIM_ASSET_PATH`` and ``USERSIM_ASSETS_DIR``). ``None``
+    # searches the overrides only.
     assets_root: Path | None = None
 
     @classmethod
@@ -307,9 +306,9 @@ def assets_dir(cls) -> Path:
         """This probe's asset folder, ``<root>/<label>/``, where its bank loader reads.
 
         Resolved as every bank loader in this package resolves its folder: the
-        deliberate overrides first, then the class's ``assets_root``, then the
-        packaged banks. A probe shipped in its own package calls this from its
-        loader, so an override reaches its banks too.
+        deliberate overrides first, then the class's ``assets_root``. A probe
+        shipped in its own package calls this from its loader, so an override
+        reaches its banks too.
         """
         # _assets imports this module at its top, so importing it here at the
         # top would be circular.
@@ -1553,7 +1552,7 @@ def decorator(cls: type[BaseProbe]) -> type[BaseProbe]:
     "usersim.engine.probes.sov_ai_dynamic.probe",
     "usersim.engine.probes.sov_ai_facts.probe",
     "usersim.engine.probes.sov_ai_multilingual_parity.probe",
-    "usersim.engine.probes.tool_calling.generator",
+    "usersim.engine.probes.tool_calling.probe",
 )
 
 
diff --git a/src/usersim/engine/external.py b/src/usersim/engine/external.py
index 0743544a..344f2157 100644
--- a/src/usersim/engine/external.py
+++ b/src/usersim/engine/external.py
@@ -75,13 +75,12 @@ def materialize_episode_inputs(
     """
     from usersim.cli._models import default_models_path, load_models_config
     from usersim.cli._pipeline import materialize_episode_inputs as _materialize
-    from usersim.engine.core._assets import default_assets_dir
 
     return _materialize(
         locale=locale,
         num_rows=num_rows,
         models=load_models_config(models_path or default_models_path()),
-        assets_dir=(assets_dir or default_assets_dir()).resolve(),
+        assets_dir=assets_dir.resolve() if assets_dir is not None else None,
         probe_mix=probe_mix,
         random_seed=random_seed,
         toolset_seed_path=toolset_seed_path,
diff --git a/src/usersim/engine/probes/safety_agentic/bank.py b/src/usersim/engine/probes/safety_agentic/bank.py
index e58349b8..4dc529c2 100644
--- a/src/usersim/engine/probes/safety_agentic/bank.py
+++ b/src/usersim/engine/probes/safety_agentic/bank.py
@@ -211,7 +211,7 @@ def _persona_tags_match(
 
 def _default_action_taxonomy_path() -> Path:
     """Discover the shipped ``assets/safety_agentic/action_taxonomy.yaml``
-    from the packaged asset tree. Resolution is independent of CWD; set
+    in the probe's own assets. Resolution is independent of CWD; set
     ``USERSIM_SAFETY_AGENTIC_ACTION_TAXONOMY`` to override."""
     from usersim.engine.core._assets import probe_assets_dir
 
diff --git a/src/usersim/engine/assets/tool_calling/README.md b/src/usersim/engine/probes/tool_calling/assets/tool_calling/README.md
similarity index 98%
rename from src/usersim/engine/assets/tool_calling/README.md
rename to src/usersim/engine/probes/tool_calling/assets/tool_calling/README.md
index 334986ee..643eb500 100644
--- a/src/usersim/engine/assets/tool_calling/README.md
+++ b/src/usersim/engine/probes/tool_calling/assets/tool_calling/README.md
@@ -111,11 +111,11 @@ toolsets_seed.parquet ── sample a toolset ──▶ assistant_model (model u
 ```
 
 - One toolset is sampled per conversation (`toolset_name` / `tools` columns are
-  threaded into the simulator by [`cli/_pipeline.py`](../../../cli/_pipeline.py)).
+  threaded into the simulator by [`cli/_pipeline.py`](../../../../../cli/_pipeline.py)).
 - The assistant sees the toolset's tools as OpenAI-style function specs and
   decides whether/which to call.
 - There is **no real execution**: the `api_response_model` alias (see
-  [`cli/models_default.toml`](../../../cli/models_default.toml)) synthesizes the
+  [`cli/models_default.toml`](../../../../../cli/models_default.toml)) synthesizes the
   tool's response from the schema, so a run needs no live service.
 - Conversation themes (some tool-expected, some not) come from
   `DEFAULT_TOOL_CALLING_THEMES` in `cli/_pipeline.py`, exercising the
@@ -197,7 +197,7 @@ Abridged to two of its 11 parameters; the wording is the upstream text.
 
 ```python
 import pandas as pd
-df = pd.read_parquet("assets/tool_calling/toolsets_seed.parquet")
+df = pd.read_parquet("src/usersim/engine/probes/tool_calling/assets/tool_calling/toolsets_seed.parquet")
 
 # tools per source
 df.groupby("toolset_source")["num_tools"].agg(["count", "sum"])
@@ -209,12 +209,12 @@ json.loads(df.iloc[0]["tools"])
 
 ## Related
 
-- Probe implementation: [`src/usersim/engine/probes/tool_calling/generator.py`](../../probes/tool_calling/generator.py)
-- Scorer: [`src/usersim/engine/evaluator/scorers/tool_use.py`](../../evaluator/scorers/tool_use.py)
+- Probe implementation: [`src/usersim/engine/probes/tool_calling/probe.py`](../../probe.py)
+- Scorer: [`src/usersim/engine/evaluator/scorers/tool_use.py`](../../../../evaluator/scorers/tool_use.py)
 - Turn-1 / probing prompts: [`prompts.yaml`](prompts.yaml)
 - The **agentic** safety surface uses a *different*, hand-authored mock-tool
   mechanism (per-action tool specs + canned responses) documented in
-  [`probes/safety_agentic/assets/safety_agentic/SCHEMA.md`](../../probes/safety_agentic/assets/safety_agentic/SCHEMA.md).
+  [`probes/safety_agentic/assets/safety_agentic/SCHEMA.md`](../../../safety_agentic/assets/safety_agentic/SCHEMA.md).
 
 ## Sources and licenses
 
diff --git a/src/usersim/engine/assets/tool_calling/prompts.yaml b/src/usersim/engine/probes/tool_calling/assets/tool_calling/prompts.yaml
similarity index 100%
rename from src/usersim/engine/assets/tool_calling/prompts.yaml
rename to src/usersim/engine/probes/tool_calling/assets/tool_calling/prompts.yaml
diff --git a/src/usersim/engine/assets/tool_calling/toolsets_seed.parquet b/src/usersim/engine/probes/tool_calling/assets/tool_calling/toolsets_seed.parquet
similarity index 100%
rename from src/usersim/engine/assets/tool_calling/toolsets_seed.parquet
rename to src/usersim/engine/probes/tool_calling/assets/tool_calling/toolsets_seed.parquet
diff --git a/src/usersim/engine/probes/tool_calling/generator.py b/src/usersim/engine/probes/tool_calling/probe.py
similarity index 99%
rename from src/usersim/engine/probes/tool_calling/generator.py
rename to src/usersim/engine/probes/tool_calling/probe.py
index 8bc47abe..561950df 100644
--- a/src/usersim/engine/probes/tool_calling/generator.py
+++ b/src/usersim/engine/probes/tool_calling/probe.py
@@ -23,6 +23,7 @@
 import json
 import logging
 import random
+from pathlib import Path
 from typing import Any
 
 from usersim.engine.core.behavioral import (
@@ -242,6 +243,7 @@ class ToolCallingProbe(ToolExecutionMixin, ToolCallingMixin, BaseProbe):
     """
 
     label = "tool_calling"
+    assets_root = Path(__file__).parent / "assets"
     description = (
         "Tests the assistant's ability to invoke tools correctly in response to user "
         "requests, including argument shaping, schema validation, and recovery from "
diff --git a/templates/probe/generator_tool_calling.py b/templates/probe/generator_tool_calling.py
index 8054b834..f74ffa33 100644
--- a/templates/probe/generator_tool_calling.py
+++ b/templates/probe/generator_tool_calling.py
@@ -65,7 +65,7 @@ def __init__(self, **kwargs: Any) -> None:
         if not getattr(cfg, "tools_column", None):
             raise ValueError("demo_tool_calling: cfg.tools_column not configured")
         # Real probe: parse self._data[cfg.tools_column], validate,
-        # sample subset. See tool_calling/generator.py for the
+        # sample subset. See tool_calling/probe.py for the
         # canonical tool-sampling logic.
         self._tools: list[dict] = []  # populated from row
 
diff --git a/tests/conftest.py b/tests/conftest.py
index e6d668e5..00b3f51c 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -443,3 +443,43 @@ def run(repo: Path, *args: str) -> str:
         return done.stdout.strip()
 
     return run
+
+
+@pytest.fixture
+def sample_tools():
+    return [
+        {
+            "tool": {
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get current weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"},
+                            "units": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }
+        },
+        {
+            "tool": {
+                "type": "function",
+                "function": {
+                    "name": "search_recipes",
+                    "description": "Search for recipes by ingredient",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "ingredient": {"type": "string"},
+                            "cuisine": {"type": "string"},
+                        },
+                        "required": ["ingredient"],
+                    },
+                },
+            }
+        },
+    ]
diff --git a/tests/engine/conftest.py b/tests/engine/conftest.py
index bac64fc2..2f9e3303 100644
--- a/tests/engine/conftest.py
+++ b/tests/engine/conftest.py
@@ -71,43 +71,3 @@ def minimal_persona():
         "agreeableness": 0.8,
         "neuroticism": 0.5,
     }
-
-
-@pytest.fixture
-def sample_tools():
-    return [
-        {
-            "tool": {
-                "type": "function",
-                "function": {
-                    "name": "get_weather",
-                    "description": "Get current weather for a location",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "location": {"type": "string", "description": "City name"},
-                            "units": {"type": "string", "enum": ["celsius", "fahrenheit"]},
-                        },
-                        "required": ["location"],
-                    },
-                },
-            }
-        },
-        {
-            "tool": {
-                "type": "function",
-                "function": {
-                    "name": "search_recipes",
-                    "description": "Search for recipes by ingredient",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "ingredient": {"type": "string"},
-                            "cuisine": {"type": "string"},
-                        },
-                        "required": ["ingredient"],
-                    },
-                },
-            }
-        },
-    ]
diff --git a/tests/engine/core/test_assets_discovery.py b/tests/engine/core/test_assets_discovery.py
index 00756628..3e44494f 100644
--- a/tests/engine/core/test_assets_discovery.py
+++ b/tests/engine/core/test_assets_discovery.py
@@ -1,11 +1,12 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Tests for ``usersim.engine.core._assets`` — resolution of the
-packaged asset banks.
+"""Tests for ``usersim.engine.core._assets`` — resolution of each probe's
+asset banks.
 
-The banks are package data under ``usersim/engine/assets/``, resolved
-through :mod:`importlib.resources`.
+A built-in probe's banks are package data in its own folder, under
+``usersim/engine/probes/<folder>/assets/``, resolved through
+:mod:`importlib.resources`.
 
 The invariants here fall into two groups: that resolution works and honours
 its overrides and a probe's declared ``assets_root``, and that the probe
@@ -28,65 +29,72 @@
 from usersim.engine.core._assets import (
     asset_roots_in_use,
     asset_search_path,
-    default_assets_dir,
-    packaged_assets_dir,
     probe_asset_roots,
     probe_assets_dir,
     reset_runtime_assets_dir,
     set_runtime_assets_dir,
 )
+from usersim.engine.core.probes import resolve_probe
 
 
-class TestPackagedResolution:
+class TestOwnFolderResolution:
     def test_resolves_inside_the_package(self) -> None:
-        path = packaged_assets_dir()
+        path = probe_assets_dir("sov_ai_facts")
         assert path.is_dir(), f"{path} is not a directory"
-        assert path.parent.name == "engine", f"assets must be package data, resolved {path}"
+        assert path.is_relative_to(Path(usersim.__file__).parent / "engine" / "probes"), path
 
     def test_independent_of_cwd(self, tmp_path: Path, monkeypatch) -> None:
         """Resolution must not depend on where the process was started."""
-        baseline = default_assets_dir()
+        baseline = probe_assets_dir("sov_ai_facts")
         monkeypatch.chdir(tmp_path)
-        assert default_assets_dir() == baseline
+        assert probe_assets_dir("sov_ai_facts") == baseline
 
     def test_no_cwd_fallback_even_with_a_decoy(self, tmp_path: Path, monkeypatch) -> None:
-        """A directory named ``assets`` in the CWD must not be picked up."""
-        decoy = tmp_path / "assets"
-        (decoy / "sov_ai_facts").mkdir(parents=True)
+        """A directory named after the probe in the CWD must not be picked up."""
+        (tmp_path / "sov_ai_facts").mkdir()
         monkeypatch.chdir(tmp_path)
-        assert default_assets_dir() != decoy
-        assert default_assets_dir() == packaged_assets_dir()
+        assert probe_assets_dir("sov_ai_facts") == resolve_probe("sov_ai_facts").assets_root / "sov_ai_facts"
+        assert probe_assets_dir("no_such_probe").is_absolute()
+
+    def test_the_package_ships_no_shared_assets_folder(self) -> None:
+        """Every probe reads its own folder, so banks placed in a shared folder would reach no probe."""
+        assert not (Path(usersim.__file__).parent / "engine" / "assets").exists()
 
 
 class TestOverrides:
+    def test_no_override_leaves_the_search_path_empty(self, monkeypatch) -> None:
+        monkeypatch.delenv("USERSIM_ASSET_PATH", raising=False)
+        monkeypatch.delenv("USERSIM_ASSETS_DIR", raising=False)
+        assert asset_search_path() == ()
+
     def test_env_var_takes_precedence(self, tmp_path: Path, monkeypatch) -> None:
         monkeypatch.setenv("USERSIM_ASSETS_DIR", str(tmp_path))
-        assert default_assets_dir() == tmp_path
+        assert asset_search_path()[0] == tmp_path
 
     def test_runtime_context_beats_env(self, tmp_path: Path, monkeypatch) -> None:
         monkeypatch.setenv("USERSIM_ASSETS_DIR", str(tmp_path / "env"))
         ctx = tmp_path / "ctx"
         token = set_runtime_assets_dir(ctx)
         try:
-            assert default_assets_dir() == ctx
+            assert asset_search_path()[0] == ctx
         finally:
             reset_runtime_assets_dir(token)
-        assert default_assets_dir() == tmp_path / "env"
+        assert asset_search_path()[0] == tmp_path / "env"
 
     def test_runtime_override_is_restored(self, tmp_path: Path) -> None:
-        baseline = default_assets_dir()
+        baseline = asset_search_path()
         token = set_runtime_assets_dir(tmp_path)
         reset_runtime_assets_dir(token)
-        assert default_assets_dir() == baseline
+        assert asset_search_path() == baseline
 
     def test_explicit_root_wins_in_probe_assets_dir(self, tmp_path: Path) -> None:
         assert probe_assets_dir("sov_ai_facts", assets_root=tmp_path) == (tmp_path / "sov_ai_facts")
 
 
 class TestRegistryAndLayoutInvariants:
-    """Every registered probe resolves to an asset folder, and every packaged
-    folder belongs to a registered probe. Importing the generator triggers the
-    probe bootstrap that populates the registry."""
+    """Every registered probe resolves to an asset folder, and every built-in
+    probe's folder belongs to a registered probe. Importing the generator
+    triggers the probe bootstrap that populates the registry."""
 
     @staticmethod
     def _labels() -> set[str]:
@@ -102,7 +110,7 @@ def test_every_registered_probe_resolves_to_a_folder(self) -> None:
         assert not unresolved, f"registered probes without an asset folder: {unresolved}"
 
     def test_every_built_in_probe_ships_its_folder_in_the_package(self) -> None:
-        """In the packaged banks or in the probe's own folder, so a plain install has it."""
+        """In the probe's own folder in the package, so a plain install has it."""
         package = Path(usersim.__file__).parent
         outside = {
             label: probe_assets_dir(label)
@@ -116,8 +124,6 @@ def test_a_built_in_that_declares_a_root_keeps_it_in_its_own_folder(self) -> Non
 
         The folder is named after the probe, or holds several probes that share it.
         """
-        from usersim.engine.core.probes import resolve_probe
-
         declared = {label: resolve_probe(label) for label in self._labels() if resolve_probe(label).assets_root}
         assert declared, "no built-in probe declares an assets_root"
         folders = {label: Path(sys.modules[cls.__module__].__file__).parent for label, cls in declared.items()}
@@ -129,29 +135,14 @@ def test_a_built_in_that_declares_a_root_keeps_it_in_its_own_folder(self) -> Non
             assert Path(cls.assets_root) == folder / "assets", label
             assert (folder / "assets" / label).is_dir(), label
 
-    def test_packaged_tree_has_no_stray_top_level_entries(self) -> None:
-        """Everything shipped under assets/ should be a probe folder. Catches
-        a doc image or scratch file riding into the wheel, and a folder left
-        behind by a renamed probe."""
-        labels = self._labels()
-        stray = [
-            p.name for p in packaged_assets_dir().iterdir() if p.name not in labels and not p.name.startswith("__")
-        ]
-        assert not stray, f"unexpected entries in packaged assets/: {stray}"
-
 
 class TestAssetSearchPath:
     """Assets resolve along an ordered path, so a package can contribute one
     probe's banks without restating the shipped ones."""
 
-    def test_packaged_root_is_always_last(self, monkeypatch, tmp_path) -> None:
-        from usersim.engine.core._assets import (
-            asset_search_path,
-            packaged_assets_dir,
-        )
-
+    def test_a_probe_s_own_root_comes_after_the_search_path(self, monkeypatch, tmp_path) -> None:
         monkeypatch.setenv("USERSIM_ASSET_PATH", str(tmp_path))
-        assert asset_search_path()[-1] == packaged_assets_dir()
+        assert probe_asset_roots("sov_ai_facts") == (tmp_path, resolve_probe("sov_ai_facts").assets_root)
 
     def test_entries_are_searched_in_order(self, monkeypatch, tmp_path) -> None:
         from usersim.engine.core._assets import asset_search_path
@@ -187,19 +178,14 @@ def test_contributed_root_wins_for_the_probe_it_has(
 
     def test_shipped_banks_stay_reachable(self, monkeypatch, tmp_path) -> None:
         """Prepending a root must not hide the probes it does not carry."""
-        from usersim.engine.core._assets import (
-            packaged_assets_dir,
-            probe_assets_dir,
-        )
-
         contributed = tmp_path / "extra"
         (contributed / "financial_services").mkdir(parents=True)
         monkeypatch.setenv("USERSIM_ASSET_PATH", str(contributed))
-        assert probe_assets_dir("tool_calling").parent == packaged_assets_dir()
+        assert probe_assets_dir("tool_calling").parent == resolve_probe("tool_calling").assets_root
 
     def test_explicit_root_is_pinned_not_searched(self, tmp_path) -> None:
         """A user who named a directory is told when assets are absent
-        rather than quietly served the packaged copies."""
+        rather than quietly served the probe's own copies."""
         from usersim.engine.core._assets import probe_assets_dir
 
         resolved = probe_assets_dir("tool_calling", assets_root=tmp_path)
@@ -227,14 +213,12 @@ def test_a_declared_root_serves_its_probe(self, register_test_probe, tmp_path) -
 
         assert probe_assets_dir("ext_probe") == tmp_path / "ext_probe"
 
-    def test_it_is_searched_after_the_overrides_and_before_the_packaged_banks(
-        self, register_test_probe, monkeypatch, tmp_path
-    ) -> None:
+    def test_it_is_searched_after_the_overrides(self, register_test_probe, monkeypatch, tmp_path) -> None:
         override = tmp_path / "override"
         monkeypatch.setenv("USERSIM_ASSET_PATH", str(override))
         register_test_probe("ext_probe", assets_root=tmp_path / "declared")
 
-        assert probe_asset_roots("ext_probe") == (override, tmp_path / "declared", packaged_assets_dir())
+        assert probe_asset_roots("ext_probe") == (override, tmp_path / "declared")
 
     def test_a_deliberate_override_wins_over_the_declared_root(
         self, register_test_probe, monkeypatch, tmp_path
@@ -266,7 +250,7 @@ def test_a_declared_root_serves_only_its_own_probe(self, register_test_probe, tm
         (tmp_path / "tool_calling").mkdir()
         register_test_probe("ext_probe", assets_root=tmp_path)
 
-        assert probe_assets_dir("tool_calling") == packaged_assets_dir() / "tool_calling"
+        assert probe_assets_dir("tool_calling") == resolve_probe("tool_calling").assets_root / "tool_calling"
 
     def test_roots_in_use_add_declared_roots_after_the_search_path(self, register_test_probe, tmp_path) -> None:
         register_test_probe("ext_probe", assets_root=tmp_path)
@@ -279,10 +263,10 @@ def test_roots_in_use_add_declared_roots_after_the_search_path(self, register_te
 class TestProbeAssetsDir:
     """``BaseProbe.assets_dir()`` is the folder a probe's own bank loader reads."""
 
-    def test_a_built_in_probe_reads_its_packaged_folder(self) -> None:
-        from usersim.engine.core.probes import resolve_probe
+    def test_a_built_in_probe_reads_its_own_folder(self) -> None:
+        probe = resolve_probe("tool_calling")
 
-        assert resolve_probe("tool_calling").assets_dir() == packaged_assets_dir() / "tool_calling"
+        assert probe.assets_dir() == probe.assets_root / "tool_calling"
 
     def test_a_probe_reads_the_folder_under_its_declared_root(self, register_test_probe, tmp_path) -> None:
         (tmp_path / "ext_probe").mkdir()
@@ -300,40 +284,11 @@ def test_a_deliberate_override_reaches_the_probe(self, register_test_probe, monk
         assert probe.assets_dir() == override / "ext_probe"
 
 
-class TestPinnedPackagedRoot:
-    """Pinning the packaged directory pins the assets that ship with User Sim."""
-
-    @staticmethod
-    def _package(monkeypatch, tmp_path: Path) -> Path:
-        """A stand-in ``usersim`` package whose packaged banks are at ``engine/assets/``."""
-        import usersim.engine.core._assets as assets
-
-        package = tmp_path / "usersim"
-        (package / "engine" / "assets").mkdir(parents=True)
-        monkeypatch.setattr(assets, "packaged_assets_dir", lambda: package / "engine" / "assets")
-        return package
-
-    def test_it_reaches_a_probe_whose_banks_are_in_its_own_folder_in_the_package(
-        self, register_test_probe, monkeypatch, tmp_path
-    ) -> None:
-        package = self._package(monkeypatch, tmp_path)
-        own = package / "engine" / "probes" / "ext_probe" / "assets"
-        (own / "ext_probe").mkdir(parents=True)
-        register_test_probe("ext_probe", assets_root=own)
-
-        assert probe_assets_dir("ext_probe", assets_root=package / "engine" / "assets") == own / "ext_probe"
-
-    def test_it_stays_strict_for_a_root_outside_the_package(self, register_test_probe, monkeypatch, tmp_path) -> None:
-        package = self._package(monkeypatch, tmp_path)
-        (tmp_path / "extension" / "ext_probe").mkdir(parents=True)
-        register_test_probe("ext_probe", assets_root=tmp_path / "extension")
-
-        pinned = package / "engine" / "assets"
-        assert probe_assets_dir("ext_probe", assets_root=pinned) == pinned / "ext_probe"
+class TestPinnedRoot:
+    """A pinned root is strict for every probe, one that declares its own root included."""
 
-    def test_any_other_pinned_root_stays_strict(self, register_test_probe, monkeypatch, tmp_path) -> None:
-        package = self._package(monkeypatch, tmp_path)
-        own = package / "engine" / "probes" / "ext_probe" / "assets"
+    def test_a_probe_that_declares_a_root_is_read_from_the_pinned_one(self, register_test_probe, tmp_path) -> None:
+        own = tmp_path / "own"
         (own / "ext_probe").mkdir(parents=True)
         register_test_probe("ext_probe", assets_root=own)
 
diff --git a/tests/engine/core/test_default_asset_paths.py b/tests/engine/core/test_default_asset_paths.py
index 7ff10971..a62bf7b1 100644
--- a/tests/engine/core/test_default_asset_paths.py
+++ b/tests/engine/core/test_default_asset_paths.py
@@ -9,7 +9,7 @@
 ``core/probing_taxonomy.py`` returned ``assets/sov_ai_dynamic/<locale>/categories.yaml``
 while the on-disk directory was still ``assets/population_probing/``.
 The per-loader unit-test files all bypass ``default_*_path()`` — they
-either write tmp_path fixtures or hardcode ``(packaged_assets_dir() / "...")``
+either write tmp_path fixtures or hardcode ``(probe_assets_dir(probe) / "...")``
 strings — so a default-path constant could point at ``/nonexistent``
 and every per-loader suite would still be green.
 
diff --git a/tests/engine/core/test_provenance.py b/tests/engine/core/test_provenance.py
index d320a452..000950ec 100644
--- a/tests/engine/core/test_provenance.py
+++ b/tests/engine/core/test_provenance.py
@@ -164,7 +164,7 @@ def test_env_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
     [
         "usersim.engine.probes.general_open_ended.probe",
         "usersim.engine.probes.general_educational.probe",
-        "usersim.engine.probes.tool_calling.generator",
+        "usersim.engine.probes.tool_calling.probe",
     ],
 )
 class TestProbeMetadata:
diff --git a/tests/engine/test_generator_row_scope.py b/tests/engine/test_generator_row_scope.py
index 1eee06c2..7d83c734 100644
--- a/tests/engine/test_generator_row_scope.py
+++ b/tests/engine/test_generator_row_scope.py
@@ -13,7 +13,7 @@
 import pytest
 
 from usersim.engine.config import ConversationSimulatorConfig
-from usersim.engine.core._assets import default_assets_dir
+from usersim.engine.core._assets import asset_search_path
 from usersim.engine.generator import ConversationSimulatorGenerator
 
 
@@ -32,13 +32,13 @@ class TestRuntimeAssetsRoot:
     """The per-row asset root must not outlive the row that set it."""
 
     async def test_restored_after_a_row_fails(self, tmp_path: Path) -> None:
-        baseline = default_assets_dir()
+        baseline = asset_search_path()
         gen = _generator_without_resources(ConversationSimulatorConfig(name="conversation", assets_dir=str(tmp_path)))
 
         with pytest.raises(Exception):
             await gen.agenerate({})
 
-        assert default_assets_dir() == baseline, (
+        assert asset_search_path() == baseline, (
             "the row's asset root is still installed, so banks for whatever "
             "runs next resolve against it instead of the configured root"
         )
@@ -129,7 +129,9 @@ async def test_the_row_does_see_its_own_root(self, tmp_path: Path) -> None:
         """Guards the test above: it must fail for the right reason."""
         seen: list[Path] = []
         gen = _generator_without_resources(ConversationSimulatorConfig(name="conversation", assets_dir=str(tmp_path)))
-        gen.get_model = lambda *a, **k: seen.append(default_assets_dir()) or (_ for _ in ()).throw(RuntimeError("stop"))
+        gen.get_model = lambda *a, **k: seen.append(asset_search_path()[0]) or (_ for _ in ()).throw(
+            RuntimeError("stop")
+        )
 
         with pytest.raises(Exception):
             await gen.agenerate({})
diff --git a/tests/fixtures/extension_package/verify_seams.py b/tests/fixtures/extension_package/verify_seams.py
index c4da175d..e7731a02 100644
--- a/tests/fixtures/extension_package/verify_seams.py
+++ b/tests/fixtures/extension_package/verify_seams.py
@@ -130,9 +130,8 @@ def preflight_refusal(locales: list[str]) -> str:
 # A contributed probe's themes come from its installed assets, read as a run
 # reads them, with the run's asset root installed.
 from usersim.cli._pipeline import _probe_themes  # noqa: E402
-from usersim.engine.core._assets import default_assets_dir  # noqa: E402
 
-themes = _probe_themes("fixture_probe", "en_US", default_assets_dir())
+themes = _probe_themes("fixture_probe", "en_US", None)
 check(
     "themes come from the contributed assets",
     themes == ['{"type": "fixture topic", "description": "A topic every fixture row draws."}'],
diff --git a/tests/probes/tool_calling/__init__.py b/tests/probes/tool_calling/__init__.py
new file mode 100644
index 00000000..52a7a9da
--- /dev/null
+++ b/tests/probes/tool_calling/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/engine/probes/test_tool_catalog.py b/tests/probes/tool_calling/test_catalog.py
similarity index 99%
rename from tests/engine/probes/test_tool_catalog.py
rename to tests/probes/tool_calling/test_catalog.py
index c59a08ab..98bc57b0 100644
--- a/tests/engine/probes/test_tool_catalog.py
+++ b/tests/probes/tool_calling/test_catalog.py
@@ -19,7 +19,7 @@
 from jsonschema.exceptions import SchemaError
 
 from usersim.engine.core.missing import is_missing
-from usersim.engine.probes.tool_calling.generator import ToolCallingProbe
+from usersim.engine.probes.tool_calling.probe import ToolCallingProbe
 
 JSON_SCHEMA_TYPES = frozenset({"string", "number", "integer", "boolean", "array", "object", "null"})
 _FUNCTION_NAME = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
diff --git a/tests/engine/probes/test_tool_calling.py b/tests/probes/tool_calling/test_probe.py
similarity index 98%
rename from tests/engine/probes/test_tool_calling.py
rename to tests/probes/tool_calling/test_probe.py
index 4cda404e..1d7ff993 100644
--- a/tests/engine/probes/test_tool_calling.py
+++ b/tests/probes/tool_calling/test_probe.py
@@ -16,7 +16,7 @@
 from usersim.engine.core.llm import ContextWindowError
 from usersim.engine.core.outcomes import OutcomeBuilder, Provenance
 from usersim.engine.core.simulation import ConversationLoop
-from usersim.engine.probes.tool_calling.generator import (
+from usersim.engine.probes.tool_calling.probe import (
     ToolCallingProbe,
     _build_tool_context,
     _find_tool_spec,
@@ -115,7 +115,7 @@ async def fake_call_llm(models, alias, messages):
         from unittest.mock import patch
 
         with patch(
-            "usersim.engine.probes.tool_calling.generator.acall_llm",
+            "usersim.engine.probes.tool_calling.probe.acall_llm",
             side_effect=fake_call_llm,
         ):
             content, rerolled = await _simulate_tool_response(
@@ -233,7 +233,7 @@ async def fake_call_llm(models, alias, messages, **kwargs):
         "usersim.engine.core.simulation.acall_llm",
         "usersim.engine.core.judges.acall_llm",
         "usersim.engine.core.llm.acall_llm",
-        "usersim.engine.probes.tool_calling.generator.acall_llm",
+        "usersim.engine.probes.tool_calling.probe.acall_llm",
     )
     with ExitStack() as stack:
         for target in targets:
diff --git a/tests/engine/probes/test_verifiers.py b/tests/probes/tool_calling/test_verifiers.py
similarity index 100%
rename from tests/engine/probes/test_verifiers.py
rename to tests/probes/tool_calling/test_verifiers.py
diff --git a/tests/test_check_dist.py b/tests/test_check_dist.py
index cb72d69d..336431db 100644
--- a/tests/test_check_dist.py
+++ b/tests/test_check_dist.py
@@ -18,7 +18,7 @@
 check_dist = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(check_dist)
 
-_PACKAGE = ["usersim/__init__.py", "usersim/engine/assets/probe/bank.yaml"]
+_PACKAGE = ["usersim/__init__.py", "usersim/engine/probes/probe/assets/probe/bank.yaml"]
 
 
 def _sdist(path: Path, files: list[str], root: str = "usersim-1.0") -> Path:
@@ -54,13 +54,19 @@ def test_a_matching_pair_passes(tmp_path: Path) -> None:
         (None, [*_PACKAGE, "usersim/stale.py"], "the sdist doesn't"),
         (None, ["usersim/__init__.py"], "no asset banks"),
         (
-            ["pyproject.toml", *(f"src/{f}" for f in [*_PACKAGE, "usersim/engine/assets/x/embeddings.parquet"])],
-            [*_PACKAGE, "usersim/engine/assets/x/embeddings.parquet"],
+            [
+                "pyproject.toml",
+                *(f"src/{f}" for f in [*_PACKAGE, "usersim/engine/probes/x/assets/x/embeddings.parquet"]),
+            ],
+            [*_PACKAGE, "usersim/engine/probes/x/assets/x/embeddings.parquet"],
             "embeddings.parquet",
         ),
         (
-            ["pyproject.toml", *(f"src/{f}" for f in [*_PACKAGE, "usersim/engine/assets/x/_eval_scorecard.parquet"])],
-            [*_PACKAGE, "usersim/engine/assets/x/_eval_scorecard.parquet"],
+            [
+                "pyproject.toml",
+                *(f"src/{f}" for f in [*_PACKAGE, "usersim/engine/probes/x/assets/x/_eval_scorecard.parquet"]),
+            ],
+            [*_PACKAGE, "usersim/engine/probes/x/assets/x/_eval_scorecard.parquet"],
             "scorecard",
         ),
         (["pyproject.toml", "tests/test_x.py", *(f"src/{f}" for f in _PACKAGE)], None, "under tests/"),
@@ -78,12 +84,8 @@ def test_a_package_file_missing_from_the_wheel_is_reported(tmp_path: Path) -> No
     assert len(problems) == 1 and "lacks 1 package file" in problems[0] and spec in problems[0]
 
 
-@pytest.mark.parametrize(
-    "schema",
-    ["usersim/engine/assets/probe/SCHEMA.md", "usersim/engine/probes/probe/assets/probe/SCHEMA.md"],
-    ids=["shared-assets-folder", "probe-folder"],
-)
-def test_a_bank_schema_must_ship(tmp_path: Path, schema: str) -> None:
+def test_a_bank_schema_must_ship(tmp_path: Path) -> None:
+    schema = "usersim/engine/probes/probe/assets/probe/SCHEMA.md"
     problems = check_dist.check_archives(*_pair(tmp_path), package_files=[*_PACKAGE, schema])
     assert len(problems) == 1 and schema in problems[0]
 
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 2fea32ab..7c30cda4 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -41,7 +41,6 @@
 )
 from usersim.cli.evaluate import _parse_csv_or_none, _parse_judges
 from usersim.cli.simulate import _parse_probe_mix
-from usersim.engine.core._assets import packaged_assets_dir
 
 # ---------------------------------------------------------------------------
 # Top-level parser
@@ -389,7 +388,6 @@ def test_build_simulator_accepts_each_probe_singly(self, probe):
         data_designer, builder = build_simulator_config_builder(
             locale="en_US",
             models=models,
-            assets_dir=packaged_assets_dir(),
             probe_mix={probe: 1.0},
         )
         assert data_designer is not None
@@ -401,7 +399,6 @@ def test_build_simulator_rejects_unknown_probe(self):
             build_simulator_config_builder(
                 locale="en_US",
                 models=models,
-                assets_dir=packaged_assets_dir(),
                 probe_mix={"made_up": 1.0},
             )
 
@@ -410,7 +407,6 @@ def test_build_simulator_accepts_mixed_general_and_inclusion(self):
         data_designer, builder = build_simulator_config_builder(
             locale="en_US",
             models=models,
-            assets_dir=packaged_assets_dir(),
             probe_mix={
                 "tool_calling": 0.4,
                 "safety_agentic": 0.3,
@@ -838,7 +834,7 @@ def test_default_asset_dir_exists(self, command):
             "evaluate-assets": evaluate_assets,
             "gen-assets": gen_assets,
         }[command]
-        default = module.probe_assets_dir("financial_services", assets_root=module.packaged_assets_dir()) / "en_US"
+        default = module.shipped_assets_dir("financial_services") / "en_US"
         assert default.is_dir(), f"{command} default resolves to a missing dir: {default}"
         assert (default / "region_meta.yaml").exists() or any(default.iterdir())
 
diff --git a/tests/test_cli_simulate_inputs.py b/tests/test_cli_simulate_inputs.py
index 79165e36..c38aae10 100644
--- a/tests/test_cli_simulate_inputs.py
+++ b/tests/test_cli_simulate_inputs.py
@@ -49,7 +49,7 @@
 from usersim.cli._models import to_model_configs as _real_to_model_configs
 from usersim.cli._pipeline import materialize_episode_inputs
 from usersim.engine import generator as generator_module
-from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir
+from usersim.engine.core._assets import probe_assets_dir
 from usersim.engine.core.manifest import load_run_manifest
 from usersim.engine.core.missing import none_for_missing
 from usersim.engine.core.storage import list_runs, read_partitioned_dataset
@@ -66,7 +66,7 @@
     "usersim.engine.probes.health_disclosure.move_runtime",
     "usersim.engine.probes.safety_agentic.probe",
     "usersim.engine.probes.safety_chat_pressure.classifier",
-    "usersim.engine.probes.tool_calling.generator",
+    "usersim.engine.probes.tool_calling.probe",
 )
 _LLM_SITES = tuple(m for m in _LLM_MODULES if hasattr(importlib.import_module(m), "acall_llm"))
 
@@ -122,7 +122,6 @@ def _materialize(probe_mix: dict[str, float], num_rows: int, seed: int = 1, max_
         locale="en_US",
         num_rows=num_rows,
         models=_models(),
-        assets_dir=packaged_assets_dir(),
         probe_mix=probe_mix,
         random_seed=seed,
         max_turns=max_turns,
@@ -316,8 +315,8 @@ def providers(**extra):
 
 def test_changed_assets_are_a_new_setup_and_moved_ones_are_not(rows, tmp_path):
     first, second = tmp_path / "assets", tmp_path / "elsewhere"
-    shutil.copytree(packaged_assets_dir(), first)
-    shutil.copytree(packaged_assets_dir(), second)
+    shutil.copytree(probe_assets_dir("tool_calling").parent, first)
+    shutil.copytree(probe_assets_dir("tool_calling").parent, second)
     moved = _fingerprint(rows, assets_dir=first)
     readme = next(first.rglob("README.md"))
     readme.write_text(readme.read_text() + "\nedited\n")
@@ -345,10 +344,10 @@ def test_a_change_under_a_probe_declared_assets_root_is_a_new_setup(register_tes
     bank.parent.mkdir(parents=True)
     bank.write_text("items: []\n")
     register_test_probe("ext_probe", assets_root=tmp_path / "pkg")
-    before = _inputs._asset_roots_digest(packaged_assets_dir())
+    before = _inputs._asset_roots_digest(None)
     bank.write_text("items: [edited]\n")
 
-    assert _inputs._asset_roots_digest(packaged_assets_dir()) != before
+    assert _inputs._asset_roots_digest(None) != before
 
 
 def test_a_data_designer_release_is_part_of_the_setup(rows, monkeypatch):
@@ -593,7 +592,7 @@ def test_saved_rows_have_a_plain_runs_columns_plus_input_id(probe_type, tmp_path
             locales=["en_US"],
             num_rows=2,
             out=plain_out,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={probe_type: 1.0},
             random_seed=1,
@@ -682,7 +681,7 @@ def test_a_plain_run_records_when_it_started_and_leaves_no_artifacts(tmp_path, m
             locales=["en_US"],
             num_rows=2,
             out=tmp_path / "plain",
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={"general_open_ended": 1.0},
             random_seed=1,
@@ -840,12 +839,17 @@ def test_rows_that_cannot_run_are_refused(rows, edit, message):
         prepare_episode_inputs(_edited(rows, edit))
 
 
-def test_a_missing_stored_asset_folder_is_an_error_until_one_is_given(rows):
+def test_rows_stored_without_an_asset_folder_read_each_probe_s_own(rows):
+    assert {row["usersim_config"]["assets_dir"] for row in rows} == {None}
+    assert prepare_episode_inputs(rows).assets_dir is None
+
+
+def test_a_missing_stored_asset_folder_is_an_error_until_one_is_given(rows, tmp_path):
     moved = _edited(rows, lambda r: [row["usersim_config"].update(assets_dir="/no/such/assets") for row in r])
 
     with pytest.raises(ValueError, match="--assets-dir"):
         prepare_episode_inputs(moved)
-    assert prepare_episode_inputs(moved, assets_dir=packaged_assets_dir()).assets_dir == packaged_assets_dir()
+    assert prepare_episode_inputs(moved, assets_dir=tmp_path).assets_dir == tmp_path.resolve()
 
 
 def _write(rows, path: Path) -> Path:
diff --git a/tests/test_cli_simulate_run_partition.py b/tests/test_cli_simulate_run_partition.py
index 8f71436b..75cc60dc 100644
--- a/tests/test_cli_simulate_run_partition.py
+++ b/tests/test_cli_simulate_run_partition.py
@@ -41,7 +41,6 @@
 import pandas as pd
 import pytest
 
-from usersim.engine.core._assets import packaged_assets_dir
 from usersim.engine.core.storage import (
     list_runs,
     new_run_id,
@@ -268,7 +267,7 @@ def _fake_builder(**kwargs):
                 locales=["en_US"],
                 num_rows=1,
                 out=out,
-                assets_dir=packaged_assets_dir(),
+                assets_dir=None,
                 max_turns=1,
                 probe_mix={"general_open_ended": 1.0},
                 random_seed=42,
@@ -355,7 +354,7 @@ def _fake_builder(**kwargs):
                 locales=["en_US"],
                 num_rows=1,
                 out=out,
-                assets_dir=packaged_assets_dir(),
+                assets_dir=None,
                 max_turns=1,
                 probe_mix={"general_open_ended": 1.0},
                 random_seed=42,
@@ -399,7 +398,7 @@ def create(self, builder, num_records=None, artifact_path=None):
             locales=["en_US"],
             num_rows=1,
             out=out,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={"financial_services": 1.0},
             random_seed=42,
@@ -451,7 +450,7 @@ def create(self, builder, num_records=None, artifact_path=None):
             locales=["en_US"],
             num_rows=1,
             out=out,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={"general_open_ended": 1.0},
             random_seed=42,
@@ -499,7 +498,7 @@ def create(self, builder, num_records=None, artifact_path=None):
             locales=["en_US"],
             num_rows=1,
             out=out,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={"general_open_ended": 1.0},
             random_seed=42,
diff --git a/tests/test_extension_seams.py b/tests/test_extension_seams.py
index 5370fe08..ac69c2e5 100644
--- a/tests/test_extension_seams.py
+++ b/tests/test_extension_seams.py
@@ -125,7 +125,7 @@ def test_a_contributed_probe_cannot_take_a_builtin_label(self, extension, probe_
         with caplog.at_level(logging.WARNING, logger="usersim.engine"):
             assert "tool_calling" in known_probes()
         assert resolve_probe("tool_calling") is builtin
-        assert "'tool_calling' is already registered by usersim.engine.probes.tool_calling.generator" in caplog.text
+        assert "'tool_calling' is already registered by usersim.engine.probes.tool_calling.probe" in caplog.text
 
 
 @pytest.fixture
diff --git a/tests/test_replay_reasoning_config.py b/tests/test_replay_reasoning_config.py
index 5ff37207..bcece821 100644
--- a/tests/test_replay_reasoning_config.py
+++ b/tests/test_replay_reasoning_config.py
@@ -29,7 +29,6 @@
 )
 from usersim.cli._pipeline import build_simulator_config_builder
 from usersim.engine.config import ConversationSimulatorConfig
-from usersim.engine.core._assets import packaged_assets_dir
 from usersim.engine.core.episode_input import construct_episode_preamble
 from usersim.engine.core.manifest import SimulationConfigSnapshot, build_run_manifest
 
@@ -85,7 +84,7 @@ def column(models, **kwargs) -> ConversationSimulatorConfig:
         _, builder = build_simulator_config_builder(
             locale="en_US",
             models=models,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             probe_mix={"general_open_ended": 1.0},
             **kwargs,
         )
@@ -203,7 +202,7 @@ def create(self, builder, num_records=None, artifact_path=None):
             locales=["en_US"],
             num_rows=1,
             out=tmp_path,
-            assets_dir=packaged_assets_dir(),
+            assets_dir=None,
             max_turns=1,
             probe_mix={"general_open_ended": 1.0},
             random_seed=1,
@@ -223,7 +222,7 @@ def test_materialized_rows_carry_the_switch_to_a_host(monkeypatch):
         locale="en_US",
         num_rows=1,
         models=_models(**_REPLAY),
-        assets_dir=packaged_assets_dir(),
+        assets_dir=None,
         probe_mix={"general_open_ended": 1.0},
     )
 
diff --git a/tests/test_simulator_pipeline_e2e.py b/tests/test_simulator_pipeline_e2e.py
index 326108e1..d7a2d7d0 100644
--- a/tests/test_simulator_pipeline_e2e.py
+++ b/tests/test_simulator_pipeline_e2e.py
@@ -50,7 +50,6 @@
 
 import json
 from contextlib import contextmanager
-from pathlib import Path
 from typing import Any
 from unittest.mock import patch
 
@@ -60,7 +59,7 @@
 # self-registers every probe class.
 import usersim.engine.generator  # noqa: F401
 from usersim.engine.config import ConversationSimulatorConfig
-from usersim.engine.core._assets import packaged_assets_dir
+from usersim.engine.core._assets import probe_assets_dir
 from usersim.engine.core.outcomes import OutcomeBuilder, Provenance
 from usersim.engine.core.probes import known_probes, resolve_probe
 
@@ -162,7 +161,7 @@ def _patched_call_llm():
       judge + early-stop checker.
     - ``core/context.py`` — context-compression rolling summary
       generation.
-    - ``probes/tool_calling/generator.py`` — probe-internal tool
+    - ``probes/tool_calling/probe.py`` — probe-internal tool
       arg-generation calls (it doesn't go through ``ConversationLoop``
       for the tool-call branch).
     - ``probes/safety_agentic/probe.py`` — mock-environment
@@ -177,7 +176,7 @@ def _patched_call_llm():
         "usersim.engine.core.simulation.acall_llm",
         "usersim.engine.core.judges.acall_llm",
         "usersim.engine.core.context.acall_llm",
-        "usersim.engine.probes.tool_calling.generator.acall_llm",
+        "usersim.engine.probes.tool_calling.probe.acall_llm",
         "usersim.engine.probes.safety_agentic.probe.acall_llm",
     )
     patches = [patch(t, side_effect=_mock_call_llm_side_effect) for t in targets]
@@ -209,15 +208,13 @@ def _cli_built_simulator_config(probe_type: str, locale: str) -> ConversationSim
         resolve_toolset_seed_for_mix,
     )
 
-    assets_dir = (packaged_assets_dir()).resolve()
     models = load_models_config(default_models_path())
 
     probe_mix = {probe_type: 1.0}
-    toolset_seed = resolve_toolset_seed_for_mix(probe_mix, assets_dir)
+    toolset_seed = resolve_toolset_seed_for_mix(probe_mix)
     _, builder = build_simulator_config_builder(
         locale=locale,
         models=models,
-        assets_dir=assets_dir,
         max_turns=1,
         probe_mix=probe_mix,
         toolset_seed_path=toolset_seed,
@@ -254,7 +251,7 @@ def _synthetic_row_data(
         cfg.theme_column: _theme_for(probe_type),
     }
     if cfg.tools_column is not None:
-        data[cfg.tools_column] = _toolset_for_test(repo_root_assets())
+        data[cfg.tools_column] = _toolset_for_test()
         data[cfg.toolset_name_column] = "weather_tools"
     return data
 
@@ -274,11 +271,7 @@ def _theme_for(probe_type: str) -> str:
     return "__not_used__"
 
 
-def repo_root_assets() -> Path:
-    return packaged_assets_dir()
-
-
-def _toolset_for_test(assets_dir: Path) -> list[dict[str, Any]]:
+def _toolset_for_test() -> list[dict[str, Any]]:
     """Read one row from the shipped ``toolsets_seed.parquet`` to use
     as the synthetic ``tools`` column value. Reads only the first
     row's ``tools`` field — keeps the test small and avoids
@@ -286,7 +279,7 @@ def _toolset_for_test(assets_dir: Path) -> list[dict[str, Any]]:
     """
     import pyarrow.parquet as pq
 
-    toolset_path = assets_dir / "tool_calling" / "toolsets_seed.parquet"
+    toolset_path = probe_assets_dir("tool_calling") / "toolsets_seed.parquet"
     table = pq.read_table(toolset_path).slice(0, 1).to_pylist()
     raw = table[0]["tools"]
     if isinstance(raw, str):
diff --git a/tests/test_toolset_seed_cli.py b/tests/test_toolset_seed_cli.py
index 9f47d563..cd897dca 100644
--- a/tests/test_toolset_seed_cli.py
+++ b/tests/test_toolset_seed_cli.py
@@ -27,8 +27,8 @@
     TOOLSET_SEED_SUFFIXES,
     resolve_toolset_seed_path,
 )
-from usersim.engine.core._assets import packaged_assets_dir, probe_assets_dir
-from usersim.engine.probes.tool_calling.generator import _normalize_tool_list
+from usersim.engine.core._assets import probe_assets_dir
+from usersim.engine.probes.tool_calling.probe import _normalize_tool_list
 
 
 def _assets_root(tmp_path: Path, *seed_names: str) -> Path:
@@ -305,7 +305,7 @@ def _build(self, mix, seed, assets_dir=None):
         return build_simulator_config_builder(
             locale="en_US",
             models=load_models_config(default_models_path()),
-            assets_dir=Path(assets_dir).resolve() if assets_dir else packaged_assets_dir(),
+            assets_dir=Path(assets_dir).resolve() if assets_dir else None,
             probe_mix=mix,
             toolset_seed_path=seed,
         )