traigent 0.19.1.dev0__tar.gz → 0.19.2__tar.gz

{traigent-0.19.1.dev0 → traigent-0.19.2}/CHANGELOG.md

@@ -6,6 +6,71 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.19.2] - 2026-07-04
+
+Multi-run analytics release: agents can now read the experiment-group
+cohort — one aggregated, source-preserving table of results across runs
+for the same agent + dataset.
+
+### Added
+- Three analytics MCP tools exposing the experiment-group cohort
+  endpoints: `analytics_list_experiment_groups`,
+  `analytics_get_experiment_group`, and
+  `analytics_list_experiment_group_configuration_runs` (one row per
+  configuration-run across the cohort's runs, carrying `configuration`,
+  `measures`, status, `trial_number`, and source ids). Rows remain
+  individual source runs — grouped, never merged or deduped by config
+  hash. (#1707)
+- Server/tool parity guard: every `ANALYTICS_TOOL_NAMES` entry must be
+  registered on the FastMCP server, so a defined-but-unregistered tool
+  can no longer ship silently. (#1707)
+
+### Fixed
+- `traigent next-steps` now honors `TRAIGENT_BACKEND_URL` /
+  `TRAIGENT_API_URL` — the `--backend-url` option previously ignored the
+  documented environment variable and silently fell back to
+  `http://localhost:5000`. Wiring and help text now match
+  `traigent plan`. (#1707)
+
+## [0.19.1] - 2026-07-03
+
+No-silent-legacy hardening release: five classes of silent failure now either
+work correctly or fail loudly.
+
+### Fixed
+- `ObjectiveSchema` weights now govern `best_config` selection for grid/random
+  runs via observed-range (min-max, orientation-aware) weighted scoring;
+  per-trial `metrics["score"]` is populated and post-hoc
+  `calculate_weighted_scores` uses the same scorer. Flipping weights
+  0.9/0.1 ↔ 0.1/0.9 on an accuracy/cost tradeoff now flips the winner. (#1682)
+- `warm_start_transfer` returned in the session-create response now reaches
+  `result.metadata` (previously dropped; runs reported `no_seed_configs` from
+  valid cloud-tracked priors). An explicit `warm_start_from` that applies 0
+  seeds emits a warning naming the refusal reason. (#1683)
+- Dataset file-not-found errors name the resolution rule
+  (`TRAIGENT_DATASET_ROOT` vs cwd), the registry-resolved path, and the exact
+  candidate tried — the doubled-path case is self-diagnosing. (#1684)
+
+### Changed (fail loud instead of silent)
+- Smart algorithms (`bayesian`, `tpe`, `cmaes`, `nsga2`, `optuna*`) raise an
+  actionable error when the managed cloud path cannot execute them, instead of
+  returning a silent 0-trial COMPLETED result with `best_config=None`. Runtime
+  `optimize(algorithm=...)` smart overrides re-resolve to cloud-required
+  policy (no silent local fallback). (#1681)
+- `.optimize()` rejects decorator-only arguments at call time with a
+  move-it-to-the-decorator `TypeError` — `warm_start_from` and 39 sibling
+  options were previously swallowed silently. (#1683)
+- Deprecated `execution_mode` selectors (notably `"edge_analytics"`) raise
+  `ConfigurationError` with `algorithm=` + `offline=` migration guidance on
+  every entry path (decorator, `initialize`, `TraigentConfig`, client) —
+  previously a silent 0-trial run. On the wire, `metadata["mode"]` now carries
+  the canonical `local`/`hybrid`/`hybrid_api` vocabulary. (#1684, #1393)
+- Nonpositive cost limits raise at configuration time; a budget-gate block
+  logs "budget gate blocked N planned trials (estimated $X > limit $Y)"
+  instead of silently completing with 0 trials. (#1684)
+- Flagship multi-objective examples and docs migrated off removed/deprecated
+  parameters (`execution_mode`, `budget_limit`). (#1684)
+
 ## [0.19.0] - 2026-07-03
 
 ### Added

{traigent-0.19.1.dev0/traigent.egg-info → traigent-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: traigent
-Version: 0.19.1.dev0
+Version: 0.19.2
 Summary: Enterprise-grade LLM optimization platform with advanced analytics and AI-powered insights
 Author-email: Traigent Team <opensource@traigent.ai>
 License-Expression: AGPL-3.0-only OR LicenseRef-Traigent-Commercial

{traigent-0.19.1.dev0 → traigent-0.19.2}/docs/api-reference/decorator-reference.md

@@ -596,8 +596,9 @@ approve.
 )
 ```
 
-`budget_limit` / `budget_metric` / `budget_include_pruned` are deprecated aliases
-for compatibility. Use `cost_limit` for hard USD spend control.
+`budget_limit` / `budget_metric` / `budget_include_pruned` were removed in
+0.13.0 and now raise `TypeError`. Use `cost_limit` for hard USD spend control,
+or `metric_limit` / `metric_name` for other cumulative metrics.
 
 **Stop Conditions**:
 

{traigent-0.19.1.dev0 → traigent-0.19.2}/docs/architecture/stop_conditions.md

@@ -31,8 +31,10 @@ Built-in implementations:
 | `HypervolumeConvergenceStopCondition` | Stops when hypervolume improvement remains below a threshold across a sliding window. | `convergence_metric="hypervolume_improvement"`, `convergence_window`, `convergence_threshold`. |
 | `SemanticSaturationStopCondition` | Stops when per-example quality vectors are stable and monitored continuous objectives are no longer improving. | `semantic_saturation={...}`. |
 
-`budget_limit` remains as a deprecated alias for `metric_limit` for compatibility.
-New code should not use it.
+`budget_limit`/`budget_metric`/`budget_include_pruned` were removed in 0.13.0.
+Passing any of them to `@traigent.optimize` or `.optimize(...)` now raises
+`TypeError`. Use `cost_limit` for money-spend control, or `metric_limit`/
+`metric_name` for other cumulative metrics.
 
 ## Cost limit vs metric limit
 
@@ -59,10 +61,12 @@ def chat(question: str) -> str:
     ...
 ```
 
-Legacy migration:
+Removed legacy API:
 
 ```python
-# Deprecated compatibility path. Emits a DeprecationWarning.
+# Raises TypeError: budget_limit/budget_metric/budget_include_pruned were
+# removed in 0.13.0. Use cost_limit=<value> and/or metric_limit=<value> with
+# metric_name=<name> instead.
 @traigent.optimize(
     eval_dataset="qa.jsonl",
     configuration_space={"temperature": [0.0, 0.5, 0.9]},
@@ -73,9 +77,18 @@ def chat(question: str) -> str:
     ...
 ```
 
-If a legacy `budget_limit` call omits the metric name, Traigent defaults to
-`total_cost` for compatibility and warns that money spend control should use
-`cost_limit` instead.
+Migrate to:
+
+```python
+@traigent.optimize(
+    eval_dataset="qa.jsonl",
+    configuration_space={"temperature": [0.0, 0.5, 0.9]},
+    metric_limit=50_000,
+    metric_name="total_tokens",
+)
+def chat(question: str) -> str:
+    ...
+```
 
 The orchestrator instantiates the conditions during construction via
 `_configure_stop_conditions()` and calls `reset()` for every run so state never leaks

{traigent-0.19.1.dev0 → traigent-0.19.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "traigent"
-version = "0.19.1.dev0"
+version = "0.19.2"
 authors = [
     {name = "Traigent Team", email = "opensource@traigent.ai"},
 ]

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/analytics_mcp/server.py

@@ -28,12 +28,15 @@ from traigent.analytics_mcp.tools import (
     analytics_compare_runs_tool,
     analytics_get_correlation_matrix_tool,
     analytics_get_example_insights_tool,
+    analytics_get_experiment_group_tool,
     analytics_get_parameter_insights_tool,
     analytics_get_project_overview_tool,
     analytics_get_run_decision_brief_tool,
     analytics_get_run_leaderboard_tool,
     analytics_get_run_report_tool,
     analytics_get_single_run_pareto_tool,
+    analytics_list_experiment_group_configuration_runs_tool,
+    analytics_list_experiment_groups_tool,
     analytics_render_chart_tool,
     auth_status_tool,
     health_check_tool,
@@ -259,6 +262,59 @@ def create_server() -> Any:
     ) -> dict[str, Any]:
         return analytics_render_chart_tool(payload, kind, output_path)
 
+    @server.tool(
+        description=(
+            "List experiment-group cohorts for a project — source-preserving "
+            "groups of optimization runs keyed by (agent_id + dataset_id). A "
+            "group is a browsing/aggregation view over source runs, never a "
+            "merged analytics run. Optional agent_id/dataset_id filters. "
+            "Backend auth required."
+        )
+    )
+    async def analytics_list_experiment_groups(
+        project_id: str,
+        agent_id: str | None = None,
+        dataset_id: str | None = None,
+    ) -> dict[str, Any]:
+        return await analytics_list_experiment_groups_tool(
+            project_id,
+            agent_id,
+            dataset_id,
+        )
+
+    @server.tool(
+        description=(
+            "Fetch one experiment group's summary (counts, status rollup, and "
+            "source experiments) by group_id. The group is a source-preserving "
+            "cohort keyed by (agent_id + dataset_id); join on source ids, "
+            "never on config hash. Backend auth required."
+        )
+    )
+    async def analytics_get_experiment_group(
+        project_id: str,
+        group_id: str,
+    ) -> dict[str, Any]:
+        return await analytics_get_experiment_group_tool(project_id, group_id)
+
+    @server.tool(
+        description=(
+            "Fetch the group's aggregated multi-run results table: one row per "
+            "configuration-run across the cohort's runs, each carrying "
+            "configuration, measures, status, trial_number, and the source "
+            "ids (experiment_run_id, configuration_run_id, experiment_id). "
+            "Rows remain individual source runs — grouped, not merged or "
+            "deduped by config hash. Backend auth required."
+        )
+    )
+    async def analytics_list_experiment_group_configuration_runs(
+        project_id: str,
+        group_id: str,
+    ) -> dict[str, Any]:
+        return await analytics_list_experiment_group_configuration_runs_tool(
+            project_id,
+            group_id,
+        )
+
     return server
 
 

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/analytics_mcp/tools.py

@@ -52,6 +52,9 @@ ANALYTICS_TOOL_NAMES: tuple[str, ...] = (
     "analytics_get_parameter_insights",
     "analytics_get_example_insights",
     "analytics_render_chart",
+    "analytics_list_experiment_groups",
+    "analytics_get_experiment_group",
+    "analytics_list_experiment_group_configuration_runs",
 )
 
 _SUPPORTED_CHART_KINDS: tuple[str, ...] = ("run_pareto", "run_correlations")
@@ -259,7 +262,14 @@ async def _call_backend(coro_factory: Any, *, what: str) -> dict[str, Any]:
             backend_url=backend_url,
         )
 
-    return {"ok": True, what.replace(" ", "_"): data}
+    return {"ok": True, what.replace(" ", "_"): _to_plain_payload(data)}
+
+
+def _to_plain_payload(data: Any) -> Any:
+    to_dict = getattr(data, "to_dict", None)
+    if callable(to_dict):
+        return to_dict()
+    return data
 
 
 async def health_check_tool() -> dict[str, Any]:
@@ -594,3 +604,84 @@ def analytics_render_chart_tool(
         return _failure("Chart rendering failed.", code="render_failed")
 
     return {"ok": True, "kind": kind, "chart_path": path}
+
+
+async def analytics_list_experiment_groups_tool(
+    project_id: str,
+    agent_id: str | None = None,
+    dataset_id: str | None = None,
+) -> dict[str, Any]:
+    """List experiment groups/cohorts for a project.
+
+    A cohort is a **source-preserving grouped view** keyed by
+    ``(agent_id + dataset_id)``. Rows remain individual source runs (join on
+    ``experiment_run_id`` / ``configuration_run_id`` / ``experiment_id``, never
+    on config hash). Grouping is NOT a merged analytics run.
+    """
+    try:
+        pid = _require_identifier(project_id, field="project_id")
+    except _ToolInputError as exc:
+        return _failure(str(exc))
+
+    aid = str(agent_id).strip() if agent_id is not None else None
+    did = str(dataset_id).strip() if dataset_id is not None else None
+    if aid == "":
+        aid = None
+    if did == "":
+        did = None
+
+    return await _call_backend(
+        lambda reader: reader.list_experiment_groups(
+            pid,
+            agent_id=aid,
+            dataset_id=did,
+        ),
+        what="experiment groups",
+    )
+
+
+async def analytics_get_experiment_group_tool(
+    project_id: str,
+    group_id: str,
+) -> dict[str, Any]:
+    """Fetch one experiment group/cohort detail.
+
+    A cohort is a **source-preserving grouped view** keyed by
+    ``(agent_id + dataset_id)``. Rows remain individual source runs (join on
+    ``experiment_run_id`` / ``configuration_run_id`` / ``experiment_id``, never
+    on config hash). Grouping is NOT a merged analytics run.
+    """
+    try:
+        pid = _require_identifier(project_id, field="project_id")
+        gid = _require_identifier(group_id, field="group_id")
+    except _ToolInputError as exc:
+        return _failure(str(exc))
+    return await _call_backend(
+        lambda reader: reader.get_experiment_group(gid, pid),
+        what="experiment group",
+    )
+
+
+async def analytics_list_experiment_group_configuration_runs_tool(
+    project_id: str,
+    group_id: str,
+) -> dict[str, Any]:
+    """List configuration runs for one experiment group/cohort.
+
+    A cohort is a **source-preserving grouped view** keyed by
+    ``(agent_id + dataset_id)``. Rows remain individual source runs (join on
+    ``experiment_run_id`` / ``configuration_run_id`` / ``experiment_id``, never
+    on config hash). Grouping is NOT a merged analytics run.
+
+    This returns the "one aggregated multi-run table": one row per
+    configuration-run with ``configuration`` + ``measures`` + source ids.
+    """
+    try:
+        pid = _require_identifier(project_id, field="project_id")
+        gid = _require_identifier(group_id, field="group_id")
+    except _ToolInputError as exc:
+        return _failure(str(exc))
+    return await _call_backend(
+        lambda reader: reader.list_experiment_group_configuration_runs(gid, pid),
+        what="experiment group configuration runs",
+    )

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/api/config_builder.py

@@ -163,14 +163,6 @@ class ConfigurationBuilder:
         """Clear global configuration."""
         self.global_config.clear()
 
-    @staticmethod
-    def _normalize_execution_mode(execution_mode: str) -> str:
-        """Normalize execution mode labels (deprecated)."""
-        return resolve_execution_policy(
-            execution_mode=execution_mode,
-            source_hint="config_builder.normalize_execution_mode",
-        ).legacy_execution_mode.value
-
 
 # Module-level functions for backward compatibility
 def build_optimize_configuration(

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/api/parameter_validator.py

@@ -17,7 +17,6 @@ from traigent.config.types import (
     ResolvedExecutionPolicy,
     resolve_execution_policy,
     validate_algorithm_name,
-    validate_execution_mode,
 )
 from traigent.evaluators.base import Dataset, EvaluationExample
 from traigent.utils.exceptions import ValidationError
@@ -98,25 +97,10 @@ class ParameterValidator:
 
         return params
 
-    @staticmethod
-    def _is_privacy_alias(execution_mode: str | ExecutionMode) -> bool:
-        if isinstance(execution_mode, str):
-            return execution_mode.strip().lower() == "privacy"
-        return False
-
-    def _validate_execution_mode(
-        self, execution_mode: str | ExecutionMode
-    ) -> ExecutionMode:
-        """Validate deprecated execution mode parameter."""
-        from traigent.utils.exceptions import ConfigurationError
-
-        try:
-            return validate_execution_mode(execution_mode)
-        except (TypeError, ValueError, ConfigurationError) as exc:
-            raise ValidationError(
-                f"Invalid execution_mode '{execution_mode}'. {exc}. "
-                "Use algorithm='auto'|'grid'|'random' and offline=True for no egress."
-            ) from exc
+    # NOTE: execution_mode validation is NOT duplicated here (#1393). The
+    # single validation path is _resolve_execution_policy ->
+    # traigent.config.types.resolve_execution_policy, which raises on removed
+    # (edge_analytics) and fail-closed (privacy/cloud) legacy selectors.
 
     def _validate_algorithm(self, algorithm: str) -> str:
         """Validate the algorithm selector."""

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/api/types.py

@@ -1349,6 +1349,33 @@ class OptimizationResult:
             for obj in self.objectives
         )
 
+    def _weighted_score_for_trial(
+        self,
+        trial: TrialResult,
+        normalized: dict[str, float],
+        normalized_weights: dict[str, float],
+        ranges: dict[str, tuple[float, float]],
+        objective_schema: Any | None,
+    ) -> float:
+        """Weighted score for one trial, single-sourced with live selection.
+
+        With a real ObjectiveSchema this delegates to
+        ``ObjectiveSchema.compute_weighted_score(metrics, ranges=...)`` — the
+        same scoring function live selection uses (issue #1682) — so post-hoc
+        analysis and live selection share one implementation. Without a
+        schema, the documented legacy cross-SDK path (auto-detected minimize
+        list + observed-range normalization) is retained.
+        """
+        # Import here to avoid circular dependency during module load
+        from traigent.core.objectives import ObjectiveSchema as _ObjectiveSchema
+
+        if isinstance(objective_schema, _ObjectiveSchema):
+            weighted = objective_schema.compute_weighted_score(
+                trial.metrics or {}, ranges=ranges
+            )
+            return float(weighted) if weighted is not None else 0.0
+        return self._score_trial(normalized, normalized_weights) if normalized else 0.0
+
     def _compute_weighted_scores(
         self,
         ranges: dict[str, tuple[float, float]],
@@ -1367,8 +1394,8 @@ class OptimizationResult:
             normalized = self._normalize_trial_metrics(
                 trial, ranges, minimize_objectives, objective_schema
             )
-            weighted_score = (
-                self._score_trial(normalized, objective_weights) if normalized else 0.0
+            weighted_score = self._weighted_score_for_trial(
+                trial, normalized, objective_weights, ranges, objective_schema
             )
             weighted_scores.append((trial, weighted_score))
 
@@ -1437,8 +1464,8 @@ class OptimizationResult:
             normalized = self._normalize_trial_metrics(
                 trial, ranges, resolved_minimize, resolved_schema
             )
-            weighted = (
-                self._score_trial(normalized, normalized_weights) if normalized else 0.0
+            weighted = self._weighted_score_for_trial(
+                trial, normalized, normalized_weights, ranges, resolved_schema
             )
             per_trial.append(
                 {

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/cli/next_steps_command.py

@@ -33,8 +33,12 @@ console = Console(width=120)
 @click.option(
     "--backend-url",
     default=DEFAULT_LOCAL_URL,
+    envvar=["TRAIGENT_BACKEND_URL", "TRAIGENT_API_URL"],
     show_default=True,
-    help=("Backend API base URL. Requires a backend with the next-steps endpoint."),
+    help=(
+        "Backend API base URL. Requires a backend with the next-steps endpoint. "
+        "(env: TRAIGENT_BACKEND_URL / TRAIGENT_API_URL)"
+    ),
 )
 def next_steps(
     experiment_run_id: str,

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/cloud/api_operations.py

@@ -101,10 +101,19 @@ _LEGACY_SESSION_CONTRACT_DEPRECATION = (
 
 
 class TraigentSessionApiResult(tuple):
-    """Three-ID session creation result with optional owning context attrs."""
+    """Three-ID session creation result with optional owning context attrs.
+
+    ``warm_start_transfer`` carries the backend's opaque, IP-safe warm-start
+    decision block (transfer_mode / refused_reason / search_space_overlap /
+    n_seed_configs_applied / ...) when the session-CREATE response includes
+    one. The backend communicates the warm-start decision at CREATE time and
+    does not resend it at finalize, so dropping it here made the SDK report
+    cold-start defaults for valid warm starts (issue #1683, Bug B).
+    """
 
     project_id: str | None
     tenant_id: str | None
+    warm_start_transfer: dict[str, Any] | None
 
     def __new__(
         cls,
@@ -114,10 +123,12 @@ class TraigentSessionApiResult(tuple):
         *,
         project_id: str | None = None,
         tenant_id: str | None = None,
+        warm_start_transfer: dict[str, Any] | None = None,
     ):
         obj = super().__new__(cls, (session_id, experiment_id, experiment_run_id))
         obj.project_id = project_id
         obj.tenant_id = tenant_id
+        obj.warm_start_transfer = warm_start_transfer
         return obj
 
 
@@ -473,17 +484,19 @@ class ApiOperations:
 
     async def create_traigent_session_via_api(
         self, session_request: SessionCreationRequest
-    ) -> tuple[str, str, str]:
+    ) -> TraigentSessionApiResult:
         """Create a Traigent optimization session using the new session endpoints.
 
         Returns:
-            Tuple of (session_id, experiment_id, experiment_run_id)
+            TraigentSessionApiResult — unpacks as a tuple of
+            (session_id, experiment_id, experiment_run_id) and carries
+            owning-context / warm_start_transfer attributes (issue #1683).
         """
         # Skip cloud session creation if backend is offline
         # Note: is_backend_offline() returns True if TRAIGENT_OFFLINE_MODE=true
         if is_backend_offline():
             logger.debug("Backend offline: using local session IDs")
-            return (
+            return TraigentSessionApiResult(
                 f"mock_session_{int(time.time())}",
                 f"mock_exp_{int(time.time())}",
                 f"mock_run_{int(time.time())}",
@@ -771,7 +784,7 @@ class ApiOperations:
         payload: dict[str, Any],
         headers: dict[str, str],
         connector: Any | None,
-    ) -> tuple[str, str, str]:
+    ) -> TraigentSessionApiResult:
         """Send the session creation request and handle responses."""
 
         self._raise_if_backend_egress_disabled("create session")
@@ -813,6 +826,14 @@ class ApiOperations:
         tenant_id = self._optional_context_id(
             result.get("tenant_id") or metadata.get("tenant_id")
         )
+        # The backend communicates the warm-start decision in the CREATE
+        # response (top-level or under metadata) and does not resend it at
+        # finalize. Retain the block verbatim (issue #1683, Bug B).
+        warm_start_transfer = result.get("warm_start_transfer")
+        if not isinstance(warm_start_transfer, dict):
+            warm_start_transfer = metadata.get("warm_start_transfer")
+        if not isinstance(warm_start_transfer, dict):
+            warm_start_transfer = None
 
         logger.info(
             f"✅ Created Traigent session: {session_id} "
@@ -824,6 +845,7 @@ class ApiOperations:
             experiment_run_id,
             project_id=project_id,
             tenant_id=tenant_id,
+            warm_start_transfer=warm_start_transfer,
         )
 
     @staticmethod

{traigent-0.19.1.dev0 → traigent-0.19.2}/traigent/cloud/backend_client.py

@@ -24,7 +24,7 @@ from urllib.parse import quote, unquote, urlparse, urlunparse
 
 # Import and re-export BackendClientConfig for backward compatibility
 from traigent.cloud._aiohttp_compat import AIOHTTP_AVAILABLE, aiohttp
-from traigent.cloud.api_operations import ApiOperations
+from traigent.cloud.api_operations import ApiOperations, TraigentSessionApiResult
 from traigent.cloud.auth import AuthenticationError, _build_api_key_auth_headers
 from traigent.cloud.backend_bridges import SDKBackendBridge, SessionExperimentMapping
 from traigent.cloud.backend_bridges import bridge as _bridge
@@ -2172,23 +2172,19 @@ class BackendIntegratedClient:
         return cast(str, self._api_ops.map_to_backend_status(status, endpoint=endpoint))
 
     def _normalize_execution_mode(self, execution_mode: str | None) -> str:
-        """Translate SDK execution modes to backend-supported values."""
-        if not execution_mode:
-            return "standard"
-
-        normalized = execution_mode.strip().lower()
-        mode_aliases = {
-            "edge_analytics": "local",
-            "edge": "local",
-            "local": "local",
-            "privacy": "privacy",
-            "private": "privacy",
-            "hybrid": "local",
-            "standard": "standard",
-            "cloud": "cloud",
-            "saas": "cloud",
-        }
-        return mode_aliases.get(normalized, "standard")
+        """Translate SDK execution modes to backend wire values.
+
+        Delegates to the canonical resolution in ``traigent.config.types``
+        (issue #1393 dedup): removed and fail-closed legacy selectors
+        (``edge_analytics``, ``privacy``, ``cloud``) raise instead of being
+        silently remapped, and unknown selectors raise instead of silently
+        defaulting.
+        """
+        # Local import: avoid a module-level cloud -> config-resolution
+        # dependency for a single compatibility shim.
+        from traigent.config.types import validate_execution_mode
+
+        return validate_execution_mode(execution_mode).value
 
     def _sanitize_error_message(self, error_message: str | None) -> str | None:
         """Sanitize error message for transmission.
@@ -2197,11 +2193,16 @@ class BackendIntegratedClient:
 
     async def _create_traigent_session_via_api(
         self, session_request: SessionCreationRequest
-    ) -> tuple[str, str, str]:
+    ) -> TraigentSessionApiResult:
         """Create a Traigent optimization session using the new session endpoints.
+
+        Returns the typed session-CREATE result (a 3-tuple of session /
+        experiment / run ids, plus owning-context and warm_start_transfer
+        attributes — issue #1683 Bug B: the warm-start decision arrives at
+        CREATE time and must not be narrowed away here).
         Delegates to api_operations module."""
         return cast(
-            tuple[str, str, str],
+            TraigentSessionApiResult,
             await self._api_ops.create_traigent_session_via_api(session_request),
         )