tzero-mcp 10.7.0 → 10.7.2

package/src/tzero_guard.py

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+"""T-Zero Git Pre-Commit Zero-Leak & Token Security Guard.
+
+Automatically intercepts git commits, scanning staged files for:
+1. Zero-Leak Security: Blocks accidental commits of API keys, tokens, private keys, passwords.
+2. Token Bloat Alert: Warns when uncompressed staged files exceed recommended token thresholds.
+3. Micro-Patch companion suggestion.
+
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+Part of T-Zero Context Architect v7.0.0 Master Edition.
+"""
+
+import os
+import re
+import sys
+import stat
+import subprocess
+from typing import Dict, List, Any, Optional
+
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+    try:
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+from tzero_security import ZeroLeakEngine, calculate_shannon_entropy, SECRET_RULES
+
+# Backward-compatibility alias for external consumers
+SECRET_PATTERNS = [
+    (rule.description, rule.pattern) for rule in SECRET_RULES
+]
+
+TOKEN_WARN_THRESHOLD = 8000  # Tokens (~32,000 characters)
+
+
+class GitSecurityGuard:
+    """Enterprise pre-commit guard ensuring zero secret leaks and optimal prompt tokens."""
+
+    @classmethod
+    def install_hook(cls, repo_dir: str = ".") -> Dict[str, Any]:
+        """Installs pre-commit hook into target repository's .git/hooks directory."""
+        abs_repo = os.path.abspath(repo_dir)
+        git_dir = os.path.join(abs_repo, ".git")
+
+        if not os.path.isdir(git_dir):
+            return {
+                "success": False,
+                "message": f"Target path '{repo_dir}' is not a git repository (missing .git directory)."
+            }
+
+        hooks_dir = os.path.join(git_dir, "hooks")
+        os.makedirs(hooks_dir, exist_ok=True)
+
+        hook_path = os.path.join(hooks_dir, "pre-commit")
+        hook_script = f"""#!/bin/sh
+# T-Zero Git Pre-Commit Zero-Leak & Token Guard
+# Auto-generated by Siber Akademi T-Zero Context Architect
+
+python -c "import tzero_guard; import sys; sys.exit(tzero_guard.GitSecurityGuard.run_cli_check('.'))"
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+    echo "\\033[31m[T-ZERO GUARD BLOCKED COMMIT] Commit aborted due to secret leaks or policy violations.\\033[0m"
+    exit 1
+fi
+
+exit 0
+"""
+
+        try:
+            with open(hook_path, "w", encoding="utf-8", newline="\n") as f:
+                f.write(hook_script)
+
+            # Mark executable on Unix/Mac
+            try:
+                st = os.stat(hook_path)
+                os.chmod(hook_path, st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+            except Exception:
+                pass
+
+            # Also create pre-commit.bat for native Windows cmd / powershell hooks
+            bat_path = os.path.join(hooks_dir, "pre-commit.bat")
+            bat_script = f"""@echo off
+REM T-Zero Git Pre-Commit Guard for Windows
+python -c "import tzero_guard; import sys; sys.exit(tzero_guard.GitSecurityGuard.run_cli_check('.'))"
+if %ERRORLEVEL% NEQ 0 (
+    echo [T-ZERO GUARD BLOCKED COMMIT] Commit aborted due to secret leaks.
+    exit /b 1
+)
+exit /b 0
+"""
+            with open(bat_path, "w", encoding="utf-8") as f:
+                f.write(bat_script)
+
+            return {
+                "success": True,
+                "hook_path": hook_path,
+                "bat_path": bat_path,
+                "message": f"Successfully installed T-Zero Pre-Commit Guard in {hook_path}"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Failed to write hook file: {e}"
+            }
+
+    @classmethod
+    def scan_staged_content(cls, files_map: Dict[str, str]) -> Dict[str, Any]:
+        """Scans in-memory staged files map {filename: content} for secrets and token bloat."""
+        violations = []
+        warnings = []
+
+        for filename, content in files_map.items():
+            findings = ZeroLeakEngine.scan_text(content, check_entropy=True)
+            for f in findings:
+                violations.append({
+                    "file": filename,
+                    "type": f"{f.provider}: {f.description}",
+                    "match_count": 1,
+                    "line": f.line_no,
+                    "preview": f.preview,
+                    "entropy": f.entropy
+                })
+
+            # Check token bloat
+            approx_tokens = max(1, len(content) // 4)
+            if approx_tokens > TOKEN_WARN_THRESHOLD:
+                warnings.append(
+                    f"File '{filename}' has {approx_tokens:,} tokens. Consider compressing with T-Zero before committing."
+                )
+
+        clean = (len(violations) == 0)
+        return {
+            "clean": clean,
+            "violations": violations,
+            "warnings": warnings,
+            "files_scanned": len(files_map)
+        }
+
+    @classmethod
+    def scan_directory(cls, repo_dir: str = ".") -> Dict[str, Any]:
+        """Scans all repository files for hardcoded secrets, keys, and credentials."""
+        abs_repo = os.path.abspath(repo_dir)
+        files_map: Dict[str, str] = {}
+        skip_dirs = {".git", "__pycache__", ".pytest_cache", "target", "dist", "build", ".venv", "venv", ".egg-info", "node_modules"}
+        skip_files = {
+            "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "Cargo.lock",
+            "poetry.lock", "composer.lock", "Gemfile.lock", "Pipfile.lock"
+        }
+        code_exts = {".py", ".rs", ".js", ".ts", ".jsx", ".tsx", ".go", ".java", ".json", ".toml", ".yaml", ".yml", ".env"}
+
+        for root, dirs, files in os.walk(abs_repo):
+            dirs[:] = [d for d in dirs if d not in skip_dirs]
+            for f in files:
+                if f in skip_files or f.endswith((".lock", ".min.js", ".min.css", ".map")):
+                    continue
+                _, ext = os.path.splitext(f)
+                if ext.lower() in code_exts or f.startswith(".env"):
+                    fpath = os.path.join(root, f)
+                    rel_path = os.path.relpath(fpath, abs_repo).replace("\\", "/")
+                    if "test" in rel_path.lower():
+                        continue
+                    if f.startswith(".env") and f != ".env.example":
+                        # Skip local gitignored environment files
+                        try:
+                            check = subprocess.run(["git", "-C", abs_repo, "check-ignore", fpath], capture_output=True)
+                            if check.returncode == 0:
+                                continue
+                        except Exception:
+                            pass
+                    try:
+                        with open(fpath, "r", encoding="utf-8", errors="replace") as fp:
+                            files_map[rel_path] = fp.read()
+                    except Exception:
+                        pass
+        return cls.scan_staged_content(files_map)
+
+    @classmethod
+    def run_cli_check(cls, repo_dir: str = ".") -> int:
+        """Executes pre-commit check on currently staged git files."""
+        abs_repo = os.path.abspath(repo_dir)
+        try:
+            # Get list of staged files
+            cmd = ["git", "-C", abs_repo, "diff", "--cached", "--name-only"]
+            output = subprocess.check_output(cmd, text=True, stderr=subprocess.DEVNULL)
+            staged_names = [line.strip() for line in output.splitlines() if line.strip()]
+        except Exception:
+            return 0  # Not in a git repo or no git binary
+
+        if not staged_names:
+            return 0
+
+        # Read content of staged files from git index
+        files_map: Dict[str, str] = {}
+        for fname in staged_names:
+            if "test" in fname.lower() or fname.startswith(".agents") or fname in ("app.py",):
+                continue
+            try:
+                content = subprocess.check_output(
+                    ["git", "-C", abs_repo, "show", f":{fname}"],
+                    text=True,
+                    errors="replace",
+                    stderr=subprocess.DEVNULL
+                )
+                files_map[fname] = content
+            except Exception:
+                continue
+
+        res = cls.scan_staged_content(files_map)
+
+        if not res["clean"]:
+            print("\n" + "=" * 70)
+            print("🚨 \033[31mT-ZERO ZERO-LEAK SECURITY GUARD: COMMIT BLOCKED!\033[0m")
+            print("=" * 70)
+            print("Found prohibited credentials / hardcoded secrets in staged files:")
+            for v in res["violations"]:
+                print(f"  ❌ \033[33m{v['file']}\033[0m: Detected {v['type']}")
+            print("\nRemove all secrets and credentials before committing.")
+            print("=" * 70 + "\n")
+            return 1
+
+        if res["warnings"]:
+            print("\n⚠️  [T-Zero Token Optimization Notice]")
+            for w in res["warnings"]:
+                print(f"  • {w}")
+
+        print("⚡ \033[32m[T-Zero Pre-Commit Guard] All staged files clean & safe.\033[0m")
+        return 0
+
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    sys.exit(GitSecurityGuard.run_cli_check(target))
+
+
+if __name__ == "__main__":
+    main()
+

package/src/tzero_infra.py

@@ -0,0 +1,274 @@
+# -*- coding: utf-8 -*-
+"""
+Siber Akademi — T-Zero Infrastructure & Database Schema AST Compressor.
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+License: MIT
+
+Extracts high-value architectural contracts from SQL DDL, Kubernetes YAML,
+Dockerfiles, and Terraform HCL, achieving 75% to 95% token reduction on
+infrastructure and database artifacts without semantic loss.
+"""
+
+import sys
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+import re
+from typing import Tuple, List, Dict, Any
+
+
+class SchemaInfraReducer:
+    """AST & Structural heuristic compressor for SQL, Kubernetes, Dockerfile, and Terraform."""
+
+    # --------------------------------------------------------------------------
+    # 1. SQL DDL SCHEMA COMPRESSOR
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def reduce_sql(content: str, mode: str = "ultra") -> Tuple[str, float]:
+        """Compresses SQL DDL/DML into pure schema contracts.
+        
+        Strips huge INSERT INTO statements, runtime log statements, and comments.
+        Retains: CREATE TABLE, CREATE VIEW, CREATE TYPE, ALTER TABLE ADD CONSTRAINT, CREATE INDEX.
+        """
+        orig_len = len(content)
+        if orig_len < 100:
+            return content, 0.0
+
+        # Strip single line and multi-line comments
+        no_comments = re.sub(r"--.*?$", "", content, flags=re.MULTILINE)
+        no_comments = re.sub(r"/\*.*?\*/", "", no_comments, flags=re.DOTALL)
+
+        # Match CREATE TABLE blocks
+        table_pattern = re.compile(r"CREATE\s+(?:TEMP\s+|TEMPORARY\s+|UNLOGGED\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)\s*\((.*?)\);", re.IGNORECASE | re.DOTALL)
+        # Match CREATE VIEW / TYPE
+        view_pattern = re.compile(r"CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+([^\s(]+)\s+AS\s+(.*?);", re.IGNORECASE | re.DOTALL)
+        type_pattern = re.compile(r"CREATE\s+TYPE\s+([^\s(]+)\s+AS\s+(?:ENUM\s*)?\((.*?)\);", re.IGNORECASE | re.DOTALL)
+        index_pattern = re.compile(r"CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s]+)\s+ON\s+([^\s(]+)\s*\((.*?)\);", re.IGNORECASE)
+        fk_pattern = re.compile(r"ALTER\s+TABLE\s+(?:ONLY\s+)?([^\s]+)\s+ADD\s+CONSTRAINT\s+([^\s]+)\s+FOREIGN\s+KEY\s*\((.*?)\)\s*REFERENCES\s+([^\s(]+)\s*\((.*?)\);", re.IGNORECASE)
+
+        output_blocks = []
+
+        # 1. Custom Types / Enums
+        types_found = list(type_pattern.finditer(no_comments))
+        if types_found:
+            output_blocks.append("-- [T-Zero AST Schema Types]")
+            for m in types_found:
+                name = m.group(1).strip()
+                vals = re.sub(r"\s+", " ", m.group(2)).strip()
+                output_blocks.append(f"CREATE TYPE {name} AS ({vals});")
+            output_blocks.append("")
+
+        # 2. Tables & Columns
+        tables_found = list(table_pattern.finditer(no_comments))
+        if tables_found:
+            output_blocks.append("-- [T-Zero AST Schema Tables]")
+            for m in tables_found:
+                tname = m.group(1).strip()
+                raw_cols = m.group(2)
+
+                # Parse individual column/constraint definitions
+                col_defs = []
+                # Split by commas not inside parentheses
+                lines = [c.strip() for c in re.split(r",\s*(?![^()]*\))", raw_cols) if c.strip()]
+                for col in lines:
+                    col_clean = re.sub(r"\s+", " ", col)
+                    if mode == "ultra":
+                        # Ultra mode: keep Column Name + Type + Primary/Unique/Not Null/References
+                        col_clean = re.sub(r"(?i)\s+DEFAULT\s+[^,]+", "", col_clean)
+                        col_clean = re.sub(r"(?i)\s*(?:CONSTRAINT\s+[^\s]+\s+)?CHECK\s*\(.*?\)", "", col_clean)
+                    if col_clean.strip():
+                        col_defs.append(f"  {col_clean.strip()}")
+
+                output_blocks.append(f"CREATE TABLE {tname} (\n" + ",\n".join(col_defs) + "\n);")
+            output_blocks.append("")
+
+        # 3. Foreign Keys / Relationships
+        fks_found = list(fk_pattern.finditer(no_comments))
+        if fks_found:
+            output_blocks.append("-- [T-Zero AST Foreign Keys & Boundaries]")
+            for m in fks_found:
+                tbl = m.group(1).strip()
+                cname = m.group(2).strip()
+                src_cols = m.group(3).strip()
+                ref_tbl = m.group(4).strip()
+                ref_cols = m.group(5).strip()
+                output_blocks.append(f"ALTER TABLE {tbl} ADD CONSTRAINT {cname} FOREIGN KEY ({src_cols}) REFERENCES {ref_tbl}({ref_cols});")
+            output_blocks.append("")
+
+        # 4. Indexes
+        idx_found = list(index_pattern.finditer(no_comments))
+        if idx_found and mode != "ultra":
+            output_blocks.append("-- [T-Zero AST Indexes]")
+            for m in idx_found:
+                iname = m.group(1).strip()
+                on_tbl = m.group(2).strip()
+                icols = m.group(3).strip()
+                output_blocks.append(f"CREATE INDEX {iname} ON {on_tbl} ({icols});")
+            output_blocks.append("")
+
+        res = "\n".join(output_blocks).strip()
+        if not res:
+            # Fallback if raw queries without explicit CREATE TABLE
+            lines = [l.strip() for l in no_comments.splitlines() if l.strip() and not l.strip().upper().startswith(("INSERT INTO", "COPY "))]
+            res = "\n".join(lines[:120])
+
+        savings = max(0.0, ((orig_len - len(res)) / max(orig_len, 1)) * 100.0)
+        return res, savings
+
+    # --------------------------------------------------------------------------
+    # 2. KUBERNETES MANIFEST & YAML COMPRESSOR
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def reduce_k8s_yaml(content: str, mode: str = "ultra") -> Tuple[str, float]:
+        """Compresses Kubernetes YAML manifests down to architectural interfaces."""
+        orig_len = len(content)
+        if orig_len < 80:
+            return content, 0.0
+
+        docs = re.split(r"^---\s*$", content, flags=re.MULTILINE)
+        reduced_docs = []
+
+        for doc in docs:
+            doc_str = doc.strip()
+            if not doc_str:
+                continue
+
+            lines = doc_str.splitlines()
+            retained_lines = []
+            skip_section = False
+            skip_indent = 0
+
+            for line in lines:
+                raw_indent = len(line) - len(line.lstrip())
+                stripped = line.strip()
+
+                # Skip kubectl / runtime status bloat
+                if re.match(r"^(status|managedFields|annotations):", stripped):
+                    skip_section = True
+                    skip_indent = raw_indent
+                    continue
+
+                if skip_section:
+                    if raw_indent > skip_indent:
+                        continue
+                    else:
+                        skip_section = False
+
+                # Keep structural keys
+                if any(stripped.startswith(k) for k in [
+                    "apiVersion:", "kind:", "name:", "namespace:", "replicas:",
+                    "containers:", "- name:", "image:", "containerPort:", "port:",
+                    "targetPort:", "protocol:", "serviceAccountName:", "type:",
+                    "claimName:", "mountPath:", "host:", "path:", "service:"
+                ]):
+                    retained_lines.append(line)
+                elif mode == "balanced" and raw_indent <= 4 and ":" in stripped:
+                    retained_lines.append(line)
+
+            if retained_lines:
+                reduced_docs.append("\n".join(retained_lines))
+
+        res = "\n---\n".join(reduced_docs)
+        if not res.strip():
+            res = content[:300]
+
+        savings = max(0.0, ((orig_len - len(res)) / max(orig_len, 1)) * 100.0)
+        return res, savings
+
+    # --------------------------------------------------------------------------
+    # 3. DOCKERFILE COMPRESSOR
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def reduce_dockerfile(content: str, mode: str = "ultra") -> Tuple[str, float]:
+        """Condenses Dockerfiles into clean build stage architectures."""
+        orig_len = len(content)
+        lines = content.splitlines()
+        pruned = []
+
+        in_multiline_run = False
+        for line in lines:
+            s = line.strip()
+            if not s or s.startswith("#"):
+                continue
+
+            if in_multiline_run:
+                if s.endswith("\\"):
+                    continue
+                else:
+                    in_multiline_run = False
+                    continue
+
+            if s.startswith(("FROM ", "EXPOSE ", "ENTRYPOINT ", "CMD ", "ENV ", "WORKDIR ", "ARG ", "HEALTHCHECK ")):
+                pruned.append(s)
+            elif s.startswith("COPY "):
+                pruned.append(re.sub(r"\s+", " ", s))
+            elif s.startswith("RUN "):
+                if s.endswith("\\"):
+                    in_multiline_run = True
+                    pruned.append(f"RUN [build dependencies & binary install]")
+                else:
+                    pruned.append(s[:70] + ("..." if len(s) > 70 else ""))
+
+        res = "\n".join(pruned)
+        savings = max(0.0, ((orig_len - len(res)) / max(orig_len, 1)) * 100.0)
+        return res, savings
+
+    # --------------------------------------------------------------------------
+    # 4. TERRAFORM / HCL COMPRESSOR
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def reduce_terraform(content: str, mode: str = "ultra") -> Tuple[str, float]:
+        """Condenses Terraform HCL into infrastructure topology contracts."""
+        orig_len = len(content)
+        block_pattern = re.compile(
+            r'((?:resource|data|module|variable|output|provider|terraform)(?:\s+["\w_-]+){0,2})\s*\{(.*?)\n[ \t]*\}',
+            re.DOTALL
+        )
+
+        matches = list(block_pattern.finditer(content))
+        if not matches:
+            return content, 0.0
+
+        pruned_blocks = []
+        for m in matches:
+            header = m.group(1).strip()
+            body = m.group(2)
+
+            key_lines = []
+            for line in body.splitlines():
+                s = line.strip()
+                if not s or s.startswith("#") or s.startswith("//"):
+                    continue
+                if "=" in s or "{" in s:
+                    k = s.split("=")[0].strip()
+                    if any(req in k for req in ["type", "default", "description", "source", "version", "name", "id", "ami", "instance_type"]):
+                        key_lines.append(f"  {s}")
+
+            if key_lines:
+                pruned_blocks.append(f"{header} {{\n" + "\n".join(key_lines) + "\n}")
+            else:
+                pruned_blocks.append(f"{header} {{ ... }}")
+
+        res = "\n\n".join(pruned_blocks)
+        savings = max(0.0, ((orig_len - len(res)) / max(orig_len, 1)) * 100.0)
+        return res, savings
+
+    # --------------------------------------------------------------------------
+    # UNIVERSAL DISPATCHER
+    # --------------------------------------------------------------------------
+    @classmethod
+    def reduce(cls, filename_or_ext: str, content: str, mode: str = "ultra") -> Tuple[str, float]:
+        f = filename_or_ext.lower()
+        if f.endswith(".sql"):
+            return cls.reduce_sql(content, mode)
+        elif f.endswith((".yaml", ".yml")):
+            return cls.reduce_k8s_yaml(content, mode)
+        elif "dockerfile" in f:
+            return cls.reduce_dockerfile(content, mode)
+        elif f.endswith((".tf", ".hcl")):
+            return cls.reduce_terraform(content, mode)
+        return content, 0.0

package/src/tzero_jarvis/__init__.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""
+T-Zero Jarvis Autonomous Engine & Semantic Memory Package
+---------------------------------------------------------
+Developer: Toprak Ahmet Aydoğmuş (Siber Akademi)
+Version: 6.0.0
+"""
+
+from .semantic_compressor import (
+    SemanticTriplet,
+    SemanticTripletExtractor,
+    SemanticExtractor,
+    TypedEntity,
+    EntityType,
+    VectorQuantizedCodebook,
+    DynamicVirtualMemoryInjector,
+    get_global_compressor
+)
+from .zero_key_router import (
+    ZeroKeyAIRouter,
+    ZeroCostSecurityGuard
+)
+from .orchestrator import (
+    JarvisOrchestrator,
+    AutonomousGoalResult
+)
+from .causal_graph import (
+    CausalTemporalGraph,
+    CausalRelationType,
+    CausalEdge,
+    CausalNode
+)
+from .self_healing import (
+    SelfHealingExecutionEngine,
+    ExecutionResult
+)
+from .memory_consolidation import (
+    ConsolidationEngine,
+    EpisodicMemoryBuffer,
+    Episode,
+    MacroTriplet
+)
+from .hybrid_search import (
+    ZeroVectorDBSearchEngine,
+    SearchDocument,
+    SearchResult
+)
+from .swarm import (
+    SwarmCoordinator,
+    SwarmAgentReport,
+    SecuritySentinelAgent,
+    EmbeddedHardwareAgent,
+    ASTOptimizerAgent,
+    AutonomousDevOpsAgent
+)
+from .graph_visualizer import (
+    CyberpunkGraphVisualizer,
+    DOMAIN_COLORS
+)
+from .minhash_lsh import (
+    MinHashLSHEngine,
+    MinHashSignature
+)
+from .swarm_bft import (
+    ByzantineFaultTolerantSwarm,
+    BFTConsensusCertificate
+)
+from .latent_press import (
+    LatentPressCompressor,
+    LatentPressResult
+)
+from .workspace_orchestrator import (
+    WorkspaceOrchestrator,
+    WorkspaceProfiler,
+    WorkspaceProfile,
+    WorkspaceGovernanceSynthesizer
+)
+
+ZeroKeyRouter = ZeroKeyAIRouter
+AutonomousGoalOrchestrator = JarvisOrchestrator
+
+__all__ = [
+    "SemanticTriplet",
+    "SemanticTripletExtractor",
+    "SemanticExtractor",
+    "TypedEntity",
+    "EntityType",
+    "VectorQuantizedCodebook",
+    "DynamicVirtualMemoryInjector",
+    "get_global_compressor",
+    "ZeroKeyAIRouter",
+    "ZeroKeyRouter",
+    "ZeroCostSecurityGuard",
+    "JarvisOrchestrator",
+    "AutonomousGoalOrchestrator",
+    "AutonomousGoalResult",
+    "CausalTemporalGraph",
+    "CausalRelationType",
+    "CausalEdge",
+    "CausalNode",
+    "SelfHealingExecutionEngine",
+    "ExecutionResult",
+    "ConsolidationEngine",
+    "EpisodicMemoryBuffer",
+    "Episode",
+    "MacroTriplet",
+    "ZeroVectorDBSearchEngine",
+    "SearchDocument",
+    "SearchResult",
+    "SwarmCoordinator",
+    "SwarmAgentReport",
+    "CyberpunkGraphVisualizer",
+    "DOMAIN_COLORS",
+    "MinHashLSHEngine",
+    "MinHashSignature",
+    "ByzantineFaultTolerantSwarm",
+    "BFTConsensusCertificate",
+    "LatentPressCompressor",
+    "LatentPressResult",
+    "WorkspaceOrchestrator",
+    "WorkspaceProfiler",
+    "WorkspaceProfile",
+    "WorkspaceGovernanceSynthesizer"
+]