proxima-cli 1.0.0__py3-none-any.whl

prox/commands/agent.py

@@ -0,0 +1,345 @@
+"""prox agent — manage agents on the platform."""
+
+import json
+import subprocess
+import tarfile
+from pathlib import Path
+from typing import Optional
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from ..api import gateway_get, gateway_post, gateway_put, gateway_delete, APIError
+from ..config import get_value
+
+app = typer.Typer(help="Manage platform agents.")
+console = Console()
+
+
+@app.command("list")
+def list_agents(
+    domain: Optional[str] = typer.Option(None, "--domain", "-d", help="Filter by domain"),
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="Filter by status (active/draft)"),
+):
+    """List all agents on the platform."""
+    try:
+        params = {}
+        if domain:
+            params["domain"] = domain
+        if status:
+            params["status"] = status
+        data = gateway_get("/build/agents", params=params)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    agents = data.get("agents", [])
+    if not agents:
+        console.print("[dim]No agents found.[/dim]")
+        return
+
+    table = Table(title=f"Agents ({len(agents)})")
+    table.add_column("ID", style="bold")
+    table.add_column("Name")
+    table.add_column("Domain")
+    table.add_column("Status")
+    table.add_column("Version", justify="right")
+
+    for a in agents:
+        st = a.get("status", "draft")
+        st_style = "green" if st == "active" else "yellow" if st == "draft" else "dim"
+        table.add_row(
+            a.get("id", ""),
+            a.get("name", ""),
+            a.get("domain", ""),
+            f"[{st_style}]{st}[/{st_style}]",
+            str(a.get("version", 1)),
+        )
+
+    console.print(table)
+
+
+@app.command("get")
+def get_agent(agent_id: str = typer.Argument(help="Agent ID")):
+    """Get agent details."""
+    try:
+        data = gateway_get(f"/build/agents/{agent_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    agent = data.get("agent", data)
+    console.print(f"\n[bold]{agent.get('name', agent_id)}[/bold]")
+    console.print(f"  ID:          {agent.get('id')}")
+    console.print(f"  Codename:    {agent.get('codename', '—')}")
+    console.print(f"  Domain:      {agent.get('domain', '—')}")
+    console.print(f"  Role:        {agent.get('role', 'agent')}")
+    console.print(f"  Status:      {agent.get('status', '—')}")
+    console.print(f"  Version:     {agent.get('version', 1)}")
+    console.print(f"  Model:       {agent.get('llm', {}).get('model', '—')}")
+    if agent.get("toolboxes"):
+        console.print(f"  Toolboxes:   {', '.join(agent['toolboxes'])}")
+    if agent.get("knowledge_bases"):
+        console.print(f"  Knowledge:   {', '.join(agent['knowledge_bases'])}")
+    console.print()
+
+
+@app.command("create")
+def create_agent(
+    name: str = typer.Option(None, "--name", "-n", help="Agent name"),
+    codename: str = typer.Option(None, "--codename", help="Agent codename"),
+    domain: str = typer.Option(None, "--domain", "-d", help="Domain"),
+    role: str = typer.Option("agent", "--role", help="Role: agent or orchestrator"),
+    from_file: Optional[Path] = typer.Option(None, "--from", help="Create from agent.yaml file"),
+):
+    """Create a new agent."""
+    if from_file:
+        if not from_file.exists():
+            console.print(f"[red]Error:[/red] File not found: {from_file}")
+            raise typer.Exit(1)
+        config = yaml.safe_load(from_file.read_text())
+    else:
+        if not name:
+            console.print("[red]Error:[/red] Provide --name or --from")
+            raise typer.Exit(1)
+        agent_id = name.lower().replace(" ", "-").replace("_", "-")
+        config = {"id": agent_id, "name": name, "codename": codename or "", "domain": domain or "", "role": role}
+
+    try:
+        data = gateway_post("/build/agents", config)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]✓[/green] Agent created: {config.get('id', config.get('name'))}")
+
+
+@app.command("update")
+def update_agent(
+    agent_id: str = typer.Argument(help="Agent ID"),
+    prompt: Optional[str] = typer.Option(None, "--prompt", help="System prompt"),
+    model: Optional[str] = typer.Option(None, "--model", help="Model ID"),
+    from_file: Optional[Path] = typer.Option(None, "--from", help="Update from agent.yaml"),
+):
+    """Update an agent's configuration."""
+    if from_file:
+        if not from_file.exists():
+            console.print(f"[red]Error:[/red] File not found: {from_file}")
+            raise typer.Exit(1)
+        config = yaml.safe_load(from_file.read_text())
+    else:
+        config = {}
+        if prompt:
+            config["system_prompt"] = prompt
+        if model:
+            config["llm"] = {"model": model}
+        if not config:
+            console.print("[red]Error:[/red] Provide --prompt, --model, or --from")
+            raise typer.Exit(1)
+
+    try:
+        gateway_put(f"/build/agents/{agent_id}", config)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]✓[/green] Agent updated: {agent_id}")
+
+
+@app.command("publish")
+def publish_agent(agent_id: str = typer.Argument(help="Agent ID to publish")):
+    """Publish an agent (draft → active)."""
+    try:
+        gateway_post(f"/build/agents/{agent_id}/publish")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]✓[/green] Published: {agent_id}")
+
+
+@app.command("delete")
+def delete_agent(
+    agent_id: str = typer.Argument(help="Agent ID to delete"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete an agent."""
+    if not confirm:
+        typer.confirm(f"Delete agent '{agent_id}'? This cannot be undone", abort=True)
+
+    try:
+        gateway_delete(f"/build/agents/{agent_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]✓[/green] Deleted: {agent_id}")
+
+
+@app.command("deploy")
+def deploy_agent(
+    from_path: Path = typer.Option(..., "--from", help="Path to agent package directory"),
+):
+    """Full agent deploy: build toolbox → register → configure → publish.
+
+    Expects directory structure:
+      agent.yaml, toolbox/, workspace.json, knowledge.yaml, ontology.yaml, data/synthetic/
+    """
+    if not from_path.exists():
+        console.print(f"[red]Error:[/red] Path not found: {from_path}")
+        raise typer.Exit(1)
+
+    agent_yaml = from_path / "agent.yaml"
+    if not agent_yaml.exists():
+        console.print(f"[red]Error:[/red] No agent.yaml found in {from_path}")
+        raise typer.Exit(1)
+
+    config = yaml.safe_load(agent_yaml.read_text())
+    agent_id = config["id"]
+    console.print(f"\n[bold]Deploying:[/bold] {config.get('name', agent_id)} ({agent_id})\n")
+
+    # Step 1: Build and push toolbox (if exists)
+    toolbox_dir = from_path / "toolbox"
+    if toolbox_dir.exists() and (toolbox_dir / "Dockerfile").exists():
+        _deploy_toolbox(agent_id, toolbox_dir, config)
+
+    # Step 2: Upload knowledge data (if exists)
+    knowledge_yaml = from_path / "knowledge.yaml"
+    if knowledge_yaml.exists():
+        _deploy_knowledge(agent_id, knowledge_yaml, from_path)
+
+    # Step 2b: Deploy ontology (if exists)
+    ontology_yaml = from_path / "ontology.yaml"
+    if ontology_yaml.exists():
+        console.print("  [bold]2b.[/bold] Deploying ontology...")
+        try:
+            ont_data = yaml.safe_load(ontology_yaml.read_text())
+            ont_id = ont_data.get("id", f"{agent_id}-ontology")
+            gateway_post("/build/ontology", ont_data)
+            # Connect ontology to agent config
+            config["ontology"] = {"id": ont_id}
+            console.print(f"     [green]\u2713[/green] Ontology deployed: {ont_id}")
+        except APIError:
+            # May already exist — try update
+            try:
+                gateway_put(f"/build/ontology/{ont_data.get('id', '')}", ont_data)
+                config["ontology"] = {"id": ont_data.get('id', '')}
+                console.print(f"     [green]\u2713[/green] Ontology updated: {ont_data.get('id', '')}")
+            except APIError as e:
+                console.print(f"     [yellow]\u26a0[/yellow] Ontology: {e.detail}")
+
+    # Step 3: Create/update agent in registry
+    console.print("  [bold]3.[/bold] Registering agent...")
+    try:
+        gateway_put(f"/build/agents/{agent_id}", config)
+        console.print("     [green]✓[/green] Agent registered")
+    except APIError as e:
+        console.print(f"     [red]✗[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    # Step 4: Push workspace (if exists)
+    workspace_json = from_path / "workspace.json"
+    if workspace_json.exists():
+        console.print("  [bold]4.[/bold] Pushing workspace...")
+        try:
+            ws = json.loads(workspace_json.read_text())
+            gateway_put(f"/workspaces/{agent_id}", ws)
+            console.print("     [green]✓[/green] Workspace pushed")
+        except APIError as e:
+            console.print(f"     [yellow]⚠[/yellow] Workspace push failed: {e.detail}")
+
+    # Step 5: Publish
+    console.print("  [bold]5.[/bold] Publishing...")
+    try:
+        gateway_post(f"/build/agents/{agent_id}/publish")
+        console.print("     [green]✓[/green] Published (status: active)")
+    except APIError as e:
+        console.print(f"     [yellow]⚠[/yellow] Publish failed: {e.detail}")
+
+    # Step 6: Health check
+    console.print("  [bold]6.[/bold] Health check...")
+    try:
+        health = gateway_get(f"/agents/{agent_id}/health")
+        console.print(f"     [green]✓[/green] Healthy")
+    except APIError:
+        console.print("     [yellow]⚠[/yellow] Health check unavailable")
+
+    console.print(f"\n[green]✓ Deploy complete:[/green] {agent_id}\n")
+
+
+def _deploy_toolbox(agent_id: str, toolbox_dir: Path, config: dict):
+    """Build Docker image, push to registry, register toolbox."""
+    registry = get_value("registry")
+    if not registry:
+        console.print("  [bold]1.[/bold] Toolbox — [yellow]skipped[/yellow] (no registry configured)")
+        return
+
+    image = f"{registry}/{agent_id}-toolbox:latest"
+    console.print(f"  [bold]1.[/bold] Building toolbox → {image}")
+
+    # Build
+    result = subprocess.run(
+        ["docker", "build", "--platform", "linux/amd64", "-t", image, "."],
+        cwd=toolbox_dir, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        console.print(f"     [red]✗[/red] Docker build failed:\n{result.stderr[:300]}")
+        raise typer.Exit(1)
+    console.print("     [green]✓[/green] Image built")
+
+    # Push
+    result = subprocess.run(
+        ["docker", "push", image],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        console.print(f"     [red]✗[/red] Docker push failed:\n{result.stderr[:300]}")
+        raise typer.Exit(1)
+    console.print("     [green]✓[/green] Image pushed")
+
+    # Register toolbox with gateway
+    toolbox_id = config.get("toolboxes", [None])[0] or f"{agent_id}-toolbox"
+    console.print(f"  [bold]2.[/bold] Registering toolbox: {toolbox_id}")
+    try:
+        gateway_post("/build/toolboxes", {
+            "id": toolbox_id,
+            "name": f"{config.get('name', agent_id)} Toolbox",
+            "endpoint": f"http://{agent_id}:8001",
+            "type": "openapi",
+        })
+        # Discover tools
+        gateway_post("/build/toolboxes/discover", {"toolbox_id": toolbox_id})
+        console.print("     [green]✓[/green] Toolbox registered + tools discovered")
+    except APIError as e:
+        console.print(f"     [yellow]⚠[/yellow] Toolbox registration: {e.detail}")
+
+
+def _deploy_knowledge(agent_id: str, knowledge_yaml: Path, base_path: Path):
+    """Create knowledge sources and bases from knowledge.yaml."""
+    console.print("  [bold]2b.[/bold] Setting up knowledge...")
+    kconfig = yaml.safe_load(knowledge_yaml.read_text())
+
+    # Create sources
+    for source in kconfig.get("sources", []):
+        try:
+            gateway_post("/build/knowledge/sources", source)
+            console.print(f"     [green]✓[/green] Source: {source.get('id', '?')}")
+        except APIError:
+            pass  # May already exist
+
+    # Create bases
+    for base in kconfig.get("bases", []):
+        try:
+            gateway_post("/build/knowledge/bases", base)
+            console.print(f"     [green]✓[/green] Base: {base.get('id', '?')}")
+        except APIError:
+            pass  # May already exist
+
+    # Upload synthetic data if present
+    data_dir = base_path / "data" / "synthetic"
+    if data_dir.exists():
+        parquets = list(data_dir.glob("*.parquet"))
+        if parquets:
+            console.print(f"     [dim]({len(parquets)} parquet files — upload via knowledge source config)[/dim]")

prox/commands/catalog.py

@@ -0,0 +1,242 @@
+"""prox catalog — browse, pull, and push agent packages."""
+
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..api import catalog_get, catalog_post, catalog_download, APIError
+from ..config import PACKAGES_DIR, get_license_key, get_master_key
+
+app = typer.Typer(help="Browse and manage the Proxima Agent Catalog.")
+console = Console()
+
+
+@app.command("list")
+def list_agents(
+    domain: Optional[str] = typer.Option(None, "--domain", "-d", help="Filter by domain"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
+):
+    """List all agents in the catalog."""
+    try:
+        params = {}
+        if domain:
+            params["domain"] = domain
+        data = catalog_get("/catalog/agents", params=params)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    agents = data.get("agents", [])
+    if not agents:
+        console.print("[dim]No agents found.[/dim]")
+        return
+
+    if format == "json":
+        import json
+        console.print(json.dumps(agents, indent=2))
+        return
+
+    # Check license to mark available agents
+    licensed_ids = set()
+    try:
+        lic = catalog_get("/catalog/license")
+        licensed_ids = set(lic.get("agents", []))
+    except APIError:
+        pass  # No license configured — show all without marks
+
+    table = Table(title=f"Proxima Catalog ({len(agents)} agents)")
+    table.add_column("Agent", style="bold")
+    table.add_column("Codename", style="cyan")
+    table.add_column("Domain")
+    table.add_column("Tools", justify="right")
+    table.add_column("Version")
+    table.add_column("Access", justify="center")
+
+    for agent in agents:
+        aid = agent["id"]
+        access = "✓" if aid in licensed_ids or get_master_key() else "○"
+        access_style = "green" if access == "✓" else "dim"
+        table.add_row(
+            agent.get("name", aid),
+            agent.get("codename", ""),
+            agent.get("domain", ""),
+            str(agent.get("tools", 0)),
+            agent.get("latest_version", "—"),
+            f"[{access_style}]{access}[/{access_style}]",
+        )
+
+    console.print(table)
+    if licensed_ids:
+        console.print(f"\n[green]✓[/green] = licensed  [dim]○[/dim] = contact Proxima")
+
+
+@app.command("show")
+def show_agent(agent_id: str = typer.Argument(help="Agent ID")):
+    """Show detailed information about a catalog agent."""
+    try:
+        data = catalog_get(f"/catalog/agents/{agent_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]{data.get('name', agent_id)}[/bold] ({data.get('codename', '')})")
+    console.print(f"[dim]{data.get('description', '')}[/dim]\n")
+    console.print(f"  Domain:   {data.get('domain', '—')}")
+    console.print(f"  Tools:    {data.get('tools', 0)}")
+    console.print(f"  Version:  {data.get('latest_version', '—')}")
+    console.print(f"  Updated:  {data.get('updated_at', '—')}")
+
+    if data.get("tool_names"):
+        console.print(f"\n  [bold]Tools:[/bold]")
+        for t in data["tool_names"]:
+            console.print(f"    • {t}")
+
+    if data.get("industries"):
+        console.print(f"\n  [bold]Industries:[/bold] {', '.join(data['industries'])}")
+    if data.get("functions"):
+        console.print(f"  [bold]Functions:[/bold] {', '.join(data['functions'])}")
+    console.print()
+
+
+@app.command("pull")
+def pull_agent(
+    agent_id: str = typer.Argument(help="Agent ID to pull"),
+    version: Optional[str] = typer.Option(None, "--version", "-v", help="Specific version (default: latest)"),
+):
+    """Pull an agent package from the catalog."""
+    if not get_license_key() and not get_master_key():
+        console.print("[red]Error:[/red] No license key configured. Run: prox login --license-key <key>")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]Pulling[/bold] {agent_id}" + (f"@{version}" if version else " (latest)") + "...")
+
+    # Get download URL / validate access
+    try:
+        params = {"version": version} if version else {}
+        meta = catalog_get(f"/catalog/agents/{agent_id}", params=params)
+    except APIError as e:
+        if e.status == 403:
+            console.print(f"[red]Access denied:[/red] '{agent_id}' is not in your license. Contact Proxima to upgrade.")
+        else:
+            console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    actual_version = version or meta.get("latest_version", "latest")
+    dest_dir = PACKAGES_DIR / agent_id
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    tarball = dest_dir / f"{agent_id}-{actual_version}.tar.gz"
+
+    try:
+        pull_path = f"/catalog/agents/{agent_id}/pull"
+        if version:
+            pull_path += f"?version={version}"
+        catalog_download(pull_path, str(tarball))
+    except APIError as e:
+        console.print(f"[red]Download failed:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    # Extract
+    extract_dir = dest_dir / actual_version
+    extract_dir.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(tarball, "r:gz") as tar:
+        tar.extractall(path=extract_dir)
+
+    console.print(f"[green]✓[/green] Pulled {agent_id}@{actual_version} → {extract_dir}")
+    console.print(f"\n  Deploy with: [bold]prox agent deploy --from {extract_dir}[/bold]")
+
+
+@app.command("push")
+def push_agent(
+    from_path: Path = typer.Option(..., "--from", help="Path to agent directory"),
+    version: str = typer.Option(..., "--version", "-v", help="Version to publish"),
+):
+    """Push an agent package to the catalog (Proxima team only)."""
+    if not get_master_key():
+        console.print("[red]Error:[/red] Master key required. Run: prox login --master-key <key>")
+        raise typer.Exit(1)
+
+    if not from_path.exists():
+        console.print(f"[red]Error:[/red] Path not found: {from_path}")
+        raise typer.Exit(1)
+
+    # Read manifest or agent.yaml for the agent ID
+    manifest = from_path / "manifest.json"
+    agent_yaml = from_path / "agent.yaml"
+    if manifest.exists():
+        import json
+        meta = json.loads(manifest.read_text())
+        agent_id = meta["id"]
+    elif agent_yaml.exists():
+        import yaml
+        meta = yaml.safe_load(agent_yaml.read_text())
+        agent_id = meta["id"]
+    else:
+        console.print("[red]Error:[/red] No manifest.json or agent.yaml found in source directory.")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]Packaging[/bold] {agent_id}@{version}...")
+
+    # Create tarball
+    tarball_path = Path(tempfile.mktemp(suffix=".tar.gz"))
+    with tarfile.open(tarball_path, "w:gz") as tar:
+        tar.add(from_path, arcname=".")
+
+    size_mb = tarball_path.stat().st_size / (1024 * 1024)
+    console.print(f"  Package size: {size_mb:.1f} MB")
+    console.print(f"[bold]Pushing[/bold] to catalog...")
+
+    # Upload
+    try:
+        import httpx
+        from ..config import get_value
+        catalog_url = (get_value("catalog") or "https://catalog.proximaintel.com").rstrip("/")
+        with open(tarball_path, "rb") as f:
+            r = httpx.post(
+                f"{catalog_url}/catalog/agents/{agent_id}/push?version={version}",
+                headers={"X-Master-Key": get_master_key()},
+                content=f.read(),
+                timeout=300,
+            )
+        if r.status_code >= 400:
+            console.print(f"[red]Push failed:[/red] {r.text[:300]}")
+            raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Push failed:[/red] {e}")
+        raise typer.Exit(1)
+    finally:
+        tarball_path.unlink(missing_ok=True)
+
+    console.print(f"[green]✓[/green] Pushed {agent_id}@{version} to catalog")
+
+
+@app.command("license")
+def check_license():
+    """Check current license entitlements."""
+    if not get_license_key() and not get_master_key():
+        console.print("[yellow]No license key configured.[/yellow]")
+        console.print("  Run: prox login --license-key <key>")
+        return
+
+    if get_master_key():
+        console.print("[bold green]Master key active[/bold green] — full catalog access")
+        return
+
+    try:
+        data = catalog_get("/catalog/license")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]License:[/bold] {data.get('client_id', '—')}")
+    console.print(f"  Tier:     {data.get('tier', '—')}")
+    console.print(f"  Expires:  {data.get('expires', '—')}")
+    console.print(f"  Valid:    {'[green]Yes[/green]' if data.get('valid') else '[red]No[/red]'}")
+    console.print(f"\n  [bold]Licensed agents ({len(data.get('agents', []))}):[/bold]")
+    for a in data.get("agents", []):
+        console.print(f"    • {a}")
+    console.print()

prox/commands/governance.py

@@ -0,0 +1,63 @@
+"""prox governance — audit logs and platform metrics."""
+
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..api import gateway_get, APIError
+
+app = typer.Typer(help="View governance logs and stats.")
+console = Console()
+
+
+@app.command("logs")
+def logs(
+    domain: Optional[str] = typer.Option(None, "--domain", "-d"),
+    limit: int = typer.Option(20, "--limit", "-n"),
+):
+    """View audit logs."""
+    try:
+        params = {"limit": limit}
+        if domain:
+            params["domain"] = domain
+        data = gateway_get("/governance/logs", params=params)
+        entries = data.get("logs", data.get("entries", []))
+        if not entries:
+            console.print("[dim]No logs.[/dim]")
+            return
+        table = Table(title=f"Governance Logs (last {limit})")
+        table.add_column("Time", style="dim")
+        table.add_column("Type")
+        table.add_column("Agent")
+        table.add_column("User")
+        table.add_column("Tokens", justify="right")
+        for e in entries[:limit]:
+            table.add_row(
+                e.get("timestamp", "")[:19],
+                e.get("type", "query"),
+                e.get("agent_id", ""),
+                e.get("user", ""),
+                str(e.get("tokens_used", "")),
+            )
+        console.print(table)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("stats")
+def stats(domain: Optional[str] = typer.Option(None, "--domain", "-d")):
+    """View platform stats."""
+    try:
+        params = {"domain": domain} if domain else {}
+        data = gateway_get("/governance/stats", params=params)
+        console.print(f"\n  [bold]Platform Stats[/bold]{'  (' + domain + ')' if domain else ''}\n")
+        console.print(f"  Total queries:  {data.get('total_queries', 0)}")
+        console.print(f"  Total tokens:   {data.get('total_tokens', 0):,}")
+        console.print(f"  Total cost:     ${data.get('total_cost', 0):.2f}")
+        console.print(f"  Avg duration:   {data.get('avg_duration_ms', 0):.0f}ms")
+        console.print(f"  Agents active:  {data.get('agents_active', 0)}")
+        console.print()
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)