Add SLO tracking and mitigation planning in SelfAdjustingController

- Introduced latency and quality SLO tracking in the SelfAdjustingController to monitor performance metrics.
- Implemented a mitigation plan that captures SLO breaches and recommends actions based on drift advisories.
- Enhanced LiveTaskLoop to utilize the controller's mitigation plans and persist relevant summaries.
- Updated memory manager with retrieval helpers and revision logging improvements for better state management.
- Added tests to verify SLO breach recording and controller plan functionality.

Author: Wojciech Napierała

core/controller.py

@@ -7,6 +7,7 @@
     v0.3 - 2025-11-06 - Added adaptive workflow bias adjustments derived from drift
         feedback.
     v0.4 - 2025-11-07 - Logged workflow bias snapshots when drift triggers.
+    v0.5 - 2025-11-07 - Added SLO tracking and mitigation planning for drift responses.
 """
 
 from __future__ import annotations
@@ -15,7 +16,7 @@
 from collections import deque
 from dataclasses import dataclass
 from statistics import mean
-from typing import Deque, Dict, Optional
+from typing import Deque, Dict, List, Optional
 
 from config.settings import AppConfig
 from models.memory import ReviewRecord
@@ -36,14 +37,23 @@ class PerformanceSnapshot:
 class SelfAdjustingController:
     """Monitors execution metrics and recommends adjustments."""
 
-    def __init__(self, config: AppConfig, window_size: int = 10) -> None:
+    def __init__(
+        self,
+        config: AppConfig,
+        window_size: int = 10,
+        latency_slo_seconds: float = 5.0,
+        quality_slo: float = 0.85,
+    ) -> None:
         self._config = config
         self._logger = LOGGER
         self._window_size = window_size
         self._history: Deque[PerformanceSnapshot] = deque(maxlen=window_size)
         self._last_advisory: Optional[str] = None
         self._workflow_biases: Dict[str, float] = {}
         self._decay = 0.9
+        self._latency_slo = max(0.1, latency_slo_seconds)
+        self._quality_slo = quality_slo
+        self._last_plan: Dict[str, object] = {}
 
     def register_result(
         self,
@@ -65,8 +75,16 @@ def register_result(
             snapshot.latency,
             snapshot.verdict,
         )
+        slo_breaches = self._evaluate_slos(result, review)
         advisory = self._assess_drift()
         self._update_biases(selection, result, review, advisory is not None)
+        self._last_plan = self._build_mitigation_plan(
+            selection,
+            result,
+            review,
+            advisory,
+            slo_breaches,
+        )
         self._last_advisory = advisory
         return advisory
 
@@ -91,6 +109,22 @@ def _assess_drift(self) -> Optional[str]:
             self._logger.warning(advisory)
             return advisory
         return None
+    def _evaluate_slos(
+        self,
+        result: TaskResult,
+        review: Optional[ReviewRecord],
+    ) -> List[str]:
+        """Return a list of breached service objectives for the current run."""
+        breaches: List[str] = []
+        if result.latency_seconds > self._latency_slo:
+            breaches.append("latency")
+        if (
+            review
+            and review.quality_score is not None
+            and review.quality_score < self._quality_slo
+        ):
+            breaches.append("quality")
+        return breaches
 
     def _update_biases(
         self,
@@ -142,6 +176,58 @@ def _update_biases(
             target = reasoning_workflow if workflow == fast_workflow else fast_workflow
             if target:
                 self._bump_bias(target, 0.1)
+    def _build_mitigation_plan(
+        self,
+        selection: WorkflowSelection,
+        result: TaskResult,
+        review: Optional[ReviewRecord],
+        advisory: Optional[str],
+        slo_breaches: List[str],
+    ) -> Dict[str, object]:
+        plan: Dict[str, object] = {}
+        if advisory:
+            plan["drift_advisory"] = advisory
+        if slo_breaches:
+            plan["slo_breaches"] = slo_breaches
+
+        recommended: List[str] = []
+        if "latency" in slo_breaches:
+            recommended.extend(
+                [
+                    "reroute_to_reasoning_workflow",
+                    "increase_llm_timeout",
+                ]
+            )
+        if "quality" in slo_breaches:
+            recommended.append("expand_context_retrieval")
+        if advisory:
+            recommended.append("trigger_memory_mitigation")
+        if result.latency_seconds > self._latency_slo * 1.5:
+            recommended.append("reduce_fast_workflow_bias")
+        if (
+            review
+            and review.verdict.lower().startswith(("fail", "reject"))
+            and selection.workflow != self._find_workflow("reasoning")
+        ):
+            recommended.append("escalate_to_reasoning")
+
+        if recommended:
+            deduped = list(dict.fromkeys(recommended))
+            plan["recommended_actions"] = deduped
+
+        if self._history and (plan or slo_breaches or advisory or recommended):
+            latencies = [sample.latency for sample in self._history]
+            negatives = sum(
+                sample.verdict.lower().startswith(("fail", "reject"))
+                for sample in self._history
+            )
+            plan["window_metrics"] = {
+                "latency_avg": round(mean(latencies), 3),
+                "window_size": len(self._history),
+                "negative_reviews": negatives,
+            }
+
+        return plan
 
     def _bump_bias(self, workflow: str, delta: float) -> None:
         current = self._workflow_biases.get(workflow, 0.0)
@@ -167,3 +253,8 @@ def last_advisory(self) -> Optional[str]:
     def workflow_biases(self) -> Dict[str, float]:
         """Current controller preference weights per workflow."""
         return dict(self._workflow_biases)
+
+    @property
+    def last_plan(self) -> Dict[str, object]:
+        """Return the last mitigation plan issued by the controller."""
+        return dict(self._last_plan)

core/live_loop.py

@@ -6,6 +6,7 @@
     v0.3 - 2025-11-06 - Persisted semantic summaries and integrated controller-aware
         task selection.
     v0.4 - 2025-11-07 - Linked semantic concepts and surfaced relation context for prompts.
+    v0.5 - 2025-11-07 - Added retrieval-focused context loading and controller mitigation plans.
 """
 
 from __future__ import annotations
@@ -92,7 +93,7 @@ def run_task(
             payload=working_payload,
         )
 
-        layers = self._load_memory_snapshots()
+        layers = self._load_memory_snapshots(task)
         prompt_context = PromptContext(
             task=task,
             workflow=selection.workflow,
@@ -143,13 +144,28 @@ def run_task(
             raise
         self._persist_review(review)
 
-        mitigation_summary: Optional[Dict[str, object]] = None
         drift_advisory = self._controller.register_result(selection, result, review)
+        controller_plan = dict(self._controller.last_plan)
+
+        memory_actions: Optional[Dict[str, object]] = None
         if drift_advisory:
-            mitigation_summary = self._memory_manager.apply_drift_mitigation(task_id=request.task_id)
-            if mitigation_summary:
-                self._persist_mitigation_summary(request.task_id, mitigation_summary)
+            memory_actions = self._memory_manager.apply_drift_mitigation(task_id=request.task_id)
             self._persist_drift_advisory(request.task_id, selection.workflow, drift_advisory)
+        elif controller_plan:
+            self._logger.debug(
+                "Controller produced plan without drift advisory: %s", controller_plan
+            )
+
+        mitigation_summary: Optional[Dict[str, object]] = None
+        if controller_plan:
+            mitigation_summary = dict(controller_plan)
+        if memory_actions:
+            if mitigation_summary is None:
+                mitigation_summary = {}
+            mitigation_summary["memory_actions"] = memory_actions
+
+        if mitigation_summary:
+            self._persist_mitigation_summary(request.task_id, mitigation_summary)
 
         result_payload = cast(
             Dict[str, object],
@@ -322,9 +338,9 @@ def _store_working_item(self, key: str, payload: Dict[str, object]) -> None:
         except MemoryError as exc:
             self._logger.error("Failed to persist working memory item %s: %s", key, exc)
 
-    def _load_memory_snapshots(self, limit: int = 5) -> _LayerSnapshot:
-        episodic = self._safe_layer_slice("episodic", limit)
-        semantic = self._safe_layer_slice("semantic", limit)
+    def _load_memory_snapshots(self, task_query: str, limit: int = 5) -> _LayerSnapshot:
+        episodic = self._safe_layer_query("episodic", task_query, limit)
+        semantic = self._safe_layer_query("semantic", task_query, limit)
         reviews = self._load_recent_reviews(limit)
         relations = self._build_semantic_relations(semantic, limit)
         return _LayerSnapshot(
@@ -361,6 +377,19 @@ def _build_semantic_relations(
                 relations[node_id] = summary
         return relations
 
+    def _safe_layer_query(
+        self, layer: str, query: str, limit: int
+    ) -> List[Dict[str, object]]:
+        if query.strip():
+            try:
+                results = self._memory_manager.query_layer(layer, query, limit)
+            except MemoryError as exc:
+                self._logger.warning("Unable to query %s memory: %s", layer, exc)
+                results = []
+            if results:
+                return results
+        return self._safe_layer_slice(layer, limit)
+
     def _safe_layer_slice(self, layer: str, limit: int) -> List[Dict[str, object]]:
         try:
             items = self._memory_manager.list_layer(layer)