diff --git a/.github/ISSUE_TEMPLATE/extension-hook.yml b/.github/ISSUE_TEMPLATE/extension-hook.yml
new file mode 100644
index 0000000..da5b723
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/extension-hook.yml
@@ -0,0 +1,84 @@
+name: 🔌 Extension hook
+description: Ask for a hook your probe, scorer or other extension needs and User Sim does not offer
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: >-
+        Use this form when an extension needs something no hook, class
+        attribute or entry point offers. A maintainer reviews the request,
+        agrees the hook's shape with you and adds the `triaged` label when a
+        pull request is wanted.
+        [Adding a hook](https://github.com/NVIDIA-NeMo/UserSim/blob/main/CONTRIBUTING.md#adding-a-hook)
+        lists what a new hook must do.
+
+  - type: textarea
+    id: need
+    attributes:
+      label: What does your extension need to do?
+      description: >-
+        The need in general terms: what the extension has to read or change,
+        and at which stage of a run (setup, the conversation, the stored
+        columns, scoring or the report). The general shape is enough to design
+        a hook, so leave out anything confidential about your project.
+    validations:
+      required: true
+
+  - type: textarea
+    id: gap
+    attributes:
+      label: Why don't the existing hooks cover it?
+      description: >-
+        The hooks, class attributes and entry points you looked at, in
+        [architecture/probes.md](https://github.com/NVIDIA-NeMo/UserSim/blob/main/architecture/probes.md)
+        and [docs/extension_api.md](https://github.com/NVIDIA-NeMo/UserSim/blob/main/docs/extension_api.md),
+        and where each falls short.
+    validations:
+      required: true
+
+  - type: textarea
+    id: shape
+    attributes:
+      label: What shape do you propose?
+      description: >-
+        A method, class attribute or entry point, its signature, and what
+        happens for a probe that does not define it. That default should keep
+        today's behaviour.
+    validations:
+      required: true
+
+  - type: textarea
+    id: hosted
+    attributes:
+      label: Does it work when a host drives the probe?
+      description: >-
+        A host can run a probe from its own loop through `ProbeEpisodeRuntime`,
+        as
+        [EXTERNAL_PROBE_RUNTIME.md](https://github.com/NVIDIA-NeMo/UserSim/blob/main/docs/engine/EXTERNAL_PROBE_RUNTIME.md)
+        describes. Say whether the hook runs there too, and whether it calls a
+        model.
+    validations:
+      required: true
+
+  - type: textarea
+    id: investigation
+    attributes:
+      label: Prior investigation
+      description: >-
+        What you or your coding agent found in the code, documentation and
+        existing issues, such as a hook that covers part of this or an open
+        request for the same thing. If an agent investigated, paste its
+        findings.
+      placeholder: Paste the agent's findings, or describe what you checked.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      options:
+        - label: I searched existing issues and the documentation, or had my agent do so
+          required: true
+        - label: The request describes the need in general terms and holds nothing confidential
+          required: true
+        - label: If an agent helped, its findings are under Prior investigation
+          required: false
diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
index e3fd988..13caf17 100644
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -9,7 +9,8 @@ body:
         change is wanted. If you plan to build this yourself, open the pull
         request once the issue has that label; see
         [Issues before pull requests](https://github.com/NVIDIA-NeMo/UserSim/blob/main/CONTRIBUTING.md#issues-before-pull-requests).
-        To propose a probe you plan to build, use the New probe form instead.
+        To propose a probe you plan to build, use the New probe form instead,
+        and to ask for a hook your extension needs, the Extension hook form.
 
   - type: textarea
     id: problem
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8d69673..651c349 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -352,7 +352,9 @@ your package adds with its own prefix, such as `my_bookings`; unprefixed
 names belong to the built-ins, and
 [`architecture/plugins.md`](architecture/plugins.md) lists the names this
 covers. [`docs/extensions.md`](docs/extensions.md) builds a whole extension
-package, a probe with its bank, a scorer and their tests, step by step. Import
+package, a probe with its bank, a scorer and their tests, step by step, and
+[`templates/extension_package/`](templates/extension_package/) is one to copy
+and fill in. Import
 from `usersim.extension` and `usersim.testing`;
 [`docs/extension_api.md`](docs/extension_api.md) lists every name they export.
 
@@ -445,6 +447,31 @@ To propose a probe, open the
 Triage settles where it lives: in this repository, as an extension, or as an
 extension first.
 
+### Adding a hook
+
+When a probe, scorer or other extension needs something no hook, class
+attribute or entry point offers, open the
+[Extension hook form](https://github.com/NVIDIA-NeMo/UserSim/issues/new?template=extension-hook.yml).
+[`architecture/probes.md`](architecture/probes.md) lists the hooks and
+declarations a probe has, and [`docs/extension_api.md`](docs/extension_api.md)
+the names an extension imports.
+
+A new hook:
+
+- **is general:** it serves probes beyond the one that asks for it, and its
+  name and documentation describe that general use.
+- **keeps today's behaviour by default:** a probe that does not define it runs,
+  and stores its rows, as before.
+- **is `async def` if it can call a model,** so the loop awaits it.
+- **works when a host drives the probe:** `assert_hosted_parity` passes for a
+  probe that uses it.
+- **comes with its uses:** the extension fixture in
+  `tests/fixtures/extension_package/` uses it, so `make check-extensions`
+  proves it works from an installed package. The pull request that adds it
+  also updates the conformance checks, `templates/probe/`,
+  [`architecture/probes.md`](architecture/probes.md) and
+  [`docs/engine/AUTHORING_A_PROBE.md`](docs/engine/AUTHORING_A_PROBE.md).
+
 ## Code style
 
 `ruff` owns formatting and linting; there is no separate style config to
diff --git a/Makefile b/Makefile
index fa11529..95974e9 100644
--- a/Makefile
+++ b/Makefile
@@ -268,7 +268,7 @@ health-check:  ## Live one-row simulate + eval + report against a provider
 		|| { echo "report produced no index.html"; exit 1; }; \
 	echo "✓ simulate, eval and report all completed"
 
-check-extensions:  ## Install an out-of-tree package and prove all six seams work
+check-extensions:  ## Install an out-of-tree package, prove all six seams work, and test the package template
 	@set -eu; \
 	WORK=$$(mktemp -d); \
 	EMPTY=$$(mktemp -d); \
@@ -280,10 +280,15 @@ check-extensions:  ## Install an out-of-tree package and prove all six seams wor
 	test -x "$$WORK/venv/bin/python" || { echo "venv was not created"; exit 1; }; \
 	$(UV) pip install --quiet --python "$$WORK/venv/bin/python" "$$WORK"/*.whl; \
 	cp -R tests/fixtures/extension_package "$$WORK/ext"; \
+	cp -R templates/extension_package "$$WORK/template"; \
 	$(UV) pip install --quiet --python "$$WORK/venv/bin/python" "$$WORK/ext"; \
 	echo "→ asking the installed CLI what it can see, from $$EMPTY"; \
 	cp tests/fixtures/extension_package/verify_seams.py "$$EMPTY/"; \
-	cd "$$EMPTY" && "$$WORK/venv/bin/python" verify_seams.py
+	cd "$$EMPTY" && "$$WORK/venv/bin/python" verify_seams.py; \
+	echo "→ installing templates/extension_package and running its tests"; \
+	$(UV) pip install --quiet --python "$$WORK/venv/bin/python" "$$WORK/template" \
+		"pytest>=8.0" "pytest-asyncio>=1.0,<2" "pytest-env>=1.1,<2"; \
+	cd "$$WORK/template" && "$$WORK/venv/bin/python" -m pytest -q -p no:cacheprovider
 
 # --- housekeeping ----------------------------------------------------------
 
diff --git a/docs/engine/AUTHORING_A_PROBE.md b/docs/engine/AUTHORING_A_PROBE.md
index 85ebca6..a6767b9 100644
--- a/docs/engine/AUTHORING_A_PROBE.md
+++ b/docs/engine/AUTHORING_A_PROBE.md
@@ -33,46 +33,56 @@ piece to pick and *how* to wire it.
 
 ## Step 0: pick your shape
 
+A probe sets the area its conversations explore and the bounds of that area:
+the topics or tasks, and the facts a scorer checks. The simulated user, played
+from a persona, explores the area in its own words, so rows on the same topic
+open differently and go different ways, and a run covers what its personas
+bring to it. Give the user model an area and its bounds rather than a message
+to send: a fixed opening starts every row in a locale the same way, and the run
+explores only what that one message reaches. Send a bank's text verbatim only
+when its exact wording is what the probe tests.
+
 Use this decision tree to pick which substrate combination matches
 your probe:
 
 ```
-Does the probe have an asset bank (curated facts / queries / strategies / actions)?
+Who writes the user's first message?
 │
-├── NO → BaseProbe alone
-│        Examples: general_open_ended, general_educational
-│        Template: templates/probe/generator_baseprobe_only.py
+├── The user model, in the persona's voice, inside an area the probe sets
+│   (start here: the persona's own wording IS the feature)
+│   │
+│   ├── The areas are topics, listed per locale
+│   │   → BaseProbe, with a themes(locale) classmethod
+│   │     (see "Give each row a theme" in Step 3)
+│   │     Examples: general_open_ended, general_educational
+│   │     Template: templates/probe/generator_baseprobe_only.py
+│   │
+│   └── The areas come from a curated bank, with facts a scorer checks
+│       → BankBackedProbe, with the area and its facts in the user system prompt
+│         Examples: sov_ai_dynamic, the bookings worked example below
+│         Template: templates/probe/generator_custom_turn1.py
+│       → or CustomTurn1InstructionMixin, when only turn 1 follows
+│         an instruction of its own
 │
-└── YES → BankBackedProbe + mixin (depends on turn-1 shape)
-         │
-         ├── Turn-1 should be the bank's text VERBATIM
-         │   (false-premise wording, exact phrasing for matched-pair joins,
-         │    or reviewer-authored content must survive unchanged)
-         │   │
-         │   ├── Single back-and-forth conversation
-         │   │   → BankVerbatimMixin
-         │   │     Examples: sov_ai_facts, sov_ai_multilingual_parity
-         │   │     Template: templates/probe/generator_bank_verbatim.py
-         │   │
-         │   ├── Multi-turn with bank-driven per-turn nudges (reframings)
-         │   │   → BankReframingMixin
-         │   │     Example: safety_chat_pressure
-         │   │     Template: templates/probe/generator_bank_reframing.py
-         │   │
-         │   └── Single user turn + multi-assistant-turn tool loop
-         │       (NO user-LLM at all; assistant tool-calls intercepted)
-         │       → AgenticMixin (custom run_dispatch)
-         │         Example: safety_agentic
-         │         Template: templates/probe/generator_agentic.py
-         │
-         └── Turn-1 should be GENERATED by the user-LLM in the persona's
-             voice, but ANCHORED to a bank-derived hint
-             (paraphrasing through persona voice IS the feature)
-             → BankBackedProbe, with the hint in the user system prompt
-               Example: sov_ai_dynamic
-               Template: templates/probe/generator_custom_turn1.py
-             → or CustomTurn1InstructionMixin, when only turn 1 follows
-               an instruction of its own
+└── A bank's text, VERBATIM, because its exact wording is what the probe tests
+    (false-premise wording, exact phrasing for matched-pair joins,
+     or reviewer-authored content that must survive unchanged)
+    │
+    ├── Single back-and-forth conversation
+    │   → BankVerbatimMixin
+    │     Examples: sov_ai_facts, sov_ai_multilingual_parity
+    │     Template: templates/probe/generator_bank_verbatim.py
+    │
+    ├── Multi-turn with bank-driven per-turn nudges (reframings)
+    │   → BankReframingMixin
+    │     Example: safety_chat_pressure
+    │     Template: templates/probe/generator_bank_reframing.py
+    │
+    └── Single user turn + multi-assistant-turn tool loop
+        (NO user-LLM at all; assistant tool-calls intercepted)
+        → AgenticMixin (custom run_dispatch)
+          Example: safety_agentic
+          Template: templates/probe/generator_agentic.py
 ```
 
 There's also a **tool-calling capability** shape (test the assistant's
@@ -174,7 +184,7 @@ notifying. See `docs/engine/EXTERNAL_PROBE_RUNTIME.md`.
 For `BankBackedProbe` subclasses:
 
 ```python
-class MyProbe(BankVerbatimMixin, BankBackedProbe):
+class MyProbe(BankBackedProbe):
     label = "my_probe"                                          # required
     bank_loader = staticmethod(_my_bank_loader)                 # required
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_FACT  # required
@@ -321,7 +331,7 @@ def _bank_loader(locale: str = "en_US"):
     return _load_bank(locale)
 
 
-class MyProbe(BankVerbatimMixin, BankBackedProbe):
+class MyProbe(BankBackedProbe):
     bank_loader = staticmethod(_bank_loader)
 ```
 
@@ -364,7 +374,7 @@ def _check_locale_bank(locale_dir: Path) -> None:
     MyBank.from_yaml((locale_dir / "sample.yaml").read_text(encoding="utf-8"))
 
 
-class MyProbe(BankVerbatimMixin, BankBackedProbe):
+class MyProbe(BankBackedProbe):
     locale_bank_check = staticmethod(_check_locale_bank)
     authoring_guide = "https://example.com/my-probe/README.md#adding-a-locale"
 ```
@@ -388,7 +398,7 @@ bank fails a check rather than a run. Return one string per problem, or an
 empty list, and read what your loaders read without calling a model:
 
 ```python
-class MyProbe(BankVerbatimMixin, BankBackedProbe):
+class MyProbe(BankBackedProbe):
     @classmethod
     def asset_problems(cls) -> list[str]:
         problems = []
@@ -520,7 +530,7 @@ from usersim.extension import register_probe
     prompt_version="v1.0",     # MyProbe.prompt_version
     variants=("default",),     # MyProbe.variants
 )
-class MyProbe(BankVerbatimMixin, BankBackedProbe):
+class MyProbe(BankBackedProbe):
     label = "my_probe"
     ...
 ```
@@ -631,8 +641,10 @@ the assistant has a `book_appointment` tool that takes them in one fixed form.
 The probe ships banks for `en_US` and `pt_BR`; the same probe, shipped in its
 own package, is the example in [`docs/extensions.md`](../extensions.md).
 
-We'll use the **banked-verbatim** shape, so each date reaches the assistant
-exactly as the bank writes it, with `ToolExecutionMixin` to answer the
+The probe sets the area and its bounds, and the persona does the rest: the bank
+names what can be booked, the probe draws a date, a time and a number of people
+for each row, and the user model asks for the booking in its own words. It is a
+`BankBackedProbe` with no verbatim turn, and `ToolExecutionMixin` answers the
 assistant's tool call.
 
 ### File 1: the banks, `src/usersim/engine/probes/bookings/assets/bookings/<locale>/bookings.yaml`
@@ -642,12 +654,15 @@ assistant's tool call.
 ```yaml
 bank_id: bookings_en_US
 bank_version: "1.0.0"
-bookings:
+appointments:
   - id: museum_tour
-    opening: Hi! Can you book the guided museum tour for 04/03/2027 at 3:30 pm?
-    date: "2027-04-03"
-    time: "15:30"
-    people: 3
+    what: the guided tour of the city museum
+    placeholder: true
+  - id: restaurant
+    what: a table at a restaurant
+    placeholder: true
+  - id: pottery_class
+    what: a pottery class
     placeholder: true
 ```
 
@@ -656,26 +671,37 @@ bookings:
 ```yaml
 bank_id: bookings_pt_BR
 bank_version: "1.0.0"
-bookings:
+appointments:
   - id: museum_tour
-    opening: Oi! Você pode reservar a visita guiada ao museu para 04/03/2027 às 15h30?
-    date: "2027-03-04"
-    time: "15:30"
-    people: 3
+    what: a visita guiada ao museu da cidade
+    placeholder: true
+  - id: restaurant
+    what: uma mesa num restaurante
+    placeholder: true
+  - id: pottery_class
+    what: uma aula de cerâmica
     placeholder: true
 ```
 
-Both open with `04/03/2027`: 3 April to a user writing American English, and
-4 March to one writing Brazilian Portuguese. Neither says how many people are
-coming, so an assistant that books on its first reply has to guess.
+Both name the same three appointments, each in its bank's language. The
+banks hold no dates: `draw_booking` in File 2 draws one per row, with the day
+and the month different numbers no greater than 12, so the date reads as another
+date when its numbers are read in the other order. For `2027-03-06`, 6 March, a
+user who writes the day first, as people in Brazil do, writes `06/03/2027`, and
+one who writes the month first, as people in the United States do, writes
+`03/06/2027`; an assistant that reads every date one way gets one of them
+wrong. Whether the user writes the date in numbers or in words is the user
+model's choice. The user says how many people are coming only when asked, so an
+assistant that books on its first reply has to guess.
 
 ### File 2: `src/usersim/engine/probes/bookings/bank.py`
 
 ```python
-"""Booking banks: one per locale, under the probe's asset folder."""
+"""Appointment banks: one per locale, under the probe's asset folder."""
 
 from __future__ import annotations
 
+import random
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -686,12 +712,9 @@ LOCALES = ("en_US", "pt_BR")
 
 
 @dataclass(frozen=True)
-class Booking:
+class Appointment:
     id: str
-    opening: str  # turn 1, in the locale's language; leaves out how many people
-    date: str  # what the user means, as the tool takes it: YYYY-MM-DD
-    time: str  # HH:MM, 24-hour
-    people: int  # given only when the assistant asks
+    what: str  # what the user wants booked, in the locale's language
     placeholder: bool
 
 
@@ -699,12 +722,40 @@ class Booking:
 class BookingBank:
     bank_id: str
     bank_version: str
-    bookings: tuple[Booking, ...]
+    appointments: tuple[Appointment, ...]
+
+
+@dataclass(frozen=True)
+class Booking:
+    id: str
+    what: str
+    date: str  # what the user means, as the tool takes it: YYYY-MM-DD
+    time: str  # HH:MM, 24-hour
+    people: int  # given only when the assistant asks
+    placeholder: bool
 
 
 def read_booking_bank(locale_dir: Path) -> BookingBank:
     doc = yaml.safe_load((locale_dir / "bookings.yaml").read_text(encoding="utf-8"))
-    return BookingBank(doc["bank_id"], doc["bank_version"], tuple(Booking(**b) for b in doc["bookings"]))
+    return BookingBank(doc["bank_id"], doc["bank_version"], tuple(Appointment(**a) for a in doc["appointments"]))
+
+
+def draw_booking(appointment: Appointment, rng: random.Random) -> Booking:
+    """A date, a time and a number of people for ``appointment``.
+
+    The day and the month are different numbers no greater than 12, so the date
+    reads as two different dates, day first and month first.
+    """
+    month = rng.randint(1, 12)
+    day = rng.choice([d for d in range(1, 13) if d != month])
+    return Booking(
+        id=appointment.id,
+        what=appointment.what,
+        date=f"2027-{month:02d}-{day:02d}",
+        time=f"{rng.randint(9, 17):02d}:{rng.choice(('00', '30'))}",
+        people=rng.randint(2, 6),
+        placeholder=appointment.placeholder,
+    )
 ```
 
 ### File 3: `src/usersim/engine/probes/bookings/__init__.py`
@@ -726,14 +777,16 @@ BOOKINGS_USER_PROMPTS = LocalePromptPack(
     prompts={
         "en_US": (
             "{persona}\n\n"
-            "You asked an assistant to book an appointment, giving the date and time. "
-            "If it asks how many people are coming, the answer is {people}; say it the way you would. "
+            "You want an assistant to book {what} on {date} at {time}. Ask for it in your own words, "
+            "and write the date and time the way you would write them yourself, not in the form they are "
+            "given here. Say how many people are coming only if it asks; the answer is {people}. "
             "Once it confirms the booking, thank it."
         ),
         "pt_BR": (
             "{persona}\n\n"
-            "Você pediu a um assistente para marcar um horário e já disse a data e a hora. "
-            "Se ele perguntar quantas pessoas vão, a resposta é {people}; diga isso do seu jeito. "
+            "Você quer que um assistente reserve {what} para {date} às {time}. Peça do seu jeito, e "
+            "escreva a data e a hora como você mesmo escreveria, não na forma em que aparecem aqui. "
+            "Diga quantas pessoas vão só se ele perguntar; a resposta é {people}. "
             "Quando ele confirmar a reserva, agradeça."
         ),
     },
@@ -743,6 +796,8 @@ BOOKINGS_USER_PROMPTS = LocalePromptPack(
 
 The user's instructions are written in each language the probe ships, and
 `LocalePromptPack` refuses, when the module is imported, a locale without them.
+They give the user model what to book, with the date and time in the tool's
+form, and ask it to write the date and time the way it would itself.
 
 ### File 5: `src/usersim/engine/probes/bookings/probe.py`
 
@@ -757,11 +812,10 @@ from pathlib import Path
 from typing import Any
 
 from usersim.engine.core.probes import dispatch_episode
-from usersim.engine.probes.bookings.bank import LOCALES, Booking, read_booking_bank
+from usersim.engine.probes.bookings.bank import LOCALES, Booking, draw_booking, read_booking_bank
 from usersim.engine.probes.bookings.prompts import BOOKINGS_USER_PROMPTS
 from usersim.extension import (
     BankBackedProbe,
-    BankVerbatimMixin,
     OutcomeBuilder,
     Provenance,
     ToolExecutionMixin,
@@ -804,7 +858,7 @@ def _bank_loader(locale: str):
     prompt_version=PROMPT_VERSION,
     variants=tuple(PROBE_VARIANTS),
 )
-class BookingsProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
+class BookingsProbe(ToolExecutionMixin, BankBackedProbe):
     label = "bookings"
     assets_root = Path(__file__).parent / "assets"  # holds bookings/
     description = (
@@ -814,7 +868,6 @@ class BookingsProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
     bank_loader = staticmethod(_bank_loader)
     locale_bank_check = staticmethod(read_booking_bank)
     placeholder_warning_kind = WarningKind.USED_PLACEHOLDER_BOOKING
-    verbatim_field = "opening"
     output_columns = ("booking_id", "booking")
 
     @classmethod
@@ -829,12 +882,15 @@ class BookingsProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
 
     def derive_task(self, persona: dict, bank: Any, *, cfg: Any) -> Booking:
         rng = random.Random(f"{persona_uuid(persona)}:{bank.bank_version}:{cfg.random_seed}")
-        return rng.choice(bank.bookings)
+        return draw_booking(rng.choice(bank.appointments), rng)
 
     def get_user_system_prompt(self) -> str:
         return BOOKINGS_USER_PROMPTS.get(
             self._locale,
             persona=format_persona_for_prompt(self._persona),
+            what=self._task.what,
+            date=self._task.date,
+            time=self._task.time,
             people=self._task.people,
         )
 
@@ -909,7 +965,12 @@ async def simulate_bookings(
   assistant has booked, so a user who thanks it early does not end it first.
 - `should_succeed` keeps its default: an assistant that never books has not
   broken the probe's protocol, so its row is scored like any other.
-- The probe keeps `BaseProbe`'s gate prompt (Step 5).
+- `derive_task` picks the row's appointment, and `draw_booking` its date, time
+  and number of people, with a generator seeded from the persona, the bank's
+  version and the run's seed, so a row draws the same booking every time it
+  runs.
+- The user model writes every user turn, the first included, and the probe
+  keeps `BaseProbe`'s gate prompt (Step 5) to check each one.
 
 ### File 6: the placeholder warning
 
diff --git a/docs/extension_api.md b/docs/extension_api.md
index c1a1ae8..385407e 100644
--- a/docs/extension_api.md
+++ b/docs/extension_api.md
@@ -85,6 +85,8 @@ does not load the conversation loop.
 | `format_conversation_history_for_prompt` | A conversation as a text block for a judge prompt |
 | `format_tools_for_prompt` | Tool definitions as a readable prompt block |
 | `render_prompt` | Fills a template's placeholders from given values, then from the row |
+| `load_prompt_file` | A probe's `prompts.yaml` as a mapping, read from the folder its banks resolve to; empty when there is none |
+| `get_prompt` | One prompt from a probe's `prompts.yaml`, or the default it is given when the file or the key is missing |
 
 ### Locales and languages
 
diff --git a/docs/extensions.md b/docs/extensions.md
index 886ece4..ba249b9 100644
--- a/docs/extensions.md
+++ b/docs/extensions.md
@@ -11,7 +11,9 @@ the booking the assistant makes.
 point groups and how discovery behaves,
 [`docs/engine/AUTHORING_A_PROBE.md`](engine/AUTHORING_A_PROBE.md) covers every
 hook a probe can implement, and [`extension_api.md`](extension_api.md) lists
-every name the package can import from `usersim`.
+every name the package can import from `usersim`. When a package needs a hook
+User Sim does not have,
+[Adding a hook](../CONTRIBUTING.md#adding-a-hook) says how to ask for one.
 
 ## Layout
 
@@ -33,6 +35,10 @@ my-bookings/
 The banks sit under `assets/<label>/<locale>/`, the layout the asset search path
 reads.
 
+[`templates/extension_package/`](../templates/extension_package/) holds a
+package with the same layout to copy, every name in it a placeholder, and
+`make check-extensions` runs its tests against an installed User Sim.
+
 ## Names
 
 Every name the package adds starts with its prefix, `my_`, because unprefixed
@@ -92,6 +98,15 @@ asyncio_mode = "auto"
 
 ## The probe
 
+A probe sets the area its conversations explore and the bounds a scorer
+checks, and the simulated user explores that area in the persona's own words.
+Here the area is booking an appointment. The bank names what can be booked,
+the probe draws a date, a time and a number of people for each row, and the
+user model asks for the booking the way its persona would, so rows that draw
+the same appointment still open differently. A bank's text goes to the
+assistant verbatim only when its exact wording is what a probe tests, such as
+a false premise.
+
 ```python
 import json
 import random
@@ -102,7 +117,6 @@ from pathlib import Path
 import yaml
 from usersim.extension import (
     BankBackedProbe,
-    BankVerbatimMixin,
     PreviewField,
     ToolExecutionMixin,
     format_persona_for_prompt,
@@ -133,12 +147,9 @@ BOOK_APPOINTMENT = {
 
 
 @dataclass(frozen=True)
-class Booking:
+class Appointment:
     id: str
-    opening: str
-    date: str
-    time: str
-    people: int
+    what: str
     placeholder: bool
 
 
@@ -146,12 +157,22 @@ class Booking:
 class BookingBank:
     bank_id: str
     bank_version: str
-    bookings: tuple[Booking, ...]
+    appointments: tuple[Appointment, ...]
+
+
+@dataclass(frozen=True)
+class Booking:
+    id: str
+    what: str
+    date: str
+    time: str
+    people: int
+    placeholder: bool
 
 
 def read_booking_bank(locale_dir: Path) -> BookingBank:
     doc = yaml.safe_load((locale_dir / "bookings.yaml").read_text(encoding="utf-8"))
-    return BookingBank(doc["bank_id"], doc["bank_version"], tuple(Booking(**b) for b in doc["bookings"]))
+    return BookingBank(doc["bank_id"], doc["bank_version"], tuple(Appointment(**a) for a in doc["appointments"]))
 
 
 @cache
@@ -159,20 +180,37 @@ def load_booking_bank(locale: str) -> BookingBank:
     return read_booking_bank(BookingProbe.assets_dir() / locale)
 
 
+def draw_booking(appointment: Appointment, rng: random.Random) -> Booking:
+    """A date, a time and a number of people for ``appointment``.
+
+    The day and the month are different numbers no greater than 12, so the date
+    reads as two different dates, day first and month first.
+    """
+    month = rng.randint(1, 12)
+    day = rng.choice([d for d in range(1, 13) if d != month])
+    return Booking(
+        id=appointment.id,
+        what=appointment.what,
+        date=f"2027-{month:02d}-{day:02d}",
+        time=f"{rng.randint(9, 17):02d}:{rng.choice(('00', '30'))}",
+        people=rng.randint(2, 6),
+        placeholder=appointment.placeholder,
+    )
+
+
 @register_probe(family="my_bookings", prompt_version="v1.0", variants=("default",))
-class BookingProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
+class BookingProbe(ToolExecutionMixin, BankBackedProbe):
     label = "my_bookings"
     description = (
         "Tests whether an assistant books what the user means: a date, a time and a number of people, "
         "written the way people write them in the user's language."
     )
-    preview_fields = (PreviewField("my_booking_id", "Booking id"),)
+    preview_fields = (PreviewField("my_booking_id", "Appointment"),)
     default_scorers = ("my_bookings",)
     assets_root = Path(__file__).parent / "assets"
     bank_loader = staticmethod(load_booking_bank)
     locale_bank_check = staticmethod(read_booking_bank)
     placeholder_warning_kind = "my_used_placeholder_booking"
-    verbatim_field = "opening"
     output_columns = ("my_booking_id", "my_booking")
 
     @classmethod
@@ -187,15 +225,18 @@ class BookingProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
 
     def derive_task(self, persona, bank, *, cfg):
         rng = random.Random(f"{persona_uuid(persona)}:{bank.bank_version}:{cfg.random_seed}")
-        return rng.choice(bank.bookings)
+        return draw_booking(rng.choice(bank.appointments), rng)
 
     def get_user_system_prompt(self) -> str:
+        task = self._task
         return "\n\n".join(
             [
                 format_persona_for_prompt(self._persona),
-                "You asked an assistant to book an appointment, giving the date and time. "
-                f"If it asks how many people are coming, the answer is {self._task.people}; "
-                "say it the way you would. Once it confirms the booking, thank it.",
+                f"You want an assistant to book {task.what} on {task.date} at {task.time}. "
+                "Ask for it in your own words, and write the date and time the way you would write them "
+                "yourself, not in the form they are given here. "
+                f"Say how many people are coming only if it asks; the answer is {task.people}. "
+                "Once it confirms the booking, thank it.",
                 language_instruction(self._language, self._locale),
             ]
         )
@@ -232,13 +273,12 @@ class BookingProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
   `book_appointment` in `get_tools_for_assistant`, and `execute_tool_call`
   answers each call. It records the first booking in `state.metadata`, with
   how many user turns came before it.
-- **`BankVerbatimMixin`** sends the booking's `opening`, the field
-  `verbatim_field` names, as turn 1, so the date reaches the assistant written
-  exactly as the user wrote it.
-- **`get_user_system_prompt`** sets up the user model for the turns after the
-  first: the persona, the number of people it gives only when the assistant
-  asks, and `language_instruction`, which keeps it writing in the run's
-  language.
+- **`get_user_system_prompt`** gives the user model the persona, what to book,
+  the date and time in the tool's form, and the number of people, to give only
+  if the assistant asks. It asks for the date and time written the way the user
+  would write them, and `language_instruction` keeps the user writing in the
+  run's language. The user model writes every user turn, the first included,
+  and the gate checks each one.
 - **`allow_early_stop_at_turn`** keeps the conversation going until the
   assistant books, so a user who adds a thank-you to the number of people does
   not end it before the booking is made.
@@ -246,8 +286,8 @@ class BookingProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
   assistant under test is told, so it answers as it would for any user.
 - **`description`** is what the per-row preview and the capability report
   show about the probe.
-- **`preview_fields`** puts the row's booking id in the per-row preview's Probe
-  Inputs panel.
+- **`preview_fields`** puts the row's appointment in the per-row preview's
+  Probe Inputs panel.
 - **`default_scorers`** names the package's scorer, so
   `usersim eval --scorers auto` runs it whenever a run holds the probe's rows,
   beside `language_compliance`, which checks that the assistant replied in the
@@ -261,27 +301,32 @@ class BookingProbe(ToolExecutionMixin, BankVerbatimMixin, BankBackedProbe):
   bank that loads stops before any model call rather than failing every row.
 - **`asset_problems`** reads each bank the package ships, so `usersim smoke` and
   `assert_probe_conforms` report an install that is missing one.
-- **`placeholder_warning_kind`** is the warning a row records when its booking
-  is marked `placeholder: true`. Its `<prefix>_used_placeholder_<thing>` form is
-  what the capability report counts as placeholder content.
+- **`placeholder_warning_kind`** is the warning a row records when its
+  appointment is marked `placeholder: true`. Its
+  `<prefix>_used_placeholder_<thing>` form is what the capability report counts
+  as placeholder content.
 - **`output_columns`** declares the columns `build_result_extras` adds, so a run
   keeps them. `my_booking` holds, as JSON, what the user meant and what the
   assistant booked.
-- **`derive_task`** picks the row's booking with a generator seeded from the
-  persona, the bank's version and the run's seed, never the global `random`, so
-  a row draws the same booking every time it runs.
+- **`derive_task`** picks the row's appointment, and `draw_booking` its date,
+  time and number of people, with a generator seeded from the persona, the
+  bank's version and the run's seed, never the global `random`, so a row draws
+  the same booking every time it runs.
 
 The banks, `assets/my_bookings/en_US/bookings.yaml`:
 
 ```yaml
 bank_id: my_bookings_en_US
 bank_version: "1.0.0"
-bookings:
+appointments:
   - id: museum_tour
-    opening: Hi! Can you book the guided museum tour for 04/03/2027 at 3:30 pm?
-    date: "2027-04-03"
-    time: "15:30"
-    people: 3
+    what: the guided tour of the city museum
+    placeholder: true
+  - id: restaurant
+    what: a table at a restaurant
+    placeholder: true
+  - id: pottery_class
+    what: a pottery class
     placeholder: true
 ```
 
@@ -290,21 +335,28 @@ and `assets/my_bookings/pt_BR/bookings.yaml`:
 ```yaml
 bank_id: my_bookings_pt_BR
 bank_version: "1.0.0"
-bookings:
+appointments:
   - id: museum_tour
-    opening: Oi! Você pode reservar a visita guiada ao museu para 04/03/2027 às 15h30?
-    date: "2027-03-04"
-    time: "15:30"
-    people: 3
+    what: a visita guiada ao museu da cidade
+    placeholder: true
+  - id: restaurant
+    what: uma mesa num restaurante
+    placeholder: true
+  - id: pottery_class
+    what: uma aula de cerâmica
     placeholder: true
 ```
 
-Both open with the same date, `04/03/2027`. A user writing American English
-means 3 April and a user writing Brazilian Portuguese means 4 March. An
-assistant that reads every date month first books the Brazilian user's tour a
-month late, and one that reads every date day first books the American user's
-a month early. Neither opening says how many people are coming, so an assistant
-that books on its first reply has to guess.
+Both banks name the same three appointments, each in its bank's language.
+Every date `draw_booking` picks reads as two dates. For `2027-03-06`, 6 March, a
+user who writes the day first, as people in Brazil do, writes `06/03/2027`,
+which an assistant that reads every date month first books for 3 June. A user
+who writes the month first, as people in the United States do, writes
+`03/06/2027`, which an assistant that reads every date day first gets wrong the
+other way. Whether the user writes the date in numbers or in words is the user
+model's choice, as it would be a person's. The user says how many people are
+coming only when asked, so an assistant that books on its first reply has to
+guess.
 
 `placeholder: true` marks content no subject-matter expert has reviewed, which
 for these banks means a native speaker of the bank's language; see
@@ -364,11 +416,19 @@ installed. With discovery off, the tests import the package to register it:
 
 ```python
 import json
+import random
 
 from usersim.extension import ConversationSimulatorConfig
-from usersim.testing import assert_hosted_parity, assert_probe_conforms, assert_scorer_conforms, run_episode
+from usersim.testing import (
+    ScriptedModel,
+    assert_hosted_parity,
+    assert_probe_conforms,
+    assert_scorer_conforms,
+    run_episode,
+)
 
 import my_bookings.probe  # noqa: F401  registers the probe; discovery is off under test
+from my_bookings.probe import Appointment, draw_booking
 from my_bookings.scorer import score
 
 PERSONA = {"first_name": "Ana", "last_name": "Souza", "age": 35, "city": "Recife"}
@@ -383,22 +443,31 @@ async def test_the_scorer_conforms():
     await assert_scorer_conforms("my_bookings")
 
 
-async def test_an_episode_opens_in_portuguese_and_records_the_booking():
+async def test_the_user_asks_for_the_drawn_booking_in_their_own_words():
     run = await run_episode("my_bookings", config=CONFIG, persona=PERSONA, language="Portuguese")
 
     assert run.row["conversation_status"] is True
-    opening = json.loads(run.row["conversation_messages"])[0]
-    assert opening["content"] == "Oi! Você pode reservar a visita guiada ao museu para 04/03/2027 às 15h30?"
     booking = json.loads(run.row["my_booking"])
-    assert booking["expected"] == {"date": "2027-03-04", "time": "15:30", "people": 3}
+    assert booking["expected"] == {"date": "2027-03-06", "time": "11:00", "people": 6}
+    instructions = run.prompts[0]["messages"][0]["content"]
+    assert "a visita guiada ao museu da cidade on 2027-03-06 at 11:00" in instructions
+    opening = json.loads(run.row["conversation_messages"])[0]
+    assert opening == {"role": "user", "content": ScriptedModel.CONTENT["user"]}  # the user model's own words
     assert booking["made"]["after_user_turns"] == 1  # the scripted assistant books on its first reply
     warnings = json.loads(run.row["simulation_outcome"])["warnings"]
     assert [w["kind"] for w in warnings] == ["my_used_placeholder_booking"]
 
 
+def test_every_drawn_date_reads_two_ways():
+    appointment = Appointment(id="museum_tour", what="the guided tour of the city museum", placeholder=True)
+    for seed in range(200):
+        _, month, day = draw_booking(appointment, random.Random(seed)).date.split("-")
+        assert month != day and int(month) <= 12 and int(day) <= 12
+
+
 async def test_a_month_first_reading_of_a_day_first_date_is_wrong():
-    made = {"arguments": {"date": "2027-04-03", "time": "15:30", "people": 3}, "after_user_turns": 2}
-    expected = {"date": "2027-03-04", "time": "15:30", "people": 3}
+    made = {"arguments": {"date": "2027-06-03", "time": "11:00", "people": 6}, "after_user_turns": 2}
+    expected = {"date": "2027-03-06", "time": "11:00", "people": 6}
     result = await score({"my_booking": json.dumps({"expected": expected, "made": made})}, models={})
 
     assert result == {
@@ -420,9 +489,12 @@ async def test_a_host_reproduces_a_standalone_run():
   empty fields.
 - **`run_episode`** runs a whole episode with scripted models, through the same
   generator as `usersim simulate`, with nothing patched and no provider. Here it
-  runs in `pt_BR`: the opening reaches the assistant as written, and the
-  scripted assistant, which calls a tool as soon as one is offered, books on its
-  first reply.
+  runs in `pt_BR`: the user model's instructions, the first prompt the episode
+  sends, hold the drawn booking, and the opening is what the user model
+  replied, the scripted user's stock line. The scripted assistant, which calls a
+  tool as soon as one is offered, books on its first reply.
+- **`draw_booking`** is tested on its own over many seeds, since one episode
+  draws one date.
 - **The scorer** is tested on a row built by hand, in which the assistant read
   the Brazilian date month first.
 - **`assert_hosted_parity`** checks that a host driving the probe through
diff --git a/src/usersim/extension.py b/src/usersim/extension.py
index f119334..d823c31 100644
--- a/src/usersim/extension.py
+++ b/src/usersim/extension.py
@@ -63,7 +63,7 @@
         ToolExecutionMixin,
         register_probe,
     )
-    from usersim.engine.core.prompt_loader import render_prompt
+    from usersim.engine.core.prompt_loader import get_prompt, load_prompt_file, render_prompt
     from usersim.engine.core.simulation import (
         ConversationState,
         finalize_completed,
@@ -119,6 +119,8 @@
     "format_interaction_style_instructions",
     "format_persona_for_prompt",
     "format_tools_for_prompt",
+    "get_prompt",
+    "load_prompt_file",
     "persona_full_name",
     "persona_uuid",
     "render_prompt",
@@ -189,7 +191,7 @@
         "ToolExecutionMixin",
         "register_probe",
     ),
-    "usersim.engine.core.prompt_loader": ("render_prompt",),
+    "usersim.engine.core.prompt_loader": ("get_prompt", "load_prompt_file", "render_prompt"),
     "usersim.engine.core.simulation": (
         "ConversationState",
         "finalize_completed",
diff --git a/templates/extension_package/README.md b/templates/extension_package/README.md
new file mode 100644
index 0000000..09a9c98
--- /dev/null
+++ b/templates/extension_package/README.md
@@ -0,0 +1,70 @@
+# Extension package template
+
+A package to copy when you start a probe of your own: the probe, its scorer, the
+assets they read and their tests, wired together. Every name in it is a
+placeholder to replace. [`docs/extensions.md`](../../docs/extensions.md) builds a
+complete package step by step and explains each piece.
+
+```
+extension_package/
+├── pyproject.toml
+├── src/my_probe/
+│   ├── __init__.py
+│   ├── probe.py
+│   ├── scorer.py
+│   └── assets/my_probe/
+│       ├── prompts.yaml
+│       ├── en_US/themes.yaml
+│       └── pt_BR/themes.yaml
+└── tests/
+    ├── conftest.py
+    └── test_my_probe.py
+```
+
+## The probe sets the area, and the persona explores it
+
+Each locale's `themes.yaml` lists the areas a run draws from, one per row: a
+topic and the bounds the conversation stays within. The simulated user gets the
+row's area through `prompts.yaml` and explores it in the persona's own words, so
+the probe never writes the user's messages. Keep it that way as you fill it in:
+write areas and their bounds, not messages to send.
+
+## Make it yours
+
+1. Copy this folder out of the repository, and rename `my-probe`, the
+   distribution, and `my_probe`, the package, the probe's label and the
+   scorer's name. Every name the package adds starts with your prefix, as
+   `my_tool_calls` and `my_tool_used` start with `my_`; see
+   [Names](../../docs/extensions.md#names).
+2. Write your areas in `themes.yaml`, one file per locale in its language, and
+   list each locale in `LOCALES` in `probe.py`.
+3. Write the user's instructions in `prompts.yaml`. `render_prompt` fills
+   `{persona}`, `{area}` and any column of the row.
+4. Replace `DO_TASK` with the tool your probe offers the assistant, or drop it,
+   `ToolExecutionMixin` and `execute_tool_call` if it offers none.
+5. Replace the scorer with what your probe measures.
+6. Name the User Sim releases the package works with in `pyproject.toml`.
+
+## Test it
+
+```bash
+uv sync
+uv run pytest
+uv run usersim smoke
+```
+
+The tests check the probe and the scorer against the contract, run an episode
+with scripted models and no provider, and check that a host driving the probe
+reproduces a standalone run. `make check-extensions` installs this template next
+to a freshly built User Sim and runs them, so the template keeps working as User
+Sim changes.
+
+## In this repository instead
+
+A probe that belongs in this repository keeps the same shape: `probe.py` with
+its assets in `assets/<label>/` beside it, under
+`src/usersim/engine/probes/<label>/`.
+[Where should a probe live?](../../CONTRIBUTING.md#where-should-a-probe-live)
+says when a probe belongs here, and
+[`AUTHORING_A_PROBE.md`](../../docs/engine/AUTHORING_A_PROBE.md) what else an
+in-tree probe needs.
diff --git a/templates/extension_package/pyproject.toml b/templates/extension_package/pyproject.toml
new file mode 100644
index 0000000..79f81e0
--- /dev/null
+++ b/templates/extension_package/pyproject.toml
@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "my-probe"
+version = "0.1.0"
+requires-python = ">=3.10"
+# Name the User Sim releases the package works with, such as "usersim>=0.2,<0.3":
+# the first release with every hook it uses, up to the next minor release.
+dependencies = ["usersim", "pyyaml"]
+
+[project.entry-points."usersim.probes"]
+my_probe = "my_probe.probe:MyProbe"
+
+[project.entry-points."usersim.scorers"]
+my_probe = "my_probe.scorer"
+
+[tool.setuptools.package-data]
+my_probe = ["assets/**/*.yaml"]
+
+[dependency-groups]
+dev = ["pytest", "pytest-asyncio", "pytest-env"]
+
+[tool.pytest.ini_options]
+env = ["USERSIM_DISABLE_EXTENSIONS=1"]
+asyncio_mode = "auto"
diff --git a/templates/extension_package/src/my_probe/__init__.py b/templates/extension_package/src/my_probe/__init__.py
new file mode 100644
index 0000000..14d054f
--- /dev/null
+++ b/templates/extension_package/src/my_probe/__init__.py
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""my_probe: replace with one line on what the probe tests."""
diff --git a/templates/extension_package/src/my_probe/assets/my_probe/en_US/themes.yaml b/templates/extension_package/src/my_probe/assets/my_probe/en_US/themes.yaml
new file mode 100644
index 0000000..e4312f2
--- /dev/null
+++ b/templates/extension_package/src/my_probe/assets/my_probe/en_US/themes.yaml
@@ -0,0 +1,7 @@
+# The areas a run draws from, one per row. Each sets a topic and the bounds the
+# conversation stays within; the simulated user explores it in their own words.
+# Replace these with yours, written in the locale's language.
+- type: first_area
+  description: Replace with an area for the user to explore, and the bounds it stays within.
+- type: second_area
+  description: Replace with another area, so rows explore different ground.
diff --git a/templates/extension_package/src/my_probe/assets/my_probe/prompts.yaml b/templates/extension_package/src/my_probe/assets/my_probe/prompts.yaml
new file mode 100644
index 0000000..141dc92
--- /dev/null
+++ b/templates/extension_package/src/my_probe/assets/my_probe/prompts.yaml
@@ -0,0 +1,7 @@
+# The simulated user's instructions, read with get_prompt. render_prompt fills
+# {persona}, {area} and any column of the row. Replace the text with yours.
+user_system_prompt: |
+  {persona}
+
+  You want an assistant's help with this: {area}
+  Ask in your own words, the way this person would, and follow up on what it says.
diff --git a/templates/extension_package/src/my_probe/assets/my_probe/pt_BR/themes.yaml b/templates/extension_package/src/my_probe/assets/my_probe/pt_BR/themes.yaml
new file mode 100644
index 0000000..787e041
--- /dev/null
+++ b/templates/extension_package/src/my_probe/assets/my_probe/pt_BR/themes.yaml
@@ -0,0 +1,7 @@
+# The areas a run draws from, one per row. Each sets a topic and the bounds the
+# conversation stays within; the simulated user explores it in their own words.
+# Replace these with yours, written in the locale's language.
+- type: first_area
+  description: Substitua por uma área para o usuário explorar e pelos limites em que a conversa fica.
+- type: second_area
+  description: Substitua por outra área, para que as linhas explorem terrenos diferentes.
diff --git a/templates/extension_package/src/my_probe/probe.py b/templates/extension_package/src/my_probe/probe.py
new file mode 100644
index 0000000..440e426
--- /dev/null
+++ b/templates/extension_package/src/my_probe/probe.py
@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from pathlib import Path
+
+import yaml
+
+from usersim.extension import (
+    BaseProbe,
+    ToolExecutionMixin,
+    format_persona_for_prompt,
+    get_prompt,
+    language_instruction,
+    load_prompt_file,
+    register_probe,
+    render_prompt,
+)
+
+#: The locales the package ships themes for. A new locale is a folder under
+#: assets/my_probe/ holding a themes.yaml in its language, plus an entry here.
+LOCALES = ("en_US", "pt_BR")
+
+#: The tool the assistant under test is offered. Replace it with yours, or drop
+#: it, ToolExecutionMixin and execute_tool_call if the probe offers none.
+DO_TASK = {
+    "type": "function",
+    "function": {
+        "name": "do_task",
+        "description": "Replace with what the tool does.",
+        "parameters": {
+            "type": "object",
+            "properties": {"argument": {"type": "string", "description": "Replace with what the tool takes."}},
+            "required": ["argument"],
+        },
+    },
+}
+
+#: The instructions used when prompts.yaml has none; asset_problems reports that case.
+DEFAULT_USER_PROMPT = "{persona}\n\nYou want an assistant's help with this: {area}"
+
+
+def read_themes(locale_dir: Path) -> list[dict]:
+    """The areas in one locale's ``themes.yaml``, each with a ``description``."""
+    themes = yaml.safe_load((locale_dir / "themes.yaml").read_text(encoding="utf-8"))
+    if not themes or not all("description" in theme for theme in themes):
+        raise ValueError(f"{locale_dir / 'themes.yaml'} needs at least one theme, each with a description")
+    return themes
+
+
+@register_probe(family="my_probe", prompt_version="v1.0", variants=("default",))
+class MyProbe(ToolExecutionMixin, BaseProbe):
+    label = "my_probe"
+    description = "Replace with what the probe tests, as the per-row preview and the capability report show it."
+    assets_root = Path(__file__).parent / "assets"
+    locale_bank_check = staticmethod(read_themes)
+    default_scorers = ("my_probe",)
+    output_columns = ("my_tool_calls",)
+
+    @classmethod
+    def themes(cls, locale: str) -> list[dict]:
+        return read_themes(cls.assets_dir() / locale)
+
+    @classmethod
+    def asset_problems(cls) -> list[str]:
+        problems = []
+        for locale in LOCALES:
+            try:
+                read_themes(cls.assets_dir() / locale)
+            except Exception as error:
+                problems.append(f"{locale}: {type(error).__name__}: {error}")
+        if "user_system_prompt" not in load_prompt_file(cls.label):
+            problems.append("prompts.yaml has no user_system_prompt")
+        return problems
+
+    def get_user_system_prompt(self) -> str:
+        prompt = render_prompt(
+            get_prompt(self.label, "user_system_prompt", DEFAULT_USER_PROMPT),
+            self._data,
+            persona=format_persona_for_prompt(self._persona),
+            area=self.theme()["description"],
+        )
+        return f"{prompt}\n\n{language_instruction(self._language, self._locale)}"
+
+    def get_assistant_system_prompt(self) -> str:
+        return ""
+
+    def get_tools_for_assistant(self) -> list:
+        return [DO_TASK]
+
+    async def execute_tool_call(self, name, args, tc, state, models, *, turn_idx, call_idx) -> str:
+        state.metadata.setdefault("my_tool_calls", []).append({"name": name, "arguments": args})
+        return json.dumps({"status": "done"})
+
+    def build_result_extras(self, state) -> dict:
+        calls = state.metadata.get("my_tool_calls", [])
+        return {**super().build_result_extras(state), "my_tool_calls": json.dumps(calls, ensure_ascii=False)}
diff --git a/templates/extension_package/src/my_probe/scorer.py b/templates/extension_package/src/my_probe/scorer.py
new file mode 100644
index 0000000..d1f770b
--- /dev/null
+++ b/templates/extension_package/src/my_probe/scorer.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+
+from usersim.extension import register_scorer
+
+
+async def score(row, models):
+    """Whether the assistant used the tool. Replace with what your probe measures."""
+    if not row.get("my_tool_calls"):
+        return {}
+    return {"my_tool_used": float(bool(json.loads(row["my_tool_calls"])))}
+
+
+register_scorer("my_probe", score, deterministic=True)
diff --git a/templates/extension_package/tests/conftest.py b/templates/extension_package/tests/conftest.py
new file mode 100644
index 0000000..cd93e58
--- /dev/null
+++ b/templates/extension_package/tests/conftest.py
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+pytest_plugins = ["usersim.testing.pytest_plugin"]
diff --git a/templates/extension_package/tests/test_my_probe.py b/templates/extension_package/tests/test_my_probe.py
new file mode 100644
index 0000000..4d60c86
--- /dev/null
+++ b/templates/extension_package/tests/test_my_probe.py
@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from importlib.metadata import entry_points
+
+from my_probe.probe import MyProbe  # registers the probe; discovery is off under test
+from my_probe.scorer import score
+
+from usersim.extension import ConversationSimulatorConfig
+from usersim.testing import (
+    ScriptedModel,
+    assert_hosted_parity,
+    assert_probe_conforms,
+    assert_scorer_conforms,
+    run_episode,
+)
+
+PERSONA = {"first_name": "Ana", "last_name": "Souza", "age": 35, "city": "Recife"}
+CONFIG = ConversationSimulatorConfig(name="conversation_messages", max_turns=2, random_seed=7, locale="pt_BR")
+AREA = MyProbe.themes("pt_BR")[0]
+
+
+def test_the_entry_points_name_the_probe_and_the_scorer():
+    assert {ep.name: ep.value for ep in entry_points(group="usersim.probes")}["my_probe"] == "my_probe.probe:MyProbe"
+    assert {ep.name: ep.value for ep in entry_points(group="usersim.scorers")}["my_probe"] == "my_probe.scorer"
+
+
+def test_the_probe_conforms():
+    assert_probe_conforms("my_probe")
+
+
+async def test_the_scorer_conforms():
+    await assert_scorer_conforms("my_probe")
+
+
+async def test_the_user_explores_the_row_area_in_their_own_words():
+    run = await run_episode("my_probe", config=CONFIG, persona=PERSONA, data={"theme": AREA}, language="Portuguese")
+
+    assert run.row["conversation_status"] is True
+    instructions = run.prompts[0]["messages"][0]["content"]
+    assert AREA["description"] in instructions
+    opening = json.loads(run.row["conversation_messages"])[0]
+    assert opening == {"role": "user", "content": ScriptedModel.CONTENT["user"]}  # the user model's own words
+    calls = json.loads(run.row["my_tool_calls"])
+    assert [call["name"] for call in calls] == ["do_task"]  # the scripted assistant calls the tool it is offered
+
+
+async def test_the_scorer_reads_the_tool_calls():
+    assert await score({"my_tool_calls": json.dumps([{"name": "do_task", "arguments": {}}])}, models={}) == {
+        "my_tool_used": 1.0
+    }
+    assert await score({"my_tool_calls": "[]"}, models={}) == {"my_tool_used": 0.0}
+
+
+async def test_a_host_reproduces_a_standalone_run():
+    await assert_hosted_parity("my_probe", config=CONFIG, persona=PERSONA, data={"theme": AREA}, language="Portuguese")
diff --git a/templates/probe/README.md b/templates/probe/README.md
index 942e7e9..57a3432 100644
--- a/templates/probe/README.md
+++ b/templates/probe/README.md
@@ -23,6 +23,13 @@ do we need to surface?* Each probe owns:
   `target_request_id`, `action_request_id`, …) that the matching
   out-of-sim scorer reads.
 
+A probe sets the area a conversation explores, a topic or a task and the
+facts a scorer checks, and the simulated user explores it in the persona's own
+words. Hand the user model the area, not a message to send: a fixed opening
+starts every row in a locale the same way. Send a bank's text verbatim only
+when its exact wording is what the probe tests, such as a false premise;
+Step 0 of the authoring tutorial says which shape fits.
+
 If the new "probe" is just a different prompt for an existing probe,
 prefer a `probe_variant` over a new module.
 
diff --git a/templates/probe/generator_baseprobe_only.py b/templates/probe/generator_baseprobe_only.py
index 9490061..226f7f7 100644
--- a/templates/probe/generator_baseprobe_only.py
+++ b/templates/probe/generator_baseprobe_only.py
@@ -3,9 +3,12 @@
 
 """Probe template — BaseProbe only, no asset bank.
 
-Use this shape when the probe asks general questions of the assistant
-without needing reviewer-curated content (the ``general_open_ended``
-and ``general_educational`` probes use this shape).
+Use this shape when the probe sets topics for the simulated user to
+explore, without needing reviewer-curated content (the
+``general_open_ended`` and ``general_educational`` probes use this
+shape). Each row draws one topic from ``themes(locale)``, and the user
+explores it in the persona's own words: the probe sets the area, never
+the message.
 
 What the unified ``ConversationLoop`` provides for you:
 - Multi-turn back-and-forth with the user-LLM.
@@ -15,7 +18,10 @@
 - Frustration escalation, early-stop heuristics.
 
 What you provide:
-- The user-agent system prompt (how the simulated user behaves).
+- ``themes(locale)``: the topics a run draws from, one per row, each a
+  mapping with at least a ``description``.
+- The user-agent system prompt (how the simulated user behaves, and the
+  row's topic).
 - The assistant system prompt (empty per pure-capability-test policy;
   see docs/engine/README.md "Assistant under test").
 
@@ -25,6 +31,10 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
+import yaml
+
 # After you copy this file into ``src/usersim/engine/probes/<your_probe>/``,
 # also copy ``prompts.py`` next to it and import from
 # ``usersim.engine.probes.<your_probe>.prompts``.
@@ -44,12 +54,21 @@ class DemoGeneralProbe(BaseProbe):
     """Smallest viable probe — no asset bank, default everything else."""
 
     label = "demo_general"
+    assets_root = Path(__file__).parent / "assets"  # holds demo_general/, beside this module
+
+    @classmethod
+    def themes(cls, locale: str) -> list[dict]:
+        # One file of topics per locale, written in its language. A run
+        # draws one per row and stores it in the row's ``theme`` column.
+        return yaml.safe_load((cls.assets_dir() / locale / "themes.yaml").read_text(encoding="utf-8"))
 
     def get_user_system_prompt(self) -> str:
-        return DEMO_USER_AGENT_PROMPTS.get(
+        prompt = DEMO_USER_AGENT_PROMPTS.get(
             self._locale,
             persona=self._persona.get("first_name", "the user"),
         )
+        # The topic bounds the conversation; the persona picks the question.
+        return f"{prompt}\n\nTopic: {self.theme()['description']}"
 
     def get_assistant_system_prompt(self) -> str:
         # Pure-capability-test policy. Empty system prompt;
diff --git a/tests/test_extension_api.py b/tests/test_extension_api.py
index f4d700a..5679cd6 100644
--- a/tests/test_extension_api.py
+++ b/tests/test_extension_api.py
@@ -39,6 +39,7 @@
     *sorted((_REPO / "templates" / "probe").glob("*.py")),
     _REPO / "templates" / "probe" / "test_probe.py.template",
     *sorted((_REPO / "tests" / "fixtures" / "extension_package" / "usersim_extension_fixture").glob("*.py")),
+    *sorted((_REPO / "templates" / "extension_package").rglob("*.py")),
 )
 
 #: Pages whose Python examples an extension author copies.
@@ -56,6 +57,7 @@
     ("usersim.engine.probes.YOUR_PROBE", "probe"),
     ("usersim.engine.probes.bookings.bank", "LOCALES"),
     ("usersim.engine.probes.bookings.bank", "Booking"),
+    ("usersim.engine.probes.bookings.bank", "draw_booking"),
     ("usersim.engine.probes.bookings.bank", "read_booking_bank"),
     ("usersim.engine.probes.bookings.prompts", "BOOKINGS_USER_PROMPTS"),
     ("usersim.engine.probes.my_probe.bank", "load_my_bank_default"),