feat: complete validation expansion with guardrail wiring, desktop failure-injection tests, isolation coverage, and opt-in online API lane

Author: rookiestar28

.secrets.baseline

@@ -133,14 +133,14 @@
         "filename": "README.md",
         "hashed_secret": "9d4e1e23bd5b727046a9e3b4b7db57bd8d6ee684",
         "is_verified": false,
-        "line_number": 607
+        "line_number": 654
       },
       {
         "type": "Secret Keyword",
         "filename": "README.md",
         "hashed_secret": "11fa7c37d697f30e6aee828b4426a10f83ab2380",
         "is_verified": false,
-        "line_number": 808
+        "line_number": 855
       }
     ],
     "__init__.py": [
@@ -149,7 +149,7 @@
         "filename": "__init__.py",
         "hashed_secret": "fdee7bc7f680ce9707185015de5ff37b5098748b",
         "is_verified": false,
-        "line_number": 2171
+        "line_number": 2172
       }
     ],
     "docs\\PLUGIN_MIGRATION.md": [
@@ -750,5 +750,5 @@
       }
     ]
   },
-  "generated_at": "2026-02-16T17:49:36Z"
+  "generated_at": "2026-02-16T19:37:41Z"
 }

README.md

@@ -10,6 +10,16 @@ A continuous, real-time runtime diagnostics suite for ComfyUI featuring **LLM-po
 
 ## Latest Updates (Feb 2026) - Click to expand
 
+<details>
+<summary><strong>Validation Expansion Remediation: Desktop Hardening + Isolation Test Pack</strong></summary>
+
+- Added targeted desktop failure-injection regression tests for corrupt state recovery, flush-failure non-crash paths, and history migration continuity.
+- Added non-ComfyUI isolation coverage for metadata contract validation and PromptComposer/harness payload compatibility.
+- Added an opt-in online API test lane scaffold (`RUN_ONLINE_API_TESTS=true`) to separate secret-scoped provider checks from default local runs.
+- Validation gate status: detect-secrets + pre-commit + backend full pytest + frontend E2E passed; online provider smoke tests remain opt-in/secret-scoped and skip safely when credentials are absent.
+
+</details>
+
 <details>
 <summary><strong>Validation Expansion Foundation: Runtime Guardrail Config (partial rollout)</strong></summary>
 
@@ -1103,6 +1113,18 @@ python scripts/phase2_gate.py
 python scripts/phase2_gate.py --fast
 ```
 
+### Validation Expansion Pack (Targeted)
+
+```powershell
+# Targeted remediation pack (R17/T13/T9 + scaffolded T5 lane)
+.\.venv\Scripts\python.exe -m pytest tests/test_r17_guardrails.py tests/test_t13_desktop_failures.py tests/test_t13_flush_storm.py tests/test_t13_migration.py tests/test_t9_pipeline_contract.py tests/test_t9_harness.py tests/integration/test_pipeline_isolation.py tests/integration/test_online_api_opt_in.py
+
+# Opt-in online lane (secret-scoped)
+$env:RUN_ONLINE_API_TESTS='true'
+.\.venv\Scripts\python.exe -m pytest tests/integration/test_online_api_opt_in.py -q
+Remove-Item Env:RUN_ONLINE_API_TESTS
+```
+
 **CI Status**: The gate runs automatically on push/PR to `main` and `dev` branches.
 
 ---

__init__.py

@@ -74,6 +74,7 @@
     core_rate_limit=getattr(CONFIG, "llm_core_rate_limit", None),
     light_rate_limit=getattr(CONFIG, "llm_light_rate_limit", None),
     max_concurrent=getattr(CONFIG, "llm_max_concurrent", None),
+    rate_window_seconds=getattr(getattr(CONFIG, "guardrails", None), "RATE_LIMIT_WINDOW_SECONDS", None),
 )
 
 

history_store.py

@@ -92,7 +92,13 @@ class HistoryStore:
         history = store.get_all()
     """
 
-    def __init__(self, filepath: str, maxlen: int = 50, max_bytes: int = 0):
+    def __init__(
+        self,
+        filepath: str,
+        maxlen: int = 50,
+        max_bytes: int = 0,
+        aggregate_window_seconds: int = 60,
+    ):
         """
         Initialize the history store.
         
@@ -109,7 +115,11 @@ def __init__(self, filepath: str, maxlen: int = 50, max_bytes: int = 0):
         self._history: List[HistoryEntry] = []
         self._loaded = False
         # Aggregation window: within this window, repeated identical errors are aggregated.
-        self._aggregate_window_seconds = 60
+        try:
+            window = int(aggregate_window_seconds)
+        except Exception:
+            window = 60
+        self._aggregate_window_seconds = window if window > 0 else 60
 
     @property
     def filepath(self) -> str:

logger.py

@@ -128,10 +128,18 @@ def _get_history_store() -> HistoryStore:
     global _history_store
     if _history_store is None:
         _migrate_legacy_data()
+        aggregate_window_seconds = 60
+        try:
+            aggregate_window_seconds = int(
+                getattr(CONFIG.guardrails, "AGGREGATION_WINDOW_SECONDS", 60)
+            )
+        except Exception:
+            aggregate_window_seconds = 60
         _history_store = HistoryStore(
             _history_file,
             maxlen=CONFIG.history_size,
-            max_bytes=getattr(CONFIG, 'history_size_bytes', 5*1024*1024)
+            max_bytes=getattr(CONFIG, 'history_size_bytes', 5*1024*1024),
+            aggregate_window_seconds=aggregate_window_seconds,
         )
     return _history_store
 
@@ -465,7 +473,14 @@ def __init__(self, message_queue):
         self.buffer = []
         self.in_traceback = False
         self.last_buffer_time = 0
-        self._aggregate_window_seconds = 60
+        try:
+            self._aggregate_window_seconds = int(
+                getattr(CONFIG.guardrails, "AGGREGATION_WINDOW_SECONDS", 60)
+            )
+        except Exception:
+            self._aggregate_window_seconds = 60
+        if self._aggregate_window_seconds <= 0:
+            self._aggregate_window_seconds = 60
 
     def _parse_ts(self, ts: str) -> datetime.datetime:
         try:

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-doctor"
 description = "A real-time debugging assistant for ComfyUI, featuring interactive debugging chat, and 50+ fix patterns. Automatically intercepts terminal output from startup, and delivers prioritized fix suggestions with node-level context extraction. Now supports JSON-based pattern management with hot-reload and full i18n support for 9 languages."
-version = "1.6.4"
+version = "1.6.5"
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.10"

rate_limiter.py

@@ -21,15 +21,17 @@ class RateLimiter:
     Uses time.monotonic() to avoid issues with system clock changes.
     """
 
-    def __init__(self, max_per_minute: int = 60):
+    def __init__(self, max_per_minute: int = 60, window_seconds: int = 60):
         """
         Initialize rate limiter.
         
         Args:
             max_per_minute: Maximum requests allowed per minute.
+            window_seconds: Refill window size in seconds.
         """
         self.max_tokens = max_per_minute
         self.tokens = float(max_per_minute)
+        self.window_seconds = window_seconds if window_seconds > 0 else 60
         self.last_refill = time.monotonic()
         self._lock = threading.Lock()
 
@@ -51,8 +53,8 @@ def _refill(self) -> None:
         """Refill tokens based on elapsed time."""
         now = time.monotonic()
         elapsed = now - self.last_refill
-        # Refill at rate of max_tokens per 60 seconds
-        refill_amount = elapsed * (self.max_tokens / 60.0)
+        # Refill at rate of max_tokens per configured window.
+        refill_amount = elapsed * (self.max_tokens / float(self.window_seconds))
         self.tokens = min(self.max_tokens, self.tokens + refill_amount)
         self.last_refill = now
 

services/config_guardrails.py

@@ -1,6 +1,16 @@
 from dataclasses import dataclass
 import os
-from typing import Optional
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    try:
+        value = int(raw)
+    except (TypeError, ValueError):
+        return default
+    return value if value > 0 else default
 
 @dataclass
 class GuardrailConfig:
@@ -24,11 +34,11 @@ class GuardrailConfig:
     def load(cls) -> "GuardrailConfig":
         """Load configuration from environment variables with defaults."""
         return cls(
-            MAX_HISTORY_ENTRIES=int(os.getenv("DOCTOR_GUARDRAIL_MAX_HISTORY", "1000")),
-            MAX_LOG_SIZE_MB=int(os.getenv("DOCTOR_GUARDRAIL_MAX_LOG_SIZE_MB", "10")),
-            MAX_JOB_RETENTION_SECONDS=int(os.getenv("DOCTOR_GUARDRAIL_JOB_RETENTION", "86400")),
-            RATE_LIMIT_WINDOW_SECONDS=int(os.getenv("DOCTOR_GUARDRAIL_RATE_LIMIT_WINDOW", "60")),
-            AGGREGATION_WINDOW_SECONDS=int(os.getenv("DOCTOR_GUARDRAIL_AGGREGATION_WINDOW", "60")),
-            PROVIDER_TIMEOUT_SECONDS=int(os.getenv("DOCTOR_GUARDRAIL_PROVIDER_TIMEOUT", "30")),
-            PROVIDER_MAX_RETRIES=int(os.getenv("DOCTOR_GUARDRAIL_PROVIDER_RETRIES", "3"))
+            MAX_HISTORY_ENTRIES=_env_int("DOCTOR_GUARDRAIL_MAX_HISTORY", 1000),
+            MAX_LOG_SIZE_MB=_env_int("DOCTOR_GUARDRAIL_MAX_LOG_SIZE_MB", 10),
+            MAX_JOB_RETENTION_SECONDS=_env_int("DOCTOR_GUARDRAIL_JOB_RETENTION", 86400),
+            RATE_LIMIT_WINDOW_SECONDS=_env_int("DOCTOR_GUARDRAIL_RATE_LIMIT_WINDOW", 60),
+            AGGREGATION_WINDOW_SECONDS=_env_int("DOCTOR_GUARDRAIL_AGGREGATION_WINDOW", 60),
+            PROVIDER_TIMEOUT_SECONDS=_env_int("DOCTOR_GUARDRAIL_PROVIDER_TIMEOUT", 30),
+            PROVIDER_MAX_RETRIES=_env_int("DOCTOR_GUARDRAIL_PROVIDER_RETRIES", 3),
         )

services/node_health.py

@@ -0,0 +1,71 @@
+"""
+T5 Service: Node Health Scoring.
+
+Calculates heuristic health scores for nodes based on error history.
+Currently limited to "Failure Frequency" as we do not track successful executions yet.
+"""
+
+from typing import List, Dict, Any
+from collections import defaultdict
+
+class NodeHealthService:
+    """
+    Analyzes error history to determine node health.
+    """
+    
+    @staticmethod
+    def calculate_node_failures(history: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Calculate failure counts per node type.
+        
+        Args:
+            history: List of error history entries.
+            
+        Returns:
+            List of dicts: [{"node_class": str, "count": int, "last_error": str}, ...]
+            Sorted by count descending.
+        """
+        node_stats = defaultdict(lambda: {"count": 0, "last_error": "", "node_class": ""})
+        
+        for entry in history:
+            node_info = entry.get("node_info", {})
+            if not node_info:
+                # Try to extract from snapshot if available (legacy)
+                continue
+                
+            node_class = node_info.get("node_class") or node_info.get("node_type")
+            if not node_class:
+                continue
+            
+            # Key by node class (type) rather than specific node_id instance
+            # to capture systematic improvements needed for a node type.
+            key = node_class
+            
+            try:
+                weight = int(entry.get("repeat_count", 1) or 1)
+            except Exception:
+                weight = 1
+                
+            node_stats[key]["node_class"] = node_class
+            node_stats[key]["count"] += weight
+            node_stats[key]["last_error"] = entry.get("error_type") or "Unknown Error"
+            
+        # Convert to list and sort
+        results = list(node_stats.values())
+        results.sort(key=lambda x: x["count"], reverse=True)
+        
+        return results
+
+    @staticmethod
+    def calculate_health_score(failures: int, total_executions: int = 0) -> float:
+        """
+        Calculate a 0.0-1.0 health score.
+        If total_executions is 0 (unknown), score is based on raw failure count decay.
+        """
+        if total_executions > 0:
+            return max(0.0, 1.0 - (failures / total_executions))
+        
+        # Heuristic decay: 1 failure = 0.9, 10 failures = 0.5, 100 failures = 0.1
+        # Simple exponential decay for now
+        import math
+        return float(max(0.0, 1.0 * (0.95 ** failures)))

services/providers/base.py

@@ -29,10 +29,27 @@ class BaseProviderAdapter(ABC):
     Enforces consistent timeout, retry, and response structure.
     """
 
-    def __init__(self, provider_id: str, timeout: float = 30.0, max_retries: int = 2):
+    def __init__(
+        self,
+        provider_id: str,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+    ):
         self.provider_id = provider_id
-        self.timeout = timeout
-        self.max_retries = max_retries
+        default_timeout = 30.0
+        default_retries = 2
+        try:
+            # CRITICAL: keep this import local to avoid module import coupling at startup.
+            from config import CONFIG  # pylint: disable=import-outside-toplevel
+            default_timeout = float(getattr(CONFIG.guardrails, "PROVIDER_TIMEOUT_SECONDS", 30))
+            default_retries = int(getattr(CONFIG.guardrails, "PROVIDER_MAX_RETRIES", 2))
+        except Exception:
+            pass
+
+        resolved_timeout = default_timeout if timeout is None else float(timeout)
+        resolved_retries = default_retries if max_retries is None else int(max_retries)
+        self.timeout = resolved_timeout if resolved_timeout > 0 else default_timeout
+        self.max_retries = resolved_retries if resolved_retries >= 0 else default_retries
 
     async def execute_with_retry(
         self,