diff --git a/src/pragmata/annotation/__init__.py b/src/pragmata/annotation/__init__.py
index 16f377c2..6c0a39e5 100644
--- a/src/pragmata/annotation/__init__.py
+++ b/src/pragmata/annotation/__init__.py
@@ -17,6 +17,7 @@
     "ExportResult",
     "IaaReport",
     "ImportResult",
+    "Locale",
     "SetupResult",
     "Task",
     "UserSpec",
@@ -31,6 +32,7 @@
     "ExportResult": ("pragmata.core.annotation.export_runner", "ExportResult"),
     "IaaReport": ("pragmata.core.schemas.iaa_report", "IaaReport"),
     "ImportResult": ("pragmata.api.annotation_import", "ImportResult"),
+    "Locale": ("pragmata.core.schemas.annotation_task", "Locale"),
     "SetupResult": ("pragmata.core.annotation.setup", "SetupResult"),
     "Task": ("pragmata.core.schemas.annotation_task", "Task"),
     "UserSpec": ("pragmata.core.settings.annotation_settings", "UserSpec"),
@@ -65,6 +67,7 @@ def __dir__() -> list[str]:
     from pragmata.api.annotation_setup import teardown as teardown
     from pragmata.core.annotation.export_runner import ExportResult as ExportResult
     from pragmata.core.annotation.setup import SetupResult as SetupResult
+    from pragmata.core.schemas.annotation_task import Locale as Locale
     from pragmata.core.schemas.annotation_task import Task as Task
     from pragmata.core.schemas.iaa_report import IaaReport as IaaReport
     from pragmata.core.settings.annotation_settings import UserSpec as UserSpec
diff --git a/src/pragmata/api/__init__.py b/src/pragmata/api/__init__.py
index f521ae0f..f4ea5c25 100644
--- a/src/pragmata/api/__init__.py
+++ b/src/pragmata/api/__init__.py
@@ -1,7 +1,7 @@
 """Internal API layer."""
 
-from pragmata.core.settings.settings_base import UNSET
+from pragmata.core.settings.settings_base import UNSET, Unset
 
 from .version import get_version
 
-__all__ = ["get_version", "UNSET"]
+__all__ = ["get_version", "UNSET", "Unset"]
diff --git a/src/pragmata/api/annotation_import.py b/src/pragmata/api/annotation_import.py
index 5733cea1..a9b4867c 100644
--- a/src/pragmata/api/annotation_import.py
+++ b/src/pragmata/api/annotation_import.py
@@ -22,6 +22,7 @@
     resolve_import_paths,
 )
 from pragmata.core.paths.paths import WorkspacePaths
+from pragmata.core.schemas.annotation_task import Locale
 from pragmata.core.settings.annotation_settings import AnnotationSettings
 from pragmata.core.settings.settings_base import UNSET, Unset, load_config_file, resolve_api_key
 
@@ -65,6 +66,9 @@ def import_records(
     base_dir: str | Path | Unset = UNSET,
     config_path: str | Path | Unset = UNSET,
     calibration_fraction: float | Unset = UNSET,
+    calibration_min_submitted: int | None | Unset = UNSET,
+    calibration_partition_seed: int | Unset = UNSET,
+    locale: Locale | Unset = UNSET,
 ) -> ImportResult:
     """Validate and fan out records to per-purpose Argilla annotation datasets.
 
@@ -91,6 +95,9 @@ def import_records(
     Credential resolution:
     - ``api_url``: kwarg > ``ARGILLA_API_URL`` env > config (``argilla.api_url``)
     - ``api_key``: kwarg > ``ARGILLA_API_KEY`` env (secrets never live in config)
+    - ``locale``: kwarg > ``--config`` file (``annotation.locale``) > default
+      EN. Cascades to per-workspace/per-task overrides defined in the YAML
+      config.
 
     Args:
         records: Input data — list[dict], file path (str/Path), HF Dataset,
@@ -106,6 +113,18 @@ def import_records(
             dataset for this import. Falls through to YAML config and the
             built-in default (0.1) when omitted. Set to 0.0 for
             production-only batches.
+        calibration_min_submitted: Deployment-level overlap requirement for
+            the calibration dataset. ``None`` disables calibration entirely
+            (must be paired with ``calibration_fraction=0.0``). Inherits to
+            workspaces/tasks unless they override it.
+        calibration_partition_seed: Deterministic seed used to assign new
+            records to calibration vs production buckets. Existing
+            assignments are locked by the partition manifest; this only
+            affects records not yet seen.
+        locale: Deployment-level UI locale for Argilla dataset
+            titles/questions/guidelines used when auto-creating datasets.
+            Cascades to workspaces/tasks unless they carve out their own
+            value in YAML.
 
     Returns:
         ImportResult with totals, per-dataset counts, partition counts, and
@@ -120,6 +139,9 @@ def import_records(
             "dataset_id": dataset_id,
             "base_dir": base_dir,
             "calibration_fraction": calibration_fraction,
+            "calibration_min_submitted": calibration_min_submitted,
+            "calibration_partition_seed": calibration_partition_seed,
+            "locale": locale,
         },
     )
 
diff --git a/src/pragmata/api/annotation_setup.py b/src/pragmata/api/annotation_setup.py
index 2abf6783..f148605e 100644
--- a/src/pragmata/api/annotation_setup.py
+++ b/src/pragmata/api/annotation_setup.py
@@ -31,7 +31,7 @@ def setup(
 
     Datasets are not created here — they are auto-created on import,
     scoped by dataset_id. Per-task overlap (production and calibration
-    ``min_submitted``) is configured via ``workspace_dataset_map`` in the
+    ``min_submitted``) is configured via ``workspaces`` in the
     YAML config.
 
     Settings are resolved from config file and/or keyword overrides. Omitted
diff --git a/src/pragmata/cli/commands/annotation.py b/src/pragmata/cli/commands/annotation.py
index de8476b2..410866fd 100644
--- a/src/pragmata/cli/commands/annotation.py
+++ b/src/pragmata/cli/commands/annotation.py
@@ -2,8 +2,8 @@
 
 import typer
 
-from pragmata.api import UNSET
-from pragmata.cli.parsing import parse_tasks, parse_user_specs
+from pragmata.api import UNSET, Unset
+from pragmata.cli.parsing import parse_locale, parse_tasks, parse_user_specs
 
 annotation_app = typer.Typer(help="Annotation pipeline commands.")
 
@@ -35,7 +35,7 @@ def setup_command(
 
     Datasets are created automatically on import, not here. Per-task overlap
     (production and calibration ``min_submitted``) is configured via
-    ``workspace_dataset_map`` in the YAML config (``--config``).
+    ``workspaces`` in the YAML config (``--config``).
     """
     from pragmata import annotation
 
@@ -97,6 +97,25 @@ def import_command(
         "Falls through to YAML config and built-in default (0.1) when omitted; "
         "set to 0.0 for production-only batches.",
     ),
+    no_calibration: bool = typer.Option(
+        False,
+        "--no-calibration",
+        help="Disable calibration entirely for this batch: sets calibration_min_submitted=None "
+        "and calibration_fraction=0.0. Cannot be combined with --calibration-fraction > 0.",
+    ),
+    calibration_partition_seed: int | None = typer.Option(
+        None,
+        "--calibration-partition-seed",
+        help="Deterministic seed for assigning new records to calibration vs production. "
+        "Existing assignments are locked by the partition manifest.",
+    ),
+    locale: str | None = typer.Option(
+        None,
+        "--locale",
+        help="Deployment-level UI locale for Argilla dataset titles/questions/guidelines "
+        "(en, de). Inherits to workspaces/tasks unless they carve out a value in YAML. "
+        "Falls back to config, then 'en'.",
+    ),
 ) -> None:
     """Validate and import records into annotation datasets.
 
@@ -106,6 +125,22 @@ def import_command(
     """
     from pragmata import annotation
 
+    if no_calibration and calibration_fraction is not None and calibration_fraction > 0:
+        typer.echo(
+            "Error: --no-calibration cannot be combined with --calibration-fraction > 0.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+
+    resolved_calibration_fraction: float | Unset
+    resolved_calibration_min_submitted: int | None | Unset
+    if no_calibration:
+        resolved_calibration_fraction = 0.0
+        resolved_calibration_min_submitted = None
+    else:
+        resolved_calibration_fraction = UNSET if calibration_fraction is None else calibration_fraction
+        resolved_calibration_min_submitted = UNSET
+
     result = annotation.import_records(
         records,
         api_url=UNSET if api_url is None else api_url,
@@ -114,7 +149,10 @@ def import_command(
         dataset_id=UNSET if dataset_id is None else dataset_id,
         base_dir=UNSET if base_dir is None else base_dir,
         config_path=UNSET if config is None else config,
-        calibration_fraction=UNSET if calibration_fraction is None else calibration_fraction,
+        calibration_fraction=resolved_calibration_fraction,
+        calibration_min_submitted=resolved_calibration_min_submitted,
+        calibration_partition_seed=UNSET if calibration_partition_seed is None else calibration_partition_seed,
+        locale=parse_locale(locale) or UNSET,
     )
     typer.echo(f"Total records: {result.total_records}")
     typer.echo(
diff --git a/src/pragmata/cli/parsing.py b/src/pragmata/cli/parsing.py
index fe79d657..73a6cbef 100644
--- a/src/pragmata/cli/parsing.py
+++ b/src/pragmata/cli/parsing.py
@@ -7,7 +7,7 @@
 from pragmata.api import UNSET
 
 if TYPE_CHECKING:
-    from pragmata.annotation import Task, UserSpec
+    from pragmata.annotation import Locale, Task, UserSpec
 
 
 def parse_cli_value(value: str | None) -> Any:
@@ -51,6 +51,22 @@ def parse_tasks(raw: str | None) -> "list[Task] | None":
     return [Task(item.strip()) for item in raw.split(",")]
 
 
+def parse_locale(raw: str | None) -> "Locale | None":
+    """Parse a locale string (e.g. ``en``, ``de``).
+
+    Returns None when no locale is supplied, leaving locale selection to
+    the downstream default. Raises ``ValueError`` if the locale is unknown.
+    """
+    from pragmata.core.annotation.locales.registry import CATALOGS
+
+    if raw is None:
+        return None
+    locale = raw.strip()
+    if locale not in CATALOGS:
+        raise ValueError(f"Unknown locale: {locale!r}. Supported: {sorted(CATALOGS)}")
+    return locale
+
+
 def parse_user_specs(path: str | None) -> "list[UserSpec] | None":
     """Load annotator user specs from a JSON file.
 
diff --git a/src/pragmata/core/annotation/argilla_task_definitions.py b/src/pragmata/core/annotation/argilla_task_definitions.py
index 449c2e98..de757197 100644
--- a/src/pragmata/core/annotation/argilla_task_definitions.py
+++ b/src/pragmata/core/annotation/argilla_task_definitions.py
@@ -5,18 +5,44 @@
 core/settings/). They encode the annotation protocol (fields, questions, labels)
 and are hardcoded per ADR-0009.
 
+Display strings (titles, guidelines, and label option text) are looked up
+from per-locale catalogs in :mod:`pragmata.core.annotation.locales`.
+Identities (field/question ``name=``) and label *values* (``"yes"``,
+``"no"``, ``DiscardReason.*.value``) are stable across locales — exports
+carry the value, not the display text, so they merge cleanly across
+multi-language deployments.
+
 Distribution (min_submitted) is intentionally omitted — it is an operational
-setting controlled by AnnotationSettings.workspace_dataset_map and applied at
+setting controlled by AnnotationSettings.workspaces and applied at
 dataset creation time.
 """
 
 import functools
+import json
 from importlib.resources import files
 from string import Template
+from typing import Any
 
 import argilla as rg
 
-from pragmata.core.schemas.annotation_task import DiscardReason, Task
+from pragmata.core.annotation.locales.loader import DISCARD_WIDGET_KEYS
+from pragmata.core.annotation.locales.registry import CATALOGS, get_catalog
+from pragmata.core.annotation.locales.types import Catalog, CatalogKind
+from pragmata.core.schemas.annotation_task import DiscardReason, Locale, Task
+
+
+class _DiscardTemplate(Template):
+    """``string.Template`` with ``@@`` delimiter; JS body uses ``$nuxt``/``$i18n``.
+
+    The discard_flow.html template body contains literal ``$``-references
+    (``$nuxt``, ``$i18n``, ``$el``); switching the delimiter to ``@@``
+    keeps those intact. When editing discard_flow.html, do not introduce
+    ``@@`` tokens in the JS or HTML body unless you intend them as
+    substitution placeholders.
+    """
+
+    delimiter = "@@"
+
 
 DATASET_NAMES: dict[Task, str] = {
     Task.RETRIEVAL: "retrieval",
@@ -50,69 +76,128 @@ def _collapsible_field(name: str, title: str, template_text: str) -> rg.CustomFi
     )
 
 
-def _discard_questions() -> list[rg.LabelQuestion | rg.TextQuestion]:
+def _localised_labels(catalog: Catalog, task: Task, question: str, values: list[str]) -> dict[str, str]:
+    """Build the value→display-text map Argilla's LabelQuestion accepts as ``labels=``.
+
+    The stored value (dict key) is the machine identifier — what lands in
+    exports. The display text (dict value) is what the annotator sees in
+    the UI. Catalog key: ``(task, "label", "<question>.<value>")``.
+    """
+    return {value: catalog[(task, "label", f"{question}.{value}")] for value in values}
+
+
+def _discard_questions(task: Task, catalog: Catalog) -> list[rg.LabelQuestion | rg.TextQuestion]:
+    discard_reason_values = [r.value for r in DiscardReason]
     return [
         rg.LabelQuestion(
             name="discard_reason",
-            title="Discard reason",
-            labels=[r.value for r in DiscardReason],
+            title=catalog[(task, "question", "discard_reason")],
+            labels=_localised_labels(catalog, task, "discard_reason", discard_reason_values),
+            required=False,
+        ),
+        rg.TextQuestion(
+            name="discard_notes",
+            title=catalog[(task, "question", "discard_notes")],
             required=False,
         ),
-        rg.TextQuestion(name="discard_notes", title="Discard notes (optional)", required=False),
     ]
 
 
+def _discard_i18n_payload_for_locale(loc: Locale, task: Task) -> dict[str, Any]:
+    """Per-locale block of strings the discard widget JS reads at runtime.
+
+    Includes the widget's own chrome strings, the discard-reason option
+    list (value + display text), and the two helper-question titles the
+    widget uses for ``aria-label`` matching when scoping the native
+    Argilla cards it hides.
+    """
+    catalog = CATALOGS[loc]
+    payload: dict[str, Any] = {key: catalog[(task, "widget", f"discard.{key}")] for key in DISCARD_WIDGET_KEYS}
+    payload["discard_reason_title"] = catalog[(task, "question", "discard_reason")]
+    payload["discard_notes_title"] = catalog[(task, "question", "discard_notes")]
+    payload["reason_options"] = [
+        {"value": r.value, "text": catalog[(task, "label", f"discard_reason.{r.value}")]} for r in DiscardReason
+    ]
+    return payload
+
+
+def _render_discard_template(template_text: str, task: Task, dataset_locale: Locale) -> str:
+    """Substitute the all-locales i18n payload into ``discard_flow.html``.
+
+    The widget JS picks the active locale at runtime (Argilla's chrome
+    locale, with a fallback chain). All supported locales are shipped so
+    the switch is instant. ``SUPPORTED_LOCALES`` is ordered with the
+    dataset's creation locale first; this is defensive only -- the JS
+    iterates every locale when matching ``aria-label`` attributes and
+    EN/DE titles do not collide today.
+    """
+    locales_in_order = [dataset_locale] + [loc for loc in sorted(CATALOGS) if loc != dataset_locale]
+    i18n_payload = {loc: _discard_i18n_payload_for_locale(loc, task) for loc in locales_in_order}
+    return _DiscardTemplate(template_text).substitute(
+        I18N_JSON=json.dumps(i18n_payload, ensure_ascii=False),
+        SUPPORTED_LOCALES_JSON=json.dumps(locales_in_order),
+        DEFAULT_LOCALE_JSON=json.dumps(dataset_locale),
+    )
+
+
 @functools.cache
-def build_task_settings() -> dict[Task, rg.Settings]:
-    """Build Argilla Settings for each annotation task.
+def build_task_settings(locale: Locale = "en") -> dict[Task, rg.Settings]:
+    """Build Argilla Settings for each annotation task, in the given locale.
 
     Deferred construction — call after an Argilla client is connected
-    (or with a mock client in tests). Cached after first call.
+    (or with a mock client in tests). Cached per locale after first call.
     """
+    catalog = get_catalog(locale)
     template_text = files("pragmata.core.annotation").joinpath("collapsible_field.html").read_text(encoding="utf-8")
     discard_template = files("pragmata.core.annotation").joinpath("discard_flow.html").read_text(encoding="utf-8")
 
     # Fresh CustomField per task — FieldBase carries a `_dataset` attribute that
     # Argilla's Settings/Dataset plumbing mutates, so sharing one instance across
     # three rg.Settings risks cross-task coupling on future SDK changes.
-    def discard_field() -> rg.CustomField:
+    def discard_field(task: Task) -> rg.CustomField:
         return rg.CustomField(
             name="discard_flow",
-            title="Discard this record",
-            template=discard_template,
+            title=catalog[(task, "field", "discard_flow")],
+            template=_render_discard_template(discard_template, task, locale),
             advanced_mode=True,
             required=False,
         )
 
+    def t(task: Task, kind: CatalogKind, name: str) -> str:
+        return catalog[(task, kind, name)]
+
+    def _yes_no(task: Task, question: str) -> dict[str, str]:
+        return _localised_labels(catalog, task, question, ["yes", "no"])
+
     return {
         Task.RETRIEVAL: rg.Settings(
             fields=[
-                rg.TextField(name="query", title="Query", required=True),
-                rg.TextField(name="chunk", title="Chunk", required=True),
-                _collapsible_field("generated_answer", "Generated answer", template_text),
-                discard_field(),
+                rg.TextField(name="query", title=t(Task.RETRIEVAL, "field", "query"), required=True),
+                rg.TextField(name="chunk", title=t(Task.RETRIEVAL, "field", "chunk"), required=True),
+                _collapsible_field("generated_answer", t(Task.RETRIEVAL, "field", "generated_answer"), template_text),
+                discard_field(Task.RETRIEVAL),
             ],
             questions=[
                 rg.LabelQuestion(
                     name="topically_relevant",
-                    title="Does this passage contain information that is substantively relevant to the query?",
-                    labels=["yes", "no"],
+                    title=t(Task.RETRIEVAL, "question", "topically_relevant"),
+                    labels=_yes_no(Task.RETRIEVAL, "topically_relevant"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="evidence_sufficient",
-                    title="Does this passage provide sufficient evidence to support answering the query?",
-                    labels=["yes", "no"],
+                    title=t(Task.RETRIEVAL, "question", "evidence_sufficient"),
+                    labels=_yes_no(Task.RETRIEVAL, "evidence_sufficient"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="misleading",
-                    title="Could this passage plausibly lead to an incorrect or distorted answer?",
-                    labels=["yes", "no"],
+                    title=t(Task.RETRIEVAL, "question", "misleading"),
+                    labels=_yes_no(Task.RETRIEVAL, "misleading"),
                     required=True,
                 ),
-                rg.TextQuestion(name="notes", title="Notes (optional)", required=False),
-                *_discard_questions(),
+                rg.TextQuestion(name="notes", title=t(Task.RETRIEVAL, "question", "notes"), required=False),
+                *_discard_questions(Task.RETRIEVAL, catalog),
             ],
             metadata=[
                 rg.TermsMetadataProperty("record_uuid", visible_for_annotators=False),
@@ -121,100 +206,100 @@ def discard_field() -> rg.CustomField:
                 rg.TermsMetadataProperty("doc_id", visible_for_annotators=False),
                 rg.IntegerMetadataProperty("chunk_rank", min=1, visible_for_annotators=False),
             ],
-            guidelines="Retrieval. TODO: Revisit after first annotation iteration.",
+            guidelines=t(Task.RETRIEVAL, "guidelines", ""),
         ),
         Task.GROUNDING: rg.Settings(
             fields=[
-                rg.TextField(name="answer", title="Answer", required=True),
-                rg.TextField(name="context_set", title="Context set", required=True),
-                _collapsible_field("query", "Query", template_text),
-                discard_field(),
+                rg.TextField(name="answer", title=t(Task.GROUNDING, "field", "answer"), required=True),
+                rg.TextField(name="context_set", title=t(Task.GROUNDING, "field", "context_set"), required=True),
+                _collapsible_field("query", t(Task.GROUNDING, "field", "query"), template_text),
+                discard_field(Task.GROUNDING),
             ],
             questions=[
                 rg.LabelQuestion(
                     name="support_present",
-                    title="Is at least one claim in the answer supported by the provided context?",
-                    labels=["yes", "no"],
+                    title=t(Task.GROUNDING, "question", "support_present"),
+                    labels=_yes_no(Task.GROUNDING, "support_present"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="unsupported_claim_present",
-                    title="Does the answer contain claims not supported by the provided context?",
-                    labels=["yes", "no"],
+                    title=t(Task.GROUNDING, "question", "unsupported_claim_present"),
+                    labels=_yes_no(Task.GROUNDING, "unsupported_claim_present"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="contradicted_claim_present",
-                    title="Does the provided context contradict any claim in the answer?",
-                    labels=["yes", "no"],
+                    title=t(Task.GROUNDING, "question", "contradicted_claim_present"),
+                    labels=_yes_no(Task.GROUNDING, "contradicted_claim_present"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="source_cited",
-                    title="Does the answer contain a citation marker?",
-                    labels=["yes", "no"],
+                    title=t(Task.GROUNDING, "question", "source_cited"),
+                    labels=_yes_no(Task.GROUNDING, "source_cited"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="fabricated_source",
-                    title="Does the answer cite a source not present in the retrieved context?",
-                    labels=["yes", "no"],
+                    title=t(Task.GROUNDING, "question", "fabricated_source"),
+                    labels=_yes_no(Task.GROUNDING, "fabricated_source"),
                     required=True,
                 ),
-                rg.TextQuestion(name="notes", title="Notes (optional)", required=False),
-                *_discard_questions(),
+                rg.TextQuestion(name="notes", title=t(Task.GROUNDING, "question", "notes"), required=False),
+                *_discard_questions(Task.GROUNDING, catalog),
             ],
             metadata=[
                 rg.TermsMetadataProperty("record_uuid", visible_for_annotators=False),
                 rg.TermsMetadataProperty("language", visible_for_annotators=False),
             ],
-            guidelines="Grounding. TODO: Revisit after first annotation iteration.",
+            guidelines=t(Task.GROUNDING, "guidelines", ""),
         ),
         Task.GENERATION: rg.Settings(
             fields=[
-                rg.TextField(name="query", title="Query", required=True),
-                rg.TextField(name="answer", title="Answer", required=True),
-                _collapsible_field("context_set", "Context set", template_text),
-                discard_field(),
+                rg.TextField(name="query", title=t(Task.GENERATION, "field", "query"), required=True),
+                rg.TextField(name="answer", title=t(Task.GENERATION, "field", "answer"), required=True),
+                _collapsible_field("context_set", t(Task.GENERATION, "field", "context_set"), template_text),
+                discard_field(Task.GENERATION),
             ],
             questions=[
                 rg.LabelQuestion(
                     name="proper_action",
-                    title="Did the system choose the appropriate action for this query?",
-                    labels=["yes", "no"],
+                    title=t(Task.GENERATION, "question", "proper_action"),
+                    labels=_yes_no(Task.GENERATION, "proper_action"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="response_on_topic",
-                    title="Does the response substantively address the user's query?",
-                    labels=["yes", "no"],
+                    title=t(Task.GENERATION, "question", "response_on_topic"),
+                    labels=_yes_no(Task.GENERATION, "response_on_topic"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="helpful",
-                    title="Would this response enable a typical user to make progress on their task?",
-                    labels=["yes", "no"],
+                    title=t(Task.GENERATION, "question", "helpful"),
+                    labels=_yes_no(Task.GENERATION, "helpful"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="incomplete",
-                    title="Does the response fail to cover required parts of the query?",
-                    labels=["yes", "no"],
+                    title=t(Task.GENERATION, "question", "incomplete"),
+                    labels=_yes_no(Task.GENERATION, "incomplete"),
                     required=True,
                 ),
                 rg.LabelQuestion(
                     name="unsafe_content",
-                    title="Does the response contain unsafe or policy-violating content?",
-                    labels=["yes", "no"],
+                    title=t(Task.GENERATION, "question", "unsafe_content"),
+                    labels=_yes_no(Task.GENERATION, "unsafe_content"),
                     required=True,
                 ),
-                rg.TextQuestion(name="notes", title="Notes (optional)", required=False),
-                *_discard_questions(),
+                rg.TextQuestion(name="notes", title=t(Task.GENERATION, "question", "notes"), required=False),
+                *_discard_questions(Task.GENERATION, catalog),
             ],
             metadata=[
                 rg.TermsMetadataProperty("record_uuid", visible_for_annotators=False),
                 rg.TermsMetadataProperty("language", visible_for_annotators=False),
             ],
-            guidelines="Generation. TODO: Revisit after first annotation iteration.",
+            guidelines=t(Task.GENERATION, "guidelines", ""),
         ),
     }
diff --git a/src/pragmata/core/annotation/discard_flow.html b/src/pragmata/core/annotation/discard_flow.html
index c18095dd..d5b9b930 100644
--- a/src/pragmata/core/annotation/discard_flow.html
+++ b/src/pragmata/core/annotation/discard_flow.html
@@ -33,41 +33,47 @@
 <body>
 
 <details class="discard-panel" id="panel">
-  <summary>&#9888; Discard this record</summary>
-  <p style="margin-top:8px;font-size:13px;color:#555">
-    Use this if the record is unsuitable for annotation
-    (e.g. invalid, unclear, or outside your expertise).
-  </p>
-
-  <label>Reason:
-    <select id="reason">
-      <option value="">&#8212; select &#8212;</option>
-      <option value="invalid_or_unrealistic">Invalid or unrealistic record</option>
-      <option value="unclear">Unclear query/context/answer relationship</option>
-      <option value="outside_reviewer_expertise">Outside my domain expertise</option>
-    </select>
+  <summary><span data-i18n="panel_summary"></span></summary>
+  <p data-i18n="panel_help" style="margin-top:8px;font-size:13px;color:#555"></p>
+
+  <label><span data-i18n="reason_label"></span>
+    <select id="reason"></select>
   </label>
 
-  <label>Optional notes:
-    <textarea id="discard-notes" rows="3"
-      placeholder="Any extra context (optional)"></textarea>
+  <label><span data-i18n="notes_label"></span>
+    <textarea id="discard-notes" rows="3"></textarea>
   </label>
 
   <button class="discard-btn" id="discard-go" disabled>
-    Discard
+    <span data-i18n="button_label"></span>
   </button>
 </details>
 
 <script>
 (function() {
+  // --- Locale + i18n payload (substituted at dataset creation time) ---
+  // Shape:
+  //   I18N = {
+  //     "en": {
+  //       "panel_summary": "...", "panel_help": "...",
+  //       "reason_label": "...", "reason_placeholder": "...",
+  //       "notes_label": "...", "notes_placeholder": "...",
+  //       "button_label": "...",
+  //       "discard_reason_title": "Discard reason",     // for aria-label probe
+  //       "discard_notes_title":  "Discard notes (optional)",
+  //       "reason_options": [{value, text}, ...]
+  //     },
+  //     "de": { ... },
+  //     ...
+  //   }
+  // SUPPORTED_LOCALES is the list of keys above, ordered with the
+  // dataset's creation locale first (so aria-label probing prefers it).
+  var I18N = @@I18N_JSON;
+  var SUPPORTED_LOCALES = @@SUPPORTED_LOCALES_JSON;
+  var DEFAULT_LOCALE = @@DEFAULT_LOCALE_JSON;
+
   var pdoc = window.parent.document;
-  // Argilla-internal selectors — will need to re-verify on Argilla upgrade.
-  var CARD_TITLE_SEL = '.title-area';
-  var CARD_SEL = '.wrapper';
   var NATIVE_DISCARD_SEL = '.button--discard';
-  var REASON_TITLE = 'Discard reason';
-  var NOTES_TITLE = 'Discard notes (optional)';
-  var HIDDEN_TITLES = [REASON_TITLE, NOTES_TITLE];
   // Delay after writing hidden question values before firing native discard,
   // so Vue has a tick to register the input/change events.
   var DISCARD_SUBMIT_DELAY_MS = 80;
@@ -79,26 +85,85 @@
     pdoc.head.appendChild(s);
   }
 
-  function cardFor(title) {
-    var areas = pdoc.querySelectorAll(CARD_TITLE_SEL);
-    for (var i = 0; i < areas.length; i++) {
-      if ((areas[i].innerText || '').trim() === title) return areas[i].closest(CARD_SEL);
+  // --- Active locale detection --------------------------------------
+  // Order of preference:
+  //   1. window.parent.$nuxt.$i18n.locale  (Argilla's nuxt-i18n state)
+  //   2. <html lang> attribute on the parent page
+  //   3. DEFAULT_LOCALE (the dataset's creation locale)
+  function currentLocale() {
+    try {
+      var nuxtLocale = window.parent.$nuxt && window.parent.$nuxt.$i18n && window.parent.$nuxt.$i18n.locale;
+      if (nuxtLocale && I18N[nuxtLocale]) return nuxtLocale;
+    } catch (e) {}
+    try {
+      var htmlLang = (pdoc.documentElement.getAttribute('lang') || '').toLowerCase().split('-')[0];
+      if (htmlLang && I18N[htmlLang]) return htmlLang;
+    } catch (e) {}
+    return DEFAULT_LOCALE;
+  }
+
+  function strings() { return I18N[currentLocale()] || I18N[DEFAULT_LOCALE]; }
+
+  // --- Render ------------------------------------------------------
+  function applyText() {
+    var s = strings();
+    var nodes = document.querySelectorAll('[data-i18n]');
+    for (var i = 0; i < nodes.length; i++) {
+      var key = nodes[i].getAttribute('data-i18n');
+      if (s[key] != null) nodes[i].textContent = s[key];
+    }
+
+    var sel = document.getElementById('reason');
+    var prev = sel.value;
+    sel.innerHTML = '';
+    var placeholder = document.createElement('option');
+    placeholder.value = '';
+    placeholder.textContent = s.reason_placeholder;
+    sel.appendChild(placeholder);
+    for (var j = 0; j < s.reason_options.length; j++) {
+      var opt = document.createElement('option');
+      opt.value = s.reason_options[j].value;
+      opt.textContent = s.reason_options[j].text;
+      sel.appendChild(opt);
+    }
+    if (prev) sel.value = prev;
+
+    document.getElementById('discard-notes').setAttribute('placeholder', s.notes_placeholder);
+  }
+
+  // --- Argilla card discovery (aria-label probing) -----------------
+  // Find a hidden helper question's card by trying every supported
+  // locale's title for it. This works even when the user has toggled
+  // Argilla's chrome to a different language than the dataset was
+  // created in — Argilla stamps the aria-label from the title stored
+  // on the dataset, which is fixed at creation.
+  function cardByQuestion(questionTitleKey) {
+    for (var i = 0; i < SUPPORTED_LOCALES.length; i++) {
+      var title = (I18N[SUPPORTED_LOCALES[i]] || {})[questionTitleKey];
+      if (!title) continue;
+      var titleArea = pdoc.querySelector('[aria-label="' + title.replace(/"/g, '\\"') + '"]');
+      if (titleArea) {
+        var card = titleArea.closest('.wrapper');
+        if (card) return card;
+      }
     }
     return null;
   }
 
   function hideStaleQuestions() {
-    HIDDEN_TITLES.forEach(function(title) {
-      var card = cardFor(title);
+    var keys = ['discard_reason_title', 'discard_notes_title'];
+    for (var i = 0; i < keys.length; i++) {
+      var card = cardByQuestion(keys[i]);
       if (card && card.style.display !== 'none') card.style.display = 'none';
-    });
+    }
   }
 
+  // --- Sizing -----------------------------------------------------
   function resizeSelf() {
     try {
       var frame = window.frameElement;
       if (!frame) return;
-      // scrollHeight is clamped to >=  iframe viewport, so shrink to
+      // scrollHeight is clamped to >= iframe viewport, so shrink to
       // 0 first then remeasure — otherwise the iframe grows but can't
       // shrink back on collapse.
       frame.style.height = '0px';
@@ -121,6 +186,7 @@
     } catch (e) {}
   }
 
+  // --- Wire up -----------------------------------------------------
   var panel = document.getElementById('panel');
   var reasonSel = document.getElementById('reason');
   var notesTa = document.getElementById('discard-notes');
@@ -136,8 +202,8 @@
     var notes = notesTa.value;
     if (!reason) return;
 
-    var reasonCard = cardFor(REASON_TITLE);
-    var notesCard = cardFor(NOTES_TITLE);
+    var reasonCard = cardByQuestion('discard_reason_title');
+    var notesCard = cardByQuestion('discard_notes_title');
     if (reasonCard) reasonCard.style.display = '';
     if (notesCard) notesCard.style.display = '';
 
@@ -174,6 +240,7 @@
   });
 
   function applyHiding() { hideStaleQuestions(); hideFieldTitle(); }
+  function rerender() { applyText(); resizeSelf(); }
 
   // Coalesce mutation bursts to one apply per paint frame — Argilla's Vue
   // app fires many mutations per render, and applyHiding is now idempotent.
@@ -184,7 +251,15 @@
     requestAnimationFrame(function () { pendingApply = false; applyHiding(); });
   }
 
-  resizeSelf();
+  // Live-react to Argilla's chrome locale toggle.
+  try {
+    var i18n = window.parent.$nuxt && window.parent.$nuxt.$i18n;
+    if (i18n && typeof i18n.onLanguageSwitched === 'function') {
+      i18n.onLanguageSwitched(rerender);
+    }
+  } catch (e) {}
+
+  rerender();
   applyHiding();
   try {
     new MutationObserver(scheduleApply).observe(pdoc.body, { childList: true, subtree: true });
diff --git a/src/pragmata/core/annotation/export_fetcher.py b/src/pragmata/core/annotation/export_fetcher.py
index d0f050c2..f7e5e2f5 100644
--- a/src/pragmata/core/annotation/export_fetcher.py
+++ b/src/pragmata/core/annotation/export_fetcher.py
@@ -109,16 +109,15 @@ def fetch_task(
     to also include responses the annotator discarded.
     """
     workspace_name: str | None = None
-    overlap = None
-    for ws_base, task_overlaps in settings.workspace_dataset_map.items():
-        if task in task_overlaps:
+    for ws_base, ws_settings in settings.workspaces.items():
+        if task in ws_settings.tasks:
             workspace_name = ws_base
-            overlap = task_overlaps[task]
             break
 
     purposes: list[bool] = [False]
-    if overlap is not None and overlap.calibration_min_submitted is not None:
-        purposes.append(True)
+    if workspace_name is not None:
+        if settings.resolved_task(workspace_name, task).calibration_min_submitted is not None:
+            purposes.append(True)
 
     statuses = ["submitted", "discarded"] if include_discarded else ["submitted"]
     query = rg.Query(filter=rg.Filter([("response.status", "in", statuses)]))
diff --git a/src/pragmata/core/annotation/export_runner.py b/src/pragmata/core/annotation/export_runner.py
index 67c78633..75936cd2 100644
--- a/src/pragmata/core/annotation/export_runner.py
+++ b/src/pragmata/core/annotation/export_runner.py
@@ -117,14 +117,14 @@ def _resolve_calibration_enabled(settings: "AnnotationSettings", tasks: list[Tas
     hide a config bug.
     """
     flags: dict[Task, bool] = {}
-    for task_overlaps in settings.workspace_dataset_map.values():
-        for task, overlap in task_overlaps.items():
+    for ws_name, ws_settings in settings.workspaces.items():
+        for task in ws_settings.tasks:
             if task in tasks:
-                flags[task] = overlap.calibration_min_submitted is not None
+                flags[task] = settings.resolved_task(ws_name, task).calibration_min_submitted is not None
     missing = [task.value for task in tasks if task not in flags]
     if missing:
         raise ValueError(
-            f"tasks {sorted(missing)} not present in workspace_dataset_map; "
+            f"tasks {sorted(missing)} not present in workspaces topology; "
             "add the task to the topology or remove it from the export request."
         )
     return flags
diff --git a/src/pragmata/core/annotation/locales/README.md b/src/pragmata/core/annotation/locales/README.md
new file mode 100644
index 00000000..6e272aae
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/README.md
@@ -0,0 +1,138 @@
+# Annotation locales
+
+Locale-specific display strings for Argilla dataset titles, fields, questions,labels, guidelines, and discard-widget chrome. Translations live as data in per-locale YAML files alongside this README; a registry auto-discovers them at import time. `Locale` is an open `str` type - a locale code is any string the registry knows about.
+
+## Package layout
+
+| File          | Purpose                                                                |
+|---------------|------------------------------------------------------------------------|
+| `types.py`    | `CatalogKind` / `CatalogKey` / `Catalog` type aliases                  |
+| `loader.py`   | YAML loader + locale-invariant structure (`_YES_NO_QUESTIONS_BY_TASK`, `DISCARD_WIDGET_KEYS`) |
+| `registry.py` | `CATALOGS` dict (auto-discovered) + `get_catalog(locale)` lookup       |
+| `en.yaml`     | English catalog (source-of-truth)                                      |
+| `de.yaml`     | German catalog                                                         |
+| `__init__.py` | Package docstring only - import from the specific module               |
+
+## Catalog shape
+
+The on-disk shape is a nested YAML mapping (`fields`, `questions`, `guidelines`, `labels`, `widget`); `loader.load_catalog` fans it out into the flat in-memory shape consumers use:
+
+```
+dict[(Task, CatalogKind, str), str]
+```
+
+where `CatalogKind` is one of `"field"`, `"question"`, `"guidelines"`, `"label"`, `"widget"`. The third tuple slot encodes the kind:
+
+- `"field"` / `"question"` - the Argilla `name=` identifier
+  (e.g. `"query"`, `"topically_relevant"`)
+- `"guidelines"` - always `""` (one guidelines string per task)
+- `"label"` - `"<question_name>.<label_value>"`
+  (e.g. `"topically_relevant.yes"`, `"discard_reason.unclear"`)
+- `"widget"` - `"discard.<widget_key>"` for strings inside the injected
+  discard HTML widget (e.g. `"discard.button_label"`)
+
+## What stays stable across locales
+
+These are machine identifiers and never translated - exports and downstream parsing depend on them:
+
+- Field `name=` and question `name=`
+- Label *values* (e.g. `"yes"`, `"no"`, `DiscardReason.UNCLEAR.value`)
+- The set of catalog keys (every locale must define the same keys as
+  `en.yaml`)
+
+Only the catalog *values* (display text) vary by locale.
+
+## Adding a new locale
+
+### 1. Copy `en.yaml` to `<code>.yaml`
+
+Name the file after the locale code (e.g. `fr.yaml`). The registry picks
+it up at import; the file stem is what operators pass to `--locale`.
+
+```sh
+cp src/pragmata/core/annotation/locales/en.yaml \
+   src/pragmata/core/annotation/locales/fr.yaml
+```
+
+### 2. Translate values, keep keys
+
+Edit the new file. Translate every string under `fields:`, `questions:`,
+`guidelines:`, `labels:`, and `widget:`. Do not rename keys, do not add new
+ones - the keys are wired into Argilla and the discard widget; only the
+values change per locale.
+
+```yaml
+fields:
+  retrieval:
+    query: Requête
+    chunk: Passage
+    # ...
+
+labels:
+  yes_display: Oui
+  no_display: Non
+  discard_reasons:
+    invalid_or_unrealistic: Enregistrement invalide ou irréaliste
+    unclear: Relation ambiguë
+    outside_reviewer_expertise: Hors expertise
+
+widget:
+  panel_summary: Rejeter cet enregistrement
+  reason_label: "Motif :"
+  # ...
+```
+
+### 3. Run the tests
+
+```sh
+uv run python -m pytest tests/unit/core/annotation/test_locales.py -v
+```
+
+`TestCatalogCompleteness` parametrises over every registered locale and
+tells you about any missing or stray keys versus `en.yaml`.
+`TestLocaleAwareSettings` confirms the display strings actually flow into
+the rendered `rg.Settings`.
+
+That's it. No enum to edit, no registry to register, no import statement
+to add.
+
+## Correctness invariant
+
+`_YES_NO_QUESTIONS_BY_TASK` in `loader.py` lists every question that uses
+the shared `yes`/`no` `LabelQuestion`. If you add or rename such a
+question elsewhere in the codebase, update this mapping in the same
+change - otherwise the loader will emit stale label rows and the catalog
+completeness test will fail.
+
+`DISCARD_WIDGET_KEYS` in `loader.py` is the source-of-truth list of chrome
+strings inside the discard widget. Adding a key requires updating the
+`widget:` section of every locale YAML; missing keys raise `KeyError` at
+load time.
+
+`DiscardReason` (in `core/schemas/annotation_task.py`) drives the
+discard-reason label fan-out. Adding a reason requires updating every
+locale's `labels.discard_reasons:` map; missing reasons raise `KeyError`
+at load time.
+
+## What the YAML must contain
+
+Spelled out per task (under `fields:`, `questions:`, `guidelines:`):
+
+- Field titles (e.g. `"query"`, `"chunk"`, `"answer"`, `"context_set"`)
+- Question titles (the full sentence shown above each `LabelQuestion`)
+- Guidelines text (one per task)
+- The `notes`, `discard_reason`, `discard_notes` question titles
+- The `discard_flow` field title
+
+Spelled out once each, then fanned out by the loader:
+
+- `labels.yes_display` / `labels.no_display` - one string each; the loader
+  emits a label row for every yes/no `LabelQuestion` in every task
+- `labels.discard_reasons.*` - one string per `DiscardReason` value;
+  fanned out per task
+- `widget.*` - seven chrome strings for the discard widget; fanned out
+  per task
+
+So a contributor writes every display string exactly once. The loader
+handles the duplication across the per-task catalog rows consumers
+expect.
diff --git a/src/pragmata/core/annotation/locales/__init__.py b/src/pragmata/core/annotation/locales/__init__.py
new file mode 100644
index 00000000..f85584d8
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/__init__.py
@@ -0,0 +1,15 @@
+"""Locale-specific display strings for Argilla dataset titles, questions, guidelines.
+
+Translations live as data in ``<locale>.yaml`` files alongside this module;
+:mod:`registry` auto-discovers them at import time. Catalogs are keyed by
+``(task, kind, name)`` where ``kind`` is one of ``"field"``, ``"question"``,
+``"guidelines"``, ``"label"``. Identities (``name=``) and label values are
+not translated — only display text.
+
+Adding a locale:
+1. Drop ``<code>.yaml`` in this directory (copy ``en.yaml`` and translate).
+2. Run the catalog completeness test; it surfaces any missing or stray keys
+   versus the EN reference.
+
+No Python edit required — the file stem becomes the locale code.
+"""
diff --git a/src/pragmata/core/annotation/locales/de.yaml b/src/pragmata/core/annotation/locales/de.yaml
new file mode 100644
index 00000000..e97cf35b
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/de.yaml
@@ -0,0 +1,91 @@
+# German catalog of Argilla dataset display strings.
+#
+# All visible strings — including the discard widget chrome, the discard
+# helper-question titles, and the discard-reason option labels — are
+# translated. Identities (field/question name=) and label values stay
+# in English; see en.yaml for the key set every locale must define.
+
+fields:
+  retrieval:
+    query: Anfrage
+    chunk: Textabschnitt
+    generated_answer: Generierte Antwort
+    discard_flow: Diesen Datensatz verwerfen
+  grounding:
+    answer: Antwort
+    context_set: Kontextmenge
+    query: Anfrage
+    discard_flow: Diesen Datensatz verwerfen
+  generation:
+    query: Anfrage
+    answer: Antwort
+    context_set: Kontextmenge
+    discard_flow: Diesen Datensatz verwerfen
+
+questions:
+  retrieval:
+    topically_relevant: >-
+      Enthält dieser Textabschnitt Informationen, die für die Anfrage
+      inhaltlich relevant sind?
+    evidence_sufficient: >-
+      Liefert dieser Textabschnitt ausreichende Belege, um die Anfrage zu
+      beantworten?
+    misleading: >-
+      Könnte dieser Textabschnitt plausibel zu einer falschen oder verzerrten
+      Antwort führen?
+    notes: Anmerkungen (optional)
+    discard_reason: Verwerfungsgrund
+    discard_notes: Anmerkungen zur Verwerfung (optional)
+  grounding:
+    support_present: >-
+      Wird mindestens eine Aussage in der Antwort durch den bereitgestellten
+      Kontext gestützt?
+    unsupported_claim_present: >-
+      Enthält die Antwort Aussagen, die nicht durch den bereitgestellten
+      Kontext gestützt werden?
+    contradicted_claim_present: >-
+      Widerspricht der bereitgestellte Kontext einer Aussage in der Antwort?
+    source_cited: Enthält die Antwort eine Quellenangabe?
+    fabricated_source: >-
+      Zitiert die Antwort eine Quelle, die nicht im abgerufenen Kontext
+      enthalten ist?
+    notes: Anmerkungen (optional)
+    discard_reason: Verwerfungsgrund
+    discard_notes: Anmerkungen zur Verwerfung (optional)
+  generation:
+    proper_action: >-
+      Hat das System die für diese Anfrage angemessene Aktion gewählt?
+    response_on_topic: >-
+      Geht die Antwort inhaltlich auf die Anfrage des Nutzers ein?
+    helpful: >-
+      Würde diese Antwort einem typischen Nutzer ermöglichen, bei seiner
+      Aufgabe voranzukommen?
+    incomplete: Lässt die Antwort erforderliche Teile der Anfrage unbeantwortet?
+    unsafe_content: Enthält die Antwort unsichere oder richtlinienverletzende Inhalte?
+    notes: Anmerkungen (optional)
+    discard_reason: Verwerfungsgrund
+    discard_notes: Anmerkungen zur Verwerfung (optional)
+
+guidelines:
+  retrieval: "Retrieval. TODO: Nach erster Annotationsiteration überarbeiten."
+  grounding: "Grounding. TODO: Nach erster Annotationsiteration überarbeiten."
+  generation: "Generation. TODO: Nach erster Annotationsiteration überarbeiten."
+
+labels:
+  yes_display: "Ja"
+  no_display: "Nein"
+  discard_reasons:
+    invalid_or_unrealistic: Ungültiger oder unrealistischer Datensatz
+    unclear: Unklarer Zusammenhang zwischen Anfrage/Kontext/Antwort
+    outside_reviewer_expertise: Außerhalb meines Fachgebiets
+
+widget:
+  panel_summary: Diesen Datensatz verwerfen
+  panel_help: >-
+    Verwenden Sie dies, wenn der Datensatz nicht zur Annotation geeignet
+    ist (z. B. ungültig, unklar oder außerhalb Ihres Fachgebiets).
+  reason_label: "Grund:"
+  reason_placeholder: "— auswählen —"
+  notes_label: "Optionale Anmerkungen:"
+  notes_placeholder: Zusätzlicher Kontext (optional)
+  button_label: Verwerfen
diff --git a/src/pragmata/core/annotation/locales/en.yaml b/src/pragmata/core/annotation/locales/en.yaml
new file mode 100644
index 00000000..df076bdc
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/en.yaml
@@ -0,0 +1,83 @@
+# English catalog of Argilla dataset display strings (source-of-truth locale).
+#
+# Identities (field/question name=) and label values are locale-invariant and
+# live in code — only the strings here are translated. Every locale must
+# define the same key set as en.yaml (enforced by tests).
+
+fields:
+  retrieval:
+    query: Query
+    chunk: Chunk
+    generated_answer: Generated answer
+    discard_flow: Discard this record
+  grounding:
+    answer: Answer
+    context_set: Context set
+    query: Query
+    discard_flow: Discard this record
+  generation:
+    query: Query
+    answer: Answer
+    context_set: Context set
+    discard_flow: Discard this record
+
+questions:
+  retrieval:
+    topically_relevant: >-
+      Does this passage contain information that is substantively relevant to
+      the query?
+    evidence_sufficient: >-
+      Does this passage provide sufficient evidence to support answering the
+      query?
+    misleading: >-
+      Could this passage plausibly lead to an incorrect or distorted answer?
+    notes: Notes (optional)
+    discard_reason: Discard reason
+    discard_notes: Discard notes (optional)
+  grounding:
+    support_present: >-
+      Is at least one claim in the answer supported by the provided context?
+    unsupported_claim_present: >-
+      Does the answer contain claims not supported by the provided context?
+    contradicted_claim_present: >-
+      Does the provided context contradict any claim in the answer?
+    source_cited: Does the answer contain a citation marker?
+    fabricated_source: >-
+      Does the answer cite a source not present in the retrieved context?
+    notes: Notes (optional)
+    discard_reason: Discard reason
+    discard_notes: Discard notes (optional)
+  generation:
+    proper_action: Did the system choose the appropriate action for this query?
+    response_on_topic: Does the response substantively address the user's query?
+    helpful: >-
+      Would this response enable a typical user to make progress on their task?
+    incomplete: Does the response fail to cover required parts of the query?
+    unsafe_content: Does the response contain unsafe or policy-violating content?
+    notes: Notes (optional)
+    discard_reason: Discard reason
+    discard_notes: Discard notes (optional)
+
+guidelines:
+  retrieval: "Retrieval. TODO: Revisit after first annotation iteration."
+  grounding: "Grounding. TODO: Revisit after first annotation iteration."
+  generation: "Generation. TODO: Revisit after first annotation iteration."
+
+labels:
+  yes_display: "Yes"
+  no_display: "No"
+  discard_reasons:
+    invalid_or_unrealistic: Invalid or unrealistic record
+    unclear: Unclear query/context/answer relationship
+    outside_reviewer_expertise: Outside reviewer expertise
+
+widget:
+  panel_summary: Discard this record
+  panel_help: >-
+    Use this if the record is unsuitable for annotation (e.g. invalid,
+    unclear, or outside your expertise).
+  reason_label: "Reason:"
+  reason_placeholder: "— select —"
+  notes_label: "Optional notes:"
+  notes_placeholder: Any extra context (optional)
+  button_label: Discard
diff --git a/src/pragmata/core/annotation/locales/loader.py b/src/pragmata/core/annotation/locales/loader.py
new file mode 100644
index 00000000..e8844dc8
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/loader.py
@@ -0,0 +1,72 @@
+"""YAML catalog loader and locale-invariant structural metadata.
+
+A locale catalog is a flat ``dict[(Task, CatalogKind, str), str]`` consumed by
+:mod:`pragmata.core.annotation.argilla_task_definitions`. The translatable
+strings live in per-locale YAML files; the *structure* (which questions share
+the yes/no LabelQuestion, which DiscardReason values exist) is code and lives
+here. :func:`load_catalog` fans the YAML inputs over that structure into the
+flat catalog shape.
+"""
+
+from pathlib import Path
+
+from pragmata.core.annotation.locales.types import Catalog
+from pragmata.core.schemas.annotation_task import DiscardReason, Task
+from pragmata.core.settings.settings_base import load_config_file
+
+_YES_NO_QUESTIONS_BY_TASK: dict[Task, list[str]] = {
+    Task.RETRIEVAL: ["topically_relevant", "evidence_sufficient", "misleading"],
+    Task.GROUNDING: [
+        "support_present",
+        "unsupported_claim_present",
+        "contradicted_claim_present",
+        "source_cited",
+        "fabricated_source",
+    ],
+    Task.GENERATION: ["proper_action", "response_on_topic", "helpful", "incomplete", "unsafe_content"],
+}
+
+DISCARD_WIDGET_KEYS: tuple[str, ...] = (
+    "panel_summary",
+    "panel_help",
+    "reason_label",
+    "reason_placeholder",
+    "notes_label",
+    "notes_placeholder",
+    "button_label",
+)
+
+
+def load_catalog(path: Path) -> Catalog:
+    """Build a Catalog from a YAML translation file.
+
+    Raises ``KeyError`` if a required top-level section, task, field, question,
+    or label value is missing — fail-loud is intentional so a typo in a locale
+    file surfaces at import time, not at first widget render.
+    """
+    data = load_config_file(path)
+    catalog: Catalog = {}
+
+    for kind in ("field", "question"):
+        for task_name, entries in data[f"{kind}s"].items():
+            task = Task(task_name)
+            for name, display in entries.items():
+                catalog[(task, kind, name)] = display
+
+    for task_name, text in data["guidelines"].items():
+        catalog[(Task(task_name), "guidelines", "")] = text
+
+    labels = data["labels"]
+    yes_display, no_display = labels["yes_display"], labels["no_display"]
+    discard_reasons: dict[str, str] = labels["discard_reasons"]
+    widget: dict[str, str] = data["widget"]
+    for task, question_names in _YES_NO_QUESTIONS_BY_TASK.items():
+        for question in question_names:
+            catalog[(task, "label", f"{question}.yes")] = yes_display
+            catalog[(task, "label", f"{question}.no")] = no_display
+        for reason in DiscardReason:
+            catalog[(task, "label", f"discard_reason.{reason.value}")] = discard_reasons[reason.value]
+        for key in DISCARD_WIDGET_KEYS:
+            catalog[(task, "widget", f"discard.{key}")] = widget[key]
+
+    return catalog
diff --git a/src/pragmata/core/annotation/locales/registry.py b/src/pragmata/core/annotation/locales/registry.py
new file mode 100644
index 00000000..58e74a94
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/registry.py
@@ -0,0 +1,26 @@
+"""Catalog registry — auto-discovers locale YAML files at import.
+
+A deployment adds a locale by dropping ``<code>.yaml`` into this directory;
+the registry picks it up at import with no Python edit required. The locale
+code is the file stem (``en.yaml`` → ``"en"``).
+"""
+
+from pathlib import Path
+
+from pragmata.core.annotation.locales.loader import load_catalog
+from pragmata.core.annotation.locales.types import Catalog
+from pragmata.core.schemas.annotation_task import Locale
+
+_LOCALES_DIR = Path(__file__).parent
+
+CATALOGS: dict[Locale, Catalog] = {
+    yaml_file.stem: load_catalog(yaml_file) for yaml_file in sorted(_LOCALES_DIR.glob("*.yaml"))
+}
+
+
+def get_catalog(locale: Locale) -> Catalog:
+    """Return the display-string catalog for a locale.
+
+    Raises ``KeyError`` if the locale has no registered catalog.
+    """
+    return CATALOGS[locale]
diff --git a/src/pragmata/core/annotation/locales/types.py b/src/pragmata/core/annotation/locales/types.py
new file mode 100644
index 00000000..273dcb1a
--- /dev/null
+++ b/src/pragmata/core/annotation/locales/types.py
@@ -0,0 +1,19 @@
+"""Shared types for locale catalogs."""
+
+from typing import Literal
+
+from pragmata.core.schemas.annotation_task import Task
+
+CatalogKind = Literal["field", "question", "guidelines", "label", "widget"]
+# Naming convention for the ``name`` slot:
+#   - ``"field"`` / ``"question"`` / ``"guidelines"``: the field/question
+#     ``name=`` identifier, or ``""`` for guidelines.
+#   - ``"label"``: ``"<question_name>.<label_value>"`` (e.g.
+#     ``"topically_relevant.yes"``). Label *values* are machine identifiers
+#     and never translated — only the display text varies by locale.
+#   - ``"widget"``: free-form key for strings inside our injected HTML
+#     widgets (e.g. ``discard_flow.html``). Shared across tasks: keyed by
+#     ``Task.RETRIEVAL`` with ``("widget", "discard.panel_summary")`` style,
+#     and identical for grounding/generation per locale.
+type CatalogKey = tuple[Task, CatalogKind, str]
+type Catalog = dict[CatalogKey, str]
diff --git a/src/pragmata/core/annotation/record_builder.py b/src/pragmata/core/annotation/record_builder.py
index 28e4d33c..d7564b7b 100644
--- a/src/pragmata/core/annotation/record_builder.py
+++ b/src/pragmata/core/annotation/record_builder.py
@@ -19,13 +19,14 @@
 
 from pragmata.core.annotation.argilla_ops import create_dataset
 from pragmata.core.annotation.argilla_task_definitions import build_task_settings, dataset_name
+from pragmata.core.annotation.locales.registry import CATALOGS
 from pragmata.core.schemas.annotation_import import (
     PartitionManifest,
     PartitionManifestEntry,
     QueryResponsePair,
 )
-from pragmata.core.schemas.annotation_task import Task
-from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskOverlap
+from pragmata.core.schemas.annotation_task import Locale, Task
+from pragmata.core.settings.annotation_settings import AnnotationSettings
 
 logger = logging.getLogger(__name__)
 
@@ -150,15 +151,9 @@ def build_generation_record(pair: QueryResponsePair, record_uuid: str) -> rg.Rec
     )
 
 
-def _invert_workspace_map(
-    workspace_dataset_map: dict[str, dict[Task, TaskOverlap]],
-) -> dict[Task, tuple[str, TaskOverlap]]:
-    """Invert workspace_dataset_map to task → (workspace_base, overlap)."""
-    task_to_ws: dict[Task, tuple[str, TaskOverlap]] = {}
-    for ws_base, task_overlaps in workspace_dataset_map.items():
-        for task, overlap in task_overlaps.items():
-            task_to_ws[task] = (ws_base, overlap)
-    return task_to_ws
+def _invert_workspace_map(settings: AnnotationSettings) -> dict[Task, str]:
+    """Invert workspaces topology to task → workspace_base."""
+    return {task: ws_base for ws_base, ws in settings.workspaces.items() for task in ws.tasks}
 
 
 # ---------------------------------------------------------------------------
@@ -277,6 +272,32 @@ def _build_batches(
     return batches
 
 
+def _detect_dataset_locale(dataset: rg.Dataset, task: Task) -> Locale | None:
+    """Infer an existing Argilla dataset's creation locale from its label displays.
+
+    Probes the first ``LabelQuestion``'s value→display map (via the private
+    ``_model.settings.options`` — public ``.labels`` is lossy, returns keys
+    only) against each per-locale catalog. Returns ``None`` if no locale
+    matches — e.g. when the dataset was provisioned outside pragmata.
+    """
+    question = next(
+        (q for q in dataset.settings.questions if isinstance(q, rg.LabelQuestion)),
+        None,
+    )
+    if question is None:
+        return None
+    try:
+        options = question._model.settings.options
+    except AttributeError:
+        return None
+    existing = {opt["value"]: opt["text"] for opt in options}
+    for loc, catalog in CATALOGS.items():
+        rendered = {v: catalog.get((task, "label", f"{question.name}.{v}")) for v in existing}
+        if all(rendered.values()) and rendered == existing:
+            return loc
+    return None
+
+
 def _ensure_dataset(
     client: rg.Argilla,
     *,
@@ -286,8 +307,15 @@ def _ensure_dataset(
     ws_base: str,
     dataset_id: str,
     task_settings_map: dict[Task, rg.Settings],
+    locale: Locale,
 ) -> rg.Dataset:
-    """Resolve or create the Argilla dataset for a (task, purpose) pair."""
+    """Resolve or create the Argilla dataset for a (task, purpose) pair.
+
+    When an existing dataset is found, its creation locale is probed against
+    the configured ``locale``. A mismatch is logged as a warning and the
+    import proceeds — label *values* are locale-invariant so data integrity
+    is preserved (only display text differs).
+    """
     ds_name = dataset_name(task, calibration=calibration, dataset_id=dataset_id)
     workspace = client.workspaces(ws_base)
     if workspace is None:
@@ -303,6 +331,18 @@ def _ensure_dataset(
     dataset, ds_created = create_dataset(client, ds_name, ws_base, task_cfg)
     if ds_created:
         logger.info("Auto-created dataset %r in workspace %r", ds_name, ws_base)
+    else:
+        existing_locale = _detect_dataset_locale(dataset, task)
+        if existing_locale is not None and existing_locale != locale:
+            logger.warning(
+                "Locale mismatch on dataset %r (workspace %r): existing dataset was created "
+                "with locale=%r but this import uses locale=%r. Appending records (label "
+                "values are locale-invariant; only display text differs).",
+                ds_name,
+                ws_base,
+                existing_locale,
+                locale,
+            )
     return dataset
 
 
@@ -331,8 +371,7 @@ def fan_out_records(
         vs production totals are computable from ``assignments`` and stay in
         the api layer.
     """
-    task_to_ws = _invert_workspace_map(settings.workspace_dataset_map)
-    task_settings_map = build_task_settings()
+    task_to_ws = _invert_workspace_map(settings)
     batches = _build_batches(records, assignments)
 
     dataset_counts: dict[str, int] = {}
@@ -340,22 +379,23 @@ def fan_out_records(
     for (task, calibration), rg_records in batches.items():
         if not rg_records:
             continue
-        binding = task_to_ws.get(task)
-        if binding is None:
-            logger.warning("Task %r not in workspace_dataset_map - skipping", task)
+        ws_base = task_to_ws.get(task)
+        if ws_base is None:
+            logger.warning("Task %r not in workspaces topology - skipping", task)
             continue
-        ws_base, overlap = binding
+        resolved = settings.resolved_task(ws_base, task)
         if calibration:
-            if overlap.calibration_min_submitted is None:
-                # Defensive: should not happen because assign_partitions only
-                # assigns calibration when topology supports it. Surface as an
-                # error rather than silently route to production.
+            if resolved.calibration_min_submitted is None:
+                # assign_partitions only assigns calibration when topology supports
+                # it; surfacing as an error rather than silently routing to production.
                 raise RuntimeError(
                     f"Task {task.value} has calibration records assigned but topology disables calibration"
                 )
-            min_submitted = overlap.calibration_min_submitted
+            min_submitted = resolved.calibration_min_submitted
         else:
-            min_submitted = overlap.production_min_submitted
+            min_submitted = resolved.production_min_submitted
+        locale = resolved.locale
+        task_settings_map = build_task_settings(locale)
         dataset = _ensure_dataset(
             client,
             task=task,
@@ -364,6 +404,7 @@ def fan_out_records(
             ws_base=ws_base,
             dataset_id=settings.dataset_id,
             task_settings_map=task_settings_map,
+            locale=locale,
         )
         dataset.records.log(rg_records, on_error=RecordErrorHandling.WARN)
         ds_name = dataset.name
diff --git a/src/pragmata/core/annotation/setup.py b/src/pragmata/core/annotation/setup.py
index 5b1a47ef..4228aeae 100644
--- a/src/pragmata/core/annotation/setup.py
+++ b/src/pragmata/core/annotation/setup.py
@@ -53,7 +53,7 @@ def setup_workspaces(
 ) -> SetupResult:
     """Create all workspaces idempotently per settings topology."""
     result = SetupResult()
-    for ws_base in settings.workspace_dataset_map:
+    for ws_base in settings.workspaces:
         workspace, created = create_workspace(client, ws_base)
         (result.created_workspaces if created else result.skipped_workspaces).append(ws_base)
     return result
@@ -96,15 +96,15 @@ def teardown_resources(
     Ordering: datasets first (Argilla requires workspace to be empty before deletion).
     Missing resources are silently skipped. User accounts are not touched.
     """
-    for ws_base, task_overlaps in settings.workspace_dataset_map.items():
+    for ws_base, ws_settings in settings.workspaces.items():
         workspace = client.workspaces(ws_base)
         if workspace is None:
             logger.info("Workspace %r not found — skipping", ws_base)
             continue
 
-        for task, overlap in task_overlaps.items():
+        for task in ws_settings.tasks:
             purposes_present = [False]  # production always exists
-            if overlap.calibration_min_submitted is not None:
+            if settings.resolved_task(ws_base, task).calibration_min_submitted is not None:
                 purposes_present.append(True)
             for calibration in purposes_present:
                 ds_name = dataset_name(task, calibration=calibration, dataset_id=settings.dataset_id)
diff --git a/src/pragmata/core/schemas/annotation_task.py b/src/pragmata/core/schemas/annotation_task.py
index 0d291eac..2d6390cb 100644
--- a/src/pragmata/core/schemas/annotation_task.py
+++ b/src/pragmata/core/schemas/annotation_task.py
@@ -2,6 +2,19 @@
 
 from enum import StrEnum
 
+Locale = str
+"""Locale code for Argilla dataset display strings.
+
+Open string (e.g. ``"en"``, ``"de"``, ``"pt-BR"``). Validated at catalog
+lookup via :func:`pragmata.core.annotation.locales.registry.get_catalog` —
+a deployment adds a locale by dropping ``<code>.yaml`` into
+``core/annotation/locales/`` with no Python edit required.
+
+Display strings come from the per-locale catalog; field/question ``name=``
+identities and label values are locale-invariant so exports merge cleanly
+across locales.
+"""
+
 
 class Task(StrEnum):
     """Annotation task types."""
diff --git a/src/pragmata/core/settings/annotation_settings.py b/src/pragmata/core/settings/annotation_settings.py
index 3a583455..cc96e417 100644
--- a/src/pragmata/core/settings/annotation_settings.py
+++ b/src/pragmata/core/settings/annotation_settings.py
@@ -1,13 +1,23 @@
-"""Operational settings for annotation (workspace topology, distribution)."""
+"""Operational settings for annotation (workspace topology, distribution).
+
+Settings are organised into three scopes — deployment (``AnnotationSettings``),
+workspace (``WorkspaceSettings``), task (``TaskSettings``). Fields listed in
+``AnnotationSettings._INHERITED_FIELDS`` may be set at any scope; child scopes
+default to ``INHERIT``. Models hold the **specified** values exactly as given
+(``INHERIT`` survives validation, raw inputs round-trip losslessly through
+``model_dump()``). ``resolved_task(workspace_name, task)`` returns the
+**computed** values after walking task → workspace → deployment — the CSS
+"computed value" analogy: first non-``INHERIT`` ancestor wins.
+"""
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal, Self
+from typing import ClassVar, Literal, Self
 
 from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt, model_validator
 
-from pragmata.core.schemas.annotation_task import Task
-from pragmata.core.settings.settings_base import ResolveSettings
+from pragmata.core.schemas.annotation_task import Locale, Task
+from pragmata.core.settings.settings_base import INHERIT, Inherit, ResolveSettings
 from pragmata.core.types import SafePathSegment
 
 
@@ -19,82 +29,125 @@ class ArgillaSettings(BaseModel):
     api_url: str | None = None
 
 
-class TaskOverlap(BaseModel):
-    """Per-task overlap topology: production and (optional) calibration thresholds.
+class TaskSettings(BaseModel):
+    """Per-task overrides; inherited fields default to ``INHERIT`` (use workspace value)."""
 
-    Calibration is declared here so future imports can route a subset of
-    records to a separate calibration dataset for IAA.
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
 
-    Attributes:
-        production_min_submitted: Argilla ``min_submitted`` for the production
-            dataset (typically 1; >1 enables full overlap on production).
-        calibration_min_submitted: Argilla ``min_submitted`` for a future
-            calibration dataset, or ``None`` to disable calibration for this
-            task. Default 3 covers Krippendorff alpha plus pairwise Cohen
-            kappa.
+    production_min_submitted: PositiveInt | Inherit = INHERIT
+    calibration_min_submitted: PositiveInt | None | Inherit = INHERIT
+    locale: Locale | Inherit = INHERIT
+
+
+class WorkspaceSettings(BaseModel):
+    """Per-workspace overrides plus the workspace's ``tasks`` mapping.
+
+    Inherited fields default to ``INHERIT`` (use deployment value). ``None`` on
+    ``calibration_min_submitted`` explicitly disables calibration for any task
+    that inherits from this workspace.
     """
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
 
-    production_min_submitted: PositiveInt = 1
-    calibration_min_submitted: PositiveInt | None = 3
+    production_min_submitted: PositiveInt | Inherit = INHERIT
+    calibration_min_submitted: PositiveInt | None | Inherit = INHERIT
+    locale: Locale | Inherit = INHERIT
+    tasks: dict[Task, TaskSettings]
+
+
+@dataclass(frozen=True)
+class ResolvedTaskSettings:
+    """Concrete per-task settings after inheritance resolution (CSS 'computed' values)."""
+
+    production_min_submitted: int
+    calibration_min_submitted: int | None
+    locale: Locale
 
 
 class AnnotationSettings(ResolveSettings):
     """Configurable runtime settings for annotation (setup, import, export).
 
-    Controls workspace topology and per-task overlap thresholds.
-    Task definitions (Argilla rg.Settings per task) are hardcoded — see
-    core/annotation/argilla_task_definitions.py.
+    Controls workspace topology and per-task overlap thresholds. Deployment-level
+    fields in ``_INHERITED_FIELDS`` are inherited by workspaces and tasks unless
+    overridden — see module docstring for the inheritance model. Task definitions
+    (Argilla ``rg.Settings`` per task) are hardcoded; see
+    ``core/annotation/argilla_task_definitions.py``.
     """
 
     argilla: ArgillaSettings = Field(default_factory=ArgillaSettings)
     base_dir: Path = Field(default_factory=Path.cwd)
     dataset_id: SafePathSegment = ""
-    workspace_dataset_map: dict[str, dict[Task, TaskOverlap]] = Field(
-        default_factory=lambda: {
-            "retrieval": {Task.RETRIEVAL: TaskOverlap()},
-            "grounding": {Task.GROUNDING: TaskOverlap()},
-            "generation": {Task.GENERATION: TaskOverlap()},
-        }
-    )
+    production_min_submitted: PositiveInt = 1
+    calibration_min_submitted: PositiveInt | None = 3
+    locale: Locale = "en"
     calibration_fraction: float = Field(0.1, ge=0.0, le=1.0)
     calibration_partition_seed: NonNegativeInt = 0
     include_discarded: bool = False
+    workspaces: dict[str, WorkspaceSettings] = Field(
+        default_factory=lambda: {
+            "retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()}),
+            "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings()}),
+            "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings()}),
+        }
+    )
 
-    @model_validator(mode="after")
-    def _check_calibration_topology(self) -> Self:
-        if self.calibration_fraction <= 0.0:
-            return self
-        missing = sorted(
-            {
-                task.value
-                for task_overlaps in self.workspace_dataset_map.values()
-                for task, overlap in task_overlaps.items()
-                if overlap.calibration_min_submitted is None
-            }
-        )
-        if missing:
-            raise ValueError(
-                f"calibration_fraction={self.calibration_fraction} > 0 but topology has no "
-                f"calibration dataset for tasks: {missing}. Either set calibration_fraction=0.0 "
-                f"or enable calibration in workspace_dataset_map."
-            )
-        return self
+    _INHERITED_FIELDS: ClassVar[tuple[str, ...]] = (
+        "production_min_submitted",
+        "calibration_min_submitted",
+        "locale",
+    )
+
+    def resolved_task(self, workspace_name: str, task: Task) -> ResolvedTaskSettings:
+        """Return the computed task settings: task → workspace → deployment.
+
+        First non-``INHERIT`` ancestor wins. Consumers should call this rather
+        than reading inheritable fields directly off ``TaskSettings`` /
+        ``WorkspaceSettings``, which hold raw specified values.
+        """
+        ws = self.workspaces[workspace_name]
+        ts = ws.tasks[task]
+        kwargs: dict[str, object] = {}
+        for name in self._INHERITED_FIELDS:
+            value = getattr(ts, name)
+            if value is INHERIT:
+                value = getattr(ws, name)
+            if value is INHERIT:
+                value = getattr(self, name)
+            kwargs[name] = value
+        return ResolvedTaskSettings(**kwargs)  # type: ignore[arg-type]
 
     @model_validator(mode="after")
     def _validate_task_uniqueness(self) -> Self:
         seen: set[Task] = set()
-        for task_overlaps in self.workspace_dataset_map.values():
-            for task in task_overlaps:
+        for ws in self.workspaces.values():
+            for task in ws.tasks:
                 if task in seen:
                     raise ValueError(
-                        f"task {task.value!r} appears in multiple workspace_dataset_map entries; "
+                        f"task {task.value!r} appears in multiple workspaces; "
                         "each task must belong to exactly one workspace."
                     )
                 seen.add(task)
         return self
 
+    @model_validator(mode="after")
+    def _check_calibration_topology(self) -> Self:
+        if self.calibration_fraction <= 0.0:
+            return self
+        missing = [
+            f"{ws_name}/{task.value}"
+            for ws_name, ws in self.workspaces.items()
+            for task in ws.tasks
+            if self.resolved_task(ws_name, task).calibration_min_submitted is None
+        ]
+        if missing:
+            raise ValueError(
+                f"calibration_fraction={self.calibration_fraction} > 0 but these "
+                f"workspace/task pairs disable calibration: {', '.join(missing)}. "
+                f"Either set calibration_fraction=0.0 or enable calibration at "
+                f"the appropriate scope."
+            )
+        return self
+
 
 @dataclass
 class UserSpec:
diff --git a/src/pragmata/core/settings/settings_base.py b/src/pragmata/core/settings/settings_base.py
index 26e9dcd4..44a269e6 100644
--- a/src/pragmata/core/settings/settings_base.py
+++ b/src/pragmata/core/settings/settings_base.py
@@ -24,6 +24,28 @@ def __bool__(self) -> bool:
 type Unset = _UnsetType
 
 
+class _InheritType:
+    """Sentinel meaning 'inherit from parent scope' on nested settings models.
+
+    Distinct from ``Unset``: ``Unset`` is stripped pre-validation by
+    ``prune_unset``; ``Inherit`` persists through validation as a raw
+    specified value. CSS-style: child scopes store ``INHERIT`` until a
+    read-time resolver walks the scope chain and returns the computed value.
+    """
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "INHERIT"
+
+    def __bool__(self) -> bool:
+        raise TypeError("INHERIT has no truth value. Use `x is INHERIT`.")
+
+
+INHERIT: Final[_InheritType] = _InheritType()
+type Inherit = _InheritType
+
+
 API_KEY_ENV_VARS: Final[dict[str, str]] = {
     "mistralai": "MISTRAL_API_KEY",
     "cohere": "COHERE_API_KEY",
diff --git a/tests/integration/test_annotation_calibration.py b/tests/integration/test_annotation_calibration.py
index cdcd05f4..f99a3f35 100644
--- a/tests/integration/test_annotation_calibration.py
+++ b/tests/integration/test_annotation_calibration.py
@@ -16,7 +16,7 @@
 from pragmata.core.paths.paths import WorkspacePaths
 from pragmata.core.schemas.annotation_import import PartitionManifest
 from pragmata.core.schemas.annotation_task import Task
-from pragmata.core.settings.annotation_settings import AnnotationSettings
+from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskSettings, WorkspaceSettings
 
 pytestmark = [pytest.mark.integration, pytest.mark.annotation]
 
@@ -219,3 +219,58 @@ def test_records_carry_calibration_metadata_to_argilla(client: rg.Argilla, base_
             assert cal_record_uuids == cal_uuids
     finally:
         teardown_resources(client, auto_settings)
+
+
+class TestPerWorkspaceMinSubmitted:
+    """Inherited carve-out reaches the live Argilla dataset's distribution config."""
+
+    def test_workspace_carve_out_creates_correct_dataset_min_submitted(
+        self, client: rg.Argilla, base_dir: Path
+    ) -> None:
+        """Per-task ``production_min_submitted`` carve-out flows into the dataset's distribution.
+
+        Deployment default is 1; the retrieval workspace overrides to 2; the
+        retrieval task carves out 4. The created Argilla dataset's
+        ``distribution.min_submitted`` must reflect the inherited value (4).
+        """
+        auto_id = "testcarveout"
+        carved_settings = AnnotationSettings(
+            dataset_id=auto_id,
+            production_min_submitted=1,
+            workspaces={
+                "retrieval": WorkspaceSettings(
+                    production_min_submitted=2,
+                    tasks={Task.RETRIEVAL: TaskSettings(production_min_submitted=4)},
+                ),
+                "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings()}),
+                "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings()}),
+            },
+        )
+        teardown_resources(client, carved_settings)
+        setup_workspaces(client, carved_settings)
+
+        try:
+            records = [_make_raw(i) for i in range(3)]
+            import_records(
+                records,
+                dataset_id=auto_id,
+                base_dir=base_dir,
+                calibration_fraction=0.0,
+                **_CREDS,
+            )
+
+            prod_name = dataset_name(Task.RETRIEVAL, calibration=False, dataset_id=auto_id)
+            prod_ds = client.datasets(prod_name, workspace="retrieval")
+            assert prod_ds is not None
+            # Task-level carve-out (4) wins over workspace (2) and deployment (1).
+            assert prod_ds.distribution.min_submitted == 4
+
+            # Sibling workspace inherits deployment default (1).
+            grounding_prod = client.datasets(
+                dataset_name(Task.GROUNDING, calibration=False, dataset_id=auto_id),
+                workspace="grounding",
+            )
+            assert grounding_prod is not None
+            assert grounding_prod.distribution.min_submitted == 1
+        finally:
+            teardown_resources(client, carved_settings)
diff --git a/tests/integration/test_annotation_import.py b/tests/integration/test_annotation_import.py
index d010cc12..095ab19c 100644
--- a/tests/integration/test_annotation_import.py
+++ b/tests/integration/test_annotation_import.py
@@ -52,12 +52,12 @@ def clean_environment(client: rg.Argilla):
     the scoped datasets) get removed.
     """
     full_teardown_settings = _SETTINGS.model_copy(update={"dataset_id": ""})
-    for ws_base in _SETTINGS.workspace_dataset_map:
+    for ws_base in _SETTINGS.workspaces:
         purge_workspace_datasets(client, ws_base)
     teardown_resources(client, full_teardown_settings)
     setup_workspaces(client, _SETTINGS)
     yield
-    for ws_base in _SETTINGS.workspace_dataset_map:
+    for ws_base in _SETTINGS.workspaces:
         purge_workspace_datasets(client, ws_base)
     teardown_resources(client, full_teardown_settings)
 
diff --git a/tests/integration/test_annotation_setup.py b/tests/integration/test_annotation_setup.py
index 4783e9b9..c12e7b86 100644
--- a/tests/integration/test_annotation_setup.py
+++ b/tests/integration/test_annotation_setup.py
@@ -39,11 +39,11 @@ def clean_slate(client: rg.Argilla):
     Orphan datasets from earlier runs are purged first — Argilla blocks
     workspace deletion while any dataset is linked.
     """
-    for ws_base in _DEFAULT_SETTINGS.workspace_dataset_map:
+    for ws_base in _DEFAULT_SETTINGS.workspaces:
         purge_workspace_datasets(client, ws_base)
     teardown_resources(client, _DEFAULT_SETTINGS)
     yield
-    for ws_base in _DEFAULT_SETTINGS.workspace_dataset_map:
+    for ws_base in _DEFAULT_SETTINGS.workspaces:
         purge_workspace_datasets(client, ws_base)
     teardown_resources(client, _DEFAULT_SETTINGS)
 
diff --git a/tests/test_facade_lazy.py b/tests/test_facade_lazy.py
index e74a3d12..e6b5a0a6 100644
--- a/tests/test_facade_lazy.py
+++ b/tests/test_facade_lazy.py
@@ -119,6 +119,7 @@ def test_dir_returns_public_surface() -> None:
         "ExportResult",
         "IaaReport",
         "ImportResult",
+        "Locale",
         "SetupResult",
         "Task",
         "UserSpec",
diff --git a/tests/unit/api/test_annotation.py b/tests/unit/api/test_annotation.py
index 32d42fab..d0ed65bc 100644
--- a/tests/unit/api/test_annotation.py
+++ b/tests/unit/api/test_annotation.py
@@ -304,19 +304,22 @@ def test_negative_fraction_raises(self) -> None:
     def _no_calibration_config(tmp_path: Path) -> Path:
         """Write a YAML config that disables calibration on every task."""
         yaml_text = (
-            "workspace_dataset_map:\n"
+            "workspaces:\n"
             "  retrieval:\n"
-            "    retrieval:\n"
-            "      production_min_submitted: 1\n"
-            "      calibration_min_submitted: null\n"
+            "    tasks:\n"
+            "      retrieval:\n"
+            "        production_min_submitted: 1\n"
+            "        calibration_min_submitted: null\n"
             "  grounding:\n"
-            "    grounding:\n"
-            "      production_min_submitted: 1\n"
-            "      calibration_min_submitted: null\n"
+            "    tasks:\n"
+            "      grounding:\n"
+            "        production_min_submitted: 1\n"
+            "        calibration_min_submitted: null\n"
             "  generation:\n"
-            "    generation:\n"
-            "      production_min_submitted: 1\n"
-            "      calibration_min_submitted: null\n"
+            "    tasks:\n"
+            "      generation:\n"
+            "        production_min_submitted: 1\n"
+            "        calibration_min_submitted: null\n"
         )
         path = tmp_path / "config.yaml"
         path.write_text(yaml_text)
diff --git a/tests/unit/cli/test_cli_annotation.py b/tests/unit/cli/test_cli_annotation.py
index a0ed0f31..6b019666 100644
--- a/tests/unit/cli/test_cli_annotation.py
+++ b/tests/unit/cli/test_cli_annotation.py
@@ -1,4 +1,4 @@
-"""Tests for the annotation IAA CLI command."""
+"""Tests for the annotation CLI commands."""
 
 from datetime import datetime, timezone
 from unittest.mock import patch
@@ -6,6 +6,8 @@
 from typer.testing import CliRunner
 
 from pragmata.annotation import Task
+from pragmata.api import UNSET
+from pragmata.api.annotation_import import ImportResult
 from pragmata.cli.app import app
 from pragmata.core.schemas.iaa_report import (
     AnnotatorPair,
@@ -17,6 +19,10 @@
 runner = CliRunner()
 
 
+def _empty_import_result() -> ImportResult:
+    return ImportResult(total_records=0, dataset_counts={})
+
+
 def _make_report(*, alpha: float | None = 0.6, ci_lower: float | None = 0.3, ci_upper: float | None = 0.9) -> IaaReport:
     return IaaReport(
         export_id="test-export",
@@ -70,3 +76,79 @@ def test_empty_report_no_crash(self, mock_iaa):
         )
         result = runner.invoke(app, ["annotation", "iaa", "empty"])
         assert result.exit_code == 0
+
+
+class TestImportCommandFlags:
+    """CLI wiring for --no-calibration and --calibration-partition-seed."""
+
+    @patch("pragmata.annotation.import_records")
+    def test_no_calibration_sets_fraction_and_min_submitted(self, mock_import, tmp_path):
+        mock_import.return_value = _empty_import_result()
+        records_file = tmp_path / "records.jsonl"
+        records_file.write_text("", encoding="utf-8")
+
+        result = runner.invoke(app, ["annotation", "import", str(records_file), "--no-calibration"])
+
+        assert result.exit_code == 0
+        kwargs = mock_import.call_args.kwargs
+        assert kwargs["calibration_fraction"] == 0.0
+        assert kwargs["calibration_min_submitted"] is None
+
+    @patch("pragmata.annotation.import_records")
+    def test_no_calibration_conflicts_with_positive_fraction(self, mock_import, tmp_path):
+        records_file = tmp_path / "records.jsonl"
+        records_file.write_text("", encoding="utf-8")
+
+        result = runner.invoke(
+            app,
+            ["annotation", "import", str(records_file), "--no-calibration", "--calibration-fraction", "0.2"],
+        )
+
+        assert result.exit_code == 2
+        assert "cannot be combined" in result.output
+        mock_import.assert_not_called()
+
+    @patch("pragmata.annotation.import_records")
+    def test_no_calibration_with_zero_fraction_is_allowed(self, mock_import, tmp_path):
+        mock_import.return_value = _empty_import_result()
+        records_file = tmp_path / "records.jsonl"
+        records_file.write_text("", encoding="utf-8")
+
+        result = runner.invoke(
+            app,
+            ["annotation", "import", str(records_file), "--no-calibration", "--calibration-fraction", "0.0"],
+        )
+
+        assert result.exit_code == 0
+        kwargs = mock_import.call_args.kwargs
+        assert kwargs["calibration_fraction"] == 0.0
+        assert kwargs["calibration_min_submitted"] is None
+
+    @patch("pragmata.annotation.import_records")
+    def test_partition_seed_threaded_through(self, mock_import, tmp_path):
+        mock_import.return_value = _empty_import_result()
+        records_file = tmp_path / "records.jsonl"
+        records_file.write_text("", encoding="utf-8")
+
+        result = runner.invoke(
+            app,
+            ["annotation", "import", str(records_file), "--calibration-partition-seed", "42"],
+        )
+
+        assert result.exit_code == 0
+        kwargs = mock_import.call_args.kwargs
+        assert kwargs["calibration_partition_seed"] == 42
+
+    @patch("pragmata.annotation.import_records")
+    def test_partition_seed_default_is_unset(self, mock_import, tmp_path):
+        mock_import.return_value = _empty_import_result()
+        records_file = tmp_path / "records.jsonl"
+        records_file.write_text("", encoding="utf-8")
+
+        result = runner.invoke(app, ["annotation", "import", str(records_file)])
+
+        assert result.exit_code == 0
+        kwargs = mock_import.call_args.kwargs
+        assert kwargs["calibration_partition_seed"] is UNSET
+        assert kwargs["calibration_min_submitted"] is UNSET
+        assert kwargs["calibration_fraction"] is UNSET
diff --git a/tests/unit/cli/test_parsing.py b/tests/unit/cli/test_parsing.py
index 17b2b789..42a2fb00 100644
--- a/tests/unit/cli/test_parsing.py
+++ b/tests/unit/cli/test_parsing.py
@@ -7,7 +7,7 @@
 
 from pragmata.annotation import Task, UserSpec
 from pragmata.api import UNSET
-from pragmata.cli.parsing import parse_cli_value, parse_tasks, parse_user_specs
+from pragmata.cli.parsing import parse_cli_value, parse_locale, parse_tasks, parse_user_specs
 
 
 class TestParseCliValue:
@@ -46,6 +46,24 @@ def test_invalid_task_raises(self) -> None:
             parse_tasks("nonexistent")
 
 
+class TestParseLocale:
+    def test_none_returns_none(self) -> None:
+        assert parse_locale(None) is None
+
+    def test_valid_locale_en(self) -> None:
+        assert parse_locale("en") == "en"
+
+    def test_valid_locale_de(self) -> None:
+        assert parse_locale("de") == "de"
+
+    def test_whitespace_tolerant(self) -> None:
+        assert parse_locale("  en  ") == "en"
+
+    def test_invalid_locale_raises(self) -> None:
+        with pytest.raises(ValueError, match="Unknown locale"):
+            parse_locale("xx")
+
+
 class TestParseUserSpecs:
     def test_none_returns_none(self) -> None:
         assert parse_user_specs(None) is None
diff --git a/tests/unit/core/annotation/test_argilla_task_definitions.py b/tests/unit/core/annotation/test_argilla_task_definitions.py
index 0763c49b..c1f9b4fc 100644
--- a/tests/unit/core/annotation/test_argilla_task_definitions.py
+++ b/tests/unit/core/annotation/test_argilla_task_definitions.py
@@ -229,14 +229,46 @@ def test_dataset_name_values(self):
         assert DATASET_NAMES[Task.GENERATION] == "generation"
 
 
-class TestDiscardFlowHtmlEnumSync:
-    """Guard against drift between DiscardReason enum and discard_flow.html options."""
-
-    def test_html_option_values_match_enum(self):
-        import re
-        from importlib.resources import files
-
-        html = files("pragmata.core.annotation").joinpath("discard_flow.html").read_text(encoding="utf-8")
-        option_values = set(re.findall(r'<option value="([^"]+)"', html))
-        option_values.discard("")  # ignore placeholder "-- select --" option
-        assert option_values == {r.value for r in DiscardReason}
+class TestDiscardFlowI18nPayload:
+    """Guard against drift between DiscardReason enum and the discard widget payload.
+
+    Option values are now injected via the i18n JSON baked into the rendered
+    ``discard_flow.html`` template at build time, not hardcoded in the HTML.
+    """
+
+    def test_rendered_template_contains_all_enum_values(self):
+        # Option values are injected via the i18n JSON payload at build time,
+        # not hardcoded in the HTML. Assert each DiscardReason.value appears
+        # in the rendered output of the discard CustomField.
+        discard_field = next(f for f in _RETRIEVAL.fields if f.name == "discard_flow")
+        rendered = discard_field.template
+        for reason in DiscardReason:
+            assert f'"value": "{reason.value}"' in rendered, (
+                f"DiscardReason.{reason.name} value {reason.value!r} missing from rendered widget"
+            )
+
+
+class TestCatalogDrivesRenderedOutput:
+    """The catalog is the source of truth for user-visible strings.
+
+    Swapping a catalog entry must change the rendered title; identities
+    (``name=``) and label values stay frozen so exports merge cleanly.
+    """
+
+    def test_catalog_drives_field_title(self, monkeypatch):
+        from pragmata.core.annotation.locales.registry import CATALOGS
+
+        sentinel = "SENTINEL_TITLE"
+        stub = dict(CATALOGS["en"])
+        stub[(Task.RETRIEVAL, "field", "query")] = sentinel
+        monkeypatch.setitem(CATALOGS, "en", stub)
+        # build_task_settings is @functools.cache'd; clear so the swap takes effect
+        # and again on the way out so later tests see the unmodified catalog.
+        build_task_settings.cache_clear()
+        try:
+            rendered = build_task_settings("en")[Task.RETRIEVAL]
+            query_field = _get_field(rendered, "query")
+            assert query_field is not None
+            assert query_field.title == sentinel
+        finally:
+            build_task_settings.cache_clear()
diff --git a/tests/unit/core/annotation/test_export_fetcher.py b/tests/unit/core/annotation/test_export_fetcher.py
index 70b5d989..3806026a 100644
--- a/tests/unit/core/annotation/test_export_fetcher.py
+++ b/tests/unit/core/annotation/test_export_fetcher.py
@@ -16,7 +16,7 @@
     RetrievalAnnotation,
 )
 from pragmata.core.schemas.annotation_task import Task
-from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskOverlap
+from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskSettings, WorkspaceSettings
 
 # ---------------------------------------------------------------------------
 # Mock helpers
@@ -27,10 +27,10 @@
 
 _SETTINGS = AnnotationSettings(
     calibration_fraction=0.0,
-    workspace_dataset_map={
-        "retrieval": {Task.RETRIEVAL: TaskOverlap(calibration_min_submitted=None)},
-        "grounding": {Task.GROUNDING: TaskOverlap(calibration_min_submitted=None)},
-        "generation": {Task.GENERATION: TaskOverlap(calibration_min_submitted=None)},
+    workspaces={
+        "retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings(calibration_min_submitted=None)}),
+        "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings(calibration_min_submitted=None)}),
+        "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings(calibration_min_submitted=None)}),
     },
 )
 
@@ -367,10 +367,10 @@ def test_discard_fields_default_when_absent(self) -> None:
 
     def test_calibration_enabled_fetches_both_datasets_and_tags_rows(self) -> None:
         settings = AnnotationSettings(
-            workspace_dataset_map={
-                "retrieval": {Task.RETRIEVAL: TaskOverlap(calibration_min_submitted=3)},
-                "grounding": {Task.GROUNDING: TaskOverlap(calibration_min_submitted=3)},
-                "generation": {Task.GENERATION: TaskOverlap(calibration_min_submitted=3)},
+            workspaces={
+                "retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings(calibration_min_submitted=3)}),
+                "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings(calibration_min_submitted=3)}),
+                "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings(calibration_min_submitted=3)}),
             },
         )
         prod_record = _make_record(
diff --git a/tests/unit/core/annotation/test_export_runner.py b/tests/unit/core/annotation/test_export_runner.py
index 85672fde..d89bb140 100644
--- a/tests/unit/core/annotation/test_export_runner.py
+++ b/tests/unit/core/annotation/test_export_runner.py
@@ -490,8 +490,14 @@ def test_sidecar_dataset_id_null_when_unset(self, tmp_path: Path, mock_client: M
 class TestResolveCalibrationEnabled:
     def test_raises_when_task_missing_from_topology(self) -> None:
         from pragmata.core.annotation.export_runner import _resolve_calibration_enabled
-        from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskOverlap
+        from pragmata.core.settings.annotation_settings import (
+            AnnotationSettings,
+            TaskSettings,
+            WorkspaceSettings,
+        )
 
-        settings = AnnotationSettings(workspace_dataset_map={"retrieval": {Task.RETRIEVAL: TaskOverlap()}})
+        settings = AnnotationSettings(
+            workspaces={"retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
         with pytest.raises(ValueError, match="grounding"):
             _resolve_calibration_enabled(settings, [Task.RETRIEVAL, Task.GROUNDING])
diff --git a/tests/unit/core/annotation/test_fan_out_records.py b/tests/unit/core/annotation/test_fan_out_records.py
index 72b39a73..6128f387 100644
--- a/tests/unit/core/annotation/test_fan_out_records.py
+++ b/tests/unit/core/annotation/test_fan_out_records.py
@@ -11,7 +11,7 @@
 from pragmata.core.annotation.record_builder import fan_out_records
 from pragmata.core.schemas.annotation_import import Chunk, QueryResponsePair
 from pragmata.core.schemas.annotation_task import Task
-from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskOverlap
+from pragmata.core.settings.annotation_settings import AnnotationSettings, TaskSettings, WorkspaceSettings
 
 
 def _make_pair(query: str) -> QueryResponsePair:
@@ -24,16 +24,18 @@ def _make_pair(query: str) -> QueryResponsePair:
 
 
 def _settings(*, calibration_enabled: bool = True) -> AnnotationSettings:
-    overlap = TaskOverlap(calibration_min_submitted=3 if calibration_enabled else None)
+    def _task() -> TaskSettings:
+        return TaskSettings(calibration_min_submitted=3 if calibration_enabled else None)
+
     return AnnotationSettings(
         dataset_id="run1",
         # When calibration_min_submitted=None for every task, calibration_fraction
         # must be 0 to satisfy the AnnotationSettings model validator.
         calibration_fraction=0.5 if calibration_enabled else 0.0,
-        workspace_dataset_map={
-            "retrieval": {Task.RETRIEVAL: overlap},
-            "grounding": {Task.GROUNDING: overlap},
-            "generation": {Task.GENERATION: overlap},
+        workspaces={
+            "retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: _task()}),
+            "grounding": WorkspaceSettings(tasks={Task.GROUNDING: _task()}),
+            "generation": WorkspaceSettings(tasks={Task.GENERATION: _task()}),
         },
     )
 
@@ -148,14 +150,14 @@ def test_dataset_counts_reflect_per_dataset_record_counts(self, patched_create_d
         assert cal_total == 3 * 3  # 3 cal records * 3 tasks
         assert prod_total == 2 * 3  # 2 prod records * 3 tasks
 
-    def test_skips_tasks_not_in_workspace_dataset_map(self, patched_create_dataset, caplog) -> None:
+    def test_skips_tasks_not_in_workspaces_topology(self, patched_create_dataset, caplog) -> None:
         client = MagicMock()
         _, created = patched_create_dataset
 
         # Topology only declares retrieval; grounding/generation are absent.
         partial_settings = AnnotationSettings(
             dataset_id="run1",
-            workspace_dataset_map={"retrieval": {Task.RETRIEVAL: TaskOverlap()}},
+            workspaces={"retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
         )
         records = [_make_pair("q0")]
         from pragmata.core.annotation.record_builder import derive_record_uuid
@@ -168,4 +170,59 @@ def test_skips_tasks_not_in_workspace_dataset_map(self, patched_create_dataset,
         # Only retrieval gets a dataset; grounding and generation are skipped with a warning.
         assert len(result) == 1
         assert any(ds_name.startswith("retrieval_") for (_, ds_name) in created)
-        assert "not in workspace_dataset_map" in caplog.text
+        assert "not in workspaces topology" in caplog.text
+
+
+class TestImportLocaleConflict:
+    """Re-importing into an existing dataset with a different locale logs a warning and proceeds.
+
+    Label *values* are locale-invariant, so the data is still safe to append;
+    only the displayed text differs. The mismatch is surfaced as a warning so
+    operators can investigate, not raised.
+    """
+
+    def test_relocale_warn_append(self, fake_dataset_factory, caplog) -> None:
+        import argilla as rg
+
+        from pragmata.core.annotation.argilla_task_definitions import build_task_settings, dataset_name
+        from pragmata.core.annotation.record_builder import derive_record_uuid
+
+        # Build an EN-flavoured existing dataset; _detect_dataset_locale will
+        # match its label displays against the EN catalog.
+        en_settings = build_task_settings("en")[Task.RETRIEVAL]
+        ds_name = dataset_name(Task.RETRIEVAL, calibration=False, dataset_id="run1")
+        fake_dataset = fake_dataset_factory(ds_name)
+        fake_dataset.settings = rg.Settings(
+            fields=en_settings.fields,
+            questions=en_settings.questions,
+            metadata=en_settings.metadata,
+            guidelines=en_settings.guidelines,
+        )
+
+        def _create(client, name, ws_base, task_cfg):
+            # Simulate an existing dataset: ds_created=False, returning the EN-flavoured one.
+            return fake_dataset, False
+
+        records = [_make_pair("q0")]
+        assignments = {derive_record_uuid(records[0]): False}
+
+        # DE-locale settings — mismatch against the EN existing dataset.
+        settings_de = AnnotationSettings(
+            dataset_id="run1",
+            locale="de",
+            calibration_fraction=0.0,
+            workspaces={"retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+
+        with patch("pragmata.core.annotation.record_builder.create_dataset", side_effect=_create):
+            with caplog.at_level("WARNING", logger="pragmata.core.annotation.record_builder"):
+                result = fan_out_records(MagicMock(), records=records, settings=settings_de, assignments=assignments)
+
+        # Records were appended (no error raised), and a warning was logged.
+        # Assert against locale .name rather than the %r-formatted .value so the
+        # test isn't tied to the log formatter's quote style.
+        assert len(result) == 1
+        assert "Locale mismatch" in caplog.text
+        assert "en" in caplog.text
+        assert "de" in caplog.text
+        fake_dataset.records.log.assert_called_once()
diff --git a/tests/unit/core/annotation/test_locales.py b/tests/unit/core/annotation/test_locales.py
new file mode 100644
index 00000000..9cf4822d
--- /dev/null
+++ b/tests/unit/core/annotation/test_locales.py
@@ -0,0 +1,174 @@
+"""Tests for locale catalogs and locale-aware task-settings construction."""
+
+import argilla as rg
+import pytest
+
+from pragmata.core.annotation.argilla_task_definitions import build_task_settings
+from pragmata.core.annotation.locales.registry import CATALOGS, get_catalog
+from pragmata.core.schemas.annotation_task import Locale, Task
+
+_NON_EN_LOCALES = sorted(loc for loc in CATALOGS if loc != "en")
+_ALL_LOCALES = sorted(CATALOGS)
+
+
+class TestCatalogCompleteness:
+    """Every non-default locale must define the exact key set the default (EN) provides."""
+
+    @pytest.mark.parametrize("locale", _NON_EN_LOCALES)
+    def test_locale_keys_match_english(self, locale: Locale) -> None:
+        en_keys = set(get_catalog("en").keys())
+        other_keys = set(get_catalog(locale).keys())
+        missing = en_keys - other_keys
+        extra = other_keys - en_keys
+        assert not missing, f"{locale} catalog missing keys: {missing}"
+        assert not extra, f"{locale} catalog has unexpected keys: {extra}"
+
+    @pytest.mark.parametrize("locale", _ALL_LOCALES)
+    def test_no_empty_strings(self, locale: Locale) -> None:
+        catalog = get_catalog(locale)
+        empty = [k for k, v in catalog.items() if not v.strip()]
+        assert not empty, f"{locale} catalog has empty strings at keys: {empty}"
+
+
+class TestLocaleAwareSettings:
+    """build_task_settings() returns locale-appropriate titles while preserving structure."""
+
+    def test_default_locale_is_english(self) -> None:
+        # Cached separately from explicit "en" call, but should produce identical content.
+        default_settings = build_task_settings()
+        en_settings = build_task_settings("en")
+        for task in Task:
+            assert _titles(default_settings[task]) == _titles(en_settings[task])
+
+    def test_de_titles_differ_from_en(self) -> None:
+        en = build_task_settings("en")
+        de = build_task_settings("de")
+        # At least some titles must differ — otherwise translations aren't wired through.
+        for task in Task:
+            en_titles = _titles(en[task])
+            de_titles = _titles(de[task])
+            assert en_titles != de_titles, f"{task.value}: DE titles identical to EN — wiring broken"
+
+    @pytest.mark.parametrize("locale", _ALL_LOCALES)
+    def test_field_and_question_names_stable_across_locales(self, locale: Locale) -> None:
+        """Identities (name=) must not change with locale — exports depend on this."""
+        en = build_task_settings("en")
+        other = build_task_settings(locale)
+        for task in Task:
+            assert [f.name for f in en[task].fields] == [f.name for f in other[task].fields]
+            assert [q.name for q in en[task].questions] == [q.name for q in other[task].questions]
+
+    @pytest.mark.parametrize("locale", _ALL_LOCALES)
+    def test_label_values_stable_across_locales(self, locale: Locale) -> None:
+        """Label values (e.g. 'yes'/'no') must not change with locale — export parsing depends on this."""
+        en = build_task_settings("en")
+        other = build_task_settings(locale)
+        for task in Task:
+            for en_q, other_q in zip(en[task].questions, other[task].questions, strict=True):
+                if isinstance(en_q, rg.LabelQuestion):
+                    assert isinstance(other_q, rg.LabelQuestion)
+                    assert [_label_value(label) for label in en_q.labels] == [
+                        _label_value(label) for label in other_q.labels
+                    ]
+
+    def test_label_displays_differ_in_de(self) -> None:
+        """Label display text (option text shown in the UI) must change with locale."""
+        en = build_task_settings("en")
+        de = build_task_settings("de")
+        seen_any_diff = False
+        for task in Task:
+            for en_q, de_q in zip(en[task].questions, de[task].questions, strict=True):
+                if not isinstance(en_q, rg.LabelQuestion):
+                    continue
+                assert isinstance(de_q, rg.LabelQuestion)
+                en_displays = _option_texts(en_q)
+                de_displays = _option_texts(de_q)
+                if en_displays != de_displays:
+                    seen_any_diff = True
+        assert seen_any_diff, (
+            "DE label displays identical to EN across all questions — label translation not wired through"
+        )
+
+    def test_label_yes_no_displays_in_de(self) -> None:
+        """Spot-check: the 'yes'/'no' label values render as 'Ja'/'Nein' in DE."""
+        de = build_task_settings("de")
+        q = next(q for q in de[Task.GROUNDING].questions if q.name == "support_present")
+        assert isinstance(q, rg.LabelQuestion)
+        assert _option_map(q) == {"yes": "Ja", "no": "Nein"}
+
+    def test_discard_reason_labels_translated_in_de(self) -> None:
+        """Spot-check: discard reasons are translated, while their VALUES stay as DiscardReason.*.value."""
+        de = build_task_settings("de")
+        q = next(q for q in de[Task.GROUNDING].questions if q.name == "discard_reason")
+        assert isinstance(q, rg.LabelQuestion)
+        opts = _option_map(q)
+        assert set(opts.keys()) == {"invalid_or_unrealistic", "unclear", "outside_reviewer_expertise"}
+        # All displays should be non-English (cheap heuristic: differ from the EN spelling).
+        en = build_task_settings("en")
+        en_q = next(q for q in en[Task.GROUNDING].questions if q.name == "discard_reason")
+        assert isinstance(en_q, rg.LabelQuestion)
+        assert _option_map(q) != _option_map(en_q)
+
+
+def _discard_field(locale: Locale) -> rg.CustomField:
+    settings = build_task_settings(locale)
+    return next(f for f in settings[Task.GROUNDING].fields if f.name == "discard_flow")
+
+
+class TestDiscardWidgetI18n:
+    """Verify the discard widget template embeds locale-aware strings."""
+
+    @pytest.mark.parametrize("locale", _ALL_LOCALES)
+    def test_widget_carries_all_locales_in_payload(self, locale: Locale) -> None:
+        """Every locale's widget strings ship inside the rendered template."""
+        widget = _discard_field(locale)
+        for other_locale in _ALL_LOCALES:
+            sample = get_catalog(other_locale)[(Task.GROUNDING, "widget", "discard.button_label")]
+            assert sample in widget.template, (
+                f"Rendered widget (dataset locale={locale}) missing {other_locale} button label {sample!r}"
+            )
+
+    def test_widget_default_locale_matches_dataset_locale(self) -> None:
+        """The widget's DEFAULT_LOCALE constant points at the dataset's creation locale."""
+        assert 'var DEFAULT_LOCALE = "en"' in _discard_field("en").template
+        assert 'var DEFAULT_LOCALE = "de"' in _discard_field("de").template
+
+    def test_widget_dataset_locale_listed_first_in_supported_locales(self) -> None:
+        """SUPPORTED_LOCALES is ordered with the dataset's locale first, for aria-label probing."""
+        assert 'var SUPPORTED_LOCALES = ["de"' in _discard_field("de").template
+
+    def test_widget_aria_label_titles_translated_per_locale(self) -> None:
+        """Widget bundles every locale's question titles for aria-label probing."""
+        de_template = _discard_field("de").template
+        # Both EN and DE title strings present so the widget can find the
+        # hidden cards regardless of which chrome locale is currently active.
+        assert "Discard reason" in de_template
+        assert "Verwerfungsgrund" in de_template
+
+
+def _titles(settings: rg.Settings) -> dict[str, str]:
+    by_name = {f.name: f.title for f in settings.fields}
+    by_name.update({q.name: q.title for q in settings.questions})
+    by_name["__guidelines__"] = settings.guidelines or ""
+    return by_name
+
+
+def _label_value(label: object) -> str:
+    # Argilla's LabelQuestion.labels property exposes just the option *keys*
+    # (machine values). Useful when checking value-stability across locales.
+    return label if isinstance(label, str) else getattr(label, "value", str(label))
+
+
+def _option_texts(question: rg.LabelQuestion) -> list[str]:
+    """Ordered list of UI display strings for a LabelQuestion's options.
+
+    Reads the underlying ``_model.settings.options`` because the public
+    ``.labels`` getter is lossy — it returns only the option keys (values)
+    and drops the per-option display ``text``.
+    """
+    return [opt["text"] for opt in question._model.settings.options]
+
+
+def _option_map(question: rg.LabelQuestion) -> dict[str, str]:
+    """Value-to-display-text map for a LabelQuestion's options."""
+    return {opt["value"]: opt["text"] for opt in question._model.settings.options}
diff --git a/tests/unit/core/settings/test_annotation_settings.py b/tests/unit/core/settings/test_annotation_settings.py
index 7dc2b089..aca35884 100644
--- a/tests/unit/core/settings/test_annotation_settings.py
+++ b/tests/unit/core/settings/test_annotation_settings.py
@@ -1,25 +1,28 @@
 """Unit tests for AnnotationSettings and UserSpec."""
 
 import pytest
+import yaml
 from pydantic import ValidationError
 
 from pragmata.core.schemas.annotation_task import Task
 from pragmata.core.settings.annotation_settings import (
     AnnotationSettings,
     ArgillaSettings,
-    TaskOverlap,
+    TaskSettings,
     UserSpec,
+    WorkspaceSettings,
 )
+from pragmata.core.settings.settings_base import INHERIT
 
 
 class TestAnnotationSettingsDefaults:
-    def test_workspace_dataset_map_default(self):
+    def test_workspaces_default(self):
         s = AnnotationSettings()
-        assert s.workspace_dataset_map == {
-            "retrieval": {Task.RETRIEVAL: TaskOverlap()},
-            "grounding": {Task.GROUNDING: TaskOverlap()},
-            "generation": {Task.GENERATION: TaskOverlap()},
-        }
+        # Default factory builds three single-task workspaces.
+        assert set(s.workspaces) == {"retrieval", "grounding", "generation"}
+        assert set(s.workspaces["retrieval"].tasks) == {Task.RETRIEVAL}
+        assert set(s.workspaces["grounding"].tasks) == {Task.GROUNDING}
+        assert set(s.workspaces["generation"].tasks) == {Task.GENERATION}
 
     def test_dataset_id_default(self):
         s = AnnotationSettings()
@@ -29,31 +32,61 @@ def test_calibration_partition_seed_default(self):
         s = AnnotationSettings()
         assert s.calibration_partition_seed == 0
 
+    def test_production_min_submitted_deployment_default(self):
+        s = AnnotationSettings()
+        assert s.production_min_submitted == 1
+
+    def test_calibration_min_submitted_deployment_default(self):
+        s = AnnotationSettings()
+        assert s.calibration_min_submitted == 3
+
     def test_extra_fields_forbidden(self):
         with pytest.raises(ValidationError):
             AnnotationSettings(nonexistent_field="value")
 
 
-class TestTaskOverlapDefaults:
-    def test_production_default_one(self):
-        o = TaskOverlap()
-        assert o.production_min_submitted == 1
+class TestTaskSettingsDefaults:
+    """``TaskSettings`` is default-free for inherited fields (INHERIT)."""
 
-    def test_calibration_default_three(self):
-        o = TaskOverlap()
-        assert o.calibration_min_submitted == 3
+    def test_production_default_inherit(self):
+        t = TaskSettings()
+        assert t.production_min_submitted is INHERIT
+
+    def test_calibration_default_inherit(self):
+        t = TaskSettings()
+        assert t.calibration_min_submitted is INHERIT
 
     def test_calibration_can_be_disabled(self):
-        o = TaskOverlap(calibration_min_submitted=None)
-        assert o.calibration_min_submitted is None
+        t = TaskSettings(calibration_min_submitted=None)
+        assert t.calibration_min_submitted is None
 
-    def test_extra_fields_forbidden(self):
+    def test_extra_forbid(self):
         with pytest.raises(ValidationError):
-            TaskOverlap(nonexistent_field=1)  # type: ignore[call-arg]
+            TaskSettings(nonexistent_field=1)  # type: ignore[call-arg]
 
     def test_production_must_be_positive(self):
         with pytest.raises(ValidationError):
-            TaskOverlap(production_min_submitted=0)
+            TaskSettings(production_min_submitted=0)
+
+
+class TestWorkspaceSettingsDefaults:
+    """``WorkspaceSettings`` is default-free for inherited fields (INHERIT)."""
+
+    def test_production_default_inherit(self):
+        w = WorkspaceSettings(tasks={})
+        assert w.production_min_submitted is INHERIT
+
+    def test_calibration_default_inherit(self):
+        w = WorkspaceSettings(tasks={})
+        assert w.calibration_min_submitted is INHERIT
+
+    def test_extra_forbid(self):
+        with pytest.raises(ValidationError):
+            WorkspaceSettings(tasks={}, nonexistent_field=1)  # type: ignore[call-arg]
+
+    def test_calibration_can_be_disabled(self):
+        w = WorkspaceSettings(tasks={}, calibration_min_submitted=None)
+        assert w.calibration_min_submitted is None
 
 
 class TestAnnotationSettingsResolve:
@@ -76,32 +109,56 @@ def test_unsafe_dataset_id_rejected(self, bad):
             AnnotationSettings(dataset_id=bad)
 
 
-class TestCalibrationTopologyValidator:
-    def _disabled_topology(self) -> dict:
-        from pragmata.core.schemas.annotation_task import Task
+def _disabled_topology() -> dict[str, WorkspaceSettings]:
+    """Workspaces where every task explicitly disables calibration."""
+    return {
+        "retrieval": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings(calibration_min_submitted=None)}),
+        "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings(calibration_min_submitted=None)}),
+        "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings(calibration_min_submitted=None)}),
+    }
 
-        return {
-            "retrieval": {Task.RETRIEVAL: TaskOverlap(calibration_min_submitted=None)},
-            "grounding": {Task.GROUNDING: TaskOverlap(calibration_min_submitted=None)},
-            "generation": {Task.GENERATION: TaskOverlap(calibration_min_submitted=None)},
-        }
 
+class TestCalibrationTopologyValidator:
     def test_zero_fraction_with_disabled_calibration_ok(self):
-        AnnotationSettings(calibration_fraction=0.0, workspace_dataset_map=self._disabled_topology())
+        AnnotationSettings(calibration_fraction=0.0, workspaces=_disabled_topology())
 
     def test_positive_fraction_with_disabled_calibration_rejected(self):
-        with pytest.raises(ValidationError, match="topology has no calibration dataset"):
-            AnnotationSettings(calibration_fraction=0.1, workspace_dataset_map=self._disabled_topology())
+        with pytest.raises(ValidationError, match=r"workspace/task pairs"):
+            AnnotationSettings(calibration_fraction=0.1, workspaces=_disabled_topology())
 
-    def test_positive_fraction_with_at_least_one_enabled_task_ok(self):
-        from pragmata.core.schemas.annotation_task import Task
-
-        topology = self._disabled_topology()
-        topology["retrieval"][Task.RETRIEVAL] = TaskOverlap(calibration_min_submitted=3)
-        # Mixed: retrieval calibrated, grounding/generation not -> still rejected
+    def test_positive_fraction_with_one_enabled_task_still_rejected(self):
+        topology = _disabled_topology()
+        topology["retrieval"] = WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings(calibration_min_submitted=3)})
+        # Mixed: retrieval calibrated, grounding/generation not - still rejected
         # because the validator checks every task, not "any task".
-        with pytest.raises(ValidationError, match="topology has no calibration dataset"):
-            AnnotationSettings(calibration_fraction=0.1, workspace_dataset_map=topology)
+        with pytest.raises(ValidationError, match=r"workspace/task pairs"):
+            AnnotationSettings(calibration_fraction=0.1, workspaces=topology)
+
+    def test_error_message_reports_workspace_task_pairs(self):
+        with pytest.raises(ValidationError) as excinfo:
+            AnnotationSettings(calibration_fraction=0.1, workspaces=_disabled_topology())
+        msg = str(excinfo.value)
+        assert "retrieval/retrieval" in msg
+        assert "grounding/grounding" in msg
+        assert "generation/generation" in msg
+
+    def test_per_workspace_task_inheritance(self):
+        """Workspace-level calibration_min_submitted=None is inherited by its tasks.
+
+        With calibration_fraction>0, the topology validator resolves each
+        task's calibration value through the inheritance walk and reports
+        any None resolutions by workspace/task pair.
+        """
+        workspaces = {
+            "retrieval": WorkspaceSettings(
+                calibration_min_submitted=None,
+                tasks={Task.RETRIEVAL: TaskSettings()},  # inherits None
+            ),
+            "grounding": WorkspaceSettings(tasks={Task.GROUNDING: TaskSettings()}),
+            "generation": WorkspaceSettings(tasks={Task.GENERATION: TaskSettings()}),
+        }
+        with pytest.raises(ValidationError, match=r"retrieval/retrieval"):
+            AnnotationSettings(calibration_fraction=0.1, workspaces=workspaces)
 
     def test_fraction_out_of_range_rejected(self):
         with pytest.raises(ValidationError):
@@ -110,6 +167,201 @@ def test_fraction_out_of_range_rejected(self):
             AnnotationSettings(calibration_fraction=-0.1)
 
 
+class TestResolvedTask:
+    """``resolved_task()`` walks task → workspace → deployment for inherited fields."""
+
+    def test_task_resolves_from_deployment_when_unset(self):
+        s = AnnotationSettings(
+            production_min_submitted=5,
+            workspaces={"r": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 5
+
+    def test_task_resolves_from_workspace_when_unset(self):
+        s = AnnotationSettings(
+            workspaces={
+                "r": WorkspaceSettings(
+                    production_min_submitted=7,
+                    tasks={Task.RETRIEVAL: TaskSettings()},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 7
+
+    def test_workspace_override_wins_over_deployment(self):
+        s = AnnotationSettings(
+            production_min_submitted=1,
+            workspaces={
+                "r": WorkspaceSettings(
+                    production_min_submitted=4,
+                    tasks={Task.RETRIEVAL: TaskSettings()},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 4
+
+    def test_task_override_wins_over_workspace_and_deployment(self):
+        s = AnnotationSettings(
+            production_min_submitted=1,
+            workspaces={
+                "r": WorkspaceSettings(
+                    production_min_submitted=2,
+                    tasks={Task.RETRIEVAL: TaskSettings(production_min_submitted=9)},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 9
+
+    def test_resolves_explicit_disable_at_task(self):
+        s = AnnotationSettings(
+            calibration_fraction=0.0,
+            workspaces={
+                "r": WorkspaceSettings(
+                    tasks={Task.RETRIEVAL: TaskSettings(calibration_min_submitted=None)},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).calibration_min_submitted is None
+
+    def test_resolves_workspace_disable_for_task(self):
+        s = AnnotationSettings(
+            calibration_fraction=0.0,
+            workspaces={
+                "r": WorkspaceSettings(
+                    calibration_min_submitted=None,
+                    tasks={Task.RETRIEVAL: TaskSettings()},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).calibration_min_submitted is None
+
+    def test_empty_tasks_dict_no_op(self):
+        # An empty tasks dict must not crash settings construction.
+        s = AnnotationSettings(
+            workspaces={"empty": WorkspaceSettings(tasks={})},
+        )
+        assert s.workspaces["empty"].tasks == {}
+
+    def test_raw_models_preserve_inherit_sentinel(self):
+        """The model holds specified values; ``INHERIT`` is preserved untouched."""
+        s = AnnotationSettings(
+            production_min_submitted=5,
+            workspaces={"r": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+        assert s.workspaces["r"].production_min_submitted is INHERIT
+        assert s.workspaces["r"].tasks[Task.RETRIEVAL].production_min_submitted is INHERIT
+
+    def test_shared_workspace_settings_never_mutated(self):
+        """Reused WorkspaceSettings instances must not carry stale resolved values."""
+        ws = WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})
+        _ = AnnotationSettings(production_min_submitted=1, workspaces={"retrieval": ws})
+        s2 = AnnotationSettings(production_min_submitted=42, workspaces={"retrieval": ws})
+        assert s2.resolved_task("retrieval", Task.RETRIEVAL).production_min_submitted == 42
+        # Raw instance untouched — INHERIT sentinel preserved across both constructions
+        assert ws.production_min_submitted is INHERIT
+        assert ws.tasks[Task.RETRIEVAL].production_min_submitted is INHERIT
+
+    def test_locale_resolves_from_deployment_when_unset(self):
+        s = AnnotationSettings(
+            locale="de",
+            workspaces={"r": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).locale == "de"
+
+    def test_locale_resolves_from_workspace_when_task_unset(self):
+        s = AnnotationSettings(
+            workspaces={
+                "r": WorkspaceSettings(
+                    locale="de",
+                    tasks={Task.RETRIEVAL: TaskSettings()},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).locale == "de"
+
+    def test_locale_task_override_wins_over_workspace_and_deployment(self):
+        s = AnnotationSettings(
+            locale="en",
+            workspaces={
+                "r": WorkspaceSettings(
+                    locale="de",
+                    tasks={Task.RETRIEVAL: TaskSettings(locale="en")},
+                ),
+            },
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).locale == "en"
+
+    def test_locale_default_resolves_to_en(self):
+        s = AnnotationSettings(
+            workspaces={"r": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+        assert s.resolved_task("r", Task.RETRIEVAL).locale == "en"
+
+
+class TestTaskUniquenessValidator:
+    def test_same_task_in_two_workspaces_rejected(self):
+        with pytest.raises(ValidationError, match=r"task 'retrieval' appears in multiple workspaces"):
+            AnnotationSettings(
+                workspaces={
+                    "a": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()}),
+                    "b": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()}),
+                },
+            )
+
+
+class TestCalibrationTopologyResolution:
+    """``_check_calibration_topology`` resolves inheritance for each task.
+
+    A workspace-level ``calibration_min_submitted=None`` must surface in the
+    topology check via the inheritance walk, even though the raw task models
+    still hold ``INHERIT``.
+    """
+
+    def test_workspace_disable_surfaces_via_resolution(self):
+        with pytest.raises(ValidationError, match=r"r/retrieval"):
+            AnnotationSettings(
+                calibration_fraction=0.1,
+                workspaces={
+                    "r": WorkspaceSettings(
+                        calibration_min_submitted=None,
+                        tasks={Task.RETRIEVAL: TaskSettings()},
+                    ),
+                    "g": WorkspaceSettings(
+                        calibration_min_submitted=None,
+                        tasks={Task.GROUNDING: TaskSettings()},
+                    ),
+                    "x": WorkspaceSettings(
+                        calibration_min_submitted=None,
+                        tasks={Task.GENERATION: TaskSettings()},
+                    ),
+                },
+            )
+
+
+class TestYamlRoundtrip:
+    """Specified values round-trip losslessly; ``resolved_task()`` gives computed values."""
+
+    def test_model_dump_preserves_inherit_sentinel(self):
+        """``model_dump()`` returns specified values: child scopes stay ``INHERIT``."""
+        s = AnnotationSettings(
+            production_min_submitted=5,
+            workspaces={"r": WorkspaceSettings(tasks={Task.RETRIEVAL: TaskSettings()})},
+        )
+        dumped = s.model_dump()
+        assert dumped["production_min_submitted"] == 5
+        assert dumped["workspaces"]["r"]["production_min_submitted"] is INHERIT
+        assert dumped["workspaces"]["r"]["tasks"][Task.RETRIEVAL]["production_min_submitted"] is INHERIT
+        # But resolved_task gives the computed value.
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 5
+
+    def test_sparse_yaml_input_roundtrips_to_resolved_value(self):
+        data = yaml.safe_load(
+            "production_min_submitted: 4\ncalibration_fraction: 0.0\nworkspaces: {r: {tasks: {retrieval: {}}}}\n"
+        )
+        s = AnnotationSettings(**data)
+        assert s.resolved_task("r", Task.RETRIEVAL).production_min_submitted == 4
+
+
 class TestArgillaSettings:
     def test_defaults_to_none_api_url(self):
         s = AnnotationSettings()