plugin-scanner 2.0.924__tar.gz → 2.0.926__tar.gz

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.924
+Version: 2.0.926
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.924"
+version = "2.0.926"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.924"
+version = "2.0.926"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/guard/aibom_trust_metadata.py

@@ -190,7 +190,8 @@ def _local_skill_security_for_artifact(
         key=lambda finding: (finding.get("file", ""), finding.get("ruleId", ""), finding.get("message", "")),
     )
     severity_counts = _cisco_severity_counts(run)
-    score = _cisco_layer_score(severity_counts) if status == "enabled" else None
+    analyzers_used = _cisco_analyzers_used(run)
+    score = _cisco_layer_score(severity_counts, analyzers_used=analyzers_used) if status == "enabled" else None
     safety = None
     if score is not None:
         safety = {
@@ -582,7 +583,8 @@ def _cisco_trust_layer(
     status = str(getattr(run, "status", "unknown"))
     message = str(getattr(run, "message", ""))
     severity_counts = _cisco_severity_counts(run)
-    trust_score = _cisco_layer_score(severity_counts) if status == "enabled" else None
+    analyzers_used = _cisco_analyzers_used(run)
+    trust_score = _cisco_layer_score(severity_counts, analyzers_used=analyzers_used) if status == "enabled" else None
     trust_components: list[dict[str, object]] = []
     if trust_score is not None:
         component_status = "positive"
@@ -590,14 +592,21 @@ def _cisco_trust_layer(
             component_status = "critical"
         elif trust_score < 70:
             component_status = "warning"
+        # Confidence scales with number of analyzers that ran:
+        # 1 analyzer = 90, 2 = 95, 3+ = 99
+        analyzer_confidence = min(90 + (len(analyzers_used) - 1) * 5, 99)
         trust_components.append(
             {
                 "componentId": component_id,
-                "confidence": 90,
+                "confidence": analyzer_confidence,
                 "label": label,
                 "score": trust_score,
                 "status": component_status,
-                "summary": message or f"{label} completed with {sum(severity_counts.values())} findings.",
+                "summary": message
+                or (
+                    f"{label} completed with {sum(severity_counts.values())} findings "
+                    f"using {len(analyzers_used)} analyzer(s)."
+                ),
                 "weight": 1.0,
             }
         )
@@ -666,14 +675,38 @@ def _cisco_severity_counts(run: object) -> dict[str, int]:
     return counts
 
 
-def _cisco_layer_score(severity_counts: dict[str, int]) -> int:
+def _cisco_analyzers_used(run: object) -> tuple[str, ...]:
+    """Extract analyzer names from a Cisco inventory run."""
+    metadata = getattr(run, "metadata", None)
+    if isinstance(metadata, dict):
+        raw = metadata.get("analyzersUsed")
+        if isinstance(raw, (list, tuple)):
+            return tuple(str(a) for a in raw if a)
+    return ("yara",)
+
+
+def _cisco_layer_score(
+    severity_counts: dict[str, int],
+    *,
+    analyzers_used: tuple[str, ...] = ("yara",),
+) -> int:
     raw_score = 100 - (
         30 * severity_counts["critical"]
         + 12 * severity_counts["high"]
         + 4 * severity_counts["medium"]
         + severity_counts["low"]
     )
-    return max(0, min(100, raw_score))
+    # Ceiling: more analyzers = higher max achievable score.
+    # 1 analyzer: max 90, 2: max 95, 3+: max 100.
+    # Clean YARA-only can't reach 100; clean multi-analyzer can.
+    analyzer_count = len(analyzers_used)
+    if analyzer_count >= 3:
+        ceiling = 100
+    elif analyzer_count == 2:
+        ceiling = 95
+    else:
+        ceiling = 90
+    return max(0, min(ceiling, raw_score))
 
 
 def _trust_components_from_domain(domain: TrustDomainScore) -> list[dict[str, object]]:

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/guard/daemon/hook_worker.py

@@ -105,7 +105,7 @@ class HookWorker:
             workspace=workspace,
         )
         response = self.engine.review(request)
-        return response.to_harness_json()
+        return _harness_json_from_review_response(harness, event_name, response)
 
     def _runtime_harness(self, params: Mapping[str, list[str]]) -> str | None:
         values = params.get("runtime-harness", [])
@@ -237,4 +237,73 @@ class HookWorker:
     # caching and exact-match verification.
 
 
-__all__ = ["HookWorker", "HookWorkerUnsupported"]
+def _canonical_hook_harness(harness: str) -> str:
+    return harness.strip().lower().replace("_", "-")
+
+
+def post_tool_native_block_response(
+    *,
+    reason: str = "HOL Guard blocked this tool output because it could not be proven safe.",
+    reason_code: str = "fast_path_block",
+) -> dict[str, object]:
+    return {
+        "decision": "block",
+        "reason": reason,
+        "continue": False,
+        "stopReason": reason,
+        "policy_action": "block",
+        "risk_summary": reason,
+        "model_output_action": "block",
+        "notice": "warning",
+        "reason_code": reason_code,
+    }
+
+
+def post_tool_fail_safe_response(
+    harness: str,
+    *,
+    reason: str = "HOL Guard could not complete local hook review safely.",
+    reason_code: str = "daemon_worker_exception",
+) -> dict[str, object]:
+    if _canonical_hook_harness(harness) == "pi":
+        return {
+            "decision": "deny",
+            "reason": reason,
+            "model_output_action": "block",
+            "notice": "warning",
+            "reason_code": reason_code,
+        }
+    return post_tool_native_block_response(reason=reason, reason_code=reason_code)
+
+
+def _harness_json_from_review_response(
+    harness: str,
+    event_name: str,
+    response: object,
+) -> dict[str, object]:
+    to_harness_json = getattr(response, "to_harness_json", None)
+    payload = to_harness_json() if callable(to_harness_json) else {}
+    if not isinstance(payload, dict):
+        payload = {}
+    if event_name != "PostToolUse":
+        return payload
+    if _canonical_hook_harness(harness) == "pi":
+        return payload
+    decision = str(payload.get("decision") or "")
+    model_output_action = str(payload.get("model_output_action") or "")
+    if decision == "allow" and model_output_action == "allow_original":
+        return {
+            "policy_action": "allow",
+            "hookSpecificOutput": {"hookEventName": event_name},
+        }
+    reason = str(payload.get("reason") or "HOL Guard blocked this tool output because it could not be proven safe.")
+    reason_code = str(payload.get("reason_code") or "fast_path_block")
+    return post_tool_native_block_response(reason=reason, reason_code=reason_code)
+
+
+__all__ = [
+    "HookWorker",
+    "HookWorkerUnsupported",
+    "post_tool_fail_safe_response",
+    "post_tool_native_block_response",
+]

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -4032,7 +4032,7 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         fall back, because the request may have omitted full output and
         supplied only ``guard_source_ref``.
         """
-        from .hook_worker import HookWorkerUnsupported
+        from .hook_worker import HookWorkerUnsupported, post_tool_fail_safe_response
 
         if home_dir is None or guard_home is None:
             return None
@@ -4055,13 +4055,17 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         except Exception:
             # Fail safe: deny/block. Do not fall back to legacy CLI for
             # requests that omitted full output and supplied only guard_source_ref.
-            return {
-                "decision": "deny",
-                "reason": "HOL Guard could not complete local hook review safely.",
-                "model_output_action": "block",
-                "notice": "warning",
-                "reason_code": "daemon_worker_exception",
-            }
+            rt_values = params.get("runtime-harness", [])
+            actual_harness = (
+                rt_values[-1].strip()
+                if rt_values and isinstance(rt_values[-1], str) and rt_values[-1].strip()
+                else default_harness
+            )
+            return post_tool_fail_safe_response(
+                actual_harness,
+                reason="HOL Guard could not complete local hook review safely.",
+                reason_code="daemon_worker_exception",
+            )
 
     def _handle_runtime_hook_legacy_cli(
         self,

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/guard/runtime/secret_file_requests.py

@@ -134,6 +134,16 @@ _DOCKER_GLOBAL_SENSITIVE_CONTEXT_OPTIONS = frozenset(
 )
 # Docker global flag options (no value) that signal a non-default/TLS control plane.
 _DOCKER_GLOBAL_SENSITIVE_CONTEXT_FLAGS = frozenset({"--tls", "--tlsverify"})
+_DOCKER_SENSITIVE_CONTEXT_ENV_KEYS = frozenset(
+    {
+        "COMPOSE_ENV_FILES",
+        "DOCKER_CERT_PATH",
+        "DOCKER_CONFIG",
+        "DOCKER_CONTEXT",
+        "DOCKER_HOST",
+        "DOCKER_TLS_VERIFY",
+    }
+)
 _DOCKER_COMPOSE_SUBCOMMAND = "compose"
 _DOCKER_COMPOSE_OPTIONS_WITH_VALUES = frozenset(
     {
@@ -911,6 +921,23 @@ def extract_sensitive_tool_action_request(
                     wrapper_chain=wrapper_chain,
                 )
             return docker_sensitive_request
+        if raw_command_text != command_text:
+            docker_sensitive_request = _docker_sensitive_tool_action_request(
+                tool_name=requested_tool_name,
+                normalized_tool_name=effective_tool_name,
+                command_text=raw_command_text,
+            )
+            if docker_sensitive_request is not None:
+                if wrapper_chain:
+                    docker_sensitive_request = _request_with_wrapper_context(
+                        replace(
+                            docker_sensitive_request,
+                            command_text=normalized_command_text,
+                        ),
+                        raw_command_text=raw_command_text,
+                        wrapper_chain=wrapper_chain,
+                    )
+                return docker_sensitive_request
         docker_config_request = _docker_config_tool_action_request(
             tool_name=requested_tool_name,
             normalized_tool_name=effective_tool_name,
@@ -1033,7 +1060,8 @@ def _docker_sensitive_tool_action_request(
             "container workflows. Docker Compose actions are sensitive when they use "
             "subcommands that execute arbitrary commands or copy files (run, exec, cp, push, "
             "publish, watch), supply secret-bearing input (--env-file), target a non-default "
-            "Docker host or context, or carry TLS/credential material."
+            "Docker host or context, or carry TLS/credential material through flags or "
+            "environment variables."
         ),
     )
 
@@ -3953,17 +3981,59 @@ def _normalize_tool_name(tool_name: object) -> str | None:
     return tool_name.strip().lower()
 
 
-def _docker_sensitive_reason(command_text: str) -> str | None:
+def _docker_sensitive_reason(command_text: str, *, _inherited_sensitive_env: bool = False) -> str | None:
     parts = _split_shell_parts(command_text.strip())
+    exported_env_context: dict[str, bool] = {}
     for segment in _iter_shell_command_segments(parts):
+        if segment and _normalized_shell_command_name(segment[0]) == "env":
+            env_tokens = segment[1:]
+            env_sensitive = _inherited_sensitive_env or _docker_env_context_is_sensitive(env_tokens)
+            remaining_tokens: list[str] = []
+            split_found = False
+            for i, tok in enumerate(env_tokens):
+                split_payload = _docker_env_split_string_payload(
+                    tok,
+                    env_tokens[i + 1] if i + 1 < len(env_tokens) else None,
+                )
+                if split_payload is not None:
+                    split_found = True
+                    nested_reason = _docker_sensitive_reason(split_payload)
+                    if nested_reason is not None:
+                        return nested_reason
+                    if _docker_env_context_is_sensitive(_split_shell_parts(split_payload)):
+                        env_sensitive = True
+                    consumed = 1 if tok in {"--split-string", "-S"} else 0
+                    remaining_tokens = env_tokens[i + consumed + 1 :]
+                    break
+            if not split_found:
+                remaining_tokens = [
+                    tok for tok in env_tokens if not tok.startswith("-") and not _SHELL_ASSIGNMENT_PATTERN.match(tok)
+                ]
+            remaining_cmd = " ".join(remaining_tokens)
+            if remaining_cmd:
+                remaining_reason = _docker_sensitive_reason(remaining_cmd, _inherited_sensitive_env=env_sensitive)
+                if remaining_reason is not None:
+                    return remaining_reason
+            continue
         command_name, command_index = _shell_segment_primary_command(segment)
+        if command_name == "export" and command_index is not None:
+            exported_env_context.update(_docker_exported_env_context_sensitivity(segment[:command_index]))
+            exported_env_context.update(_docker_exported_env_context_sensitivity(segment[command_index + 1 :]))
+            continue
         if command_name != "docker" or command_index is None:
             continue
+        sensitive_env_context = (
+            _inherited_sensitive_env
+            or any(exported_env_context.values())
+            or _docker_env_context_is_sensitive(segment[:command_index])
+        )
         global_tokens = segment[command_index + 1 :]
         subcommand_index = _docker_subcommand_index(global_tokens)
         if subcommand_index is None:
             continue
-        sensitive_context = _docker_global_context_is_sensitive(global_tokens[:subcommand_index])
+        sensitive_context = sensitive_env_context or _docker_global_context_is_sensitive(
+            global_tokens[:subcommand_index]
+        )
         args = global_tokens[subcommand_index:]
         subcommand = args[0].lower()
         if subcommand in _DOCKER_ALWAYS_SENSITIVE_SUBCOMMANDS:
@@ -4074,6 +4144,74 @@ def _docker_global_context_value_is_sensitive(flag: str, value: str) -> bool:
     return True
 
 
+def _docker_env_context_is_sensitive(prefix_tokens: list[str]) -> bool:
+    index = 0
+    while index < len(prefix_tokens):
+        token = prefix_tokens[index]
+        assignment = _docker_env_assignment(token)
+        if assignment is not None:
+            key, value = assignment
+            if _docker_env_context_value_is_sensitive(key, value):
+                return True
+        split_payload = _docker_env_split_string_payload(
+            token,
+            prefix_tokens[index + 1] if index + 1 < len(prefix_tokens) else None,
+        )
+        if split_payload is not None and _docker_env_context_is_sensitive(_split_shell_parts(split_payload)):
+            return True
+        index += 1
+    return False
+
+
+def _docker_exported_env_context_sensitivity(args: list[str]) -> dict[str, bool]:
+    exported: dict[str, bool] = {}
+    for token in args:
+        if token.startswith("-"):
+            continue
+        assignment = _docker_env_assignment(token)
+        if assignment is None:
+            continue
+        key, value = assignment
+        exported[key] = _docker_env_context_value_is_sensitive(key, value)
+    return exported
+
+
+def _docker_env_assignment(token: str) -> tuple[str, str] | None:
+    normalized = _shell_command_token_without_attached_redirection(token).strip()
+    if not _SHELL_ASSIGNMENT_PATTERN.match(normalized):
+        return None
+    key, _, value = normalized.partition("=")
+    key = key.rstrip("+").upper()
+    if key not in _DOCKER_SENSITIVE_CONTEXT_ENV_KEYS:
+        return None
+    return key, value.strip().strip("\"'")
+
+
+def _docker_env_split_string_payload(token: str, next_token: str | None) -> str | None:
+    if token in {"--split-string", "-S"}:
+        return next_token or ""
+    if token.startswith("--split-string="):
+        return token.split("=", 1)[1]
+    if token.startswith("-S"):
+        return token[2:] or (next_token or "")
+    clustered_payload = _env_clustered_split_string_payload(token)
+    if clustered_payload is None:
+        return None
+    return clustered_payload or (next_token or "")
+
+
+def _docker_env_context_value_is_sensitive(key: str, value: str) -> bool:
+    normalized_value = value.strip().strip("\"'")
+    if key == "DOCKER_CONTEXT":
+        return normalized_value.lower() not in {"", "default"}
+    if key == "DOCKER_HOST":
+        lowered = normalized_value.lower()
+        return bool(normalized_value) and not lowered.startswith(("unix://", "npipe://"))
+    if key == "DOCKER_TLS_VERIFY":
+        return normalized_value.lower() not in {"", "0", "false", "no"}
+    return bool(normalized_value)
+
+
 def _docker_compose_sensitive_reason(args: list[str], *, sensitive_context: bool) -> str | None:
     if sensitive_context:
         return "compose-sensitive-context"

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/guard/store_policy.py

@@ -320,6 +320,27 @@ class StorePolicyMixin:
                             requested_runtime_exact_match_key=runtime_exact_match_key,
                         ):
                             continue
+                        integrity_result = self._policy_integrity_result_for_row(
+                            candidate,
+                            mode=str((cached_state or {}).get("mode") or "degraded"),
+                            key=None,
+                            key_id=None,
+                            trusted_generation=_mapping_int(cached_state, "generation"),
+                        )
+                        if integrity_result.status != "valid":
+                            events.append(
+                                (
+                                    "policy_integrity_violation",
+                                    {
+                                        "decision_id": int(candidate["decision_id"]),
+                                        "harness": str(candidate["harness"]),
+                                        "artifact_id": candidate["artifact_id"],
+                                        "integrity_status": integrity_result.status,
+                                        "message": integrity_result.message,
+                                    },
+                                )
+                            )
+                            continue
                         selected_payload = self._policy_row_payload(candidate)
                         if is_remote_policy_source(str(candidate["source"])):
                             events.append(
@@ -342,7 +363,13 @@ class StorePolicyMixin:
                             )
                         break
                 for event_name, payload in events:
-                    self.add_event(event_name, payload, current_time)
+                    connection.execute(
+                        """
+                        insert into guard_events (event_name, payload_json, occurred_at)
+                        values (?, ?, ?)
+                        """,
+                        (event_name, json.dumps(payload), current_time),
+                    )
                 return {
                     "decision": selected_payload,
                     "ignored_local_integrity": None,
@@ -445,13 +472,19 @@ class StorePolicyMixin:
                     candidate["decision_id"],
                     integrity_result.status,
                 )
-        for event_name, payload in events:
-            self.add_event(event_name, payload, current_time)
-        return {
-            "decision": selected_payload,
-            "ignored_local_integrity": ignored_local_integrity,
-            "trust_status": trust_status,
-        }
+            for event_name, payload in events:
+                connection.execute(
+                    """
+                    insert into guard_events (event_name, payload_json, occurred_at)
+                    values (?, ?, ?)
+                    """,
+                    (event_name, json.dumps(payload), current_time),
+                )
+            return {
+                "decision": selected_payload,
+                "ignored_local_integrity": ignored_local_integrity,
+                "trust_status": trust_status,
+            }
 
     def resolve_policy_decision(
         self,

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/integrations/cisco_mcp_scanner.py

@@ -100,10 +100,27 @@ def _build_summary(
 
 def _load_mcp_scanner_components(*, blocked_root: Path | None = None) -> dict[str, _CiscoAnalyzerFactory]:
     module = _load_distribution_module("cisco-ai-mcp-scanner", "mcpscanner", blocked_root=blocked_root)
-    analyzer = getattr(module, "YaraAnalyzer", None)
-    if not _is_analyzer_factory(analyzer):
-        raise ImportError("cisco-ai-mcp-scanner does not expose mcpscanner.YaraAnalyzer")
-    return {"YaraAnalyzer": analyzer}
+    components: dict[str, _CiscoAnalyzerFactory] = {}
+
+    yara_analyzer = getattr(module, "YaraAnalyzer", None)
+    if _is_analyzer_factory(yara_analyzer):
+        components["YaraAnalyzer"] = yara_analyzer
+
+    # LLM analyzer: available when MCP_SCANNER_LLM_API_KEY is set
+    if os.environ.get("MCP_SCANNER_LLM_API_KEY"):
+        llm_analyzer = getattr(module, "LLMAnalyzer", None)
+        if _is_analyzer_factory(llm_analyzer):
+            components["LLMAnalyzer"] = llm_analyzer
+
+    # Cisco AI Defense API analyzer: available when MCP_SCANNER_API_KEY is set
+    if os.environ.get("MCP_SCANNER_API_KEY"):
+        api_analyzer = getattr(module, "APIAnalyzer", None)
+        if _is_analyzer_factory(api_analyzer):
+            components["APIAnalyzer"] = api_analyzer
+
+    if not components:
+        raise ImportError("cisco-ai-mcp-scanner does not expose any analyzer factories")
+    return components
 
 
 def _load_distribution_module(
@@ -380,6 +397,46 @@ async def _scan_targets(
     return tuple(findings), targets_scanned
 
 
+async def _scan_targets_multi(
+    plugin_dir: Path,
+    targets: tuple[_StaticScanTarget, ...],
+    analyzers: tuple[tuple[str, _CiscoAnalyzer], ...],
+) -> tuple[tuple[Finding, ...], int, tuple[str, ...], dict[str, str]]:
+    findings: list[Finding] = []
+    targets_scanned = 0
+    successful_analyzers: set[str] = set()
+    analyzer_errors: dict[str, str] = {}
+    for target in targets:
+        try:
+            content = target.read_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        targets_scanned += 1
+        for analyzer_name, analyzer in analyzers:
+            try:
+                external_findings = await analyzer.analyze(
+                    content,
+                    {
+                        "tool_name": target.tool_name,
+                        "content_type": target.content_type,
+                        "file_path": str(target.read_path),
+                    },
+                )
+            except Exception as exc:
+                if analyzer_name not in analyzer_errors:
+                    analyzer_errors[analyzer_name] = str(exc)
+                continue
+            successful_analyzers.add(analyzer_name)
+            for finding in external_findings:
+                normalized = _normalize_finding(plugin_dir, target.read_path, finding)
+                findings.append(normalized)
+    # Preserve configured order for deterministic output
+    ordered_successful = tuple(name for name, _ in analyzers if name in successful_analyzers)
+    # Only report errors for analyzers that never succeeded
+    failed_only = {n: e for n, e in analyzer_errors.items() if n not in successful_analyzers}
+    return tuple(findings), targets_scanned, ordered_successful, failed_only
+
+
 def run_cisco_mcp_scan(
     plugin_dir: Path,
     mode: str = "auto",
@@ -431,13 +488,15 @@ def run_cisco_mcp_scan(
         )
 
     try:
-        analyzer_class = components["YaraAnalyzer"]
-        analyzer = analyzer_class()
+        analyzers: list[tuple[str, _CiscoAnalyzer]] = []
+        for name, factory in components.items():
+            analyzer_name = name.replace("Analyzer", "").lower()
+            analyzers.append((analyzer_name, factory()))
         targets = _collect_static_targets(plugin_dir)
-        scan_awaitable: Awaitable[tuple[tuple[Finding, ...], int]] = _scan_targets(plugin_dir, targets, analyzer)
+        scan_awaitable = _scan_targets_multi(plugin_dir, targets, tuple(analyzers))
         if timeout_seconds is not None:
             scan_awaitable = asyncio.wait_for(scan_awaitable, timeout=timeout_seconds)
-        findings, targets_scanned = _run_awaitable(scan_awaitable)
+        findings, targets_scanned, successful_analyzers, analyzer_errors = _run_awaitable(scan_awaitable)
     except (TimeoutError, asyncio.TimeoutError):
         return _build_summary(
             status=CiscoIntegrationStatus.TIMED_OUT,
@@ -449,17 +508,39 @@ def run_cisco_mcp_scan(
             message=f"Cisco MCP scanner failed: {exc}",
         )
 
+    # When all configured analyzers failed, report as failed
+    if not successful_analyzers and analyzer_errors:
+        error_details = "; ".join(f"{n}: {e}" for n, e in analyzer_errors.items())
+        return _build_summary(
+            status=CiscoIntegrationStatus.FAILED,
+            message=f"All configured analyzers failed: {error_details}",
+        )
+    # When no targets were scanned, no analyzer actually ran
+    if targets_scanned == 0:
+        return _build_summary(
+            status=CiscoIntegrationStatus.SKIPPED,
+            message="No scannable MCP targets found; scan skipped.",
+        )
+    # Only report analyzers that actually ran successfully
+    analyzer_names = successful_analyzers if successful_analyzers else tuple(name for name, _ in analyzers)
+    error_suffix = (
+        f" (skipped: {', '.join(f'{n} ({e})' for n, e in analyzer_errors.items())})" if analyzer_errors else ""
+    )
     if findings:
         message = (
             f"Cisco MCP scanner completed static analysis for {targets_scanned} target(s) "
-            f"and reported {len(findings)} finding(s)."
+            f"using {', '.join(analyzer_names)} analyzer(s) "
+            f"and reported {len(findings)} finding(s).{error_suffix}"
         )
     else:
-        message = f"Cisco MCP scanner completed static analysis for {targets_scanned} target(s) with no findings."
+        message = (
+            f"Cisco MCP scanner completed static analysis for {targets_scanned} target(s) "
+            f"using {', '.join(analyzer_names)} analyzer(s) with no findings.{error_suffix}"
+        )
     return _build_summary(
         status=CiscoIntegrationStatus.ENABLED,
         message=message,
         findings=findings,
         targets_scanned=targets_scanned,
-        analyzers_used=("yara",),
+        analyzers_used=analyzer_names,
     )

{plugin_scanner-2.0.924 → plugin_scanner-2.0.926}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.0.924"
+__version__ = "2.0.926"