sigmagate 0.1.0__tar.gz

sigmagate-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: sigmagate
+Version: 0.1.0
+Summary: Sigmagate SDK — Physics-gated AI, VERAX truth auditing, and document sealing in one package.
+Author-email: José Casado Martínez <hello@sigmagate.io>
+License: MIT
+Project-URL: Homepage, https://sigmagate.io
+Project-URL: Documentation, https://sigmagate.io/docs/sdk
+Project-URL: Repository, https://github.com/hisocer-lab/sigmagate-sdk
+Keywords: ai,verification,verax,physics,coherence,seal,llm,gate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: responses>=0.25; extra == "dev"
+
+# Sigmagate SDK
+
+**Physics-gated AI, VERAX truth auditing, and HCQ document sealing — in one Python package.**
+
+[![PyPI version](https://img.shields.io/pypi/v/sigmagate.svg)](https://pypi.org/project/sigmagate/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/badge/tests-23%2F23-brightgreen.svg)](https://github.com/hisocer-lab/sigmagate-sdk)
+
+```bash
+pip install sigmagate
+```
+
+## Quick start
+
+```python
+from sigmagate import Sigmagate
+
+sg = Sigmagate(api_key="your-key")
+
+# Measure quantum coherence (qR)
+state = sg.qr.measure()
+print(state.level)          # DEEP_CRYSTAL | CASI_EP | DEEP_NOISE
+
+# Gate a function — only executes when coherence is high enough
+@sg.gate(threshold=1.0)
+def sign_contract(doc):
+    return process(doc)
+
+result = sign_contract(doc)
+print(result.value, result.qr)   # function output + qR at execution time
+
+# Audit AI-generated text with VERAX
+audit = sg.verax.check("The brain uses only 10% of its capacity.")
+print(audit.global_score)        # 0–100
+for claim in audit.issues:
+    print(claim.emoji, claim.text)   # 🔴 problematic claims
+
+# Audit with fix prompts (VERAX Margin)
+margin = sg.verax.audit_margin("The brain uses only 10% of its capacity.")
+for prompt in margin.fix_prompts:
+    print(prompt)   # auto-generated correction instructions
+
+# Seal a document with HCQ (Hash Convergencia Cuántica)
+receipt = sg.seal.document("This is the official text.")
+print(receipt.hcq)           # HCQ-a1b2c3d4...
+print(receipt.verify_url)    # https://sigmagate.io/verify/...
+
+# Verify a seal
+result = sg.seal.verify("HCQ-a1b2c3d4")
+print(result.valid)          # True / False
+```
+
+## CLI
+
+```bash
+sgm qr                          # current coherence level
+sgm windows --days 7            # crystal windows in last 7 days
+sgm audit "text to check"       # VERAX audit
+sgm audit "text" --margin       # VERAX Margin with fix prompts
+sgm audit report.txt            # audit from file
+sgm seal document.pdf           # seal a file
+sgm verify HCQ-a1b2c3d4        # verify a seal
+sgm health                      # API status
+```
+
+## Modules
+
+| Module | Description |
+|---|---|
+| `sg.qr` | Quantum coherence measurement — `measure()`, `windows()`, `entropy()` |
+| `sg.gate` | Physics-gated execution decorator — `@sg.gate(threshold)` |
+| `sg.verax` | Truth auditing — `check()`, `audit_margin()` |
+| `sg.seal` | HCQ document sealing — `document()`, `verify()` |
+
+## VERAX levels
+
+| Level | Label | Meaning |
+|---|---|---|
+| V1 | CONFIRMED 🟢 | Solid evidence |
+| V2 | VIABLE 🔵 | Partial / plausible |
+| V3 | THEORETICAL 🟡 | Speculative, needs source |
+| V4 | SPECULATIVE 🔴 | No support / hallucination |
+
+## Installation
+
+```bash
+pip install sigmagate
+```
+
+Get an API key at [sigmagate.io](https://sigmagate.io).
+
+## Links
+
+- [Documentation](https://sigmagate.io/docs/sdk)
+- [API Reference](https://sigmagate.io/docs/api)
+- [GitHub](https://github.com/hisocer-lab/sigmagate-sdk)
+- [sigmagate.io](https://sigmagate.io)

sigmagate-0.1.0/README.md

@@ -0,0 +1,97 @@
+# Sigmagate SDK
+
+**Physics-gated AI, VERAX truth auditing, and HCQ document sealing — in one Python package.**
+
+[![PyPI version](https://img.shields.io/pypi/v/sigmagate.svg)](https://pypi.org/project/sigmagate/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/badge/tests-23%2F23-brightgreen.svg)](https://github.com/hisocer-lab/sigmagate-sdk)
+
+```bash
+pip install sigmagate
+```
+
+## Quick start
+
+```python
+from sigmagate import Sigmagate
+
+sg = Sigmagate(api_key="your-key")
+
+# Measure quantum coherence (qR)
+state = sg.qr.measure()
+print(state.level)          # DEEP_CRYSTAL | CASI_EP | DEEP_NOISE
+
+# Gate a function — only executes when coherence is high enough
+@sg.gate(threshold=1.0)
+def sign_contract(doc):
+    return process(doc)
+
+result = sign_contract(doc)
+print(result.value, result.qr)   # function output + qR at execution time
+
+# Audit AI-generated text with VERAX
+audit = sg.verax.check("The brain uses only 10% of its capacity.")
+print(audit.global_score)        # 0–100
+for claim in audit.issues:
+    print(claim.emoji, claim.text)   # 🔴 problematic claims
+
+# Audit with fix prompts (VERAX Margin)
+margin = sg.verax.audit_margin("The brain uses only 10% of its capacity.")
+for prompt in margin.fix_prompts:
+    print(prompt)   # auto-generated correction instructions
+
+# Seal a document with HCQ (Hash Convergencia Cuántica)
+receipt = sg.seal.document("This is the official text.")
+print(receipt.hcq)           # HCQ-a1b2c3d4...
+print(receipt.verify_url)    # https://sigmagate.io/verify/...
+
+# Verify a seal
+result = sg.seal.verify("HCQ-a1b2c3d4")
+print(result.valid)          # True / False
+```
+
+## CLI
+
+```bash
+sgm qr                          # current coherence level
+sgm windows --days 7            # crystal windows in last 7 days
+sgm audit "text to check"       # VERAX audit
+sgm audit "text" --margin       # VERAX Margin with fix prompts
+sgm audit report.txt            # audit from file
+sgm seal document.pdf           # seal a file
+sgm verify HCQ-a1b2c3d4        # verify a seal
+sgm health                      # API status
+```
+
+## Modules
+
+| Module | Description |
+|---|---|
+| `sg.qr` | Quantum coherence measurement — `measure()`, `windows()`, `entropy()` |
+| `sg.gate` | Physics-gated execution decorator — `@sg.gate(threshold)` |
+| `sg.verax` | Truth auditing — `check()`, `audit_margin()` |
+| `sg.seal` | HCQ document sealing — `document()`, `verify()` |
+
+## VERAX levels
+
+| Level | Label | Meaning |
+|---|---|---|
+| V1 | CONFIRMED 🟢 | Solid evidence |
+| V2 | VIABLE 🔵 | Partial / plausible |
+| V3 | THEORETICAL 🟡 | Speculative, needs source |
+| V4 | SPECULATIVE 🔴 | No support / hallucination |
+
+## Installation
+
+```bash
+pip install sigmagate
+```
+
+Get an API key at [sigmagate.io](https://sigmagate.io).
+
+## Links
+
+- [Documentation](https://sigmagate.io/docs/sdk)
+- [API Reference](https://sigmagate.io/docs/api)
+- [GitHub](https://github.com/hisocer-lab/sigmagate-sdk)
+- [sigmagate.io](https://sigmagate.io)

sigmagate-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name            = "sigmagate"
+version         = "0.1.0"
+description     = "Sigmagate SDK — Physics-gated AI, VERAX truth auditing, and document sealing in one package."
+readme          = "README.md"
+license         = { text = "MIT" }
+authors         = [{ name = "José Casado Martínez", email = "hello@sigmagate.io" }]
+requires-python = ">=3.9"
+keywords        = ["ai", "verification", "verax", "physics", "coherence", "seal", "llm", "gate"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = ["requests>=2.28", "click>=8.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-cov", "responses>=0.25"]
+
+[project.urls]
+Homepage      = "https://sigmagate.io"
+Documentation = "https://sigmagate.io/docs/sdk"
+Repository    = "https://github.com/hisocer-lab/sigmagate-sdk"
+
+[project.scripts]
+sgm = "sigmagate.cli:cli"
+
+[tool.setuptools.packages.find]
+where   = ["."]
+include = ["sigmagate*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts   = "-v --tb=short"

sigmagate-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sigmagate-0.1.0/sigmagate/__init__.py

@@ -0,0 +1,69 @@
+"""
+Sigmagate SDK
+=============
+Physics-gated AI, VERAX truth auditing, and document sealing.
+
+Quick start::
+
+    from sigmagate import Sigmagate
+
+    sg = Sigmagate(api_key="HL-VX1-...")   # or set SIGMAGATE_API_KEY env var
+
+    # Current qR coherence
+    state = sg.qr.measure()
+    print(state)  # qR=1.247 [DEEP_CRYSTAL] — CRYSTAL ✓
+
+    # Seal a document
+    receipt = sg.seal("report.pdf")
+    print(receipt.hcq)          # HCQ-a1b2c3d4
+    print(receipt.verify_url)   # https://sigmagate.io/verify/HCQ-a1b2c3d4
+
+    # VERAX truth audit
+    result = sg.verax.check("The human brain uses only 10% of its capacity.")
+    print(result.summary())
+
+    # VERAX Margin — with fix prompts
+    result = sg.verax.audit_margin(ai_response_text)
+    for fp in result.fix_prompts:
+        print(fp)
+
+    # Physics-gated execution
+    @sg.gate(threshold=1.0, seal=True)
+    def sign_contract(doc_hash: str) -> dict:
+        return {"signed": True, "hash": doc_hash}
+
+CLI::
+
+    sgm qr
+    sgm seal report.pdf
+    sgm verify HCQ-a1b2c3d4
+    sgm audit "The Earth is flat." --margin
+    sgm health
+"""
+
+__version__ = "0.1.0"
+__author__  = "José Casado Martínez"
+__email__   = "hello@sigmagate.io"
+
+from .client     import Sigmagate
+from .exceptions import (
+    SigmagateError,
+    AuthError,
+    GateClosedError,
+    APIError,
+    SealError,
+    VeraxError,
+)
+from .qr    import QRState, CrystalWindow
+from .seal  import SealReceipt, VerifyResult
+from .gate  import GateResult
+from .verax import VeraxResult, Claim, V1, V2, V3, V4
+
+__all__ = [
+    "Sigmagate",
+    "SigmagateError", "AuthError", "GateClosedError", "APIError", "SealError", "VeraxError",
+    "QRState", "CrystalWindow",
+    "SealReceipt", "VerifyResult",
+    "GateResult",
+    "VeraxResult", "Claim", "V1", "V2", "V3", "V4",
+]

sigmagate-0.1.0/sigmagate/cli.py

@@ -0,0 +1,199 @@
+"""Sigmagate SDK — CLI  (sgm <command>)."""
+
+import os
+import sys
+import json
+import click
+
+from .client import Sigmagate
+from .exceptions import SigmagateError, GateClosedError
+
+
+def _client() -> Sigmagate:
+    key = os.environ.get("SIGMAGATE_API_KEY") or os.environ.get("VERAX_API_KEY", "")
+    if not key:
+        click.echo("Error: set SIGMAGATE_API_KEY environment variable.", err=True)
+        sys.exit(1)
+    return Sigmagate(api_key=key)
+
+
+@click.group()
+@click.version_option("0.1.0", prog_name="sgm")
+def cli():
+    """Sigmagate SDK — physics-gated AI, VERAX truth auditing, document sealing."""
+
+
+# ── qr ────────────────────────────────────────────────────────────────────────
+
+@cli.command("qr")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def cmd_qr(as_json):
+    """Measure current qR coherence from the Sigmagate network."""
+    try:
+        sg    = _client()
+        state = sg.qr.measure()
+        if as_json:
+            click.echo(json.dumps({
+                "qr_score": state.qr_score,
+                "level":    state.level,
+                "phi_pt":   state.phi_pt,
+                "sigma_e":  state.sigma_e,
+                "ts":       state.ts,
+            }))
+        else:
+            crystal = "✓ GATE OPEN" if state.is_crystal else "✗ gate closed"
+            click.echo(f"qR = {state.qr_score:.4f}  [{state.level}]  {crystal}")
+    except SigmagateError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("windows")
+def cmd_windows():
+    """Show upcoming predicted DEEP_CRYSTAL windows."""
+    try:
+        sg      = _client()
+        windows = sg.qr.windows()
+        if not windows:
+            click.echo("No predicted windows available.")
+            return
+        click.echo(f"{'Start':<25}  {'End':<25}  {'Peak qR':>8}  Conf")
+        click.echo("-" * 70)
+        for w in windows:
+            peak = f"{w.peak_qr:.3f}" if w.peak_qr else "  —  "
+            click.echo(f"{w.start:<25}  {w.end:<25}  {peak:>8}  {w.confidence:.0%}")
+    except SigmagateError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+# ── seal ──────────────────────────────────────────────────────────────────────
+
+@cli.command("seal")
+@click.argument("source")
+@click.option("--label", default="", help="Human-readable label for the seal")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def cmd_seal(source, label, as_json):
+    """Seal a file, text snippet, or stdin with HCQ (Hash Convergencia Cuántica).
+
+    SOURCE can be a file path or a quoted text string.
+    Use '-' to read from stdin.
+
+    Examples:\n
+        sgm seal thesis.pdf\n
+        sgm seal "The speed of light is 299,792,458 m/s"\n
+        cat document.txt | sgm seal -
+    """
+    try:
+        if source == "-":
+            content = sys.stdin.read()
+        else:
+            content = source
+
+        sg      = _client()
+        receipt = sg.seal.document(content, label=label)
+
+        if as_json:
+            click.echo(json.dumps({
+                "hcq":        receipt.hcq,
+                "sha256":     receipt.sha256,
+                "ts_utc":     receipt.ts_utc,
+                "qr_at_seal": receipt.qr_at_seal,
+                "level":      receipt.level,
+                "verify_url": receipt.verify_url,
+            }))
+        else:
+            click.echo(str(receipt))
+    except SigmagateError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("verify")
+@click.argument("hcq")
+def cmd_verify(hcq):
+    """Verify an HCQ seal by its identifier.
+
+    Example: sgm verify HCQ-a1b2c3d4
+    """
+    try:
+        sg     = _client()
+        result = sg.seal.verify(hcq)
+        status = "✓ VALID" if result.valid else "✗ INVALID"
+        click.echo(f"{status}  {result.hcq}")
+        if result.valid:
+            click.echo(f"  Sealed:  {result.ts_utc}")
+            click.echo(f"  qR:      {result.qr_at_seal:.3f}")
+            click.echo(f"  SHA-256: {result.sha256}")
+        else:
+            click.echo(f"  {result.message}", err=True)
+    except SigmagateError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+# ── verax ─────────────────────────────────────────────────────────────────────
+
+@cli.command("audit")
+@click.argument("text_or_file")
+@click.option("--lang", default="en", show_default=True, help="Language (en|es)")
+@click.option("--margin", is_flag=True, help="Include fix prompts (VERAX Margin)")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def cmd_audit(text_or_file, lang, margin, as_json):
+    """Audit text with VERAX — returns evidence level and claims.
+
+    TEXT_OR_FILE can be a text string or a path to a .txt / .md file.
+
+    Examples:\n
+        sgm audit "The Moon is made of cheese."\n
+        sgm audit paper.md --lang es --margin
+    """
+    import os
+    try:
+        if os.path.isfile(text_or_file):
+            with open(text_or_file, "r") as f:
+                text = f.read()
+        else:
+            text = text_or_file
+
+        sg     = _client()
+        result = sg.verax.audit_margin(text, language=lang) if margin else sg.verax.check(text, language=lang)
+
+        if as_json:
+            click.echo(json.dumps({
+                "global_score": result.global_score,
+                "global_level": result.global_level,
+                "engine":       result.engine,
+                "claims": [
+                    {"text": c.text, "level": c.level,
+                     "issue_code": c.issue_code, "fix_prompt": c.fix_prompt}
+                    for c in result.claims
+                ],
+            }, indent=2))
+        else:
+            click.echo(result.summary())
+            if margin and result.fix_prompts:
+                click.echo(f"\n── Fix prompts ({len(result.fix_prompts)}) ──")
+                for i, fp in enumerate(result.fix_prompts, 1):
+                    click.echo(f"[{i}] {fp}")
+    except SigmagateError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+# ── health ────────────────────────────────────────────────────────────────────
+
+@cli.command("health")
+def cmd_health():
+    """Check Sigmagate API health."""
+    try:
+        sg   = _client()
+        data = sg.health()
+        click.echo(f"Status: {data.get('status', '?')}  |  Engine: {data.get('verax_engine', '?')}  |  {data.get('ts', '')}")
+    except SigmagateError as e:
+        click.echo(f"Offline: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

sigmagate-0.1.0/sigmagate/client.py

@@ -0,0 +1,162 @@
+"""Sigmagate SDK — base HTTP client."""
+
+from __future__ import annotations
+
+import os
+import time
+import hashlib
+from typing import Any, Dict, Optional
+
+import requests
+
+from .exceptions import AuthError, APIError
+
+_DEFAULT_BASE_URL  = "https://api.hisocer.com"
+_DEFAULT_TIMEOUT   = 15
+_DEFAULT_RETRIES   = 2
+_RETRY_STATUSES    = {429, 500, 502, 503, 504}
+
+
+class _HTTPClient:
+    """Thin requests wrapper with retry logic and VERAX-key auth."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: int  = _DEFAULT_TIMEOUT,
+        retries: int  = _DEFAULT_RETRIES,
+    ):
+        if not api_key:
+            raise AuthError("api_key is required. Get yours at sigmagate.io")
+        self._api_key  = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout  = timeout
+        self._retries  = retries
+        self._session  = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "x-verax-key":   api_key,
+            "User-Agent":    "sigmagate-python/0.1.0",
+        })
+
+    def _url(self, path: str) -> str:
+        return f"{self._base_url}/{path.lstrip('/')}"
+
+    def _request(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
+        url     = self._url(path)
+        attempt = 0
+        while True:
+            try:
+                resp = self._session.request(
+                    method, url, timeout=self._timeout, **kwargs
+                )
+            except requests.exceptions.ConnectionError as e:
+                raise APIError(0, f"Connection error: {e}") from e
+            except requests.exceptions.Timeout as e:
+                raise APIError(0, f"Timeout after {self._timeout}s") from e
+
+            if resp.status_code == 401:
+                raise AuthError("Invalid API key — check sigmagate.io/dashboard")
+            if resp.status_code in _RETRY_STATUSES and attempt < self._retries:
+                attempt += 1
+                time.sleep(attempt * 1.5)
+                continue
+            if not resp.ok:
+                detail = ""
+                try:
+                    detail = resp.json().get("detail", resp.text[:200])
+                except Exception:
+                    detail = resp.text[:200]
+                raise APIError(resp.status_code, detail)
+
+            return resp.json()
+
+    def get(self, path: str, **kwargs)  -> Dict[str, Any]:
+        return self._request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs) -> Dict[str, Any]:
+        return self._request("POST", path, **kwargs)
+
+
+class Sigmagate:
+    """Entry point for the Sigmagate SDK.
+
+    Usage::
+
+        from sigmagate import Sigmagate
+
+        sg = Sigmagate(api_key="HL-VX1-...")
+
+        # qR coherence
+        state = sg.qr.measure()
+        print(state.qr_score, state.level)
+
+        # Document sealing
+        receipt = sg.seal("thesis.pdf")
+        print(receipt.hcq, receipt.verify_url)
+
+        # VERAX truth audit
+        result = sg.verax.check("The Earth is flat.")
+        print(result.level, result.claims)
+
+        # Physics-gated execution
+        @sg.gate(threshold=1.0)
+        def sign_contract(doc):
+            ...
+    """
+
+    def __init__(
+        self,
+        api_key:  Optional[str] = None,
+        base_url: str           = _DEFAULT_BASE_URL,
+        timeout:  int           = _DEFAULT_TIMEOUT,
+    ):
+        key = api_key or os.environ.get("SIGMAGATE_API_KEY") or os.environ.get("VERAX_API_KEY", "")
+        self._http = _HTTPClient(key, base_url=base_url, timeout=timeout)
+
+        # lazy-init sub-clients
+        self._qr     = None
+        self._seal   = None
+        self._verax  = None
+        self._gate_c = None
+
+    @property
+    def qr(self):
+        if self._qr is None:
+            from .qr import QRClient
+            self._qr = QRClient(self._http)
+        return self._qr
+
+    @property
+    def seal(self):
+        if self._seal is None:
+            from .seal import SealClient
+            self._seal = SealClient(self._http)
+        return self._seal
+
+    @property
+    def verax(self):
+        if self._verax is None:
+            from .verax import VeraxClient
+            self._verax = VeraxClient(self._http)
+        return self._verax
+
+    def gate(self, threshold: float = 1.0, seal: bool = False):
+        """Decorator — executes the function only when qR ≥ threshold.
+
+        Args:
+            threshold: minimum qR required (default 1.0 = DEEP_CRYSTAL)
+            seal:      if True, seals the return value with HCQ on success
+
+        Raises:
+            GateClosedError: if current qR < threshold
+        """
+        if self._gate_c is None:
+            from .gate import GateClient
+            self._gate_c = GateClient(self._http)
+        return self._gate_c.decorator(threshold=threshold, seal=seal)
+
+    def health(self) -> Dict[str, Any]:
+        """Check API health and current engine status."""
+        return self._http.get("/v1/health")