iris-security-sdk 0.2.12__tar.gz → 0.2.16__tar.gz

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-security-sdk
-Version: 0.2.12
+Version: 0.2.16
 Summary: IRIS — AI Agent Governance SDK. Govern AI agents locally.
 Author-email: Gilbert Martin <gilbert@iris-security.io>
 License: Apache-2.0

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/iris/__init__.py

@@ -47,7 +47,11 @@ from iris_core.evidence.vault import EvidenceVault
 from iris_core.cost.tracker import CostSummary, CostTracker, CostEntry
 from iris_core.cost.pricing import PricingRegistry
 
-__version__ = "0.2.12"
+__version__ = "0.2.16"
+
+AARM_CONFORMANCE = "Core"  # R1-R6 satisfied
+AARM_VERSION = "1.0"
+AIUC1_ALIGNMENT = "Q1-2026"
 __all__ = [
     # Main classes
     "IrisAgent",
@@ -74,6 +78,10 @@ __all__ = [
     "CostSummary",
     "CostEntry",
     "PricingRegistry",
+    "AARM_CONFORMANCE",
+    "AARM_VERSION",
+    "AIUC1_ALIGNMENT",
+    "__version__",
     "IrisViolationError",
     "IrisCrisisDetectedError",
     "IrisHITLRequiredError",

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/iris/_telemetry.py

@@ -1,10 +1,12 @@
 """First-run telemetry for IRIS SDK installs. Opt-out via IRIS_TELEMETRY_OPT_OUT=1.
 
 Each event includes an ISO 8601 UTC timestamp for server-side DoD/WoW/MoM aggregation.
+Daily CLI usage is aggregated locally and sent once per UTC day (previous day's totals).
 """
 
 from __future__ import annotations
 
+import json
 import os
 import shutil
 import sys
@@ -13,6 +15,7 @@ import uuid
 from datetime import datetime, timezone
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
+from typing import Any
 
 from iris._telemetry_config import TELEMETRY_ENABLED, TELEMETRY_ENDPOINT
 
@@ -20,6 +23,8 @@ _IRIS_DIR = Path.home() / ".iris"
 _INSTALL_ID_FILE = _IRIS_DIR / "install_id"
 _FIRST_RUN_SENTINEL = _IRIS_DIR / ".telemetry_sent"
 _FIRST_POLICY_SENTINEL = _IRIS_DIR / ".first_policy_sent"
+_RUN_STATS_FILE = _IRIS_DIR / "run_stats.json"
+_SKIPPED_COMMANDS = frozenset({"ping"})
 
 
 def detect_country() -> str:
@@ -127,6 +132,10 @@ def _get_iris_version() -> str:
         return "unknown"
 
 
+def _utc_today() -> str:
+    return datetime.now(timezone.utc).date().isoformat()
+
+
 def _build_payload(event: str) -> dict[str, str]:
     return {
         "event": event,
@@ -142,15 +151,56 @@ def _build_payload(event: str) -> dict[str, str]:
     }
 
 
-def _send_event(event: str) -> None:
+def _build_daily_payload(stats: dict[str, Any]) -> dict[str, str]:
+    payload = _build_payload("daily_usage")
+    payload["usage_date"] = str(stats["date"])
+    payload["run_count"] = str(stats["run_count"])
+    payload["commands"] = json.dumps(stats.get("commands", {}), sort_keys=True)
+    return payload
+
+
+def _empty_day_stats(day: str) -> dict[str, Any]:
+    return {"date": day, "run_count": 0, "commands": {}}
+
+
+def _load_run_stats() -> dict[str, Any]:
+    if not _RUN_STATS_FILE.exists():
+        return _empty_day_stats(_utc_today())
+    try:
+        data = json.loads(_RUN_STATS_FILE.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return _empty_day_stats(_utc_today())
+        data.setdefault("commands", {})
+        return data
+    except (OSError, json.JSONDecodeError):
+        return _empty_day_stats(_utc_today())
+
+
+def _save_run_stats(stats: dict[str, Any]) -> None:
+    _RUN_STATS_FILE.write_text(json.dumps(stats, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def _send_payload(payload: dict[str, str]) -> None:
     try:
         import httpx
 
-        httpx.post(TELEMETRY_ENDPOINT, json=_build_payload(event), timeout=2.0)
+        httpx.post(TELEMETRY_ENDPOINT, json=payload, timeout=2.0)
     except Exception:
         pass
 
 
+def _send_event(event: str) -> None:
+    _send_payload(_build_payload(event))
+
+
+def _flush_daily_usage(stats: dict[str, Any]) -> None:
+    if int(stats.get("run_count", 0)) <= 0:
+        return
+    payload = _build_daily_payload(stats)
+    thread = threading.Thread(target=_send_payload, args=(payload,), daemon=True)
+    thread.start()
+
+
 def _maybe_fire_once(event: str, sentinel: Path) -> None:
     if not telemetry_enabled():
         return
@@ -178,6 +228,34 @@ def maybe_fire_first_policy_run() -> None:
     _maybe_fire_once("first_policy_run", _FIRST_POLICY_SENTINEL)
 
 
+def maybe_record_cli_usage(command: str) -> None:
+    """Increment local run counters; send one daily_usage event per UTC day on rollover."""
+    if not telemetry_enabled() or not command or command in _SKIPPED_COMMANDS:
+        return
+
+    today = _utc_today()
+    try:
+        _IRIS_DIR.mkdir(parents=True, exist_ok=True)
+        stats = _load_run_stats()
+    except OSError:
+        return
+
+    stored_date = stats.get("date")
+    if stored_date != today:
+        if stored_date and int(stats.get("run_count", 0)) > 0:
+            _flush_daily_usage(stats)
+        stats = _empty_day_stats(today)
+
+    commands = stats.setdefault("commands", {})
+    commands[command] = int(commands.get(command, 0)) + 1
+    stats["run_count"] = int(stats.get("run_count", 0)) + 1
+
+    try:
+        _save_run_stats(stats)
+    except OSError:
+        pass
+
+
 def send_ping() -> None:
     """Fire a test telemetry ping event (internal verification)."""
     if not telemetry_enabled():

iris_security_sdk-0.2.16/iris/scan.py

@@ -0,0 +1,227 @@
+"""Offline workload detection for compliance intelligence scans."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+_PROVIDER_IMPORTS = {
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "google": "google",
+    "generativeai": "google",
+    "vertexai": "google",
+    "azure": "azure",
+    "bedrock": "aws",
+    "boto3": "aws",
+    "cohere": "cohere",
+    "mistralai": "mistral",
+}
+
+_FRAMEWORK_IMPORTS = {
+    "langchain": "langchain",
+    "crewai": "crewai",
+    "llama_index": "llama_index",
+    "semantic_kernel": "semantic_kernel",
+    "autogen": "autogen",
+    "haystack": "haystack",
+}
+
+_MODEL_PATTERNS = [
+    re.compile(r"gpt-4[a-z0-9.-]*", re.I),
+    re.compile(r"gpt-3\.5[a-z0-9.-]*", re.I),
+    re.compile(r"claude-[a-z0-9.-]+", re.I),
+    re.compile(r"gemini-[a-z0-9.-]+", re.I),
+    re.compile(r"text-embedding-[a-z0-9.-]+", re.I),
+]
+
+_MODEL_PROVIDER_PREFIXES: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^gpt-", re.I), "openai"),
+    (re.compile(r"^o[134]-", re.I), "openai"),
+    (re.compile(r"^text-embedding-", re.I), "openai"),
+    (re.compile(r"^claude-", re.I), "anthropic"),
+    (re.compile(r"^gemini-", re.I), "google"),
+    (re.compile(r"^gemini/", re.I), "google"),
+    (re.compile(r"^text-bison", re.I), "google"),
+    (re.compile(r"^command", re.I), "cohere"),
+    (re.compile(r"^mistral", re.I), "mistral"),
+    (re.compile(r"^llama", re.I), "meta"),
+    (re.compile(r"^amazon\.", re.I), "aws"),
+    (re.compile(r"^anthropic\.", re.I), "anthropic"),
+    (re.compile(r"^azure/", re.I), "azure"),
+    (re.compile(r"^vertex_ai/", re.I), "google"),
+    (re.compile(r"^openai/", re.I), "openai"),
+    (re.compile(r"^bedrock/", re.I), "aws"),
+]
+
+_DATA_CATEGORY_PATTERNS = {
+    "pii": re.compile(
+        r"\b(ssn|social_security|date_of_birth|dob|passport|email_address|phone_number|"
+        r"first_name|last_name|address_line|national_id)\b",
+        re.I,
+    ),
+    "phi": re.compile(
+        r"\b(patient_id|medical_record|diagnosis|icd_?10|hipaa|health_record|"
+        r"prescription|mrn|protected_health)\b",
+        re.I,
+    ),
+    "financial": re.compile(
+        r"\b(credit_card|card_number|bank_account|routing_number|iban|pci|"
+        r"account_balance|transaction_amount)\b",
+        re.I,
+    ),
+    "biometric": re.compile(
+        r"\b(fingerprint|face_id|retina_scan|voice_print|biometric)\b",
+        re.I,
+    ),
+}
+
+_REQUIREMENTS_FILES = (
+    "requirements.txt",
+    "requirements-dev.txt",
+    "pyproject.toml",
+    "Pipfile",
+    "setup.py",
+)
+
+
+def _iter_source_files(root: Path) -> list[Path]:
+    files: list[Path] = []
+    skip = {".git", ".venv", "venv", "node_modules", "__pycache__", ".iris", "dist", "build"}
+    for path in root.rglob("*"):
+        if any(part in skip for part in path.parts):
+            continue
+        if path.suffix in {".py", ".pyi", ".ts", ".tsx", ".js", ".jsx", ".json", ".yaml", ".yml"}:
+            if path.stat().st_size > 512_000:
+                continue
+            files.append(path)
+    return files
+
+
+def _scan_imports(text: str) -> tuple[set[str], set[str]]:
+    providers: set[str] = set()
+    frameworks: set[str] = set()
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("import ") or stripped.startswith("from "):
+            lowered = stripped.lower()
+            for needle, provider in _PROVIDER_IMPORTS.items():
+                if needle in lowered:
+                    providers.add(provider)
+            for needle, fw in _FRAMEWORK_IMPORTS.items():
+                if needle in lowered:
+                    frameworks.add(fw)
+    return providers, frameworks
+
+
+def _scan_models(text: str) -> set[str]:
+    models: set[str] = set()
+    for pattern in _MODEL_PATTERNS:
+        for match in pattern.findall(text):
+            models.add(match.lower())
+    return models
+
+
+def _scan_data_categories(text: str) -> set[str]:
+    categories: set[str] = set()
+    for category, pattern in _DATA_CATEGORY_PATTERNS.items():
+        if pattern.search(text):
+            categories.add(category)
+    return categories
+
+
+def infer_provider_from_model(model: str) -> str | None:
+    """Infer provider slug from a model identifier (shared by observability adapters)."""
+    if not model:
+        return None
+    normalized = model.strip()
+    for pattern, provider in _MODEL_PROVIDER_PREFIXES:
+        if pattern.search(normalized):
+            return provider
+    return None
+
+
+def infer_providers_from_models(models: list[str]) -> list[str]:
+    """Return sorted unique providers inferred from model names."""
+    providers: set[str] = set()
+    for model in models:
+        provider = infer_provider_from_model(model)
+        if provider:
+            providers.add(provider)
+    return sorted(providers)
+
+
+def scan_data_categories_from_text(text: str) -> list[str]:
+    """Scan arbitrary metadata/tags text for sensitive data category hints."""
+    return sorted(_scan_data_categories(text))
+
+
+def _scan_requirements(root: Path) -> tuple[set[str], set[str]]:
+    providers: set[str] = set()
+    frameworks: set[str] = set()
+    for name in _REQUIREMENTS_FILES:
+        req_path = root / name
+        if not req_path.exists():
+            continue
+        text = req_path.read_text(encoding="utf-8", errors="ignore").lower()
+        for needle, provider in _PROVIDER_IMPORTS.items():
+            if needle in text:
+                providers.add(provider)
+        for needle, fw in _FRAMEWORK_IMPORTS.items():
+            if needle in text:
+                frameworks.add(fw)
+    return providers, frameworks
+
+
+def detect_workload(path: str = ".") -> dict[str, Any]:
+    """Static offline detection of workload profile attributes."""
+    root = Path(path).resolve()
+    providers: set[str] = set()
+    frameworks: set[str] = set()
+    models: set[str] = set()
+    data_categories: set[str] = set()
+
+    req_providers, req_frameworks = _scan_requirements(root)
+    providers |= req_providers
+    frameworks |= req_frameworks
+
+    for file_path in _iter_source_files(root):
+        try:
+            text = file_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        p, f = _scan_imports(text)
+        providers |= p
+        frameworks |= f
+        models |= _scan_models(text)
+        data_categories |= _scan_data_categories(text)
+
+    agent_hints = sum(1 for _ in root.rglob("passport.yaml"))
+    autonomy = "assistive"
+    if agent_hints >= 3:
+        autonomy = "supervised"
+    if agent_hints >= 6:
+        autonomy = "autonomous"
+
+    return {
+        "source": "sdk_scan",
+        "models": sorted(models),
+        "providers": sorted(providers),
+        "frameworks": sorted(frameworks),
+        "data_categories": sorted(data_categories),
+        "deployment_regions": ["us"],
+        "agent_count": max(agent_hints, 1 if models or providers else 0),
+        "autonomy_level": autonomy,
+        "customer_facing": any(
+            part in {"pages", "app", "frontend", "ui", "web"} for part in root.parts
+        ),
+    }
+
+
+def profile_payload_hash(profile: dict[str, Any]) -> str:
+    import hashlib
+
+    canonical = json.dumps(profile, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()

iris_security_sdk-0.2.16/iris_sdk/__init__.py

@@ -0,0 +1 @@
+"""iris_sdk namespace package for scan helpers."""

iris_security_sdk-0.2.16/iris_sdk/scan.py

@@ -0,0 +1,17 @@
+"""Re-export scan helpers for iris_sdk import path."""
+
+from iris.scan import (
+    detect_workload,
+    infer_provider_from_model,
+    infer_providers_from_models,
+    profile_payload_hash,
+    scan_data_categories_from_text,
+)
+
+__all__ = [
+    "detect_workload",
+    "infer_provider_from_model",
+    "infer_providers_from_models",
+    "profile_payload_hash",
+    "scan_data_categories_from_text",
+]

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/iris_security_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-security-sdk
-Version: 0.2.12
+Version: 0.2.16
 Summary: IRIS — AI Agent Governance SDK. Govern AI agents locally.
 Author-email: Gilbert Martin <gilbert@iris-security.io>
 License: Apache-2.0

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/iris_security_sdk.egg-info/SOURCES.txt

@@ -4,9 +4,13 @@ iris/__init__.py
 iris/_telemetry.py
 iris/_telemetry_config.py
 iris/hitl.py
+iris/scan.py
+iris_sdk/__init__.py
+iris_sdk/scan.py
 iris_security_sdk.egg-info/PKG-INFO
 iris_security_sdk.egg-info/SOURCES.txt
 iris_security_sdk.egg-info/dependency_links.txt
 iris_security_sdk.egg-info/requires.txt
 iris_security_sdk.egg-info/top_level.txt
+tests/test_scan.py
 tests/test_telemetry.py

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/iris_security_sdk.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 dist
 iris
+iris_sdk
 tests

{iris_security_sdk-0.2.12 → iris_security_sdk-0.2.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iris-security-sdk"
-version = "0.2.12"
+version = "0.2.16"
 description = "IRIS — AI Agent Governance SDK. Govern AI agents locally."
 readme = "README.md"
 authors = [{ name = "Gilbert Martin", email = "gilbert@iris-security.io" }]

iris_security_sdk-0.2.16/tests/test_scan.py

@@ -0,0 +1,51 @@
+# Copyright 2024-2025 Gilbert Martin / IRIS Security, Inc.
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from iris.scan import detect_workload
+
+
+@pytest.fixture
+def sample_project(tmp_path: Path) -> Path:
+    (tmp_path / "requirements.txt").write_text(
+        "openai>=1.0\nlangchain>=0.2\n",
+        encoding="utf-8",
+    )
+    app = tmp_path / "app.py"
+    app.write_text(
+        """
+import openai
+from langchain_openai import ChatOpenAI
+
+model = ChatOpenAI(model="gpt-4o")
+client = openai.OpenAI()
+
+class UserSchema:
+    ssn = "social_security"
+    email_address = "test@example.com"
+""",
+        encoding="utf-8",
+    )
+    return tmp_path
+
+
+def test_detect_workload_finds_openai_and_langchain(sample_project: Path):
+    profile = detect_workload(str(sample_project))
+    assert "openai" in profile["providers"]
+    assert "langchain" in profile["frameworks"]
+    assert any("gpt" in m for m in profile["models"])
+    assert "pii" in profile["data_categories"]
+
+
+def test_detect_workload_offline_no_network(sample_project: Path):
+    def fail_socket(*args, **kwargs):
+        raise AssertionError("Network call attempted during offline scan")
+
+    with patch("socket.socket", side_effect=fail_socket):
+        profile = detect_workload(str(sample_project))
+    assert profile["source"] == "sdk_scan"

iris_security_sdk-0.2.16/tests/test_telemetry.py

@@ -0,0 +1,105 @@
+"""Tests for IRIS telemetry opt-out, internal/CI exclusion, and daily usage."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from iris import _telemetry
+
+
+@pytest.fixture(autouse=True)
+def _reset_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("IRIS_TELEMETRY_OPT_OUT", raising=False)
+    monkeypatch.delenv("IRIS_TELEMETRY_INTERNAL", raising=False)
+    monkeypatch.delenv("CI", raising=False)
+    monkeypatch.delenv("GITHUB_ACTIONS", raising=False)
+
+
+@pytest.fixture
+def iris_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    iris_dir = tmp_path / ".iris"
+    iris_dir.mkdir()
+    monkeypatch.setattr(_telemetry, "_IRIS_DIR", iris_dir)
+    monkeypatch.setattr(_telemetry, "_INSTALL_ID_FILE", iris_dir / "install_id")
+    monkeypatch.setattr(_telemetry, "_FIRST_RUN_SENTINEL", iris_dir / ".telemetry_sent")
+    monkeypatch.setattr(_telemetry, "_FIRST_POLICY_SENTINEL", iris_dir / ".first_policy_sent")
+    monkeypatch.setattr(_telemetry, "_RUN_STATS_FILE", iris_dir / "run_stats.json")
+    return iris_dir
+
+
+def test_telemetry_enabled_by_default() -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        assert _telemetry.telemetry_enabled() is True
+
+
+def test_telemetry_opt_out() -> None:
+    with patch.dict(os.environ, {"IRIS_TELEMETRY_OPT_OUT": "1"}):
+        assert _telemetry.telemetry_enabled() is False
+
+
+def test_telemetry_skips_ci() -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        with patch.dict(os.environ, {"GITHUB_ACTIONS": "true"}):
+            assert _telemetry.telemetry_enabled() is False
+
+
+def test_telemetry_skips_internal_flag() -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        with patch.dict(os.environ, {"IRIS_TELEMETRY_INTERNAL": "1"}):
+            assert _telemetry.telemetry_enabled() is False
+
+
+def test_telemetry_skips_iris_sdk_path() -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        with patch.object(_telemetry.shutil, "which", return_value="/Users/dev/iris-sdk/.venv/bin/iris"):
+            assert _telemetry.telemetry_enabled() is False
+
+
+def test_maybe_record_cli_usage_increments_local_stats(iris_home: Path) -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        _telemetry.maybe_record_cli_usage("scan")
+        _telemetry.maybe_record_cli_usage("scan")
+        _telemetry.maybe_record_cli_usage("compile")
+
+    stats = json.loads((iris_home / "run_stats.json").read_text())
+    assert stats["run_count"] == 3
+    assert stats["commands"] == {"scan": 2, "compile": 1}
+
+
+def test_maybe_record_cli_usage_skips_ping(iris_home: Path) -> None:
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        _telemetry.maybe_record_cli_usage("ping")
+    assert not (iris_home / "run_stats.json").exists()
+
+
+def test_day_rollover_flushes_previous_day(iris_home: Path) -> None:
+    sent: list[dict[str, str]] = []
+
+    def capture(payload: dict[str, str]) -> None:
+        sent.append(payload)
+
+    (iris_home / "run_stats.json").write_text(
+        json.dumps({"date": "2026-06-14", "run_count": 5, "commands": {"scan": 5}}),
+        encoding="utf-8",
+    )
+
+    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
+        with patch.object(_telemetry, "_utc_today", return_value="2026-06-15"):
+            with patch.object(_telemetry, "_send_payload", side_effect=capture):
+                _telemetry.maybe_record_cli_usage("scan")
+
+    assert len(sent) == 1
+    assert sent[0]["event"] == "daily_usage"
+    assert sent[0]["usage_date"] == "2026-06-14"
+    assert sent[0]["run_count"] == "5"
+    assert json.loads(sent[0]["commands"]) == {"scan": 5}
+
+    stats = json.loads((iris_home / "run_stats.json").read_text())
+    assert stats["date"] == "2026-06-15"
+    assert stats["run_count"] == 1
+    assert stats["commands"] == {"scan": 1}

iris_security_sdk-0.2.12/tests/test_telemetry.py

@@ -1,46 +0,0 @@
-"""Tests for IRIS telemetry opt-out and internal/CI exclusion."""
-
-from __future__ import annotations
-
-import os
-from unittest.mock import patch
-
-import pytest
-
-from iris import _telemetry
-
-
-@pytest.fixture(autouse=True)
-def _reset_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("IRIS_TELEMETRY_OPT_OUT", raising=False)
-    monkeypatch.delenv("IRIS_TELEMETRY_INTERNAL", raising=False)
-    monkeypatch.delenv("CI", raising=False)
-    monkeypatch.delenv("GITHUB_ACTIONS", raising=False)
-
-
-def test_telemetry_enabled_by_default() -> None:
-    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
-        assert _telemetry.telemetry_enabled() is True
-
-
-def test_telemetry_opt_out() -> None:
-    with patch.dict(os.environ, {"IRIS_TELEMETRY_OPT_OUT": "1"}):
-        assert _telemetry.telemetry_enabled() is False
-
-
-def test_telemetry_skips_ci() -> None:
-    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
-        with patch.dict(os.environ, {"GITHUB_ACTIONS": "true"}):
-            assert _telemetry.telemetry_enabled() is False
-
-
-def test_telemetry_skips_internal_flag() -> None:
-    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
-        with patch.dict(os.environ, {"IRIS_TELEMETRY_INTERNAL": "1"}):
-            assert _telemetry.telemetry_enabled() is False
-
-
-def test_telemetry_skips_iris_sdk_path() -> None:
-    with patch.object(_telemetry, "TELEMETRY_ENABLED", True):
-        with patch.object(_telemetry.shutil, "which", return_value="/Users/dev/iris-sdk/.venv/bin/iris"):
-            assert _telemetry.telemetry_enabled() is False