igel-qe-core 1.0.0

package/knowledge_base/agents/confidence_agent.py

@@ -0,0 +1,94 @@
+import logging
+from knowledge_base.models.test_requirement import (
+    GeneratedTestCase, 
+    ScenarioWithRules,
+    ConfidenceMetrics,
+    TestCaseWithConfidence
+)
+
+logger = logging.getLogger(__name__)
+
+def evaluate_coverage(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Calculate if the test cases cover the business rules.
+    If we are evaluating a single TC, we see if it represents its rule properly.
+    Here we return 1.0 if it maps to a rule, 0.0 otherwise.
+    """
+    if any(r.description == tc.business_rule.description for r in scenario.business_rules):
+        return 1.0
+    return 0.0
+
+def evaluate_traceability(tc: GeneratedTestCase) -> float:
+    """Check if the test case is traceable to a specific step."""
+    return 1.0 if "S" in tc.tc_reference and tc.business_rule else 0.0
+
+def evaluate_completeness(tc: GeneratedTestCase) -> float:
+    """Evaluate completeness of steps, data, and expected results."""
+    if not tc.steps:
+        return 0.0
+    
+    score = 0.0
+    for step in tc.steps:
+        step_score = 0.0
+        if step.action: step_score += 0.4
+        if step.data: step_score += 0.2
+        if step.expected_result: step_score += 0.4
+        score += step_score
+        
+    return score / len(tc.steps)
+
+def evaluate_automation_feasibility(tc: GeneratedTestCase) -> float:
+    """
+    Evaluate if this test case can be automated based on the Asset Registry.
+    For now, return a placeholder high score unless we have specific constraints.
+    (This will be enhanced when the Code Intelligence Agent is fully integrated).
+    """
+    return 0.9
+
+def compute_hybrid_confidence(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> TestCaseWithConfidence:
+    """
+    Compute the deterministic hybrid confidence score.
+    Weights:
+    - Coverage: 25%
+    - Traceability: 20%
+    - Completeness: 20%
+    - Historical Similarity: 15% (Stubbed to 0.8 for now)
+    - Automation Feasibility: 20%
+    """
+    coverage = evaluate_coverage(tc, scenario)
+    traceability = evaluate_traceability(tc)
+    completeness = evaluate_completeness(tc)
+    historical_similarity = 0.8 # Placeholder for vector DB search against approved tests
+    automation_feasibility = evaluate_automation_feasibility(tc)
+    
+    total = (
+        coverage * 0.25 +
+        traceability * 0.20 +
+        completeness * 0.20 +
+        historical_similarity * 0.15 +
+        automation_feasibility * 0.20
+    )
+    
+    metrics = ConfidenceMetrics(
+        coverage_score=coverage,
+        traceability_score=traceability,
+        completeness_score=completeness,
+        historical_similarity_score=historical_similarity,
+        automation_feasibility_score=automation_feasibility,
+        total_score=total
+    )
+    
+    tc.confidence_score = total
+    tc.confidence_metrics = metrics.dict()
+    
+    is_approved = total >= 0.80
+    
+    if not is_approved:
+        logger.info(f"Test case {tc.tc_reference} needs review (score: {total:.2f})")
+    else:
+        logger.info(f"Test case {tc.tc_reference} auto-approved (score: {total:.2f})")
+        
+    return TestCaseWithConfidence(
+        test_case=tc,
+        confidence=metrics,
+        is_approved=is_approved
+    )

package/knowledge_base/agents/execution_validation_agent.py

@@ -0,0 +1,129 @@
+import ast
+import logging
+import subprocess
+from pathlib import Path
+from typing import Tuple, List, Set
+
+from knowledge_base.db.client import get_conn
+
+logger = logging.getLogger(__name__)
+
+class ExecutionValidationAgent:
+    """Multi-stage validation pipeline for generated automation scripts."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        
+    def validate_syntax(self, code: str) -> Tuple[bool, str]:
+        """Stage 1: Check Python syntax."""
+        try:
+            ast.parse(code)
+            return True, ""
+        except SyntaxError as e:
+            return False, f"SyntaxError at line {e.lineno}: {e.msg}"
+            
+    def _get_known_assets(self, asset_type: str) -> Set[str]:
+        """Fetch all known assets of a specific type from the Asset Registry."""
+        assets = set()
+        try:
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("SELECT name FROM igel_asset_registry WHERE asset_type = %s", (asset_type,))
+                    for row in cur.fetchall():
+                        assets.add(row[0])
+        except Exception as e:
+            logger.error(f"Failed to query registry for {asset_type}: {e}")
+        return assets
+
+    def validate_imports(self, code: str) -> Tuple[bool, str]:
+        """Stage 2: Check if imported modules exist in the registry."""
+        try:
+            tree = ast.parse(code)
+        except SyntaxError:
+            return False, "Syntax invalid, cannot check imports."
+            
+        # For simplicity, we just extract 'from module import X' and check X
+        # A more robust check would analyze the actual repo path.
+        missing_imports = []
+        known_pos = self._get_known_assets("page_object")
+        known_utils = self._get_known_assets("utility")
+        known_clients = self._get_known_assets("api_client")
+        
+        all_known = known_pos | known_utils | known_clients
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom):
+                for name in node.names:
+                    # Ignore standard library and common 3rd party (pytest, allure, typing, etc.)
+                    if node.module and not any(node.module.startswith(p) for p in ["pytest", "allure", "typing", "selenium", "playwright", "os", "json", "time"]):
+                        # This is a naive check; in a real enterprise system, you'd match the import path to `file_path`
+                        pass
+        return True, ""
+        
+    def validate_fixtures(self, code: str) -> Tuple[bool, str]:
+        """Stage 3: Check if requested pytest fixtures exist."""
+        try:
+            tree = ast.parse(code)
+        except SyntaxError:
+            return False, "Syntax invalid, cannot check fixtures."
+            
+        known_fixtures = self._get_known_assets("fixture")
+        
+        missing = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name.startswith("test_"):
+                # pytest uses argument names to request fixtures
+                for arg in node.args.args:
+                    arg_name = arg.arg
+                    # Ignore common built-in fixtures
+                    if arg_name not in ["request", "monkeypatch", "capsys", "tmpdir", "self", "cls"]:
+                        if known_fixtures and arg_name not in known_fixtures:
+                            missing.append(f"Fixture '{arg_name}' requested by {node.name} not found in registry.")
+                            
+        if missing:
+            return False, "\n".join(missing)
+        return True, ""
+        
+    def validate_pytest_collection(self, file_path: Path) -> Tuple[bool, str]:
+        """Stage 4: Perform a pytest dry-run (collection only)."""
+        if not file_path.exists():
+            return False, f"File {file_path} does not exist."
+            
+        # Run pytest --collect-only
+        try:
+            # Note: Requires pytest to be installed in the environment running the server
+            result = subprocess.run(
+                ["pytest", "--collect-only", str(file_path)],
+                capture_output=True,
+                text=True,
+                cwd=str(self.repo_path)
+            )
+            
+            if result.returncode != 0:
+                # 5 means no tests collected, which is also an error for us
+                if result.returncode == 5:
+                    return False, "Pytest collected 0 tests."
+                return False, f"Pytest collection failed:\n{result.stderr or result.stdout}"
+                
+            return True, ""
+        except Exception as e:
+            return False, f"Error running pytest collection: {e}"
+            
+    def validate_pipeline(self, code: str, file_path: Path) -> Tuple[bool, str, str]:
+        """Run all execution validation stages."""
+        logger.info(f"Starting execution validation pipeline for {file_path}")
+        
+        ok, err = self.validate_syntax(code)
+        if not ok: return False, "syntax_failed", err
+        
+        ok, err = self.validate_imports(code)
+        if not ok: return False, "import_failed", err
+        
+        ok, err = self.validate_fixtures(code)
+        if not ok: return False, "fixture_failed", err
+        
+        ok, err = self.validate_pytest_collection(file_path)
+        if not ok: return False, "collection_failed", err
+        
+        logger.info(f"Execution validation passed for {file_path}")
+        return True, "passed", ""

package/knowledge_base/agents/feedback_agent.py

@@ -0,0 +1,56 @@
+import json
+import logging
+from typing import Dict, Any, Optional
+from knowledge_base.db.client import get_conn
+
+logger = logging.getLogger(__name__)
+
+class FeedbackAgent:
+    """Agent responsible for capturing and applying 4-level granular feedback."""
+    
+    def capture_feedback(self, level: str, target_id: str, feedback_type: str, user_comment: str, corrected_data: Optional[Dict] = None) -> bool:
+        """
+        Store granular feedback.
+        Level must be one of: 'requirement', 'scenario', 'testcase', 'teststep'.
+        """
+        if level not in ["requirement", "scenario", "testcase", "teststep"]:
+            logger.error(f"Invalid feedback level: {level}")
+            return False
+            
+        try:
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute(
+                        """
+                        INSERT INTO igel_granular_feedback 
+                        (level, target_id, feedback_type, user_comment, corrected_data)
+                        VALUES (%s, %s, %s, %s, %s::jsonb)
+                        """,
+                        (level, target_id, feedback_type, user_comment, json.dumps(corrected_data) if corrected_data else None)
+                    )
+                conn.commit()
+            logger.info(f"Captured {level} feedback for {target_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to capture feedback: {e}")
+            return False
+
+    def get_feedback_for_target(self, target_id: str) -> list:
+        """Retrieve historical feedback for a specific target to use as generation context."""
+        feedback = []
+        try:
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute(
+                        "SELECT feedback_type, user_comment, corrected_data FROM igel_granular_feedback WHERE target_id = %s",
+                        (target_id,)
+                    )
+                    for row in cur.fetchall():
+                        feedback.append({
+                            "type": row[0],
+                            "comment": row[1],
+                            "corrected_data": row[2]
+                        })
+        except Exception as e:
+            logger.error(f"Failed to get feedback: {e}")
+        return feedback

package/knowledge_base/agents/fusion_agent.py

@@ -0,0 +1,113 @@
+"""Context fusion agent — Phase 5."""
+from __future__ import annotations
+
+import re
+
+from knowledge_base.agents.state import AgenticState
+
+
+def fusion_agent(state: AgenticState) -> AgenticState:
+    rag = state.get("rag_chunks", [])
+    kg = state.get("kg_entities") or {}
+    temporal = state.get("temporal_context") or {}
+    memory = state.get("memory_context") or []
+    web = state.get("web_context") or {}
+    mcp = state.get("mcp_context") or {}
+
+    registry_keys = list(kg.get("registry_keys") or [])
+    ui_paths = list(kg.get("ui_paths") or [])
+    procedure_steps = []
+    for chunk in rag[:5]:
+        content = chunk.get("content", "")
+        for line in content.split("\n"):
+            if re.match(r"^\s*\d+[\.)]\s", line):
+                procedure_steps.append(line.strip())
+
+    memory_insights = [m.get("content", "") for m in memory if m.get("content")]
+    temporal_changes = temporal.get("feature_changes") or []
+
+    conflicts: list[dict] = list(kg.get("conflicts") or [])
+    if not conflicts and rag:
+        try:
+            from knowledge_base.core.precedence import detect_precedence_conflicts
+            pseudo = []
+            for i, chunk in enumerate(rag[:8]):
+                pseudo.append(type("R", (), {
+                    "metadata": {"source_type": chunk.get("source_type", "igel_docs")},
+                    "parent_content": chunk.get("content", ""),
+                    "file_name": chunk.get("source_name", ""),
+                })())
+            conflicts = detect_precedence_conflicts(pseudo)
+        except Exception:
+            pass
+    missing: list[str] = []
+    if not registry_keys and "configuration" in state.get("query_categories", []):
+        missing.append("no_registry_keys")
+    if not ui_paths:
+        missing.append("no_ui_paths")
+    if len(procedure_steps) < 3:
+        missing.append("no_procedure_steps")
+
+    sources_used = []
+    for chunk in rag:
+        src = chunk.get("source_name") or chunk.get("source_type", "unknown")
+        sources_used.append(src)
+    for hit in web.get("hits") or []:
+        sources_used.append(hit.get("url") or hit.get("title") or "web")
+    for hit in mcp.get("hits") or []:
+        sources_used.append(f"{hit.get('source', 'mcp')}:{hit.get('title', 'external')}")
+
+    web_boost = min(0.15, len(web.get("hits") or []) * 0.05)
+    mcp_boost = min(0.1, len(mcp.get("hits") or []) * 0.05)
+    quality = min(
+        1.0,
+        (len(rag) / 5) * 0.35
+        + (len(registry_keys) / 5) * 0.25
+        + (len(procedure_steps) / 5) * 0.25
+        + web_boost
+        + mcp_boost,
+    )
+
+    # LLM-assisted context quality when heuristic score is low
+    if quality < 0.5 and rag:
+        try:
+            from knowledge_base.generation.test_generator import _call_gpt
+            sample = "\n".join(c.get("content", "")[:200] for c in rag[:3])
+            verdict = _call_gpt(
+                "Rate context relevance 0-1 for IGEL test generation. Reply with number only.",
+                f"Query: {state.get('query', '')}\nContext sample:\n{sample}",
+                max_tokens=16,
+                temperature=0.0,
+            )
+            import re
+            m = re.search(r"0\.\d+|1\.0|1", verdict)
+            if m:
+                quality = max(quality, min(1.0, float(m.group())))
+        except Exception:
+            pass
+
+    state["fused_context"] = {
+        "registry_keys": registry_keys,
+        "ui_paths": ui_paths,
+        "procedure_steps": procedure_steps[:20],
+        "related_tcs": kg.get("related_testcases") or [],
+        "related_defects": kg.get("related_defects") or [],
+        "memory_insights": memory_insights,
+        "temporal_changes": temporal_changes,
+        "web_block": web.get("block") or "",
+        "web_hits": web.get("hits") or [],
+        "mcp_block": mcp.get("block") or "",
+        "mcp_hits": mcp.get("hits") or [],
+        "conflicts": conflicts,
+        "context_quality": quality,
+        "missing_signals": missing,
+    }
+    state["sources_used"] = list(dict.fromkeys(sources_used))
+
+    state.setdefault("agent_trace", []).append({
+        "agent": "FusionAgent",
+        "status": "complete",
+        "context_quality": quality,
+        "conflicts": len(conflicts),
+    })
+    return state

package/knowledge_base/agents/graph.py

@@ -0,0 +1,152 @@
+"""Agent orchestration graph — Phase 5 (LangGraph with parallel retrieval)."""
+from __future__ import annotations
+
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from knowledge_base.agents.fusion_agent import fusion_agent
+from knowledge_base.agents.intent_agent import intent_agent
+from knowledge_base.agents.kg_agent import kg_agent
+from knowledge_base.agents.memory_agent import memory_agent
+from knowledge_base.agents.reflection_agent import reflection_agent, should_loop_back
+from knowledge_base.agents.retrieval_agent import retrieval_agent
+from knowledge_base.agents.script_agent import script_agent
+from knowledge_base.agents.state import AgenticState, initial_state
+from knowledge_base.agents.temporal_agent import temporal_agent
+from knowledge_base.agents.validation_agent import validation_agent
+
+logger = logging.getLogger(__name__)
+
+
+def _run_agent(name: str, fn, state: AgenticState) -> AgenticState:
+    t0 = time.perf_counter()
+    result = fn(state)
+    result.setdefault("agent_trace", []).append({
+        "agent": name,
+        "status": "parallel_complete",
+        "timing_ms": round((time.perf_counter() - t0) * 1000, 1),
+    })
+    return result
+
+
+def _merge_parallel_results(base: AgenticState, partial: AgenticState) -> None:
+    for key in (
+        "rag_chunks", "web_context", "mcp_context", "sources_summary",
+        "kg_context_block", "kg_entities", "temporal_context", "memory_context",
+    ):
+        if key in partial and partial[key]:
+            base[key] = partial[key]
+    base.setdefault("agent_trace", []).extend(partial.get("agent_trace", []))
+
+
+def _run_parallel_retrieval(state: AgenticState) -> AgenticState:
+    """Run retrieval first, then KG/temporal/memory in parallel."""
+    state = retrieval_agent(state)
+    base = dict(state)
+    agents = [
+        ("KGAgent", kg_agent),
+        ("TemporalAgent", temporal_agent),
+        ("MemoryAgent", memory_agent),
+    ]
+    with ThreadPoolExecutor(max_workers=3) as pool:
+        futures = {pool.submit(fn, dict(base)): name for name, fn in agents}
+        for fut in as_completed(futures):
+            try:
+                partial = fut.result()
+                _merge_parallel_results(state, partial)
+            except Exception as exc:
+                logger.warning("Parallel agent %s failed: %s", futures[fut], exc)
+    return state
+
+
+def run_agentic_pipeline(state: AgenticState) -> AgenticState:
+    """Execute full agent pipeline without LangGraph dependency."""
+    state = intent_agent(state)
+    state = _run_parallel_retrieval(state)
+    state = fusion_agent(state)
+
+    for _ in range(2):
+        state = reflection_agent(state)
+        if should_loop_back(state):
+            state = _run_parallel_retrieval(state)
+            state = fusion_agent(state)
+        else:
+            break
+
+    state = validation_agent(state)
+    if not state.get("validation_passed", True) and len(state.get("validation_errors") or []) > 2:
+        conf = state.setdefault("confidence", {})
+        conf["publish"] = min(float(conf.get("publish", 0.5)), 0.35)
+        conf["route"] = "reject"
+    state = script_agent(state)
+    return state
+
+
+def build_graph():
+    """
+    Build LangGraph workflow when langgraph is installed; else return callable runner.
+    """
+    try:
+        from langgraph.graph import END, StateGraph
+
+        workflow = StateGraph(AgenticState)
+
+        workflow.add_node("intent", intent_agent)
+        workflow.add_node("retrieval_parallel", _run_parallel_retrieval)
+        workflow.add_node("fusion", fusion_agent)
+        workflow.add_node("reflection", reflection_agent)
+        workflow.add_node("validation", validation_agent)
+        workflow.add_node("script", script_agent)
+
+        workflow.set_entry_point("intent")
+        workflow.add_edge("intent", "retrieval_parallel")
+        workflow.add_edge("retrieval_parallel", "fusion")
+        workflow.add_edge("fusion", "reflection")
+
+        def _route_reflection(state: AgenticState) -> str:
+            if should_loop_back(state):
+                return "retrieval_parallel"
+            return "validation"
+
+        workflow.add_conditional_edges("reflection", _route_reflection)
+        workflow.add_edge("validation", "script")
+        workflow.add_edge("script", END)
+
+        return workflow.compile()
+    except ImportError:
+        logger.info("LangGraph not installed — using sequential agent runner")
+        return SequentialRunner()
+
+
+class SequentialRunner:
+    """Fallback runner when LangGraph is unavailable."""
+
+    def invoke(self, state: AgenticState) -> AgenticState:
+        return run_agentic_pipeline(state)
+
+    async def ainvoke(self, state: AgenticState) -> AgenticState:
+        return run_agentic_pipeline(state)
+
+
+def generate_agentic(
+    query: str,
+    *,
+    product: str | None = None,
+    top_k: int = 8,
+    output_format: str = "both",
+    test_id: str | None = None,
+) -> AgenticState:
+    """High-level entry point for agentic generation."""
+    state = initial_state(
+        query,
+        product=product,
+        top_k=top_k,
+        output_format=output_format,
+        test_id=test_id,
+    )
+    graph = build_graph()
+    result = graph.invoke(state)
+    if not result.get("test_id"):
+        result["test_id"] = test_id or "TC_AGENT"
+    return result

package/knowledge_base/agents/healing_agent.py

@@ -0,0 +1,62 @@
+"""Healing agent — Phase 7."""
+from __future__ import annotations
+
+from knowledge_base.config import cfg
+from knowledge_base.memory.cognee_client import get_cognee_client
+from knowledge_base.memory.memory_types import MemoryType
+from knowledge_base.generation.test_generator import _call_gpt
+
+
+def propose_fix(test_id: str, flaky_history: list[dict] | None = None) -> dict:
+    """Propose script repair for flaky test."""
+    if not cfg.COGNEE_ENABLED:
+        return {"status": "execution_memory_not_populated", "confidence": 0.0}
+
+    client = get_cognee_client()
+    patterns = client.search(
+        query=f"flaky test patterns for {test_id}",
+        memory_types=[MemoryType.EXECUTION.value, MemoryType.PATTERN.value],
+        top_k=3,
+    )
+
+    if not patterns:
+        return {
+            "status": "execution_memory_not_populated",
+            "test_id": test_id,
+            "confidence": 0.0,
+            "rationale": "No execution memory patterns found for this test.",
+        }
+
+    pattern_text = "\n".join(p.content for p in patterns)
+    history_text = ""
+    if flaky_history:
+        history_text = "\nFlaky execution history:\n" + "\n".join(
+            f"- {h}" for h in flaky_history[:10]
+        )
+    prompt = f"""Given flaky test {test_id} and these patterns:
+{pattern_text}
+{history_text}
+
+Propose a script fix. Return JSON with: proposed_change, change_type (locator|timing|assertion|fixture|registry_key), rationale."""
+
+    try:
+        response = _call_gpt(
+            "You are an IGEL test automation expert.",
+            prompt,
+            max_tokens=1024,
+            temperature=0.1,
+        )
+        confidence = 0.6
+        if "low_confidence" in response.lower():
+            confidence = 0.3
+        return {
+            "status": "complete",
+            "test_id": test_id,
+            "proposed_change": response[:2000],
+            "change_type": "timing",
+            "confidence": confidence,
+            "rationale": pattern_text[:500],
+            "low_confidence_fix": confidence < 0.5,
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e), "confidence": 0.0}

package/knowledge_base/agents/intent_agent.py

@@ -0,0 +1,76 @@
+"""Intent classification agent — Phase 5."""
+from __future__ import annotations
+
+import re
+
+from knowledge_base.agents.state import AgenticState
+
+_FEATURE_MAP = {
+    "entra": "Entra ID SSO",
+    "sso": "Entra ID SSO",
+    "mfa": "Entra ID MFA",
+    "wifi": "Network WiFi 802.1x",
+    "802.1": "Network WiFi 802.1x",
+    "icg": "ICG Certificate Management",
+    "certificate": "ICG Certificate Management",
+    "chromium": "Chromium Browser",
+    "ums": "UMS Administration",
+    "profile": "UMS Profile Assignment",
+    "amd": "AMD Driver Integration",
+    "hub": "Device Onboarding IGEL Hub",
+}
+
+_VERSIONS = ("12.8", "12.9", "12.10")
+
+
+def intent_agent(state: AgenticState) -> AgenticState:
+    query = state.get("query", "")
+    q_lower = query.lower()
+
+    if any(w in q_lower for w in ("transform", "restructure", "reformat", "improve this")):
+        intent = "transform"
+    elif any(w in q_lower for w in ("expand", "add detail", "step-by-step")):
+        intent = "expand"
+    else:
+        intent = "synthesize"
+
+    feature = "Unknown"
+    for kw, name in _FEATURE_MAP.items():
+        if kw in q_lower:
+            feature = name
+            break
+
+    version_scope = "unspecified"
+    categories: list[str] = []
+    for v in _VERSIONS:
+        if v in query or f"os {v}" in q_lower:
+            version_scope = v
+            categories.append("version_specific")
+            break
+    if version_scope == "unspecified":
+        categories.append("version_unspecified")
+
+    if any(w in q_lower for w in ("fail", "error", "negative", "boundary")):
+        categories.append("negative_case")
+    if any(w in q_lower for w in ("regression", "release", "change impact")):
+        categories.append("regression")
+    if any(w in q_lower for w in ("debug", "troubleshoot", "root cause")):
+        categories.append("troubleshooting")
+    if any(w in q_lower for w in ("registry", "profile", "configure", "setting")):
+        categories.append("configuration")
+    if intent == "synthesize" and feature == "Unknown":
+        categories.append("feature_unclear")
+
+    state["intent"] = intent
+    state["feature_area"] = feature
+    state["version_scope"] = version_scope
+    state["query_categories"] = categories
+    state.setdefault("agent_trace", []).append({
+        "agent": "IntentAgent",
+        "status": "complete",
+        "intent": intent,
+        "feature_area": feature,
+        "version_scope": version_scope,
+        "query_categories": categories,
+    })
+    return state