JVNAUTOSCI-2600: harden adaptive provider and effect seams

src/backend/integrations/internal_mcp/catalogue.py

@@ -1093,6 +1093,49 @@ def _create_concepts(**kwargs):
                 "Provide an array of concept objects, e.g., concepts=[{name: 'MyType'}]"
             ],
         )
+    requested_non_predicate_kinds = {
+        (
+            str(concept_data.get("kind") or "type").strip().lower()
+            if isinstance(concept_data, dict)
+            else "invalid"
+        )
+        for concept_data in concepts
+        if not (
+            isinstance(concept_data, dict)
+            and str(concept_data.get("kind") or "type").strip().lower()
+            == "predicate"
+        )
+    }
+    if (
+        parent_resolution.resolved_parent_kind in {"individual", "instance"}
+        and requested_non_predicate_kinds
+    ):
+        return make_error_response(
+            "parent_is_not_a_type",
+            (
+                f"Parent concept '{validated_parent_id}' is an individual, not "
+                "a semantic type. No concepts were created."
+            ),
+            details={
+                "original_parent_id": parent_id,
+                "resolved_parent_id": validated_parent_id,
+                "resolved_parent_kind": parent_resolution.resolved_parent_kind,
+                "requested_child_kinds": sorted(requested_non_predicate_kinds),
+            },
+            suggestions=[
+                "Choose an existing semantic type for parent_id",
+                (
+                    "Use scope_mode or organisation_concept_id for ownership and "
+                    "visibility; do not use an organisation or owner individual "
+                    "as parent_id"
+                ),
+                (
+                    "If the intended type does not exist, create that type first "
+                    "under a semantically close type parent"
+                ),
+            ],
+            related_concept_ids=[validated_parent_id],
+        )
 
     results = []
     with defer_relationship_extent_index_sync():
@@ -7172,7 +7215,8 @@ def _concepts_create_input_schema() -> Schema:
         },
         allow_unknown=True,
         description=(
-            "create_concepts input: parent_id (str, parent concept_id), concepts (list of {name, kind?, description?, notes?}). "
+            "create_concepts input: parent_id (str, semantic type concept_id; not an owner, organisation, user, or container individual), "
+            "concepts (list of {name, kind?, description?, notes?}). "
             "kind: 'instance' for individuals, 'type' for subtypes (default), 'predicate' for relationships. "
             "By default, deterministic pre-create lookup blocks duplicate instances/types/predicates; "
             "set allow_duplicate_instances=true to opt into legacy instance suffixing. "
@@ -10082,6 +10126,65 @@ def _summarise_turn_execution_tool_invocations(
     return summary
 
 
+def _summarise_late_effect_observations(
+    raw_observations: Any,
+    *,
+    max_items: int = 32,
+) -> tuple[list[dict[str, Any]], int]:
+    """Return an actor-safe bounded receipt projection for late effects."""
+
+    if not isinstance(raw_observations, list):
+        return [], 0
+
+    summary: list[dict[str, Any]] = []
+    for raw_entry in raw_observations[-max_items:]:
+        if not isinstance(raw_entry, Mapping):
+            continue
+        entry = {
+            key: raw_entry.get(key)
+            for key in (
+                "schema_version",
+                "observation_id",
+                "effect_id",
+                "execution_id",
+                "call_id",
+                "capability_name",
+                "method_name",
+                "outcome",
+                "effect_status",
+                "changed",
+                "observed_at_utc",
+                "output_schema_validation",
+                "output_schema_valid",
+                "output_schema_error",
+                "payload_truncated",
+                "payload_redacted",
+                "storage_transformed",
+                "error_type",
+                "error",
+            )
+            if key in raw_entry
+        }
+        payload = raw_entry.get("payload")
+        if isinstance(payload, Mapping):
+            entry["receipt"] = {
+                key: payload.get(key)
+                for key in (
+                    "success",
+                    "status",
+                    "effect_status",
+                    "changed",
+                    "error",
+                    "error_code",
+                    "mutation_outcome",
+                    "partial_failures",
+                )
+                if key in payload
+            }
+        summary.append(entry)
+    return summary, len(raw_observations)
+
+
 def _extract_turn_execution_tool_invocation_summary(
     item: Mapping[str, Any],
 ) -> list[dict[str, Any]]:
@@ -21670,6 +21773,12 @@ def _rag_get_item(**kwargs):
                 source="turn_execution_get.turn_execution_record",
             )
         )
+        (
+            late_effect_observations,
+            late_effect_observation_count,
+        ) = _summarise_late_effect_observations(
+            doc.get("late_effect_observations")
+        )
 
         payload = {
             "collection": collection,
@@ -21712,6 +21821,11 @@ def _rag_get_item(**kwargs):
             "tool_invocation_summary": _summarise_turn_execution_tool_invocations(
                 tool_invocations
             ),
+            "late_effect_observation_count": late_effect_observation_count,
+            "late_effect_observations": late_effect_observations,
+            "late_effect_observations_truncated": (
+                late_effect_observation_count > len(late_effect_observations)
+            ),
             "required_effects": required_effects,
             "postcondition_checks": postcondition_checks,
             "critic": critic_payload,

src/backend/integrations/internal_mcp/gateway.py

@@ -343,6 +343,7 @@ def invoke(
         payload: Optional[MutableMapping[str, Any]] = None,
         *,
         deadline_monotonic: float | None = None,
+        require_configured_timeout: bool = False,
         late_completion_observer: LateCompletionObserver | None = None,
     ) -> TransportResult:
         if not self._enabled:
@@ -520,6 +521,7 @@ def _observe_validated_late_completion(
                         category=definition.category,
                         advisory_timeout_sec=advisory_timeout,
                         deadline_monotonic=deadline_monotonic,
+                        require_configured_timeout=require_configured_timeout,
                         log_tag=self._log_tag,
                         late_completion_observer=observed_late_completion,
                     )
@@ -643,6 +645,16 @@ def get_method_definition(self, method_name: str) -> MethodDefinition | None:
         except Exception:
             return None
 
+    def get_method_timeout_sec(self, method_name: str) -> float | None:
+        """Return the configured hard window for one registered method."""
+
+        definition = self.get_method_definition(method_name)
+        return (
+            definition.resolved_timeout(self._transport)
+            if definition is not None
+            else None
+        )
+
     def extend_catalogue(self, definitions: Iterable[MethodDefinition]) -> None:
         for definition in definitions:
             self._catalogue.register(definition)

src/backend/integrations/internal_mcp/transport.py

@@ -676,6 +676,7 @@ def execute(
         category: str = "read",
         advisory_timeout_sec: float | None = None,
         deadline_monotonic: float | None = None,
+        require_configured_timeout: bool = False,
         log_tag: str = "[mcp_gateway]",
         late_completion_observer: LateCompletionObserver | None = None,
     ) -> TransportResult:
@@ -729,6 +730,58 @@ def execute(
             else "discard_from_turn"
         )
 
+        if (
+            require_configured_timeout
+            and deadline_monotonic is not None
+            and hard_timeout_sec < configured_hard_timeout_sec
+        ):
+            is_write = str(category or "").strip().lower() == "write"
+            payload: Dict[str, Any] = {
+                "success": False,
+                "status": "not_started",
+                "error": (
+                    f"{method_name!r} was not started because the caller's "
+                    "remaining window is shorter than its configured hard "
+                    "execution window."
+                ),
+                "error_code": (
+                    "insufficient_effect_window"
+                    if is_write
+                    else "insufficient_execution_window"
+                ),
+                "error_type": "admission_denied",
+                "retryable": True,
+                "execution_id": execution_id,
+                "configured_execution_window_seconds": (
+                    configured_hard_timeout_sec
+                ),
+                "remaining_execution_window_seconds": hard_timeout_sec,
+                "timeout_phase": "pre_dispatch",
+                "outcome_finality": "terminal_for_turn",
+                "recovery_affordances": [
+                    {
+                        "action_type": (
+                            "return_bounded_failure_or_retry_in_new_turn"
+                        )
+                    }
+                ],
+            }
+            if is_write:
+                payload["mutation_outcome"] = "not_started"
+            return TransportResult(
+                payload=payload,
+                duration_ms=max(0.0, (time.perf_counter() - submitted_at) * 1000.0),
+                execution_id=execution_id,
+                outcome="not_started",
+                timeout_sec=hard_timeout_sec,
+                advisory_timeout_sec=advisory_sec,
+                queue_duration_ms=0.0,
+                handler_duration_ms=None,
+                handler_elapsed_ms=None,
+                transport_overhead_ms=0.0,
+                timeout_phase="pre_dispatch",
+            )
+
         if hard_timeout_sec <= 0.0:
             with self._diagnostics_lock:
                 self._timeout_count += 1

src/backend/languagemodels/llm_interface.py

@@ -1785,17 +1785,15 @@ def _split_request_timeout_from_llm_params(
     def _get_structured_client_config(self, model: Optional[str]) -> LLMClientConfig:
         """Get configuration for structured tool calling client (JVNAUTOSCI-799)."""
         resolved_model = resolve_openai_model_name(model)
-        safe_temperature = resolve_safe_temperature_for_model(
-            resolved_model or self.DEFAULT_MODEL,
-            0.7,
-        )
         return LLMClientConfig(
             model=resolved_model or self.DEFAULT_MODEL,
             provider="openai",
             api_key=self.api_key,
             connection_id="#V#openai_provider",
             deployment_id=resolved_model or self.DEFAULT_MODEL,
-            temperature=safe_temperature,
+            # The effective API surface is selected by the structured adapter.
+            # Defer optional-parameter policy until that surface is known.
+            temperature=0.7,
         )
 
     def validate_model_response(self, response, model: str) -> str:

src/backend/languagemodels/structured_tool_calling/client.py

@@ -64,6 +64,7 @@ def resolve_safe_temperature_for_model(
     temperature: Optional[float],
     *,
     api_surface: str = "chat_completions",
+    profile_concept_id: str | None = None,
 ) -> Optional[float]:
     """Return a temperature that is safe to send for the given model.
 
@@ -80,6 +81,7 @@ def resolve_safe_temperature_for_model(
         parameter="temperature",
         value=temperature,
         api_surface=api_surface,
+        profile_concept_id=profile_concept_id,
     )
     return sanitised if isinstance(sanitised, (int, float)) else None