agentdiscover 2.9.2__tar.gz → 2.9.4__tar.gz

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentdiscover
-Version: 2.9.2
+Version: 2.9.4
 Summary: Discover every AI agent in your infrastructure. 5-layer detection: static analysis, network monitoring, eBPF/Kubernetes runtime, endpoint, and cloud audit (CloudTrail). Company-level correlation. AIBOM export. MCP server detection.
 Project-URL: Homepage, https://defendai.ai
 Project-URL: Documentation, https://github.com/Defend-AI-Tech-Inc/agent-discover-scanner/blob/main/README.md

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/demo/sample-repo/agents/crewai_agent.py

@@ -1,10 +1,13 @@
 from crewai import Agent, Task, Crew
 
+MODEL_NAME = "gpt-4-turbo"
+
 researcher = Agent(
     role="Researcher",
     goal="Research topics thoroughly",
     backstory="Expert researcher",
-    allow_code_execution=False
+    allow_code_execution=False,
+    model=MODEL_NAME,
 )
 
 task = Task(description="Research AI security", agent=researcher)

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/demo/sample-repo/agents/langchain_agent.py

@@ -3,7 +3,9 @@ from langchain.llms import OpenAI
 
 llm = OpenAI(temperature=0)
 tools = [Tool(name="search", func=lambda x: x, description="search")]
-agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
+agent = initialize_agent(
+    tools, llm, agent="zero-shot-react-description", model="gpt-4"
+)
 
 
 def run(query: str):

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentdiscover"
-version = "2.9.2"
+version = "2.9.4"
 description = "Discover every AI agent in your infrastructure. 5-layer detection: static analysis, network monitoring, eBPF/Kubernetes runtime, endpoint, and cloud audit (CloudTrail). Company-level correlation. AIBOM export. MCP server detection."
 readme = "README.md"
 requires-python = ">=3.10"

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/src/agent_discover_scanner/aibom.py

@@ -52,6 +52,52 @@ def generate_aibom(inventory_json: Path, output_path: Path) -> dict[str, Any]:
                         "value": ",".join(str(x) for x in layers),
                     }
                 )
+            if agent.get("declared_model"):
+                comp["properties"].append(
+                    {
+                        "name": "agent-discover:declared_model",
+                        "value": str(agent["declared_model"]),
+                    }
+                )
+            if agent.get("declared_model_source"):
+                comp["properties"].append(
+                    {
+                        "name": "agent-discover:declared_model_source",
+                        "value": str(agent["declared_model_source"]),
+                    }
+                )
+            if agent.get("runtime_env_model"):
+                comp["properties"].append(
+                    {
+                        "name": "agent-discover:runtime_env_model",
+                        "value": str(agent["runtime_env_model"]),
+                    }
+                )
+            # Generation/sampling parameters (facts only — provenance-tagged raw
+            # values, same conditional-append pattern as declared_model above).
+            # Threshold flags (HIGH_TEMPERATURE/UNBOUNDED_MAX_TOKENS/ZERO_TEMPERATURE)
+            # are deliberately NEVER written here — a formal BOM artifact shouldn't
+            # carry subjective/informational flags; see audit_reports.py instead.
+            generation_params = agent.get("generation_params")
+            if isinstance(generation_params, dict):
+                for param_name, param_data in generation_params.items():
+                    if not isinstance(param_data, dict):
+                        continue
+                    source = param_data.get("source")
+                    if source:
+                        comp["properties"].append(
+                            {
+                                "name": f"agent-discover:declared_{param_name}_source",
+                                "value": str(source),
+                            }
+                        )
+                    if "value" in param_data and param_data["value"] is not None:
+                        comp["properties"].append(
+                            {
+                                "name": f"agent-discover:declared_{param_name}",
+                                "value": str(param_data["value"]),
+                            }
+                        )
             components.append(comp)
 
     try:

agentdiscover-2.9.4/src/agent_discover_scanner/audit_reports.py

@@ -0,0 +1,170 @@
+"""Markdown reports for the audit command."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def write_ghost_agents_markdown(inventory_json: Path, dest: Path) -> None:
+    data = json.loads(inventory_json.read_text(encoding="utf-8"))
+    ghosts = (data.get("inventory") or {}).get("ghost") or []
+    lines = [
+        "# Ghost agents",
+        "",
+        "Runtime signals without matching source inventory (from latest correlation).",
+        "",
+    ]
+    if not ghosts:
+        lines.append("_No ghost agents in this run._")
+    else:
+        for g in ghosts:
+            lines.append(f"## {g.get('agent_id', 'unknown')}")
+            lines.append("")
+            lines.append(f"- **Risk:** {g.get('risk_level', '')}")
+            lines.append(f"- **Provider / framework:** {g.get('network_provider') or g.get('framework') or '—'}")
+            lines.append(f"- **Process:** {g.get('process_name') or '—'}")
+            lines.append(f"- **Last seen:** {g.get('last_seen') or '—'}")
+            lines.append("")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def write_mcp_markdown(mcp_result: dict[str, Any], dest: Path) -> None:
+    servers = mcp_result.get("servers") or []
+    lines = [
+        "# MCP servers",
+        "",
+        "Detected from configuration, process, registry, and optional network/endpoint context.",
+        "",
+        "[MCP] Enforce policies on detected servers → pip install mcpfw-defendai | mcpfw.dev",
+        "",
+    ]
+    if not servers:
+        lines.append("_No MCP servers detected in this run._")
+    else:
+        for s in servers:
+            name = s.get("server_name") or s.get("name") or "unknown"
+            lines.append(f"## {name}")
+            lines.append("")
+            lines.append(f"- **Vendor:** {s.get('vendor', '—')}")
+            lines.append(f"- **Publisher verified:** {s.get('publisher_verified', False)}")
+            lines.append(f"- **Local script:** {s.get('is_local_script', False)}")
+            lines.append("")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+_GENERATION_PARAM_ORDER = (
+    "temperature",
+    "top_p",
+    "top_k",
+    "max_tokens",
+    "frequency_penalty",
+    "presence_penalty",
+    "stop",
+    "seed",
+    "n",
+)
+
+
+def write_generation_params_markdown(inventory_json: Path, dest: Path) -> None:
+    """
+    Write generation/sampling parameter facts + informational threshold flags.
+
+    This report is intentionally separate from ghost-agents.md / the SARIF
+    security findings: HIGH_TEMPERATURE / UNBOUNDED_MAX_TOKENS / ZERO_TEMPERATURE
+    are opinions about configuration, not security findings, and must never
+    influence risk_level or agent classification (see correlator.py /
+    generation_defaults.py). This file is the only place they are surfaced.
+    """
+    data = json.loads(inventory_json.read_text(encoding="utf-8"))
+    inventory = data.get("inventory") or {}
+
+    agents_with_params = []
+    for classification, agents in inventory.items():
+        if not isinstance(agents, list):
+            continue
+        for agent in agents:
+            if isinstance(agent, dict) and agent.get("generation_params"):
+                agents_with_params.append((classification, agent))
+
+    lines = [
+        "# Generation / sampling parameters",
+        "",
+        "Raw detected values for temperature, top_p, top_k, max_tokens, "
+        "frequency_penalty, presence_penalty, stop, seed, and n, with honest "
+        "provenance per parameter — explicit (found in code), framework_default "
+        "(backfilled from a maintained provider/wrapper table), not_applicable "
+        "(fixed/rejected by the model family), or unknown (no reliable default "
+        "applies).",
+        "",
+        "**This report is informational only.** Flags below (HIGH_TEMPERATURE, "
+        "UNBOUNDED_MAX_TOKENS, ZERO_TEMPERATURE) are configuration observations, "
+        "not security findings — they do NOT affect risk_level, agent "
+        "classification, or `aibom.json`. No prescriptive \"recommended value\" "
+        "is given; that is a deliberately separate, out-of-scope decision.",
+        "",
+    ]
+
+    if not agents_with_params:
+        lines.append("_No generation/sampling parameters detected in this run._")
+    else:
+        for classification, agent in agents_with_params:
+            lines.append(f"## {agent.get('agent_id', 'unknown')}")
+            lines.append("")
+            lines.append(f"- **Classification:** {classification}")
+            lines.append(f"- **Framework:** {agent.get('framework') or '—'}")
+            if agent.get("declared_model"):
+                lines.append(f"- **Declared model:** {agent['declared_model']}")
+            lines.append("")
+            lines.append("| Parameter | Value | Provenance |")
+            lines.append("|---|---|---|")
+            params = agent.get("generation_params") or {}
+            for param_name in _GENERATION_PARAM_ORDER:
+                param_data = params.get(param_name)
+                if not isinstance(param_data, dict):
+                    continue
+                source = param_data.get("source", "unknown")
+                value = param_data.get("value", "—")
+                lines.append(f"| `{param_name}` | {value} | {source} |")
+            lines.append("")
+            flags = agent.get("generation_param_flags") or []
+            if flags:
+                lines.append("**Notes:**")
+                lines.append("")
+                for flag in flags:
+                    lines.append(f"- `{flag.get('flag')}`: {flag.get('message')}")
+                lines.append("")
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def write_audit_summary(report: dict[str, Any], dest: Path, raw_dir: Path) -> None:
+    s = report.get("summary") or {}
+    lines = [
+        "# Audit summary",
+        "",
+        f"**Generated:** {report.get('generated_at', '')}",
+        "",
+        "## Counts",
+        "",
+        f"- Confirmed: {s.get('confirmed', 0)}",
+        f"- Unknown: {s.get('unknown', 0)}",
+        f"- Ghost: {s.get('ghost', 0)}",
+        f"- Zombie: {s.get('zombie', 0)}",
+        f"- Shadow AI usage: {s.get('shadow_ai_usage', 0)}",
+        "",
+        "## Artifacts",
+        "",
+        f"- Raw scan directory: `{raw_dir}`",
+        "- `aibom.json` — CycloneDX-oriented AIBOM",
+        "- `ghost-agents.md` — Ghost agent detail",
+        "- `mcp-report.md` — MCP inventory",
+        "- `generation-params.md` — Generation/sampling parameter facts (informational)",
+        "- `summary.md` — This file",
+        "",
+    ]
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/src/agent_discover_scanner/cli.py

@@ -1012,11 +1012,12 @@ def audit(
 ):
     """
     Run the full scan-all pipeline into output/raw/, then write AIBOM JSON and Markdown reports
-    (ghost-agents.md, mcp-report.md, summary.md) beside raw/.
+    (ghost-agents.md, mcp-report.md, generation-params.md, summary.md) beside raw/.
     """
     from agent_discover_scanner.aibom import generate_aibom
     from agent_discover_scanner.audit_reports import (
         write_audit_summary,
+        write_generation_params_markdown,
         write_ghost_agents_markdown,
         write_mcp_markdown,
     )
@@ -1068,6 +1069,7 @@ def audit(
 
     generate_aibom(inv_path, output / "aibom.json")
     write_ghost_agents_markdown(inv_path, output / "ghost-agents.md")
+    write_generation_params_markdown(inv_path, output / "generation-params.md")
     write_audit_summary(report, output / "summary.md", raw_dir)
 
     nf: list = []

{agentdiscover-2.9.2 → agentdiscover-2.9.4}/src/agent_discover_scanner/correlator.py

@@ -13,6 +13,12 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import os
 
+from agent_discover_scanner.generation_defaults import (
+    classify_wrapper_key,
+    compute_threshold_flags,
+    has_any_signal,
+    resolve_generation_params,
+)
 from agent_discover_scanner.known_apps import build_known_apps, is_known_desktop_app
 
 
@@ -131,6 +137,45 @@ class AgentInventoryItem:
     saas_connections: Dict[str, Any] = field(default_factory=dict)
     risk_flags: List[str] = field(default_factory=list)
 
+    # Model identification (v2.7.1+) — local, free-pipeline model identity tiers.
+    # Distinct from (and never merged with) Layer 5's invocation-confirmed
+    # model_id / metadata.models_called, which remains the highest-confidence tier.
+    #
+    # declared_model / declared_model_source: Layer 1 static analysis — a model
+    #   identifier found via source (see signatures.py: extract_declared_model).
+    #   declared_model_source is "literal" (string constant kwarg) or
+    #   "resolved_constant" (kwarg was a Name resolved to a same-file constant).
+    declared_model: Optional[str] = None
+    declared_model_source: Optional[str] = None
+    # runtime_env_model / runtime_env_source: Layer 2 live process introspection —
+    # read from the actual environment of the running process (higher confidence
+    # than declared_model since it reflects live process memory, not source code).
+    # runtime_env_source is the matched env var name (e.g. "MODEL_NAME").
+    runtime_env_model: Optional[str] = None
+    runtime_env_source: Optional[str] = None
+
+    # Generation/sampling parameters (v2.10.0+) — Layer 1 static analysis.
+    # Facts only: raw values with honest provenance, one entry per tracked
+    # parameter (see generation_defaults.ALL_GENERATION_PARAMS), e.g.
+    #   {"temperature": {"value": 0.7, "source": "framework_default"},
+    #    "max_tokens": {"source": "unknown"}, ...}
+    # `source` is one of "literal" / "resolved_constant" (both mean: found
+    # explicitly in code — the "explicit" tier), "framework_default"
+    # (backfilled from the maintained defaults table), "not_applicable"
+    # (fixed/rejected by this provider+wrapper/model family — never has a
+    # `value`), or "unknown" (not found, no reliable default — never has a
+    # `value`). Only populated when there's real signal (a resolvable
+    # provider+wrapper OR at least one explicit value) — see
+    # generation_defaults.has_any_signal.
+    generation_params: Optional[Dict[str, Dict[str, Any]]] = None
+    # Threshold flags derived from generation_params (HIGH_TEMPERATURE,
+    # UNBOUNDED_MAX_TOKENS, ZERO_TEMPERATURE) — INFORMATIONAL ONLY.
+    # Deliberately never merged into risk_level/risk_flags/classification, and
+    # deliberately excluded from aibom.json (a formal BOM artifact shouldn't
+    # carry subjective flags). Consumed only by audit_reports.py's
+    # generation-params.md.
+    generation_param_flags: List[Dict[str, str]] = field(default_factory=list)
+
     def __post_init__(self):
         if self.discovered_at is None:
             self.discovered_at = datetime.now().isoformat()
@@ -211,12 +256,24 @@ def _populate_saas_and_risk_flags(
 
     risk_flags = []
     detected = saas.get("detected", [])
+    is_shadow = item.classification == "shadow_ai_usage"
+
     if item.classification == "ghost" and detected:
         risk_flags.append("critical_ghost")
-    if saas.get("has_cloud_provider"):
+
+    # cloud_credentials_present and database_credentials_present require evidence of
+    # actual credentials (API keys, env vars, .env files) — not just network connections
+    # to cloud services.  Shadow AI agents are browsers / desktop apps: their network
+    # traffic to Azure/GCP/AWS is normal browsing, not credential usage.  Only flag
+    # when credential_files_found exist, or when the agent is code-backed (non-shadow).
+    has_actual_cred_evidence = bool(
+        saas.get("credential_files_found") or (not is_shadow)
+    )
+    if saas.get("has_cloud_provider") and has_actual_cred_evidence:
         risk_flags.append("cloud_credentials_present")
-    if saas.get("has_database_access"):
+    if saas.get("has_database_access") and has_actual_cred_evidence:
         risk_flags.append("database_credentials_present")
+
     if saas.get("has_external_api_calls") and item.classification == "unknown":
         risk_flags.append("unverified_saas_access")
     item.risk_flags = risk_flags
@@ -246,19 +303,23 @@ class CorrelationEngine:
             findings = []
             for run in sarif.get("runs", []):
                 for result in run.get("results", []):
-                    findings.append(
-                        {
-                            "rule_id": result.get("ruleId"),
-                            "file_path": result["locations"][0]["physicalLocation"][
-                                "artifactLocation"
-                            ]["uri"],
-                            "line": result["locations"][0]["physicalLocation"]["region"][
-                                "startLine"
-                            ],
-                            "message": result["message"]["text"],
-                            "level": result.get("level", "warning"),
-                        }
-                    )
+                    finding = {
+                        "rule_id": result.get("ruleId"),
+                        "file_path": result["locations"][0]["physicalLocation"][
+                            "artifactLocation"
+                        ]["uri"],
+                        "line": result["locations"][0]["physicalLocation"]["region"][
+                            "startLine"
+                        ],
+                        "message": result["message"]["text"],
+                        "level": result.get("level", "warning"),
+                    }
+                    # Structured data (e.g. declared_model tier) carried via SARIF's
+                    # standard properties bag — see sarif_output.py / signatures.py.
+                    properties = result.get("properties")
+                    if properties:
+                        finding["extracted"] = properties
+                    findings.append(finding)
 
             return findings
         except (json.JSONDecodeError, KeyError):
@@ -692,6 +753,12 @@ class CorrelationEngine:
                         "framework_confidence": nf.get("framework_confidence"),  # "high"/"medium"/None
                         "entry_script": nf.get("entry_script"),         # resolved script path
                         "detected_host": nf.get("detected_host"),       # DNS-correlated hostname
+                        # runtime_env_model tier — read live from the process's own
+                        # environment via psutil (process_introspection.py). Highest
+                        # local-scan confidence: reflects what the process actually
+                        # has in memory, not what's hardcoded in source.
+                        "runtime_env_model": nf.get("runtime_env_model"),
+                        "runtime_env_source": nf.get("runtime_env_source"),
                     }
 
         # Index Layer 3 by provider (first match per provider for filling k8s fields)
@@ -711,8 +778,44 @@ class CorrelationEngine:
         # Track which Layer 3 findings were matched to a code finding (for GHOST: unmatched = ghost)
         matched_l3_keys: set = set()  # (namespace, pod) tuples
 
+        # DAI008 (declared_model) findings are a metadata-enrichment signal, not an
+        # independent agent signal — they never become their own inventory item.
+        # Instead, index them by (file_path, line) so their `extracted` payload can
+        # be merged onto a co-located framework/provider finding (DAI001-DAI007 at
+        # the same call site) below.
+        model_by_location: Dict[Tuple[str, int], Dict] = {}
+        for cf in code_findings:
+            if cf.get("rule_id") == "DAI008" and cf.get("extracted", {}).get("declared_model"):
+                model_by_location[(cf.get("file_path"), cf.get("line"))] = cf["extracted"]
+
+        # DAI009 (generation params) findings are likewise metadata-enrichment,
+        # never an independent agent signal. Unlike DAI008 (matched by exact
+        # file+line), generation params are commonly set on a *different* call
+        # than the one that anchors the primary framework finding (e.g. the
+        # LLM wrapper constructor `ChatOpenAI(temperature=0.7)` vs. the
+        # `initialize_agent(...)` call it's passed into) — so these are
+        # indexed by file only and merged (union across all DAI009 findings
+        # in that file) onto every primary finding in the same file below.
+        genparams_by_file: Dict[str, Dict[str, Dict]] = {}
+        wrapper_hint_by_file: Dict[str, str] = {}
+        for cf in code_findings:
+            if cf.get("rule_id") not in ("DAI008", "DAI009"):
+                continue
+            extracted = cf.get("extracted") or {}
+            file_path = cf.get("file_path")
+            if not file_path:
+                continue
+            if extracted.get("wrapper_hint"):
+                wrapper_hint_by_file[file_path] = extracted["wrapper_hint"]
+            if cf.get("rule_id") == "DAI009":
+                found = extracted.get("generation_params") or {}
+                genparams_by_file.setdefault(file_path, {}).update(found)
+
         # Process code findings (Layer 1)
         for cf in code_findings:
+            if cf.get("rule_id") in ("DAI008", "DAI009"):
+                continue  # metadata-only; merged into same-file findings above
+
             agent_id = f"{cf['file_path']}:{cf['line']}"
             framework = cls.extract_framework_from_rule(cf["rule_id"])
 
@@ -730,6 +833,31 @@ class CorrelationEngine:
 
             possible = cls._code_finding_providers(cf)
 
+            # declared_model tier (Layer 1, static): either this finding directly
+            # carries `extracted` (e.g. Bedrock model-ID string literal), or a
+            # co-located DAI008 finding at the same file+line does.
+            _model_extracted = cf.get("extracted") or model_by_location.get(
+                (cf.get("file_path"), cf.get("line"))
+            )
+            declared_model = (_model_extracted or {}).get("declared_model")
+            declared_model_source = (_model_extracted or {}).get("declared_model_source")
+
+            # Generation/sampling parameters (facts, informational flags are separate
+            # — see module docstring on AgentInventoryItem.generation_param_flags).
+            _file_path_key = cf.get("file_path")
+            _explicit_genparams = genparams_by_file.get(_file_path_key, {})
+            _wrapper_hint = wrapper_hint_by_file.get(_file_path_key)
+            generation_params = None
+            generation_param_flags: List[Dict[str, str]] = []
+            _wrapper_key = classify_wrapper_key(
+                cf.get("rule_id"), cf.get("message"), _wrapper_hint, declared_model
+            )
+            if has_any_signal(_wrapper_key, _explicit_genparams):
+                generation_params = resolve_generation_params(
+                    _wrapper_key, declared_model, _explicit_genparams
+                )
+                generation_param_flags = compute_threshold_flags(generation_params)
+
             # Layer 5 enrichment locals — filled by supplemental blocks below.
             model_id = None
             l5_framework = None
@@ -812,6 +940,8 @@ class CorrelationEngine:
             l2_entry_script: str | None = None
             l2_detected_host: str | None = None
             l2_framework_confidence: str | None = None
+            l2_runtime_env_model: str | None = None
+            l2_runtime_env_source: str | None = None
 
             if match_provider:
                 if match_provider in active_providers:
@@ -822,6 +952,8 @@ class CorrelationEngine:
                     l2_entry_script = info.get("entry_script")
                     l2_detected_host = info.get("detected_host")
                     l2_framework_confidence = info.get("framework_confidence")
+                    l2_runtime_env_model = info.get("runtime_env_model")
+                    l2_runtime_env_source = info.get("runtime_env_source")
                 network_provider = match_provider
             if matched_l3 is not None:
                 k8s_pod = matched_l3.get("pod")
@@ -910,6 +1042,12 @@ class CorrelationEngine:
                 detected_hosts=[l2_detected_host] if l2_detected_host else [],
                 framework_confidence=l2_framework_confidence,
                 evidence=_build_evidence_tags(detection_layers, l2_entry_script, l2_detected_host),
+                declared_model=declared_model,
+                declared_model_source=declared_model_source,
+                runtime_env_model=l2_runtime_env_model,
+                runtime_env_source=l2_runtime_env_source,
+                generation_params=generation_params,
+                generation_param_flags=generation_param_flags,
             )
             try:
                 _file_path = (cf.get("file_path") or "") or ""
@@ -943,6 +1081,8 @@ class CorrelationEngine:
             entry_script = info.get("entry_script")               # resolved script path
             detected_host = info.get("detected_host")             # DNS-correlated hostname
             l2_fw_confidence = info.get("framework_confidence")   # "high"/"medium"/None
+            l2_rt_env_model = info.get("runtime_env_model")       # runtime_env_model tier
+            l2_rt_env_source = info.get("runtime_env_source")
 
             if is_known_desktop_app(process_name, _known_apps):
                 # Known consumer AI tool (Cursor, Claude Desktop, etc.) → Shadow AI
@@ -985,6 +1125,8 @@ class CorrelationEngine:
                     detected_hosts=[detected_host] if detected_host else [],
                     framework_confidence=l2_fw_confidence,
                     evidence=_build_evidence_tags(["layer2"], entry_script, detected_host),
+                    runtime_env_model=l2_rt_env_model,
+                    runtime_env_source=l2_rt_env_source,
                 )
                 try:
                     _populate_saas_and_risk_flags(
@@ -1010,6 +1152,8 @@ class CorrelationEngine:
                     detection_layers=["layer2"],
                     detected_hosts=[detected_host] if detected_host else [],
                     evidence=_build_evidence_tags(["layer2"], None, detected_host),
+                    runtime_env_model=l2_rt_env_model,
+                    runtime_env_source=l2_rt_env_source,
                 )
                 try:
                     _populate_saas_and_risk_flags(