feat(config): add RuntimeProfile hardware detector

Detects CPU cores, RAM GB, GPU, free disk, Docker environment,
and Neo4j URI location at startup.

Scoring: cpu*2 + ram*2 + gpu*2 + disk + docker + db_local (max 9)
Score 0-3 -> LOW (2 workers, batch 25, depth 2)
Score 4-7 -> MEDIUM (4 workers, batch 100, depth 3)
Score 8+ -> HIGH (8 workers, batch 500, depth 5)

BHARATGRAPH_PROFILE env var overrides auto-detection.
Module-level PROFILE singleton imported by all modules.

Part of: #56

config/runtime_profile.py

@@ -0,0 +1,209 @@
+"""
+BharatGraph - Phase 31: Runtime Profile Auto-Detector
+Detects hardware at startup and assigns LOW / MEDIUM / HIGH profile.
+All downstream modules read from PROFILE rather than hardcoding limits.
+Pure ASCII - no Unicode characters.
+"""
+import os
+import multiprocessing
+import platform
+import shutil
+from loguru import logger
+
+
+# ---- Profile presets --------------------------------------------------
+
+PROFILES = {
+    "low": {
+        "max_workers":          2,
+        "batch_size":           25,
+        "graph_depth":          2,
+        "investigation_layers": 3,
+        "cache_ttl_seconds":    300,
+        "enable_gpu":           False,
+        "description": "Minimal footprint - laptop or free-tier cloud",
+    },
+    "medium": {
+        "max_workers":          4,
+        "batch_size":           100,
+        "graph_depth":          3,
+        "investigation_layers": 4,
+        "cache_ttl_seconds":    120,
+        "enable_gpu":           False,
+        "description": "Standard server - 4 CPU / 8 GB RAM",
+    },
+    "high": {
+        "max_workers":          8,
+        "batch_size":           500,
+        "graph_depth":          5,
+        "investigation_layers": 6,
+        "cache_ttl_seconds":    60,
+        "enable_gpu":           True,
+        "description": "High-performance server - 8+ CPU / 16+ GB RAM",
+    },
+}
+
+
+# ---- Hardware detection -----------------------------------------------
+
+def _cpu_cores() -> int:
+    try:
+        return multiprocessing.cpu_count()
+    except Exception:
+        return 1
+
+
+def _ram_gb() -> float:
+    try:
+        import psutil
+        return psutil.virtual_memory().total / (1024 ** 3)
+    except ImportError:
+        try:
+            with open("/proc/meminfo") as f:
+                for line in f:
+                    if line.startswith("MemTotal"):
+                        kb = int(line.split()[1])
+                        return kb / (1024 ** 2)
+        except Exception:
+            pass
+        return 2.0
+
+
+def _gpu_available() -> bool:
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except ImportError:
+        pass
+    try:
+        result = shutil.which("nvidia-smi")
+        if result:
+            import subprocess
+            r = subprocess.run(
+                ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+                capture_output=True, text=True, timeout=5
+            )
+            return r.returncode == 0 and bool(r.stdout.strip())
+    except Exception:
+        pass
+    return False
+
+
+def _free_disk_gb() -> float:
+    try:
+        usage = shutil.disk_usage(".")
+        return usage.free / (1024 ** 3)
+    except Exception:
+        return 10.0
+
+
+def _in_docker() -> bool:
+    try:
+        with open("/proc/1/cgroup") as f:
+            return "docker" in f.read() or "kubepods" in f.read()
+    except Exception:
+        pass
+    return os.path.exists("/.dockerenv")
+
+
+def _db_local() -> bool:
+    """True when Neo4j URI points to localhost (low-latency)."""
+    uri = os.getenv("NEO4J_URI", "")
+    return "localhost" in uri or "127.0.0.1" in uri or "bolt://" in uri
+
+
+# ---- Profile scoring --------------------------------------------------
+# Score >= 8 -> high, >= 4 -> medium, else low
+
+def _compute_score(cpu: int, ram: float, gpu: bool,
+                   disk: float, docker: bool, db_local: bool) -> int:
+    score = 0
+    score += 2 if cpu >= 8  else (1 if cpu >= 4 else 0)
+    score += 2 if ram >= 16 else (1 if ram >= 8  else 0)
+    score += 2 if gpu       else 0
+    score += 1 if disk >= 20 else 0
+    score += 1 if docker     else 0
+    score += 1 if db_local   else 0
+    return score
+
+
+def _score_to_profile(score: int) -> str:
+    if score >= 8:
+        return "high"
+    if score >= 4:
+        return "medium"
+    return "low"
+
+
+# ---- Public API -------------------------------------------------------
+
+class RuntimeProfile:
+    """
+    Singleton - call RuntimeProfile.get() anywhere to read settings.
+
+    Usage:
+        from config.runtime_profile import PROFILE
+        workers = PROFILE["max_workers"]
+    """
+
+    _instance = None
+
+    def __init__(self):
+        self.cpu     = _cpu_cores()
+        self.ram_gb  = _ram_gb()
+        self.gpu     = _gpu_available()
+        self.disk_gb = _free_disk_gb()
+        self.docker  = _in_docker()
+        self.db_loc  = _db_local()
+        self.os      = platform.system()
+
+        self.score = _compute_score(
+            self.cpu, self.ram_gb, self.gpu,
+            self.disk_gb, self.docker, self.db_loc
+        )
+        self.name = os.getenv("BHARATGRAPH_PROFILE", "").lower()
+        if self.name not in PROFILES:
+            self.name = _score_to_profile(self.score)
+
+        self.settings = dict(PROFILES[self.name])
+
+        logger.info(
+            f"[RuntimeProfile] Detected: CPU={self.cpu} cores, "
+            f"RAM={self.ram_gb:.1f}GB, GPU={self.gpu}, "
+            f"Disk={self.disk_gb:.1f}GB, Docker={self.docker}, "
+            f"DB-local={self.db_loc}, OS={self.os}"
+        )
+        logger.success(
+            f"[RuntimeProfile] Score={self.score} -> Profile: {self.name.upper()} "
+            f"({self.settings['description']})"
+        )
+
+    @classmethod
+    def get(cls) -> "RuntimeProfile":
+        if cls._instance is None:
+            cls._instance = RuntimeProfile()
+        return cls._instance
+
+    def __getitem__(self, key):
+        return self.settings[key]
+
+    def to_dict(self) -> dict:
+        return {
+            "profile_name": self.name,
+            "score":        self.score,
+            "hardware": {
+                "cpu_cores": self.cpu,
+                "ram_gb":    round(self.ram_gb, 1),
+                "gpu":       self.gpu,
+                "disk_gb":   round(self.disk_gb, 1),
+                "in_docker": self.docker,
+                "db_local":  self.db_loc,
+                "os":        self.os,
+            },
+            "settings":    self.settings,
+            "overridable": "Set BHARATGRAPH_PROFILE=low|medium|high to force a profile",
+        }
+
+
+# Module-level singleton - import this in all modules
+PROFILE = RuntimeProfile.get()