nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/hooks.py

@@ -1,246 +0,0 @@
-
-"""
-Strategic Hooks for Nucleus Daemon.
-The "Billion Dollar Extensions" for Network Effects, Identity, and Scale.
-
-Strategic Role:
-- Turn the Daemon into a Platform (App Store).
-- Turn the Daemon into a Global Node (Insight Exchange).
-- Deepen Host Integration (Intimacy).
-"""
-
-import json
-import logging
-import time
-import uuid
-import hashlib
-from typing import List, Optional
-from dataclasses import dataclass, asdict
-from pathlib import Path
-
-# --- CRYPTO UPGRADE (Phase 60: Gates Fix) ---
-try:
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    from cryptography.hazmat.primitives import serialization
-    CRYPTO_AVAILABLE = True
-except ImportError:
-    CRYPTO_AVAILABLE = False
-
-logger = logging.getLogger(__name__)
-
-# --- 1. The App Store Hook (AgentManifest) ---
-@dataclass
-class AgentManifest:
-    """Schema for a Tradeable Agent (The App Store Unit)."""
-    id: str
-    name: str
-    version: str
-    author_did: str # Decentralized ID of creator
-    capabilities: List[str]
-    lifecycle_state: str = "active" # active, archived, tombstone
-    price_per_invocation_usd: float = 0.0
-    hash: str = ""
-    signature: str = ""
-
-    def sign(self, identity_key: 'IdentityKey'):
-        """Sign the manifest to prove authorship."""
-        # Canonicalize the data
-        payload = f"{self.id}:{self.version}:{self.author_did}:{self.lifecycle_state}"
-        self.signature = identity_key.sign_message(payload)
-        self.hash = hashlib.sha256(payload.encode()).hexdigest()
-
-# --- 2. The Insight Hook (InsightExchange) ---
-@dataclass
-class InsightPacket:
-    """Schema for Tradeable Information (The Data Unit)."""
-    topic: str
-    content_hash: str
-    value_score: float
-    source_did: str
-    timestamp: float
-    proof: Optional[str] = None # ZK Proof of validity (Future)
-
-class InsightExchange:
-    """Protocol for trading Insights between Daemons."""
-    def __init__(self, brain_path: Path):
-        self.ledger_path = brain_path / "network" / "insights.jsonl"
-        self.ledger_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def offer_insight(self, topic: str, content: str, value: float) -> InsightPacket:
-        """Create an offer to sell info."""
-        packet = InsightPacket(
-            topic=topic,
-            content_hash=hashlib.sha256(content.encode()).hexdigest(),
-            value_score=value,
-            source_did="self", # In real impl, use IdentityKey
-            timestamp=time.time()
-        )
-        # Log offers
-        with open(self.ledger_path, "a") as f:
-            f.write(json.dumps(asdict(packet)) + "\n")
-        return packet
-
-# --- 3. The Grid Hook (RemoteExecutionProtocol) ---
-class RemoteExecutionProtocol:
-    """Interface for offloading work to the Cloud (The Grid)."""
-    def __init__(self, brain_path: Path):
-        self.config_path = brain_path / "network" / "grid_config.json"
-        
-    def dispatch_container(self, image: str, cmd: List[str], max_budget_usd: float) -> str:
-        """
-        Stub: Dispatch a Docker container to a Grid Node (e.g. Cloud Run).
-        Returns: Execution ID.
-        """
-        logger.info(f"🌩️ GRID DISPATCH: {image} (Budget: ${max_budget_usd})")
-        # In real impl, this calls Google Cloud Run API or a P2P compute market
-        return f"grid_exec_{uuid.uuid4()}"
-
-# --- 4. The Host Hook (HostIntimacy) ---
-class HostIntimacy:
-    """
-    Permission-aware OS Access. 
-    Managing the "Deep Binding" to the user's life (Files, Calendar, etc).
-    """
-    def __init__(self):
-        self.permissions = {
-            "filesystem": "read-write",
-            "geolocation": "denied",
-            "clipboard": "ask",
-            "biometrics": "unavailable"
-        }
-        
-    def check_permission(self, capability: str) -> bool:
-        """Centralized permission check."""
-        return self.permissions.get(capability, "denied") in ["allowed", "read-write", "ask"]
-
-# --- 5. The Identity Hook (IdentityKey) ---
-class IdentityKey:
-    """
-    Cryptographic Identity for the Sovereign Node (Ed25519).
-    The "Soul" of the machine.
-    """
-    def __init__(self, brain_path: Path):
-        self.key_dir = brain_path / "identity"
-        self.key_dir.mkdir(parents=True, exist_ok=True)
-        self.private_key_path = self.key_dir / "node.pem"
-        self.public_key_path = self.key_dir / "node.pub"
-        
-        self.did = ""
-        self._private_key = None
-        self._load_or_create_identity()
-        
-    def _load_or_create_identity(self):
-        if not CRYPTO_AVAILABLE:
-            logger.warning("⚠️ 'cryptography' lib not found. Using UUID stub for Identity.")
-            self.did = f"did:nucleus:stub:{uuid.uuid4()}"
-            return
-
-        if self.private_key_path.exists():
-            try:
-                with open(self.private_key_path, "rb") as f:
-                    self._private_key = serialization.load_pem_private_key(
-                        f.read(), password=None
-                    )
-                logger.info("🔑 Loaded existing IdentityKey.")
-            except Exception as e:
-                logger.error(f"❌ Failed to load IdentityKey: {e}. Generating new one.")
-                self._generate_new_key()
-        else:
-            self._generate_new_key()
-
-        # Derive Public Key and DID
-        if self._private_key:
-            public_key = self._private_key.public_key()
-            pub_bytes = public_key.public_bytes(
-                encoding=serialization.Encoding.Raw,
-                format=serialization.PublicFormat.Raw
-            )
-            # DID format: did:nucleus:<hex_pub_key>
-            self.did = f"did:nucleus:{pub_bytes.hex()}"
-            
-            # Save public key for strict reference
-            with open(self.public_key_path, "wb") as f:
-                f.write(public_key.public_bytes(
-                    encoding=serialization.Encoding.PEM,
-                    format=serialization.PublicFormat.SubjectPublicKeyInfo
-                ))
-
-    def _generate_new_key(self):
-        logger.info("✨ Generating new Ed25519 IdentityKey...")
-        self._private_key = ed25519.Ed25519PrivateKey.generate()
-        
-        # Save Private Key
-        pem = self._private_key.private_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PrivateFormat.PKCS8,
-            encryption_algorithm=serialization.NoEncryption()
-        )
-        with open(self.private_key_path, "wb") as f:
-            f.write(pem)
-
-    def sign_message(self, message: str) -> str:
-        """Sign a payload using Ed25519."""
-        if not self._private_key:
-            return f"stub_sig_{uuid.uuid4()}"
-            
-        points = message.encode("utf-8")
-        signature = self._private_key.sign(points)
-        return signature.hex()
-
-    def verify_signature(self, message: str, signature_hex: str, did: str) -> bool:
-        """Verify a signature against a DID (Public Key)."""
-        if not CRYPTO_AVAILABLE or "stub" in did:
-            return True # Fallback for dev/stub modes
-            
-        try:
-            # Extract Public Key from DID
-            if not did.startswith("did:nucleus:"):
-                return False
-            pub_key_hex = did.split(":")[-1]
-            pub_key_bytes = bytes.fromhex(pub_key_hex)
-            
-            public_key = ed25519.Ed25519PublicKey.from_public_bytes(pub_key_bytes)
-            
-            signature_bytes = bytes.fromhex(signature_hex)
-            public_key.verify(signature_bytes, message.encode("utf-8"))
-            return True
-        except Exception as e:
-            logger.warning(f"⚠️ Signature Verification Failed: {e}")
-            return False
-
-# --- 6. The Pulse (AmbientTelemetry) ---
-class AmbientTelemetry:
-    """
-    Writes status to a "Pulse File" for the HUD/Status Bar to read.
-    Frequency: High (1s-5s).
-    
-    Security (V9 Patch): Uses IdentityKey to sign heartbeats, preventing IPC hijacking.
-    """
-    def __init__(self, brain_path: Path, identity: Optional['IdentityKey'] = None):
-        self.pulse_file = brain_path / "pulse.json"
-        self.identity = identity
-        
-    def beat(self, status: str, active_tasks: int, cpu_usage: float = 0.0):
-        """Write the heartbeat with a cryptographic pulse signal."""
-        timestamp = time.time()
-        data = {
-            "timestamp": timestamp,
-            "status": status, # idle, busy, error, sleeping
-            "tasks": active_tasks,
-            "cpu": cpu_usage,
-            "color": "green" if status == "idle" else "gold" if status == "busy" else "red"
-        }
-        
-        # Add Trust Signal (Crypographic Pulse)
-        if self.identity:
-            payload = f"{timestamp}:{status}:{active_tasks}"
-            data["pulse_sig"] = self.identity.sign_message(payload)
-            data["did"] = self.identity.did
-
-        # Atomic write
-        try:
-            temp_file = self.pulse_file.with_suffix(".tmp")
-            temp_file.write_text(json.dumps(data))
-            temp_file.replace(self.pulse_file)
-        except Exception as e:
-            logger.warning(f"Failed to pulse: {e}")

package/src/mcp_server_nucleus/runtime/identity/gatekeeper.py

@@ -1,106 +0,0 @@
-"""
-Gatekeeper: The Permission Broker.
-Manages user consent ("CapabilityGrants") for sensitive operations.
-
-Strategic Role:
-- PERSISTENT: Remembers what the user allowed.
-- GRANULAR: "Network: google.com" != "Network: *".
-- INTERACTIVE: Bridges the gap between Agent Request and User Decision.
-"""
-
-import json
-import logging
-import hashlib
-from pathlib import Path
-from typing import Dict, Any
-from pydantic import BaseModel
-
-logger = logging.getLogger("GATEKEEPER")
-
-ACCESS_DENIED = False
-ACCESS_GRANTED = True
-
-class GrantRequest(BaseModel):
-    agent_id: str
-    capability: str
-    params: Dict[str, Any] # e.g. {"domain": "google.com"} or {"path": "/tmp"}
-    
-    def fingerprint(self) -> str:
-        """Unique hash for this request signature"""
-        # Canonicalize params
-        import json
-        param_str = json.dumps(self.params, sort_keys=True)
-        raw = f"{self.agent_id}|{self.capability}|{param_str}"
-        return hashlib.sha256(raw.encode()).hexdigest()
-
-class CapabilityGrant(BaseModel):
-    request_fingerprint: str
-    agent_id: str
-    capability: str
-    params: Dict[str, Any]
-    granted_at: str # ISO Timestamp
-    granted_by: str = "user"
-
-class Gatekeeper:
-    def __init__(self, brain_path: Path):
-        self.brain_path = brain_path
-        self.ledger_path = brain_path / "ledger" / "permissions.json"
-        self._cache_grants: Dict[str, CapabilityGrant] = {}
-        self._load_ledger()
-        
-    def _load_ledger(self):
-        self.ledger_path.parent.mkdir(parents=True, exist_ok=True)
-        if self.ledger_path.exists():
-            try:
-                data = json.loads(self.ledger_path.read_text())
-                for item in data:
-                    grant = CapabilityGrant(**item)
-                    self._cache_grants[grant.request_fingerprint] = grant
-            except Exception as e:
-                logger.error(f"Failed to load permission ledger: {e}")
-                
-    def _save_ledger(self):
-        data = [g.model_dump() for g in self._cache_grants.values()]
-        self.ledger_path.write_text(json.dumps(data, indent=2))
-        
-    def check_permission(self, request: GrantRequest) -> bool:
-        """
-        Check if a grant exists for this specific request.
-        """
-        fp = request.fingerprint()
-        if fp in self._cache_grants:
-            return ACCESS_GRANTED
-            
-        # TODO: Implement wildcard support? 
-        # For Phase 57, we do strict equality.
-        
-        return ACCESS_DENIED
-        
-    def grant_permission(self, request: GrantRequest):
-        """
-        Persist a new grant.
-        """
-        from datetime import datetime
-        fp = request.fingerprint()
-        
-        grant = CapabilityGrant(
-            request_fingerprint=fp,
-            agent_id=request.agent_id,
-            capability=request.capability,
-            params=request.params,
-            granted_at=datetime.now().isoformat()
-        )
-        
-        self._cache_grants[fp] = grant
-        self._save_ledger()
-        logger.info(f"Granted permission: {request.agent_id} -> {request.capability} {request.params}")
-        
-    def revoke_permission(self, request: GrantRequest):
-        """
-        Revoke a grant.
-        """
-        fp = request.fingerprint()
-        if fp in self._cache_grants:
-            del self._cache_grants[fp]
-            self._save_ledger()
-            logger.info(f"Revoked permission: {request.agent_id}")

package/src/mcp_server_nucleus/runtime/identity/keygen.py

@@ -1,147 +0,0 @@
-import hashlib
-import json
-import logging
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import NamedTuple, Optional, Dict
-
-try:
-    from cryptography.hazmat.primitives import serialization
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    HAS_CRYPTO = True
-except ImportError:
-    HAS_CRYPTO = False
-
-logger = logging.getLogger("KEY_MANAGER")
-
-class KeyPair(NamedTuple):
-    key_id: str
-    private_key_pem: str
-    public_key_pem: str
-
-class KeyManager:
-    """
-    Manages Ed25519 Key Generation, Verification, and Persistence for Nucleus.
-    """
-    def __init__(self, brain_path: Optional[Path] = None):
-        """
-        Args:
-            brain_path: Optional root path for key storage. If None, runs in stateless mode.
-        """
-        if not HAS_CRYPTO:
-            raise ImportError("cryptography module is required. Install with: pip install cryptography")
-        
-        self.brain_path = brain_path
-        if self.brain_path:
-            self.keystore_path = self.brain_path / "ledger" / "keystore.json"
-            self.keystore_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def _load_keystore(self) -> Dict[str, Dict[str, str]]:
-        if not self.brain_path or not self.keystore_path.exists():
-            return {}
-        try:
-            return json.loads(self.keystore_path.read_text())
-        except Exception:
-            return {}
-
-    def _save_keystore(self, store: Dict):
-        if self.brain_path:
-            # We don't have locking here yet, assume single user or add locking later
-            # Ideally use update_brain_file or lock
-            self.keystore_path.write_text(json.dumps(store, indent=2))
-
-    def generate_key(self, alias: Optional[str] = None) -> str:
-        """
-        Generates, Persists, and returns Key ID.
-        Args:
-            alias: Optional human readable alias (e.g. 'publisher_main')
-        """
-        kp = self.generate_keypair()
-        
-        if self.brain_path:
-            store = self._load_keystore()
-            store[kp.key_id] = {
-                "private_key_pem": kp.private_key_pem,
-                "public_key_pem": kp.public_key_pem,
-                "alias": alias,
-                "created_at": datetime.now(timezone.utc).isoformat()
-            }
-            if alias:
-                # Also index by alias for convenience? 
-                # Or just search. Let's just store by ID for now.
-                pass
-            self._save_keystore(store)
-            
-        return kp.key_id
-
-    def get_key_pair(self, key_id: str) -> Optional[KeyPair]:
-        """Retrieve key pair from disk by ID."""
-        if not self.brain_path:
-            return None
-        
-        store = self._load_keystore()
-        if key_id in store:
-            data = store[key_id]
-            return KeyPair(
-                key_id=key_id,
-                private_key_pem=data["private_key_pem"],
-                public_key_pem=data["public_key_pem"]
-            )
-        return None
-
-    def generate_keypair(self) -> KeyPair:
-        """Generates a new Ed25519 keypair and returns PEM strings (Stateless)."""
-        private_key = ed25519.Ed25519PrivateKey.generate()
-        public_key = private_key.public_key()
-        
-        # Serialize Private Key
-        private_pem = private_key.private_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PrivateFormat.PKCS8,
-            encryption_algorithm=serialization.NoEncryption()
-        )
-        
-        # Serialize Public Key
-        public_pem = public_key.public_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PublicFormat.SubjectPublicKeyInfo
-        )
-        
-        # Generate Key ID (Fingerprint of Public Key)
-        public_der = public_key.public_bytes(
-            encoding=serialization.Encoding.DER,
-            format=serialization.PublicFormat.SubjectPublicKeyInfo
-        )
-        key_id = hashlib.sha256(public_der).hexdigest()
-        
-        return KeyPair(
-            key_id=key_id,
-            private_key_pem=private_pem.decode('utf-8'),
-            public_key_pem=public_pem.decode('utf-8')
-        )
-
-    def sign(self, private_key_pem: str, data: bytes) -> bytes:
-        """Signs data with private key PEM. Returns raw bytes signature."""
-        private_key = serialization.load_pem_private_key(
-            private_key_pem.encode('utf-8'),
-            password=None
-        )
-        if not isinstance(private_key, ed25519.Ed25519PrivateKey):
-            raise ValueError("Invalid Key Type. Expected Ed25519PrivateKey.")
-            
-        return private_key.sign(data)
-
-    def verify(self, public_key_pem: str, signature: bytes, data: bytes) -> bool:
-        """Verifies signature with public key PEM. Returns True if valid."""
-        try:
-            public_key = serialization.load_pem_public_key(
-                public_key_pem.encode('utf-8')
-            )
-            if not isinstance(public_key, ed25519.Ed25519PublicKey):
-                raise ValueError("Invalid Key Type. Expected Ed25519PublicKey.")
-                
-            public_key.verify(signature, data)
-            return True
-        except Exception as e:
-            logger.warning(f"Verification Failed: {e}")
-            return False

package/src/mcp_server_nucleus/runtime/identity/manifest.py

@@ -1,62 +0,0 @@
-from enum import Enum
-from pydantic import BaseModel, Field, validator, ValidationError
-from typing import List, Optional, Literal, Dict, Any
-
-class CapabilityScope(str, Enum):
-    NETWORK = "network"
-    FILESYSTEM = "filesystem"
-    MEMORY = "memory"
-    SHELL = "shell"
-    STRATEGY = "strategy"
-    BROWSER = "browser"
-
-class Capability(BaseModel):
-    scope: CapabilityScope
-    reason: str = Field(..., description="Why this capability is needed")
-    
-    # Scope-specific fields
-    domains: Optional[List[str]] = Field(None, description="For network scope: Whitelisted domains")
-    paths: Optional[List[str]] = Field(None, description="For filesystem/strategy scope: Allowed paths")
-    mode: Optional[Literal["read", "write", "readwrite", "read_write"]] = Field(None, description="For filesystem/strategy scope: Access mode")
-
-    @validator("domains")
-    def validate_network_domains(cls, v, values):
-        if values.get("scope") == CapabilityScope.NETWORK and not v:
-            raise ValueError("Network capability must specify 'domains' whitelist.")
-        return v
-
-    @validator("paths")
-    def validate_fs_paths(cls, v, values):
-        scope = values.get("scope")
-        if scope in [CapabilityScope.FILESYSTEM, CapabilityScope.STRATEGY] and not v:
-            raise ValueError(f"{scope} capability must specify 'paths' whitelist.")
-        return v
-
-class AgentIdentity(BaseModel):
-    id: str = Field(..., pattern=r"^[a-z0-9]+(\.[a-z0-9]+)+$", description="Reverse DNS ID (e.g. nucleus.core.ops)")
-    name: str
-    version: str = Field(..., pattern=r"^\d+\.\d+\.\d+$", description="Semantic Version")
-    description: str
-    author: str
-    license: str
-
-class LifecyclePolicy(BaseModel):
-    persistence: Literal["session", "persistent", "immortal"] = "session"
-    cleanup: Literal["strict", "lazy", "none"] = "strict"
-
-class AgentManifest(BaseModel):
-    manifest_version: str = "1.0.0"
-    agent: AgentIdentity
-    capabilities: List[Capability] = Field(default_factory=list)
-    lifecycle: LifecyclePolicy = Field(default_factory=LifecyclePolicy)
-
-class ManifestValidator:
-    """
-    Validates Agent Manifests against the strict zero-trust schema.
-    """
-    @staticmethod
-    def validate(manifest_data: Dict[str, Any]) -> AgentManifest:
-        try:
-            return AgentManifest(**manifest_data)
-        except ValidationError as e:
-            raise ValueError(f"Manifest Validation Failed: {e}")

package/src/mcp_server_nucleus/runtime/identity/trust.py

@@ -1,27 +0,0 @@
-from enum import Enum
-from pydantic import BaseModel, Field
-from typing import Optional
-
-class TrustLevel(str, Enum):
-    VERIFIED = "verified"     # Signed by Nucleus Root or known partner
-    COMMUNITY = "community"   # Signed by unknown key, but structure valid
-    UNKNOWN = "unknown"       # Unsigned or invalid
-    MALICIOUS = "malicious"   # Specific deny-list
-
-class TrustProfile(BaseModel):
-    """
-    Represents the Identity of an Agent Publisher.
-    This corresponds to the 'signer' of the .nuke artifact.
-    """
-    publisher_id: str = Field(..., description="Unique Key ID (Fingerprint)")
-    trust_level: TrustLevel = Field(default=TrustLevel.UNKNOWN, description="Current trust status")
-    label: str = Field(..., description="Human readable name (e.g., 'Antigravity')")
-    public_key: str = Field(..., description="PEM encoded Public Key")
-    verification_url: Optional[str] = Field(None, description="URL to verify identity (e.g. GitHub Gist)")
-
-    def to_json(self) -> str:
-        return self.model_dump_json(indent=2)
-    
-    @classmethod
-    def from_json(cls, json_str: str) -> "TrustProfile":
-        return cls.model_validate_json(json_str)

package/src/mcp_server_nucleus/runtime/inspector.py

@@ -1,74 +0,0 @@
-"""
-Inspector: The Lens.
-Provides deep introspection into Agent Manifests for security review.
-
-Role:
-- Renders human-readable reports of what an agent can do.
-- Highlights high-risk capabilities (Network, Shell, FS).
-- Verifies Trust Chains (Future scope).
-"""
-
-from .identity.manifest import AgentManifest, CapabilityScope
-
-class ManifestViewer:
-    @staticmethod
-    def render_report(manifest: AgentManifest) -> str:
-        """
-        Generates a formatted text report of the agent's identity and capabilities.
-        """
-        agent = manifest.agent
-        lines = []
-        
-        # Header
-        lines.append("╔═══════════════════════════════════════════════════════════╗")
-        lines.append(f"║ IDENTITY: {agent.name:<47} ║")
-        lines.append(f"║ ID:       {agent.id:<47} ║")
-        lines.append(f"║ Version:  {agent.version:<47} ║")
-        lines.append(f"║ License:  {agent.license:<47} ║")
-        lines.append("╟───────────────────────────────────────────────────────────╢")
-        
-        # Description
-        desc_preview = (agent.description[:50] + '..') if len(agent.description) > 50 else agent.description
-        lines.append(f"║ {desc_preview:<57} ║")
-        lines.append("╠═══════════════════════════════════════════════════════════╣")
-        
-        # Capabilities
-        if not manifest.capabilities:
-             lines.append("║ ✅ No Capabilities Requested (Safe)                       ║")
-        else:
-            lines.append("║ ⚠️  CAPABILITIES REQUESTED                                ║")
-            lines.append("╟───────────────────────────────────────────────────────────╢")
-            
-            for cap in manifest.capabilities:
-                scope = cap.scope.value.upper()
-                icon = ManifestViewer._get_icon(cap.scope)
-                
-                lines.append(f"║ {icon} {scope:<53} ║")
-                lines.append(f"║    Reason: {cap.reason[:44]:<44} ║")
-                
-                # Details
-                if cap.scope == CapabilityScope.NETWORK and cap.domains:
-                    lines.append(f"║    Domains: {', '.join(cap.domains)[:43]:<43} ║")
-                    
-                if cap.scope == CapabilityScope.FILESYSTEM and cap.paths:
-                    mode = getattr(cap, 'mode', 'read')
-                    lines.append(f"║    [{mode.upper()}] Paths: {', '.join(cap.paths)[:38]:<38} ║")
-                
-                lines.append("╟───────────────────────────────────────────────────────────╢")
-                
-        lines.append("╚═══════════════════════════════════════════════════════════╝")
-        return "\n".join(lines)
-
-    @staticmethod
-    def _get_icon(scope: CapabilityScope) -> str:
-        if scope == CapabilityScope.NETWORK:
-            return "⚠️ "
-        if scope == CapabilityScope.SHELL:
-            return "🚨"
-        if scope == CapabilityScope.FILESYSTEM:
-            return "📁"
-        if scope == CapabilityScope.MEMORY:
-            return "🧠"
-        if scope == CapabilityScope.BROWSER:
-            return "🌐"
-        return "🔧"