nat-engine 1__py3-none-any.whl

mannf/core/agents/autonomous_loop_agent.py

@@ -0,0 +1,1086 @@
+# Copyright (C) 2026 Brad Guider
+# This file is part of NAT (Neural Agent Testing Framework).
+# Licensed under the AGPL-3.0. See LICENSE for details.
+# Commercial licensing available — see COMMERCIAL_LICENSE.md.
+
+"""AutonomousTestLoopAgent — Phase 5 end-to-end autonomous functional testing.
+
+Closes the loop: **crawl → generate scenarios → execute → analyze → feed back
+into beliefs → re-generate → repeat** — all triggered by a single ``run_loop()``
+call.
+
+The agent **composes** (not inherits) all Phase 1–4 components:
+
+* :class:`~mannf.core.agents.web_crawler_agent.WebCrawlerAgent` — BFS crawl
+* :class:`~mannf.core.browser.scenario_generator.ScenarioConfigGenerator` — scenario generation
+* :class:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator` — browser execution
+* :class:`~mannf.core.prioritization.adaptive_controller.AdaptiveController` — belief feedback
+
+Convergence criteria (first one met stops the loop):
+* ``max_iterations`` reached
+* ``max_duration_s`` time budget exhausted
+* No new failures in last ``stability_threshold`` consecutive iterations
+* (future) coverage target met
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Set
+from urllib.parse import urlparse
+
+from mannf.core.agents.autonomous_loop_models import AutonomousRunReport, LoopIterationResult
+from mannf.core.messaging.bus import MessageBus
+
+logger = logging.getLogger(__name__)
+
+
+def _page_key(url: str, base_url: str) -> str:
+    """Normalize a URL to a page-relative path for belief state keys."""
+    try:
+        base = urlparse(base_url)
+        parsed = urlparse(url)
+        if parsed.netloc == base.netloc or not parsed.netloc:
+            return parsed.path or "/"
+        return url
+    except Exception:  # noqa: BLE001
+        return url
+
+
+class AutonomousTestLoopAgent:
+    """Autonomous end-to-end functional test loop agent.
+
+    Parameters
+    ----------
+    target_url:
+        Root URL of the web application under test.
+    max_iterations:
+        Hard cap on loop iterations.
+    max_duration_s:
+        Wall-clock time budget in seconds.
+    stability_threshold:
+        Stop after this many consecutive iterations with no new failures.
+    strategy:
+        Scenario selection strategy: ``"all"``, ``"high_risk"``,
+        ``"new_changed"``, or ``"belief_targeted"``.
+    risk_threshold:
+        Minimum ``risk_score`` for ``"high_risk"`` strategy.
+    max_pages:
+        Maximum pages to crawl per iteration.
+    max_depth:
+        Maximum BFS depth for the crawler.
+    num_browser_agents:
+        Number of parallel browser executor agents.
+    headless:
+        Run browsers in headless mode.
+    llm_provider:
+        Optional LLM provider for AI-enhanced scenario generation.
+    recrawl_every:
+        Re-crawl (expensive) every N iterations; between re-crawls only
+        re-generate scenarios from the cached discovery model.
+    enable_webhook:
+        Whether to POST progress updates to ``webhook_url``.
+    webhook_url:
+        URL to receive progress webhook POSTs.
+    enable_security_scenarios:
+        When ``True``, include browser-level security test scenarios
+        (XSS, SQL injection, path traversal, SSRF, etc.) alongside
+        the standard functional scenarios.
+    """
+
+    def __init__(
+        self,
+        target_url: str,
+        *,
+        max_iterations: int = 5,
+        max_duration_s: float = 600.0,
+        stability_threshold: int = 2,
+        strategy: str = "all",
+        risk_threshold: float = 0.6,
+        max_pages: int = 50,
+        max_depth: int = 5,
+        num_browser_agents: int = 2,
+        headless: bool = True,
+        llm_provider: Any | None = None,
+        recrawl_every: int = 3,
+        enable_webhook: bool = False,
+        webhook_url: str = "",
+        enable_security_scenarios: bool = False,
+        seeded_scenarios: list[dict[str, Any]] | None = None,
+    ) -> None:
+        self.target_url = target_url
+        self.max_iterations = max_iterations
+        self.max_duration_s = max_duration_s
+        self.stability_threshold = stability_threshold
+        self.strategy = strategy
+        self.risk_threshold = risk_threshold
+        self.max_pages = max_pages
+        self.max_depth = max_depth
+        self.num_browser_agents = num_browser_agents
+        self.headless = headless
+        self.llm_provider = llm_provider
+        self.recrawl_every = recrawl_every
+        self.enable_webhook = enable_webhook
+        self.webhook_url = webhook_url
+        self.enable_security_scenarios = enable_security_scenarios
+        # Pre-seeded scenarios injected before the first crawl (Phase 7.2 zero cold-start)
+        self.seeded_scenarios: list[dict[str, Any]] = list(seeded_scenarios or [])
+
+        # Internal state
+        self._run_id = str(uuid.uuid4())
+        self._stop_requested = False
+        self._pause_requested = False
+        self._discovery_model: Any | None = None  # cached between re-crawl intervals
+        self._belief_state: Optional[Any] = None  # lazy-created on first crawl
+        self._seen_failure_keys: Set[str] = set()  # for dedup across iterations
+        self._consecutive_stable = 0
+        self._all_unique_failures: List[Dict[str, Any]] = []
+        self._covered_pages: Set[str] = set()
+        self._last_heartbeat_at: Optional[datetime] = None
+        self._paused_iteration: int = 0  # iteration at which run was paused
+        # Browser-level security findings accumulated across iterations
+        self._browser_security_findings: List[Dict[str, Any]] = []
+        # Belief evolution snapshots — one per iteration (Phase 6.5)
+        self._belief_snapshots: List[Dict[str, Any]] = []
+        # LLM root cause suggestions (Phase 6.5)
+        self._root_cause_suggestions: List[Dict[str, Any]] = []
+        # Coverage gaps — pages blocked by auth/CAPTCHA/timeout/unreachable (Phase 7.4)
+        self._coverage_gaps: List[Dict[str, Any]] = []
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    @property
+    def run_id(self) -> str:
+        return self._run_id
+
+    @property
+    def last_heartbeat_at(self) -> Optional[datetime]:
+        """The UTC datetime of the last iteration heartbeat, or ``None``."""
+        return self._last_heartbeat_at
+
+    def request_stop(self) -> None:
+        """Signal the loop to stop gracefully after the current phase."""
+        self._stop_requested = True
+
+    def request_pause(self) -> None:
+        """Signal the loop to pause gracefully after the current iteration.
+
+        The run status will be set to ``"paused"`` and the agent's iteration
+        state serialised so it can be resumed later via :meth:`resume`.
+        """
+        self._pause_requested = True
+
+    def get_pause_state(self) -> Dict[str, Any]:
+        """Return a JSON-serialisable snapshot of the current agent state.
+
+        Used to persist pause state to the database so the run can be
+        reconstructed with :meth:`resume`.
+        """
+        belief_data: Optional[Dict[str, Any]] = None
+        if self._belief_state is not None:
+            belief_data = {
+                "services": self._belief_state.services,
+                "initial_belief": self._belief_state.initial_belief,
+                "fault_likelihood": dict(self._belief_state.fault_likelihood),
+                "confidence": dict(self._belief_state.confidence),
+            }
+
+        discovery_data: Optional[Dict[str, Any]] = None
+        if self._discovery_model is not None:
+            try:
+                discovery_data = self._discovery_model.to_dict()
+            except Exception:  # noqa: BLE001
+                discovery_data = None
+
+        return {
+            "run_id": self._run_id,
+            "target_url": self.target_url,
+            "strategy": self.strategy,
+            "max_iterations": self.max_iterations,
+            "max_duration_s": self.max_duration_s,
+            "stability_threshold": self.stability_threshold,
+            "risk_threshold": self.risk_threshold,
+            "max_pages": self.max_pages,
+            "max_depth": self.max_depth,
+            "recrawl_every": self.recrawl_every,
+            "paused_iteration": self._paused_iteration,
+            "consecutive_stable": self._consecutive_stable,
+            "seen_failure_keys": list(self._seen_failure_keys),
+            "all_unique_failures": self._all_unique_failures,
+            "covered_pages": list(self._covered_pages),
+            "belief_state": belief_data,
+            "discovery_model": discovery_data,
+        }
+
+    @classmethod
+    def resume(cls, pause_state: Dict[str, Any]) -> "AutonomousTestLoopAgent":
+        """Reconstruct an agent from a previously saved pause state.
+
+        Parameters
+        ----------
+        pause_state:
+            A dict previously returned by :meth:`get_pause_state`.
+
+        Returns
+        -------
+        AutonomousTestLoopAgent
+            A new agent instance with state restored, ready to continue
+            from the paused iteration.
+        """
+        agent = cls(
+            target_url=pause_state["target_url"],
+            max_iterations=pause_state.get("max_iterations", 5),
+            max_duration_s=pause_state.get("max_duration_s", 600.0),
+            stability_threshold=pause_state.get("stability_threshold", 2),
+            strategy=pause_state.get("strategy", "all"),
+            risk_threshold=pause_state.get("risk_threshold", 0.6),
+            max_pages=pause_state.get("max_pages", 50),
+            max_depth=pause_state.get("max_depth", 5),
+            recrawl_every=pause_state.get("recrawl_every", 3),
+        )
+        # Restore run identity and iteration state
+        agent._run_id = pause_state.get("run_id", agent._run_id)
+        agent._consecutive_stable = pause_state.get("consecutive_stable", 0)
+        agent._seen_failure_keys = set(pause_state.get("seen_failure_keys", []))
+        agent._all_unique_failures = pause_state.get("all_unique_failures", [])
+        agent._covered_pages = set(pause_state.get("covered_pages", []))
+        agent._paused_iteration = pause_state.get("paused_iteration", 0)
+
+        # Restore belief state
+        belief_data = pause_state.get("belief_state")
+        if belief_data:
+            try:
+                from mannf.core.agents.belief_state import BeliefState  # noqa: PLC0415
+
+                bs = BeliefState(
+                    services=belief_data.get("services", []),
+                    initial_belief=belief_data.get("initial_belief", 0.5),
+                )
+                bs.fault_likelihood.update(belief_data.get("fault_likelihood", {}))
+                bs.confidence.update(belief_data.get("confidence", {}))
+                agent._belief_state = bs
+            except Exception:  # noqa: BLE001
+                logger.warning(
+                    "AutonomousTestLoopAgent [%s]: could not restore belief state",
+                    agent._run_id[:8],
+                )
+
+        # Restore discovery model
+        discovery_data = pause_state.get("discovery_model")
+        if discovery_data:
+            try:
+                from mannf.core.browser.discovery_model import DiscoveryModel  # noqa: PLC0415
+                import dataclasses  # noqa: PLC0415
+
+                def _from_dict(cls_: Any, data: Any) -> Any:
+                    if not dataclasses.is_dataclass(cls_) or not isinstance(data, dict):
+                        return data
+                    fields = {f.name: f for f in dataclasses.fields(cls_)}
+                    kwargs = {}
+                    for name, fld in fields.items():
+                        if name not in data:
+                            continue
+                        val = data[name]
+                        origin = getattr(fld.type, "__origin__", None)
+                        if origin is list and val is not None:
+                            inner = fld.type.__args__[0] if fld.type.__args__ else None
+                            if inner and dataclasses.is_dataclass(inner):
+                                val = [_from_dict(inner, v) for v in val]
+                        kwargs[name] = val
+                    return cls_(**kwargs)
+
+                agent._discovery_model = _from_dict(DiscoveryModel, discovery_data)
+            except Exception:  # noqa: BLE001
+                logger.warning(
+                    "AutonomousTestLoopAgent [%s]: could not restore discovery model",
+                    agent._run_id[:8],
+                )
+
+        return agent
+
+    async def run_loop(self) -> AutonomousRunReport:
+        """Execute the full autonomous test loop.
+
+        Returns
+        -------
+        AutonomousRunReport
+            Structured results for the complete run.
+        """
+        started_at = datetime.now(timezone.utc).isoformat()
+        loop_start = time.monotonic()
+
+        report = AutonomousRunReport(
+            run_id=self._run_id,
+            target_url=self.target_url,
+            strategy=self.strategy,
+            total_iterations=0,
+            total_scenarios_executed=0,
+            total_passed=0,
+            total_failed=0,
+            total_flaky=0,
+            started_at=started_at,
+            status="running",
+        )
+
+        stop_reason = "max_iterations"
+
+        try:
+            for iteration in range(1, self.max_iterations + 1):
+                if self._stop_requested:
+                    stop_reason = "stopped"
+                    break
+
+                if self._pause_requested:
+                    stop_reason = "paused"
+                    self._paused_iteration = iteration
+                    break
+
+                elapsed = time.monotonic() - loop_start
+                if elapsed >= self.max_duration_s:
+                    stop_reason = "max_duration"
+                    break
+
+                logger.info(
+                    "AutonomousTestLoopAgent [%s]: starting iteration %d/%d",
+                    self._run_id[:8],
+                    iteration,
+                    self.max_iterations,
+                )
+
+                iter_result = await self._run_iteration(
+                    iteration=iteration,
+                    elapsed_budget=self.max_duration_s - elapsed,
+                )
+                report.iterations.append(iter_result)
+                report.total_iterations = iteration
+                report.total_scenarios_executed += iter_result.scenarios_executed
+                report.total_passed += iter_result.passed
+                report.total_failed += iter_result.failed
+                report.total_flaky += iter_result.flaky
+
+                # Update heartbeat timestamp after each completed iteration
+                self._last_heartbeat_at = datetime.now(timezone.utc)
+
+                # Broadcast iteration progress via WebSocket
+                await self._broadcast_iteration(report, iter_result)
+
+                # Convergence check — stability
+                if iter_result.new_failures == 0:
+                    self._consecutive_stable += 1
+                else:
+                    self._consecutive_stable = 0
+
+                if self._consecutive_stable >= self.stability_threshold:
+                    stop_reason = "stable"
+                    break
+
+                # Check time budget again after the iteration
+                if time.monotonic() - loop_start >= self.max_duration_s:
+                    stop_reason = "max_duration"
+                    break
+
+            # Finalize report
+            completed_at = datetime.now(timezone.utc).isoformat()
+            duration_s = round(time.monotonic() - loop_start, 2)
+
+            if stop_reason == "paused":
+                report.status = "paused"
+            else:
+                report.status = "complete"
+            report.stop_reason = stop_reason
+            report.completed_at = completed_at
+            report.duration_s = duration_s
+            report.unique_failures = list(self._all_unique_failures)
+            # Attach belief snapshots and root cause suggestions (Phase 6.5)
+            report.belief_snapshots = list(self._belief_snapshots)
+            report.root_cause_suggestions = list(self._root_cause_suggestions)
+            # Attach coverage gaps (Phase 7.4)
+            report.coverage_gaps = list(self._coverage_gaps)
+            # Build security coverage metrics
+            sec_findings = self._browser_security_findings
+            owasp_categories: set[str] = set()
+            for f in sec_findings:
+                cat = f.get("owasp_category", "")
+                if cat:
+                    owasp_categories.add(cat)
+            report.coverage_summary = {
+                "pages_tested": len(self._covered_pages),
+                "total_pages_crawled": (
+                    len(self._discovery_model.pages) if self._discovery_model else 0
+                ),
+                "security_fields_tested": len({
+                    f.get("endpoint", "") for f in sec_findings
+                }),
+                "security_payloads_attempted": sum(
+                    1 for s in report.iterations
+                    for _ in range(getattr(s, "scenarios_executed", 0))
+                ) if self.enable_security_scenarios else 0,
+                "security_exploits_found": len(sec_findings),
+                "owasp_coverage": sorted(owasp_categories),
+            }
+
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("AutonomousTestLoopAgent [%s]: fatal error", self._run_id[:8])
+            report.status = "failed"
+            report.error = str(exc)
+            report.stop_reason = "error"
+            report.completed_at = datetime.now(timezone.utc).isoformat()
+            report.duration_s = round(time.monotonic() - loop_start, 2)
+
+        await self._broadcast_complete(report)
+        logger.info(
+            "AutonomousTestLoopAgent [%s]: finished — %s after %d iterations",
+            self._run_id[:8],
+            report.stop_reason,
+            report.total_iterations,
+        )
+        return report
+
+    # ------------------------------------------------------------------
+    # Per-iteration pipeline
+    # ------------------------------------------------------------------
+
+    async def _run_iteration(
+        self,
+        iteration: int,
+        elapsed_budget: float,
+    ) -> LoopIterationResult:
+        """Run one full crawl → generate → filter → execute → analyze → feedback cycle."""
+        iter_start = time.monotonic()
+
+        # ------------------------------------------------------------------
+        # Phase 1: Crawl (every recrawl_every iterations, or on first iteration)
+        # ------------------------------------------------------------------
+        should_recrawl = (iteration == 1) or ((iteration - 1) % self.recrawl_every == 0)
+        if should_recrawl:
+            self._discovery_model = await self._crawl()
+
+        # Bail out early if crawl produced nothing (graceful degradation)
+        if self._discovery_model is None or not self._discovery_model.pages:
+            logger.warning(
+                "AutonomousTestLoopAgent [%s]: iteration %d — no pages discovered, skipping",
+                self._run_id[:8],
+                iteration,
+            )
+            return LoopIterationResult(
+                iteration=iteration,
+                scenarios_generated=0,
+                scenarios_executed=0,
+                passed=0,
+                failed=0,
+                flaky=0,
+                new_failures=0,
+                coverage_pages=0,
+                duration_s=round(time.monotonic() - iter_start, 2),
+            )
+
+        # ------------------------------------------------------------------
+        # Phase 2: Generate scenarios
+        # ------------------------------------------------------------------
+        scenarios = await self._generate_scenarios()
+
+        # Merge pre-seeded scenarios on iteration 1 (zero cold-start)
+        if iteration == 1 and self.seeded_scenarios:
+            logger.info(
+                "AutonomousTestLoopAgent [%s]: merging %d pre-seeded scenarios into iteration 1",
+                self._run_id[:8],
+                len(self.seeded_scenarios),
+            )
+            # Prepend seeds so strategy filter can prioritise them
+            scenarios = list(self.seeded_scenarios) + scenarios
+
+        # ------------------------------------------------------------------
+        # Phase 3: Filter scenarios
+        # ------------------------------------------------------------------
+        previously_tested: Set[str] = set()
+        for prev_iter in self._get_previous_iteration_pages():
+            previously_tested.add(prev_iter)
+
+        selected = self._filter_scenarios(scenarios, previously_tested)
+        scenarios_generated = len(scenarios)
+
+        if not selected:
+            logger.info(
+                "AutonomousTestLoopAgent [%s]: iteration %d — no scenarios selected by strategy=%s",
+                self._run_id[:8],
+                iteration,
+                self.strategy,
+            )
+            return LoopIterationResult(
+                iteration=iteration,
+                scenarios_generated=scenarios_generated,
+                scenarios_executed=0,
+                passed=0,
+                failed=0,
+                flaky=0,
+                new_failures=0,
+                coverage_pages=0,
+                duration_s=round(time.monotonic() - iter_start, 2),
+            )
+
+        # ------------------------------------------------------------------
+        # Phase 4: Execute
+        # ------------------------------------------------------------------
+        orch_report = await self._execute_scenarios(selected)
+
+        # ------------------------------------------------------------------
+        # Phase 5: Analyze
+        # ------------------------------------------------------------------
+        passed, failed, flaky, task_details = self._analyze_report(orch_report)
+
+        # Track covered pages
+        for task in selected:
+            page_key = _page_key(task.get("url", ""), self.target_url)
+            self._covered_pages.add(page_key)
+
+        # Track coverage gaps from blocked/unreachable responses
+        self._collect_coverage_gaps(orch_report, iteration)
+
+        # ------------------------------------------------------------------
+        # Phase 5b: Reflection analysis for security scenarios
+        # ------------------------------------------------------------------
+        if self.enable_security_scenarios:
+            security_selected = [
+                s for s in selected
+                if s.get("metadata", {}).get("scenario_type") == "security"
+            ]
+            if security_selected:
+                from mannf.core.browser.reflection_analyzer import analyze_security_results  # noqa: PLC0415
+                result_items = orch_report.get("items", []) if isinstance(orch_report, dict) else []
+                new_sec_findings = analyze_security_results(security_selected, result_items)
+                if new_sec_findings:
+                    logger.info(
+                        "AutonomousTestLoopAgent [%s]: iteration %d — %d browser security findings",
+                        self._run_id[:8],
+                        iteration,
+                        len(new_sec_findings),
+                    )
+                    self._browser_security_findings.extend(new_sec_findings)
+
+        # ------------------------------------------------------------------
+        # Phase 6: Feedback — update beliefs
+        # ------------------------------------------------------------------
+        prev_unique_count = len(self._all_unique_failures)
+        new_failures = self._update_beliefs(task_details)
+
+        # ------------------------------------------------------------------
+        # Phase 6b: Persist belief snapshot for this iteration (Phase 6.5)
+        # ------------------------------------------------------------------
+        self._persist_belief_snapshot(iteration)
+
+        # ------------------------------------------------------------------
+        # Phase 6c: LLM root cause analysis for new failures (Phase 6.5)
+        # ------------------------------------------------------------------
+        if new_failures > 0:
+            newly_added = self._all_unique_failures[prev_unique_count:]
+            self._schedule_root_cause_analysis(newly_added)
+
+        # ------------------------------------------------------------------
+        # Phase 7: Fire-and-forget exporter hook (non-blocking)
+        # ------------------------------------------------------------------
+        if new_failures > 0:
+            newly_added = self._all_unique_failures[prev_unique_count:]
+            self._schedule_exporter_hook(newly_added)
+
+        iter_duration = round(time.monotonic() - iter_start, 2)
+
+        logger.info(
+            "AutonomousTestLoopAgent [%s]: iteration %d done — "
+            "generated=%d executed=%d passed=%d failed=%d flaky=%d new_failures=%d (%.1fs)",
+            self._run_id[:8],
+            iteration,
+            scenarios_generated,
+            len(selected),
+            passed,
+            failed,
+            flaky,
+            new_failures,
+            iter_duration,
+        )
+
+        return LoopIterationResult(
+            iteration=iteration,
+            scenarios_generated=scenarios_generated,
+            scenarios_executed=len(selected),
+            passed=passed,
+            failed=failed,
+            flaky=flaky,
+            new_failures=new_failures,
+            coverage_pages=len(self._covered_pages),
+            duration_s=iter_duration,
+        )
+
+    # ------------------------------------------------------------------
+    # Phase helpers
+    # ------------------------------------------------------------------
+
+    async def _crawl(self) -> Any | None:
+        """Run the WebCrawlerAgent and return the discovery model."""
+        from mannf.core.agents.web_crawler_agent import WebCrawlerAgent  # noqa: PLC0415
+
+        bus = MessageBus()
+        crawler = WebCrawlerAgent(
+            agent_id=f"auto-crawler-{self._run_id[:8]}",
+            bus=bus,
+            service_names=[self.target_url],
+            base_url=self.target_url,
+            headless=self.headless,
+            max_pages=self.max_pages,
+            max_depth=self.max_depth,
+        )
+        try:
+            await crawler.start_browser()
+            try:
+                await crawler._run_crawl()
+            finally:
+                await crawler.stop_browser()
+            return crawler._discovery_model
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "AutonomousTestLoopAgent [%s]: crawl failed — %s",
+                self._run_id[:8],
+                exc,
+            )
+            return None
+
+    async def _generate_scenarios(self) -> list[dict[str, Any]]:
+        """Generate test scenarios from the current discovery model."""
+        from mannf.core.browser.scenario_generator import ScenarioConfigGenerator  # noqa: PLC0415
+
+        if self._discovery_model is None:
+            return []
+
+        gen = ScenarioConfigGenerator(
+            self._discovery_model,
+            llm_provider=self.llm_provider,
+            include_security=self.enable_security_scenarios,
+        )
+        try:
+            if self.llm_provider is not None:
+                return await gen.generate_all_async()
+            return gen.generate_all()
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "AutonomousTestLoopAgent [%s]: scenario generation failed — %s",
+                self._run_id[:8],
+                exc,
+            )
+            return []
+
+    def _filter_scenarios(
+        self,
+        scenarios: list[dict[str, Any]],
+        previously_tested_pages: Set[str],
+    ) -> list[dict[str, Any]]:
+        """Apply the configured strategy to select which scenarios to execute."""
+        if self.strategy == "all":
+            return scenarios
+
+        if self.strategy == "high_risk":
+            return [
+                s for s in scenarios
+                if s.get("metadata", {}).get("risk_score", 0.0) >= self.risk_threshold
+            ]
+
+        if self.strategy == "new_changed":
+            filtered = []
+            for s in scenarios:
+                page_key = _page_key(s.get("url", ""), self.target_url)
+                if page_key not in previously_tested_pages:
+                    filtered.append(s)
+            # Fall back to all if nothing is new
+            return filtered or scenarios
+
+        if self.strategy == "belief_targeted":
+            return self._belief_targeted_filter(scenarios)
+
+        # Unknown strategy — run all
+        logger.warning(
+            "AutonomousTestLoopAgent: unknown strategy %r, falling back to 'all'",
+            self.strategy,
+        )
+        return scenarios
+
+    def _belief_targeted_filter(
+        self,
+        scenarios: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """Use belief state fault_likelihood to rank and select top-N scenarios."""
+        if self._belief_state is None:
+            return scenarios
+
+        fault_likelihoods = self._belief_state.fault_likelihood
+
+        def _score(s: dict[str, Any]) -> float:
+            page_key = _page_key(s.get("url", ""), self.target_url)
+            return fault_likelihoods.get(page_key, 0.5)
+
+        ranked = sorted(scenarios, key=_score, reverse=True)
+        # Take top 50% by belief score, minimum 1
+        top_n = max(1, len(ranked) // 2)
+        return ranked[:top_n]
+
+    async def _execute_scenarios(
+        self,
+        tasks: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        """Run the selected scenario tasks through FunctionalTestOrchestrator."""
+        from mannf.core.functional_orchestrator import FunctionalTestOrchestrator  # noqa: PLC0415
+
+        try:
+            orch = FunctionalTestOrchestrator(num_browser_agents=self.num_browser_agents)
+            return await orch.run(tasks)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "AutonomousTestLoopAgent [%s]: execution failed — %s",
+                self._run_id[:8],
+                exc,
+            )
+            # Return a minimal empty report so analysis phase doesn't crash
+            return {"passed": 0, "failed": len(tasks), "total": len(tasks), "tasks": []}
+
+    def _analyze_report(
+        self,
+        orch_report: dict[str, Any],
+    ) -> tuple[int, int, int, list[dict[str, Any]]]:
+        """Extract pass/fail/flaky counts and per-task details from orchestrator report.
+
+        Returns
+        -------
+        tuple[int, int, int, list[dict]]
+            ``(passed, failed, flaky, task_details)``
+        """
+        passed = int(orch_report.get("passed", 0))
+        failed = int(orch_report.get("failed", 0))
+        flaky = 0
+
+        raw_tasks: list[dict[str, Any]] = orch_report.get("tasks", [])
+        task_details: list[dict[str, Any]] = []
+
+        for t in raw_tasks:
+            task_id = t.get("task_id", "")
+            task_url = t.get("url", "")
+            outcome = t.get("outcome", "")
+            error = t.get("error", "")
+            is_flaky = t.get("flaky", False) or outcome == "flaky"
+
+            if is_flaky:
+                flaky += 1
+                # Flaky tasks were counted in passed or failed by orchestrator;
+                # don't double-count, just record for feedback
+            task_details.append(
+                {
+                    "task_id": task_id,
+                    "url": task_url,
+                    "passed": outcome == "passed" or t.get("passed", False),
+                    "failed": outcome == "failed" or (not t.get("passed", True)),
+                    "flaky": is_flaky,
+                    "error": error,
+                }
+            )
+
+        return passed, failed, flaky, task_details
+
+    def _collect_coverage_gaps(
+        self,
+        orch_report: dict[str, Any],
+        iteration: int,
+    ) -> None:
+        """Scan the orchestrator report for blocked/unreachable pages and record them.
+
+        Categories detected:
+        - **auth-blocked** — HTTP 401/403 responses.
+        - **captcha-blocked** — responses containing CAPTCHA indicators.
+        - **timeout** — tasks that exceeded the time budget.
+        - **connection-refused** — DNS/TCP failures.
+
+        Entries are deduplicated by URL+category so the same gap is not added
+        multiple times across iterations.
+
+        Parameters
+        ----------
+        orch_report:
+            Raw dict returned by :meth:`_execute_scenarios`.
+        iteration:
+            Current iteration number (included in each gap entry for context).
+        """
+        _REMEDIATION: Dict[str, str] = {
+            "auth-blocked": (
+                "Provide valid credentials via the `auth_config` option or configure "
+                "session cookies to allow NAT to access protected pages."
+            ),
+            "captcha-blocked": (
+                "Disable CAPTCHA in your test environment, or use a bypass token "
+                "to allow automated access during testing."
+            ),
+            "timeout": (
+                "Increase the `page_timeout_ms` budget or investigate slow-loading "
+                "pages that may indicate performance regressions."
+            ),
+            "connection-refused": (
+                "Verify the target URL is reachable from the test runner and that "
+                "the service is healthy before starting NAT."
+            ),
+        }
+
+        seen_keys: Set[str] = {
+            f"{g['url']}::{g['category']}" for g in self._coverage_gaps
+        }
+
+        raw_tasks: list[dict[str, Any]] = orch_report.get("tasks", [])
+        for task in raw_tasks:
+            url = task.get("url", "")
+            error = (task.get("error") or "").lower()
+            status_code = task.get("status_code")
+
+            category: Optional[str] = None
+
+            if status_code in (401, 403):
+                category = "auth-blocked"
+            elif "captcha" in error or "challenge" in error:
+                category = "captcha-blocked"
+            elif "timeout" in error or "timed out" in error:
+                category = "timeout"
+            elif (
+                "connection refused" in error
+                or "net::err_connection_refused" in error
+                or "econnrefused" in error
+            ):
+                category = "connection-refused"
+
+            if category is None:
+                continue
+
+            gap_key = f"{url}::{category}"
+            if gap_key in seen_keys:
+                continue
+            seen_keys.add(gap_key)
+
+            self._coverage_gaps.append(
+                {
+                    "url": url,
+                    "category": category,
+                    "status_code": status_code,
+                    "error_detail": task.get("error", ""),
+                    "iteration": iteration,
+                    "remediation": _REMEDIATION[category],
+                }
+            )
+
+    def _update_beliefs(self, task_details: list[dict[str, Any]]) -> int:
+        """Feed execution results back to BeliefState.
+
+        * Failed → increase fault_likelihood for that page
+        * Passed → decrease fault_likelihood
+        * Flaky → moderate increase
+
+        Returns
+        -------
+        int
+            Number of new (previously unseen) failures detected.
+        """
+        from mannf.core.agents.belief_state import BeliefState  # noqa: PLC0415
+
+        # Lazily initialise belief state on first call
+        if self._belief_state is None:
+            self._belief_state = BeliefState(services=[])
+
+        new_failures_count = 0
+
+        for t in task_details:
+            page_key = _page_key(t.get("url", ""), self.target_url)
+
+            if t.get("flaky"):
+                self._belief_state.update(page_key, 0.7)
+            elif t.get("failed"):
+                self._belief_state.update(page_key, 1.0)
+
+                # Track unique failures (dedup by url + error)
+                failure_key = f"{page_key}::{t.get('error', '')}"
+                if failure_key not in self._seen_failure_keys:
+                    self._seen_failure_keys.add(failure_key)
+                    new_failures_count += 1
+                    self._all_unique_failures.append(
+                        {
+                            "url": t.get("url", ""),
+                            "page": page_key,
+                            "error": t.get("error", ""),
+                            "task_id": t.get("task_id", ""),
+                        }
+                    )
+            elif t.get("passed"):
+                self._belief_state.update(page_key, 0.0)
+
+        return new_failures_count
+
+    def _schedule_exporter_hook(self, new_failures: List[Dict[str, Any]]) -> None:
+        """Schedule a fire-and-forget background task to export new failures.
+
+        This is intentionally non-blocking — filing failures never crash or
+        delay the autonomous loop.
+        """
+        if not new_failures:
+            return
+        try:
+            loop = asyncio.get_running_loop()
+            loop.create_task(self._export_new_failures(list(new_failures)))
+        except RuntimeError:
+            # No running event loop (e.g. called from a sync context / tests)
+            # — skip silently; filing is best-effort only.
+            pass
+
+    async def _export_new_failures(self, failures: List[Dict[str, Any]]) -> None:
+        """Best-effort: notify the dashboard's auto-filing pipeline about new failures."""
+        try:
+            from mannf.product.dashboard.app import _auto_file_bugs  # noqa: PLC0415
+            from mannf.core.agents.autonomous_loop_models import AutonomousRunReport  # noqa: PLC0415
+
+            # Build a minimal report with just the new failures so the dashboard
+            # pipeline can apply severity filtering and file tickets.
+            stub_report = AutonomousRunReport(
+                run_id=self._run_id,
+                target_url=self.target_url,
+                strategy=self.strategy,
+                total_iterations=0,
+                total_scenarios_executed=len(failures),
+                total_passed=0,
+                total_failed=len(failures),
+                total_flaky=0,
+                unique_failures=failures,
+                started_at="",
+                status="running",
+            )
+            await _auto_file_bugs(self._run_id, stub_report)
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(
+                "AutonomousTestLoopAgent [%s]: exporter hook failed (non-fatal): %s",
+                self._run_id[:8],
+                exc,
+            )
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _persist_belief_snapshot(self, iteration: int) -> None:
+        """Append a belief state snapshot for the current iteration (Phase 6.5)."""
+        if self._belief_state is None:
+            return
+        try:
+            snapshot = self._belief_state.export_snapshot(
+                run_id=self._run_id,
+                iteration=iteration,
+            )
+            self._belief_snapshots.append(snapshot)
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(
+                "AutonomousTestLoopAgent [%s]: belief snapshot failed (non-fatal): %s",
+                self._run_id[:8],
+                exc,
+            )
+
+    def _schedule_root_cause_analysis(self, new_failures: List[Dict[str, Any]]) -> None:
+        """Schedule a fire-and-forget background task to run LLM root cause analysis."""
+        if not new_failures or self.llm_provider is None:
+            return
+        try:
+            loop = asyncio.get_running_loop()
+            loop.create_task(self._run_root_cause_analysis(list(new_failures)))
+        except RuntimeError:
+            pass
+
+    async def _run_root_cause_analysis(self, failures: List[Dict[str, Any]]) -> None:
+        """Best-effort: call LLM root cause analyzer for new failures."""
+        try:
+            from mannf.core.diagnostics.root_cause_analyzer import RootCauseAnalyzer  # noqa: PLC0415
+
+            analyzer = RootCauseAnalyzer(llm_provider=self.llm_provider)
+            for failure in failures:
+                page_key = failure.get("page", "")
+                fault_likelihood = (
+                    self._belief_state.fault_likelihood.get(page_key, 1.0)
+                    if self._belief_state is not None
+                    else 1.0
+                )
+                # Collect belief history for this page from snapshots
+                belief_history = [
+                    {
+                        "iteration": s.get("iteration"),
+                        "fault_likelihood": s.get("beliefs", {}).get(page_key),
+                        "timestamp": s.get("timestamp"),
+                    }
+                    for s in self._belief_snapshots
+                    if s.get("beliefs", {}).get(page_key) is not None
+                ]
+
+                result = await analyzer.analyze(
+                    failure=failure,
+                    fault_likelihood=fault_likelihood,
+                    belief_history=belief_history,
+                )
+                if result is not None:
+                    suggestion = result.to_dict()
+                    suggestion["task_id"] = failure.get("task_id", "")
+                    suggestion["url"] = failure.get("url", "")
+                    suggestion["page"] = page_key
+                    self._root_cause_suggestions.append(suggestion)
+                    logger.debug(
+                        "AutonomousTestLoopAgent [%s]: root cause for %s — %s (confidence=%.2f)",
+                        self._run_id[:8],
+                        page_key,
+                        result.likely_cause[:80],
+                        result.confidence,
+                    )
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(
+                "AutonomousTestLoopAgent [%s]: root cause analysis failed (non-fatal): %s",
+                self._run_id[:8],
+                exc,
+            )
+
+    def _get_previous_iteration_pages(self) -> Set[str]:
+        """Return the set of page keys that have already been covered."""
+        return set(self._covered_pages)
+
+    async def _broadcast_iteration(
+        self,
+        report: AutonomousRunReport,
+        iter_result: LoopIterationResult,
+    ) -> None:
+        """Broadcast an autonomous_iteration WebSocket event (best-effort)."""
+        try:
+            from mannf.product.dashboard.telemetry import broadcast_autonomous_iteration  # noqa: PLC0415
+
+            await broadcast_autonomous_iteration(
+                run_id=self._run_id,
+                iteration=iter_result.iteration,
+                passed=iter_result.passed,
+                failed=iter_result.failed,
+                flaky=iter_result.flaky,
+                new_failures=iter_result.new_failures,
+                scenarios_executed=iter_result.scenarios_executed,
+                coverage_pages=iter_result.coverage_pages,
+            )
+        except Exception:  # noqa: BLE001
+            pass
+
+    async def _broadcast_complete(self, report: AutonomousRunReport) -> None:
+        """Broadcast an autonomous_complete WebSocket event (best-effort)."""
+        try:
+            from mannf.product.dashboard.telemetry import broadcast_autonomous_complete  # noqa: PLC0415
+
+            await broadcast_autonomous_complete(
+                run_id=self._run_id,
+                stop_reason=report.stop_reason,
+                total_iterations=report.total_iterations,
+                total_passed=report.total_passed,
+                total_failed=report.total_failed,
+            )
+        except Exception:  # noqa: BLE001
+            pass