foodforthought-cli 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

ate/cli.py

@@ -9,6 +9,7 @@ import os
 import sys
 import time
 import random
+import getpass
 import requests
 from pathlib import Path
 from typing import Optional, Dict, List
@@ -16,23 +17,43 @@ from ate.generator import generate_skill_project, TEMPLATES
 
 BASE_URL = os.getenv("ATE_API_URL", "https://kindly.fyi/api")
 API_KEY = os.getenv("ATE_API_KEY", "")
+CONFIG_DIR = Path.home() / ".ate"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
 
 
 class ATEClient:
     """Client for interacting with FoodforThought API"""
 
-    def __init__(self, base_url: str = BASE_URL, api_key: str = API_KEY):
+    def __init__(self, base_url: str = BASE_URL, api_key: Optional[str] = None):
         self.base_url = base_url
         self.headers = {
             "Content-Type": "application/json",
         }
+        
+        # Priority: Explicit Arg > Env Var > Global Default
+        if api_key is None:
+            api_key = os.getenv("ATE_API_KEY", API_KEY)
+            
         if api_key:
             # Ensure API key has correct format
             if not api_key.startswith("ate_"):
                 print("Warning: API key should start with 'ate_'", file=sys.stderr)
             self.headers["Authorization"] = f"Bearer {api_key}"
         else:
-            print("Warning: No API key found. Set ATE_API_KEY environment variable.", file=sys.stderr)
+            # Try to load from config file
+            if CONFIG_FILE.exists():
+                try:
+                    with open(CONFIG_FILE) as f:
+                        config = json.load(f)
+                        stored_key = config.get("api_key")
+                        if stored_key:
+                            self.headers["Authorization"] = f"Bearer {stored_key}"
+                except Exception:
+                    pass
+            
+            if "Authorization" not in self.headers:
+                print("Warning: No API key found. Set ATE_API_KEY environment variable or run 'ate login'.", file=sys.stderr)
 
     def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
         """Make HTTP request to API"""
@@ -1386,273 +1407,2450 @@ def generate_launch_description():
             if not all_passed:
                 sys.exit(1)
 
+    # =========================================================================
+    # Protocol Registry Methods
+    # =========================================================================
 
-def main():
-    """Main CLI entry point"""
-    parser = argparse.ArgumentParser(description="FoodforThought CLI")
-    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    def protocol_list(self, robot_model: Optional[str], transport_type: Optional[str],
+                      verified_only: bool, search: Optional[str]) -> None:
+        """List protocols from the registry"""
+        params = {}
+        if robot_model:
+            params["robotId"] = robot_model  # Can be ID or search term
+        if transport_type:
+            params["transport"] = transport_type
+        if verified_only:
+            params["verified"] = "true"
+        if search:
+            params["q"] = search
 
-    # init command
-    init_parser = subparsers.add_parser("init", help="Initialize a new repository")
-    init_parser.add_argument("name", help="Repository name")
-    init_parser.add_argument("-d", "--description", default="", help="Repository description")
-    init_parser.add_argument(
-        "-v", "--visibility", choices=["public", "private"], default="public", help="Repository visibility"
-    )
+        try:
+            response = self._request("GET", "/protocols", params=params)
+            protocols = response.get("protocols", [])
+            pagination = response.get("pagination", {})
 
-    # clone command
-    clone_parser = subparsers.add_parser("clone", help="Clone a repository")
-    clone_parser.add_argument("repo_id", help="Repository ID")
-    clone_parser.add_argument("target_dir", nargs="?", help="Target directory")
+            print(f"\n{'=' * 70}")
+            print(f"Protocol Registry ({pagination.get('total', len(protocols))} total)")
+            print(f"{'=' * 70}")
 
-    # commit command
-    commit_parser = subparsers.add_parser("commit", help="Create a commit")
-    commit_parser.add_argument("-m", "--message", required=True, help="Commit message")
-    commit_parser.add_argument("files", nargs="*", help="Files to commit")
+            if not protocols:
+                print("\nNo protocols found matching your criteria.")
+                print("Use 'ate protocol init <robot-model> --transport <type>' to contribute one!")
+                return
 
-    # push command
-    push_parser = subparsers.add_parser("push", help="Push commits to remote")
-    push_parser.add_argument("-b", "--branch", default="main", help="Branch name")
+            for proto in protocols:
+                robot = proto.get("robot", {})
+                verified = "✓" if proto.get("verified") else " "
+                primitives = proto.get("primitiveSkillCount", 0)
+                upvotes = proto.get("upvotes", 0)
+                downvotes = proto.get("downvotes", 0)
+                score = upvotes - downvotes
 
-    # deploy command
-    deploy_parser = subparsers.add_parser("deploy", help="Deploy to robot")
-    deploy_parser.add_argument("robot_type", help="Robot type (e.g., unitree-r1)")
-    deploy_parser.add_argument("-r", "--repo-id", help="Repository ID (default: current repo)")
+                print(f"\n[{verified}] {robot.get('name', 'Unknown')} - {proto.get('transportType', '?')}")
+                print(f"    ID: {proto.get('id')}")
+                print(f"    Format: {proto.get('commandFormat', '?')}")
+                print(f"    Primitives: {primitives} | Score: {score} (+{upvotes}/-{downvotes})")
+                if proto.get('verified'):
+                    print(f"    Verified: Yes")
 
-    # test command
-    test_parser = subparsers.add_parser("test", help="Test skills in simulation")
-    test_parser.add_argument("-e", "--environment", default="gazebo", 
-                           choices=["gazebo", "mujoco", "pybullet", "webots"],
-                           help="Simulation environment")
-    test_parser.add_argument("-r", "--robot", help="Robot model to test with")
-    test_parser.add_argument("--local", action="store_true", help="Run simulation locally")
+        except Exception as e:
+            print(f"Error listing protocols: {e}", file=sys.stderr)
+            sys.exit(1)
 
-    # benchmark command
-    benchmark_parser = subparsers.add_parser("benchmark", help="Run performance benchmarks")
-    benchmark_parser.add_argument("-t", "--type", default="all",
-                                choices=["speed", "accuracy", "robustness", "efficiency", "all"],
-                                help="Benchmark type")
-    benchmark_parser.add_argument("-n", "--trials", type=int, default=10, help="Number of trials")
-    benchmark_parser.add_argument("--compare", help="Compare with baseline (repository ID)")
+    def protocol_get(self, protocol_id: str) -> None:
+        """Get detailed information about a protocol"""
+        try:
+            proto = self._request("GET", f"/protocols/{protocol_id}")
+            robot = proto.get("robot", {})
 
-    # adapt command
-    adapt_parser = subparsers.add_parser("adapt", help="Adapt skills between robots")
-    adapt_parser.add_argument("source_robot", help="Source robot model")
-    adapt_parser.add_argument("target_robot", help="Target robot model")
-    adapt_parser.add_argument("-r", "--repo-id", help="Repository ID to adapt")
-    adapt_parser.add_argument("--analyze-only", action="store_true", 
-                            help="Only show compatibility analysis")
+            print(f"\n{'=' * 70}")
+            print(f"Protocol: {robot.get('name', 'Unknown')} - {proto.get('transportType', '?')}")
+            print(f"{'=' * 70}")
 
-    # validate command
-    validate_parser = subparsers.add_parser("validate", help="Validate safety and compliance")
-    validate_parser.add_argument("-c", "--checks", nargs="+", 
-                               choices=["collision", "speed", "workspace", "force", "all"],
-                               default=["all"], help="Safety checks to run")
-    validate_parser.add_argument("--strict", action="store_true", help="Use strict validation")
-    validate_parser.add_argument("-f", "--files", nargs="*", help="Specific files to validate")
+            print(f"\nRobot: {robot.get('manufacturer', '?')} {robot.get('name', '?')}")
+            print(f"Category: {robot.get('category', '?')}")
+            print(f"Transport: {proto.get('transportType', '?')}")
 
-    # stream command
-    stream_parser = subparsers.add_parser("stream", help="Stream sensor data")
-    stream_parser.add_argument("action", choices=["start", "stop", "status"],
-                             help="Streaming action")
-    stream_parser.add_argument("-s", "--sensors", nargs="+", 
-                             help="Sensors to stream (e.g., camera, lidar, imu)")
-    stream_parser.add_argument("-o", "--output", help="Output file or URL")
-    stream_parser.add_argument("--format", default="rosbag", 
-                             choices=["rosbag", "hdf5", "json", "live"],
-                             help="Data format")
+            # Command configuration
+            command = proto.get('command', {})
+            print(f"Command Format: {command.get('format', '?')}")
 
-    # pull command - Pull skill data for training
-    pull_parser = subparsers.add_parser("pull", help="Pull skill data for training")
-    pull_parser.add_argument("skill_id", help="Skill ID to pull")
-    pull_parser.add_argument("-r", "--robot", help="Filter by robot model")
-    pull_parser.add_argument("-f", "--format", default="json",
-                           choices=["json", "rlds", "lerobot"],
-                           help="Output format (default: json)")
-    pull_parser.add_argument("-o", "--output", default="./data",
-                           help="Output directory (default: ./data)")
+            # Transport-specific details
+            transport = proto.get('transportType', '')
+            if transport == 'ble':
+                ble = proto.get('ble', {})
+                if ble:
+                    print(f"\nBLE Configuration:")
+                    if ble.get('advertisedName'):
+                        print(f"  Advertised Name: {ble.get('advertisedName')}")
+                    if ble.get('serviceUuids'):
+                        print(f"  Service UUIDs: {json.dumps(ble.get('serviceUuids'), indent=4)}")
+                    if ble.get('characteristics'):
+                        print(f"  Characteristics: {json.dumps(ble.get('characteristics'), indent=4)}")
+                    if ble.get('mtu'):
+                        print(f"  MTU: {ble.get('mtu')}")
 
-    # upload command - Upload demonstrations for labeling
-    upload_parser = subparsers.add_parser("upload", help="Upload demonstrations for labeling")
-    upload_parser.add_argument("path", help="Path to video file")
-    upload_parser.add_argument("-r", "--robot", required=True, 
-                             help="Robot model in the video")
-    upload_parser.add_argument("-t", "--task", required=True,
-                             help="Task being demonstrated")
-    upload_parser.add_argument("-p", "--project", help="Project ID to associate with")
+            elif transport == 'serial':
+                serial = proto.get('serial', {})
+                if serial:
+                    print(f"\nSerial Configuration:")
+                    print(f"  Baud Rate: {serial.get('baudRate', '?')}")
+                    print(f"  Data Bits: {serial.get('dataBits', 8)}")
+                    print(f"  Stop Bits: {serial.get('stopBits', 1)}")
+                    print(f"  Parity: {serial.get('parity', 'none')}")
+                    print(f"  Flow Control: {serial.get('flowControl', 'none')}")
 
-    # check-transfer command - Check skill transfer compatibility
-    check_transfer_parser = subparsers.add_parser("check-transfer", 
-                                                  help="Check skill transfer compatibility")
-    check_transfer_parser.add_argument("-s", "--skill", help="Skill ID to check (optional)")
-    check_transfer_parser.add_argument("--from", dest="source", required=True,
-                                      help="Source robot model")
-    check_transfer_parser.add_argument("--to", dest="target", required=True,
-                                      help="Target robot model")
-    check_transfer_parser.add_argument("--min-score", type=float, default=0.0,
-                                      help="Minimum score threshold (0.0-1.0)")
+            elif transport == 'wifi':
+                wifi = proto.get('wifi', {})
+                if wifi:
+                    print(f"\nWiFi Configuration:")
+                    print(f"  Protocol: {wifi.get('protocol', '?')}")
+                    print(f"  Port: {wifi.get('port', '?')}")
+                    if wifi.get('host'):
+                        print(f"  Default Host: {wifi.get('host')}")
 
-    # labeling-status command - Check labeling job status
-    labeling_status_parser = subparsers.add_parser("labeling-status",
-                                                   help="Check labeling job status")
-    labeling_status_parser.add_argument("job_id", help="Labeling job ID")
+            elif transport == 'can':
+                can = proto.get('can', {})
+                if can:
+                    print(f"\nCAN Configuration:")
+                    print(f"  Bitrate: {can.get('bitrate', '?')}")
+                    print(f"  Interface: {can.get('interface', '?')}")
 
-    # parts command - Manage hardware parts
-    parts_parser = subparsers.add_parser("parts", help="Manage hardware parts catalog")
-    parts_subparsers = parts_parser.add_subparsers(dest="parts_action", help="Parts action")
-    
-    # parts list
-    parts_list_parser = parts_subparsers.add_parser("list", help="List available parts")
-    parts_list_parser.add_argument("-c", "--category", 
-                                   choices=["gripper", "sensor", "actuator", "controller", 
-                                           "end-effector", "camera", "lidar", "force-torque"],
-                                   help="Filter by category")
-    parts_list_parser.add_argument("-m", "--manufacturer", help="Filter by manufacturer")
-    parts_list_parser.add_argument("-s", "--search", help="Search by name or part number")
-    
-    # parts check
-    parts_check_parser = parts_subparsers.add_parser("check", 
-                                                     help="Check part compatibility for skill")
-    parts_check_parser.add_argument("skill_id", help="Skill ID to check")
-    
-    # parts require
-    parts_require_parser = parts_subparsers.add_parser("require", 
-                                                       help="Add part dependency to skill")
-    parts_require_parser.add_argument("part_id", help="Part ID to require")
-    parts_require_parser.add_argument("-s", "--skill", required=True, help="Skill ID")
-    parts_require_parser.add_argument("-v", "--version", default="1.0.0", 
-                                      help="Minimum version (default: 1.0.0)")
-    parts_require_parser.add_argument("--required", action="store_true",
-                                      help="Mark as required (not optional)")
+            # Discovery info
+            discovery = proto.get('discovery', {})
+            if discovery.get('notes'):
+                print(f"\nDiscovery Notes:")
+                print(f"  {discovery.get('notes')}")
 
-    # deps command - Dependency management
-    deps_parser = subparsers.add_parser("deps", help="Dependency management")
-    deps_subparsers = deps_parser.add_subparsers(dest="deps_action", help="Deps action")
-    
-    # deps audit
-    deps_audit_parser = deps_subparsers.add_parser("audit", 
-                                                   help="Verify all dependencies compatible")
-    deps_audit_parser.add_argument("-s", "--skill", help="Skill ID (default: current repo)")
+            # Verification status
+            verification = proto.get('verification', {})
+            print(f"\nVerification:")
+            if verification.get('verified'):
+                print(f"  Status: ✓ Verified")
+                if verification.get('notes'):
+                    print(f"  Notes: {verification.get('notes')}")
+            else:
+                print(f"  Status: Unverified")
 
-    # generate command - Generate skill from text description
-    generate_parser = subparsers.add_parser("generate", 
-                                           help="Generate skill scaffolding from text description")
-    generate_parser.add_argument("description", 
-                                help="Natural language task description (e.g., 'pick up box and place on pallet')")
-    generate_parser.add_argument("-r", "--robot", default="ur5",
-                                help="Target robot model (default: ur5)")
-    generate_parser.add_argument("-o", "--output", default="./new-skill",
-                                help="Output directory (default: ./new-skill)")
+            # Community feedback
+            print(f"\nCommunity:")
+            upvotes = proto.get('upvotes', 0)
+            downvotes = proto.get('downvotes', 0)
+            print(f"  Score: {proto.get('score', 0)} (+{upvotes}/-{downvotes})")
 
-    # workflow command - Workflow/pipeline management
-    workflow_parser = subparsers.add_parser("workflow", help="Manage skill workflows/pipelines")
-    workflow_subparsers = workflow_parser.add_subparsers(dest="workflow_action", help="Workflow action")
-    
-    # workflow validate
-    workflow_validate_parser = workflow_subparsers.add_parser("validate", 
-                                                              help="Validate workflow YAML")
-    workflow_validate_parser.add_argument("path", help="Path to workflow YAML file")
-    
-    # workflow run
-    workflow_run_parser = workflow_subparsers.add_parser("run", help="Run a workflow")
-    workflow_run_parser.add_argument("path", help="Path to workflow YAML file")
-    workflow_run_parser.add_argument("--sim", action="store_true", 
-                                    help="Run in simulation mode")
-    workflow_run_parser.add_argument("--dry-run", action="store_true",
-                                    help="Show execution plan without running")
-    
-    # workflow export
-    workflow_export_parser = workflow_subparsers.add_parser("export", 
-                                                           help="Export workflow to other formats")
-    workflow_export_parser.add_argument("path", help="Path to workflow YAML file")
-    workflow_export_parser.add_argument("-f", "--format", default="ros2",
-                                       choices=["ros2", "json"],
-                                       help="Export format (default: ros2)")
-    workflow_export_parser.add_argument("-o", "--output", help="Output file path")
+            # Associated primitives
+            primitives = proto.get('primitiveSkills', [])
+            if primitives:
+                print(f"\nPrimitive Skills ({len(primitives)}):")
+                for prim in primitives:
+                    status = prim.get('status', 'experimental')
+                    status_icon = "✓" if status in ['tested', 'verified'] else "○"
+                    reliability = prim.get('reliabilityScore')
+                    reliability_str = f" [{reliability:.0%}]" if reliability else ""
+                    print(f"  {status_icon} {prim.get('name')} ({prim.get('category', '?')}){reliability_str}")
 
-    # team command - Team collaboration
-    team_parser = subparsers.add_parser("team", help="Team collaboration management")
-    team_subparsers = team_parser.add_subparsers(dest="team_action", help="Team action")
-    
-    # team create
-    team_create_parser = team_subparsers.add_parser("create", help="Create a new team")
-    team_create_parser.add_argument("name", help="Team name")
-    team_create_parser.add_argument("-d", "--description", help="Team description")
-    
-    # team invite
-    team_invite_parser = team_subparsers.add_parser("invite", help="Invite user to team")
-    team_invite_parser.add_argument("email", help="Email of user to invite")
-    team_invite_parser.add_argument("-t", "--team", required=True, help="Team slug")
-    team_invite_parser.add_argument("-r", "--role", default="member",
-                                   choices=["owner", "admin", "member", "viewer"],
-                                   help="Role to assign (default: member)")
-    
-    # team list
-    team_subparsers.add_parser("list", help="List teams you belong to")
-    
-    # team share (skill share with team)
-    team_share_parser = team_subparsers.add_parser("share", help="Share skill with team")
-    team_share_parser.add_argument("skill_id", help="Skill ID to share")
-    team_share_parser.add_argument("-t", "--team", required=True, help="Team slug")
+            print(f"\nView online: https://kindly.fyi/foodforthought/protocols/{proto.get('id')}")
 
-    # data command - Dataset management
-    data_parser = subparsers.add_parser("data", help="Dataset and telemetry management")
-    data_subparsers = data_parser.add_subparsers(dest="data_action", help="Data action")
-    
-    # data upload
-    data_upload_parser = data_subparsers.add_parser("upload", help="Upload sensor data")
-    data_upload_parser.add_argument("path", help="Path to data directory or file")
-    data_upload_parser.add_argument("-s", "--skill", required=True, help="Associated skill ID")
-    data_upload_parser.add_argument("--stage", default="raw",
-                                   choices=["raw", "annotated", "skill-abstracted", "production"],
-                                   help="Data stage (default: raw)")
-    
-    # data list
-    data_list_parser = data_subparsers.add_parser("list", help="List datasets")
-    data_list_parser.add_argument("-s", "--skill", help="Filter by skill ID")
-    data_list_parser.add_argument("--stage", help="Filter by stage")
-    
-    # data promote
-    data_promote_parser = data_subparsers.add_parser("promote", help="Promote dataset stage")
-    data_promote_parser.add_argument("dataset_id", help="Dataset ID")
-    data_promote_parser.add_argument("--to", required=True, dest="to_stage",
-                                    choices=["annotated", "skill-abstracted", "production"],
-                                    help="Target stage")
-    
-    # data export
-    data_export_parser = data_subparsers.add_parser("export", help="Export dataset")
-    data_export_parser.add_argument("dataset_id", help="Dataset ID")
-    data_export_parser.add_argument("-f", "--format", default="rlds",
-                                   choices=["json", "rlds", "lerobot", "hdf5"],
-                                   help="Export format (default: rlds)")
-    data_export_parser.add_argument("-o", "--output", default="./export",
-                                   help="Output directory")
+        except Exception as e:
+            print(f"Error fetching protocol: {e}", file=sys.stderr)
+            sys.exit(1)
 
-    # deploy command - Enhanced deployment management
-    deploy_subparsers = deploy_parser.add_subparsers(dest="deploy_action", help="Deploy action")
-    
-    # deploy config (hybrid edge/cloud deployment)
-    deploy_config_parser = deploy_subparsers.add_parser("config", 
-                                                        help="Deploy using config file")
-    deploy_config_parser.add_argument("config_path", help="Path to deploy.yaml")
-    deploy_config_parser.add_argument("-t", "--target", required=True, 
-                                     help="Target fleet or robot")
-    deploy_config_parser.add_argument("--dry-run", action="store_true",
-                                     help="Show plan without deploying")
-    
-    # deploy status
-    deploy_status_parser = deploy_subparsers.add_parser("status", 
-                                                        help="Check deployment status")
-    deploy_status_parser.add_argument("target", help="Target fleet or robot")
+    def protocol_init(self, robot_model: str, transport_type: str, output_dir: str) -> None:
+        """Initialize a new protocol definition locally"""
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
 
-    args = parser.parse_args()
+        # Create protocol template
+        protocol_template = {
+            "robotModel": robot_model,
+            "transportType": transport_type,
+            "commandFormat": "json",  # Default, user should change
+            "version": "1.0.0",
+        }
 
-    if not args.command:
-        parser.print_help()
-        sys.exit(1)
+        # Add transport-specific fields
+        if transport_type == "ble":
+            protocol_template.update({
+                "bleServiceUuids": [{"uuid": "FFE0", "name": "Custom Service"}],
+                "bleCharacteristics": [
+                    {"uuid": "FFE1", "name": "TX", "properties": ["write"]},
+                    {"uuid": "FFE2", "name": "RX", "properties": ["notify"]}
+                ],
+                "bleAdvertisedName": f"{robot_model}-*",
+                "bleMtu": 512,
+            })
+        elif transport_type == "serial":
+            protocol_template.update({
+                "serialBaudRate": 115200,
+                "serialDataBits": 8,
+                "serialStopBits": 1,
+                "serialParity": "none",
+                "serialFlowControl": "none",
+            })
+        elif transport_type == "wifi":
+            protocol_template.update({
+                "wifiProtocol": "tcp",
+                "wifiPort": 8080,
+                "wifiHost": "192.168.1.1",
+            })
+        elif transport_type == "can":
+            protocol_template.update({
+                "canBitrate": 500000,
+                "canInterface": "can0",
+            })
+        elif transport_type == "i2c":
+            protocol_template.update({
+                "i2cAddress": 0x50,
+            })
+        elif transport_type == "spi":
+            protocol_template.update({
+                "spiMode": 0,
+                "spiSpeedHz": 1000000,
+            })
+
+        # Add command schema template
+        protocol_template["commandSchema"] = {
+            "commands": [
+                {
+                    "name": "example_command",
+                    "description": "Example command - replace with actual commands",
+                    "parameters": [
+                        {"name": "param1", "type": "int", "min": 0, "max": 100}
+                    ],
+                    "response": {"type": "json", "schema": {}}
+                }
+            ]
+        }
+
+        protocol_template["discoveryNotes"] = f"Protocol for {robot_model} via {transport_type}. Add your discovery notes here."
+
+        # Add primitive skills template
+        protocol_template["primitiveSkills"] = [
+            {
+                "name": "example_motion",
+                "displayName": "Example Motion",
+                "category": "motion",
+                "description": "Example primitive - replace with actual skills",
+                "commandType": "json",
+                "commandTemplate": '{"cmd": "example", "param": ${value}}',
+                "parameters": {
+                    "value": {"type": "number", "min": 0, "max": 100, "default": 50}
+                },
+                "executionTimeMs": 500,
+                "settleTimeMs": 100,
+                "safetyNotes": "Ensure robot is in safe position before executing"
+            }
+        ]
+
+        # Write protocol file
+        protocol_file = output_path / "protocol.json"
+        with open(protocol_file, "w") as f:
+            json.dump(protocol_template, f, indent=2)
+
+        # Create README
+        readme_content = f"""# {robot_model} Protocol ({transport_type})
+
+## Overview
+This protocol defines how to communicate with the {robot_model} robot via {transport_type}.
+
+## Discovery Notes
+Document how you discovered this protocol:
+- Tools used (e.g., nRF Connect, logic analyzer, Wireshark)
+- Reverse engineering steps
+- Testing methodology
+
+## Usage
+1. Edit `protocol.json` with the correct values
+2. Document the command schema
+3. Run `ate protocol push` to upload to FoodForThought
+
+## Commands
+Document available commands here.
+
+## Testing
+1. Connect to the robot
+2. Test each command
+3. Document results
+"""
+        readme_file = output_path / "README.md"
+        with open(readme_file, "w") as f:
+            f.write(readme_content)
+
+        print(f"Protocol template created in '{output_dir}'")
+        print(f"\nFiles created:")
+        print(f"  - {protocol_file}")
+        print(f"  - {readme_file}")
+        print(f"\nNext steps:")
+        print(f"  1. Edit protocol.json with correct values")
+        print(f"  2. Test the protocol with your robot")
+        print(f"  3. Run 'ate protocol push' to upload")
+
+    def protocol_push(self, protocol_file: Optional[str]) -> None:
+        """Upload a protocol definition to FoodForThought"""
+        # Find protocol file
+        if protocol_file:
+            proto_path = Path(protocol_file)
+        else:
+            proto_path = Path("protocol.json")
+            if not proto_path.exists():
+                proto_path = Path(".") / "protocol.json"
+
+        if not proto_path.exists():
+            print("Error: No protocol.json found. Specify path or run from protocol directory.",
+                  file=sys.stderr)
+            sys.exit(1)
+
+        with open(proto_path) as f:
+            protocol_data = json.load(f)
+
+        # Validate required fields
+        required = ["robotModel", "transportType", "commandFormat"]
+        missing = [r for r in required if r not in protocol_data]
+        if missing:
+            print(f"Error: Missing required fields: {', '.join(missing)}", file=sys.stderr)
+            sys.exit(1)
+
+        # Look up robot ID by model name using unified API
+        robot_model = protocol_data.pop("robotModel")
+        print(f"Looking up robot: {robot_model}...")
+        try:
+            robots_response = self._request("GET", "/robots/unified",
+                                           params={"search": robot_model, "limit": "1"})
+            robots = robots_response.get("robots", [])
+            if not robots:
+                print(f"Error: Robot model '{robot_model}' not found in registry.", file=sys.stderr)
+                print("Check available robots at https://kindly.fyi/foodforthought/robots")
+                sys.exit(1)
+
+            protocol_data["robotId"] = robots[0]["id"]
+            robot_name = robots[0].get("name", robot_model)
+            print(f"  Found: {robot_name} (ID: {robots[0]['id']})")
+        except Exception as e:
+            print(f"Error looking up robot: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        # Extract primitiveSkills if present (they should be created with the protocol)
+        primitives = protocol_data.get("primitiveSkills", [])
+        primitive_count = len(primitives)
+        if primitive_count > 0:
+            print(f"  Including {primitive_count} primitive skill(s)")
+
+        # Submit to API
+        print("Uploading protocol...")
+        try:
+            response = self._request("POST", "/protocols", json=protocol_data)
+            proto = response.get("protocol", {})
+            created_primitives = response.get("primitiveSkills", [])
+
+            print(f"\n✓ Protocol published successfully!")
+            print(f"  ID: {proto.get('id')}")
+            print(f"  Robot: {proto.get('robot', {}).get('name', robot_name)}")
+            print(f"  Transport: {proto.get('transportType')}")
+
+            if created_primitives:
+                print(f"\n  Primitive Skills Created ({len(created_primitives)}):")
+                for prim in created_primitives:
+                    print(f"    - {prim.get('name')}")
+
+            print(f"\nView at: https://kindly.fyi/foodforthought/protocols/{proto.get('id')}")
+            print("\nNext steps:")
+            print("  - Ask the community to test and verify your protocol")
+            print("  - Add more primitive skills with 'ate primitive add'")
+            print("  - Submit test results with 'ate primitive test <id>'")
+        except Exception as e:
+            print(f"Error uploading protocol: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def publish_protocol(self, protocol_file: Optional[str]) -> None:
+        """Alias for protocol_push - publish a protocol to FoodForThought"""
+        self.protocol_push(protocol_file)
+
+    def protocol_scan_serial(self) -> None:
+        """Scan for available serial ports"""
+        try:
+            import serial.tools.list_ports
+        except ImportError:
+            print("Error: pyserial not installed. Run: pip install pyserial", file=sys.stderr)
+            sys.exit(1)
+
+        ports = serial.tools.list_ports.comports()
+
+        print(f"\n{'=' * 60}")
+        print("Available Serial Ports")
+        print(f"{'=' * 60}")
+
+        if not ports:
+            print("\nNo serial ports found.")
+            return
+
+        for port in ports:
+            print(f"\n{port.device}")
+            print(f"  Description: {port.description}")
+            if port.manufacturer:
+                print(f"  Manufacturer: {port.manufacturer}")
+            if port.product:
+                print(f"  Product: {port.product}")
+            if port.serial_number:
+                print(f"  Serial: {port.serial_number}")
+            print(f"  Hardware ID: {port.hwid}")
+
+    def protocol_scan_ble(self) -> None:
+        """Scan for BLE devices (requires bleak)"""
+        try:
+            import asyncio
+            from bleak import BleakScanner
+        except ImportError:
+            print("Error: bleak not installed. Run: pip install bleak", file=sys.stderr)
+            sys.exit(1)
+
+        async def scan():
+            print(f"\n{'=' * 60}")
+            print("Scanning for BLE devices (10 seconds)...")
+            print(f"{'=' * 60}")
+
+            devices = await BleakScanner.discover(timeout=10.0)
+
+            if not devices:
+                print("\nNo BLE devices found.")
+                return
+
+            print(f"\nFound {len(devices)} devices:\n")
+
+            for device in sorted(devices, key=lambda d: d.rssi, reverse=True):
+                print(f"{device.name or 'Unknown'}")
+                print(f"  Address: {device.address}")
+                print(f"  RSSI: {device.rssi} dBm")
+                if device.metadata.get("uuids"):
+                    print(f"  Service UUIDs: {device.metadata.get('uuids')}")
+                print()
+
+        asyncio.run(scan())
+
+    # =========================================================================
+    # Primitive Skills Methods
+    # =========================================================================
+
+    def primitive_list(self, robot_model: Optional[str], category: Optional[str],
+                       status: Optional[str], tested_only: bool) -> None:
+        """List primitive skills"""
+        params = {}
+        if robot_model:
+            params["robotModel"] = robot_model
+        if category:
+            params["category"] = category
+        if status:
+            params["status"] = status
+        if tested_only:
+            params["testedOnly"] = "true"
+
+        try:
+            response = self._request("GET", "/primitives", params=params)
+            primitives = response.get("primitives", [])
+            pagination = response.get("pagination", {})
+
+            print(f"\n{'=' * 70}")
+            print(f"Primitive Skills ({pagination.get('total', len(primitives))} total)")
+            print(f"{'=' * 70}")
+
+            if not primitives:
+                print("\nNo primitive skills found.")
+                return
+
+            # Group by robot
+            by_robot = {}
+            for prim in primitives:
+                robot = prim.get("robotProfile", {}).get("modelName", "Unknown")
+                if robot not in by_robot:
+                    by_robot[robot] = []
+                by_robot[robot].append(prim)
+
+            for robot, prims in by_robot.items():
+                print(f"\n{robot}:")
+                for prim in prims:
+                    status_icons = {"verified": "✓", "tested": "○", "experimental": "◌", "deprecated": "✗"}
+                    icon = status_icons.get(prim.get("status", "experimental"), "?")
+                    reliability = prim.get("reliabilityScore")
+                    rel_str = f" ({reliability:.0%})" if reliability else ""
+
+                    print(f"  {icon} {prim.get('name')} [{prim.get('category')}]{rel_str}")
+                    print(f"      ID: {prim.get('id')}")
+
+        except Exception as e:
+            print(f"Error listing primitives: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def primitive_get(self, primitive_id: str) -> None:
+        """Get detailed information about a primitive skill"""
+        try:
+            response = self._request("GET", f"/primitives/{primitive_id}")
+            prim = response.get("primitive", {})
+            robot = prim.get("robotProfile", {})
+            protocol = prim.get("protocol", {})
+
+            print(f"\n{'=' * 70}")
+            print(f"Primitive: {prim.get('displayName') or prim.get('name')}")
+            print(f"{'=' * 70}")
+
+            print(f"\nRobot: {robot.get('manufacturer', '?')} {robot.get('modelName', '?')}")
+            print(f"Category: {prim.get('category', '?')}")
+            print(f"Status: {prim.get('status', '?')}")
+
+            if prim.get('reliabilityScore'):
+                print(f"Reliability: {prim.get('reliabilityScore'):.1%}")
+
+            if prim.get('description'):
+                print(f"\nDescription: {prim.get('description')}")
+
+            print(f"\nCommand Type: {prim.get('commandType')}")
+            print(f"Command Template:")
+            print(f"  {prim.get('commandTemplate')}")
+
+            # Parameters
+            params = prim.get('parameters', [])
+            if params:
+                print(f"\nParameters:")
+                for p in params:
+                    range_str = ""
+                    if p.get('min') is not None and p.get('max') is not None:
+                        range_str = f" (range: {p.get('min')}-{p.get('max')})"
+                    unit = f" {p.get('unit')}" if p.get('unit') else ""
+                    default = f", default: {p.get('default')}" if p.get('default') is not None else ""
+                    tested = f", tested safe: {p.get('testedSafe')}" if p.get('testedSafe') is not None else ""
+                    print(f"  - {p.get('name')}: {p.get('type')}{range_str}{unit}{default}{tested}")
+
+            # Timing
+            if any([prim.get('executionTimeMs'), prim.get('settleTimeMs'), prim.get('cooldownMs')]):
+                print(f"\nTiming:")
+                if prim.get('executionTimeMs'):
+                    print(f"  Execution: {prim.get('executionTimeMs')}ms")
+                if prim.get('settleTimeMs'):
+                    print(f"  Settle: {prim.get('settleTimeMs')}ms")
+                if prim.get('cooldownMs'):
+                    print(f"  Cooldown: {prim.get('cooldownMs')}ms")
+
+            # Safety
+            if prim.get('safetyNotes'):
+                print(f"\nSafety Notes:")
+                print(f"  {prim.get('safetyNotes')}")
+
+            # Dependencies
+            depends_on = prim.get('dependsOn', [])
+            if depends_on:
+                print(f"\nDepends On ({len(depends_on)}):")
+                for dep in depends_on:
+                    req = dep.get('requiredSkill', {})
+                    print(f"  - {req.get('name')} ({dep.get('dependencyType')})")
+
+            required_by = prim.get('requiredBy', [])
+            if required_by:
+                print(f"\nRequired By ({len(required_by)}):")
+                for dep in required_by:
+                    dep_skill = dep.get('dependentSkill', {})
+                    print(f"  - {dep_skill.get('name')}")
+
+        except Exception as e:
+            print(f"Error fetching primitive: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def primitive_test(self, primitive_id: str, params_json: str,
+                       result: str, notes: Optional[str], video_url: Optional[str]) -> None:
+        """Submit a test result for a primitive skill"""
+        try:
+            parameters = json.loads(params_json)
+        except json.JSONDecodeError as e:
+            print(f"Error: Invalid JSON for parameters: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        data = {
+            "parameters": parameters,
+            "result": result,
+        }
+        if notes:
+            data["resultNotes"] = notes
+        if video_url:
+            data["videoUrl"] = video_url
+
+        try:
+            response = self._request("POST", f"/primitives/{primitive_id}/test", json=data)
+            test_result = response.get("testResult", {})
+            update = response.get("primitiveUpdate", {})
+
+            print(f"\n✓ Test result submitted!")
+            print(f"  Result: {result}")
+            print(f"  New Reliability Score: {update.get('reliabilityScore', 0):.1%}")
+
+            if update.get('statusChanged'):
+                print(f"  Status upgraded to: {update.get('status')}")
+
+        except Exception as e:
+            print(f"Error submitting test result: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def primitive_deps_show(self, primitive_id: str) -> None:
+        """Show dependencies for a primitive skill"""
+        try:
+            response = self._request("GET", f"/primitives/{primitive_id}/dependencies")
+            deps = response.get("dependencies", [])
+            dependents = response.get("dependents", [])
+            summary = response.get("summary", {})
+            deployment_ready = response.get("deploymentReady", False)
+
+            print(f"\n{'=' * 60}")
+            print("Dependency Graph")
+            print(f"{'=' * 60}")
+
+            print(f"\nDeployment Ready: {'✓ Yes' if deployment_ready else '✗ No'}")
+
+            if deps:
+                print(f"\nDepends On ({len(deps)}):")
+                for dep in deps:
+                    req = dep.get("requiredSkill", {})
+                    status_ok = req.get("status") in ["tested", "verified"]
+                    icon = "✓" if status_ok else "✗"
+                    print(f"  {icon} {req.get('name')} ({req.get('status')})")
+                    print(f"      Required status: {dep.get('requiredMinStatus')}")
+                    if req.get("reliabilityScore"):
+                        print(f"      Reliability: {req.get('reliabilityScore'):.1%}")
+            else:
+                print(f"\nNo dependencies (this is a root primitive)")
+
+            if dependents:
+                print(f"\nRequired By ({len(dependents)}):")
+                for dep in dependents:
+                    skill = dep.get("dependentSkill", {})
+                    print(f"  - {skill.get('name')}")
+
+            if summary.get('blockedDependencies', 0) > 0:
+                print(f"\n⚠ {summary.get('blockedDependencies')} dependencies need testing before deployment")
+
+        except Exception as e:
+            print(f"Error fetching dependencies: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def primitive_deps_add(self, primitive_id: str, required_skill_id: str,
+                           dependency_type: str, min_status: str) -> None:
+        """Add a dependency to a primitive skill"""
+        data = {
+            "requiredSkillId": required_skill_id,
+            "dependencyType": dependency_type,
+            "requiredMinStatus": min_status,
+        }
+
+        try:
+            response = self._request("POST", f"/primitives/{primitive_id}/dependencies", json=data)
+            dep = response.get("dependency", {})
+            cross_robot = response.get("crossRobot", False)
+
+            print(f"\n✓ Dependency added!")
+            if cross_robot:
+                print(f"  ⚠ Note: This is a cross-robot dependency")
+
+        except Exception as e:
+            print(f"Error adding dependency: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def primitive_init(self, name: str, protocol_id: Optional[str] = None,
+                        from_recording: Optional[str] = None, category: str = "motion",
+                        output_dir: str = ".") -> None:
+        """Initialize a new primitive skill definition locally"""
+        print(f"\n{'=' * 60}")
+        print("Initializing Primitive Skill")
+        print(f"{'=' * 60}\n")
+
+        # Create output directory
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+
+        primitive_data = {
+            "name": name,
+            "displayName": name.replace("_", " ").title(),
+            "category": category,
+            "description": "",
+            "protocolId": protocol_id,
+            "commandType": "single",
+            "commandTemplate": "",
+            "responsePattern": "",
+            "parameters": [],
+            "executionTimeMs": None,
+            "settleTimeMs": None,
+            "cooldownMs": None,
+            "safetyNotes": "",
+            "status": "experimental",
+            "version": "1.0.0",
+        }
+
+        # If importing from a recording, populate command data
+        if from_recording:
+            recording_path = Path(from_recording)
+            if recording_path.exists():
+                with open(recording_path) as f:
+                    recording = json.load(f)
+
+                commands = recording.get("commands", [])
+                if commands:
+                    # Use first command as template
+                    primitive_data["commandTemplate"] = commands[0].get("command", "")
+                    if len(commands) > 1:
+                        primitive_data["commandType"] = "sequence"
+                        primitive_data["commandSequence"] = [
+                            {"command": c.get("command"), "delayMs": int((c.get("timestamp", 0) * 1000))}
+                            for c in commands
+                        ]
+
+                    # Extract responses for pattern
+                    responses = [c.get("response") for c in commands if c.get("response")]
+                    if responses:
+                        primitive_data["responsePattern"] = responses[0]
+
+                    print(f"✓ Imported {len(commands)} commands from recording")
+            else:
+                print(f"Warning: Recording file not found: {from_recording}", file=sys.stderr)
+
+        # Write primitive file
+        primitive_file = out_path / f"{name}.primitive.json"
+        with open(primitive_file, "w") as f:
+            json.dump(primitive_data, f, indent=2)
+
+        print(f"✓ Created: {primitive_file}")
+        print(f"\nNext steps:")
+        print(f"  1. Edit {primitive_file} to define command template and parameters")
+        print(f"  2. Test with: ate primitive test <primitive_id> --params '{{...}}'")
+        print(f"  3. Publish with: ate primitive push {primitive_file}")
+
+    def primitive_push(self, primitive_file: str) -> None:
+        """Push a primitive skill definition to FoodforThought"""
+        file_path = Path(primitive_file)
+        if not file_path.exists():
+            print(f"Error: Primitive file not found: {primitive_file}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print("Publishing Primitive Skill")
+        print(f"{'=' * 60}\n")
+
+        with open(file_path) as f:
+            primitive_data = json.load(f)
+
+        print(f"Name: {primitive_data.get('displayName') or primitive_data.get('name')}")
+        print(f"Category: {primitive_data.get('category')}")
+
+        # Validate required fields
+        if not primitive_data.get("name"):
+            print("Error: Primitive must have a name", file=sys.stderr)
+            sys.exit(1)
+
+        if not primitive_data.get("commandTemplate") and not primitive_data.get("commandSequence"):
+            print("Error: Primitive must have a commandTemplate or commandSequence", file=sys.stderr)
+            sys.exit(1)
+
+        if not primitive_data.get("protocolId"):
+            print("Warning: No protocol ID specified. The primitive won't be linked to a protocol.", file=sys.stderr)
+
+        try:
+            response = self._request("POST", "/primitives", json=primitive_data)
+            prim = response.get("primitive", {})
+            print(f"\n✓ Primitive published successfully!")
+            print(f"  ID: {prim.get('id')}")
+            print(f"  Status: {prim.get('status')}")
+            print(f"\nNext steps:")
+            print(f"  - Test it: ate primitive test {prim.get('id')} --params '{{...}}'")
+            print(f"  - View it: ate primitive get {prim.get('id')}")
+        except Exception as e:
+            print(f"Error publishing primitive: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # =========================================================================
+    # Skill Abstractions (Layer 2) - Composed from Primitives
+    # =========================================================================
+
+    def skill_init(self, name: str, robot_model: Optional[str] = None,
+                   template: str = "basic", output_dir: str = ".") -> None:
+        """Initialize a new skill abstraction (composes primitives)"""
+        print(f"\n{'=' * 60}")
+        print("Initializing Skill Abstraction")
+        print(f"{'=' * 60}\n")
+
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+
+        skill_data = {
+            "name": name,
+            "displayName": name.replace("_", " ").title(),
+            "description": "",
+            "robotModel": robot_model,
+            "version": "1.0.0",
+            "status": "experimental",
+            "primitives": [],  # List of primitive IDs this skill uses
+            "sequence": [],    # Ordered execution sequence
+            "parameters": [],  # Skill-level parameters
+            "preconditions": [],
+            "postconditions": [],
+            "errorHandling": {
+                "retryCount": 3,
+                "retryDelayMs": 1000,
+                "fallbackAction": None,
+            },
+            "metadata": {
+                "author": "",
+                "license": "MIT",
+                "tags": [],
+            }
+        }
+
+        # Write skill file
+        skill_file = out_path / f"{name}.skill.json"
+        with open(skill_file, "w") as f:
+            json.dump(skill_data, f, indent=2)
+
+        print(f"✓ Created: {skill_file}")
+        print(f"\nNext steps:")
+        print(f"  1. Add primitives: ate skill compose {skill_file} <primitive_ids...>")
+        print(f"  2. Edit {skill_file} to define sequence and parameters")
+        print(f"  3. Test with: ate skill test {skill_file}")
+        print(f"  4. Publish with: ate skill push {skill_file}")
+
+    def skill_compose(self, skill_file: str, primitive_ids: List[str]) -> None:
+        """Add primitives to a skill's composition"""
+        file_path = Path(skill_file)
+        if not file_path.exists():
+            print(f"Error: Skill file not found: {skill_file}", file=sys.stderr)
+            sys.exit(1)
+
+        with open(file_path) as f:
+            skill_data = json.load(f)
+
+        print(f"\n{'=' * 60}")
+        print(f"Composing Skill: {skill_data.get('name')}")
+        print(f"{'=' * 60}\n")
+
+        # Fetch primitive details to validate
+        for prim_id in primitive_ids:
+            try:
+                response = self._request("GET", f"/primitives/{prim_id}")
+                prim = response.get("primitive", {})
+                print(f"  ✓ Adding: {prim.get('name')} ({prim.get('category')})")
+
+                # Add to primitives list if not already present
+                if prim_id not in skill_data.get("primitives", []):
+                    skill_data.setdefault("primitives", []).append(prim_id)
+
+                # Add to sequence
+                skill_data.setdefault("sequence", []).append({
+                    "primitiveId": prim_id,
+                    "primitiveName": prim.get("name"),
+                    "parameterMapping": {},  # Map skill params to primitive params
+                    "conditionCheck": None,
+                    "onError": "abort",
+                })
+
+            except Exception as e:
+                print(f"  ✗ Failed to fetch {prim_id}: {e}", file=sys.stderr)
+
+        # Write updated skill file
+        with open(file_path, "w") as f:
+            json.dump(skill_data, f, indent=2)
+
+        print(f"\n✓ Updated {skill_file}")
+        print(f"   Primitives: {len(skill_data.get('primitives', []))}")
+        print(f"   Sequence steps: {len(skill_data.get('sequence', []))}")
+
+    def skill_list(self, robot_model: Optional[str] = None,
+                   status: Optional[str] = None) -> None:
+        """List skill abstractions"""
+        params = {}
+        if robot_model:
+            params["robotModel"] = robot_model
+        if status:
+            params["status"] = status
+
+        try:
+            response = self._request("GET", "/skills", params=params)
+            skills = response.get("skills", [])
+
+            print(f"\n{'=' * 70}")
+            print(f"Skill Abstractions ({len(skills)} total)")
+            print(f"{'=' * 70}")
+
+            if not skills:
+                print("\nNo skills found. Create one with: ate skill init <name>")
+                return
+
+            for skill in skills:
+                status_icons = {"verified": "✓", "tested": "○", "experimental": "◌"}
+                icon = status_icons.get(skill.get("status", "experimental"), "?")
+                prim_count = len(skill.get("primitives", []))
+                print(f"\n{icon} {skill.get('name')}")
+                print(f"   Robot: {skill.get('robotModel', 'Any')}")
+                print(f"   Primitives: {prim_count}")
+                print(f"   ID: {skill.get('id')}")
+
+        except Exception as e:
+            print(f"Error listing skills: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def skill_get(self, skill_id: str) -> None:
+        """Get detailed information about a skill"""
+        try:
+            response = self._request("GET", f"/skills/{skill_id}")
+            skill = response.get("skill", {})
+
+            print(f"\n{'=' * 70}")
+            print(f"Skill: {skill.get('displayName') or skill.get('name')}")
+            print(f"{'=' * 70}")
+
+            print(f"\nDescription: {skill.get('description') or 'No description'}")
+            print(f"Robot: {skill.get('robotModel', 'Any')}")
+            print(f"Status: {skill.get('status')}")
+            print(f"Version: {skill.get('version')}")
+
+            # Show sequence
+            sequence = skill.get("sequence", [])
+            if sequence:
+                print(f"\nExecution Sequence ({len(sequence)} steps):")
+                for i, step in enumerate(sequence, 1):
+                    print(f"  {i}. {step.get('primitiveName', step.get('primitiveId'))}")
+                    if step.get("conditionCheck"):
+                        print(f"      Condition: {step.get('conditionCheck')}")
+
+            # Show parameters
+            params = skill.get("parameters", [])
+            if params:
+                print(f"\nParameters:")
+                for p in params:
+                    print(f"  - {p.get('name')}: {p.get('type')}")
+
+        except Exception as e:
+            print(f"Error fetching skill: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def skill_push(self, skill_file: str) -> None:
+        """Push a skill abstraction to FoodforThought"""
+        file_path = Path(skill_file)
+        if not file_path.exists():
+            print(f"Error: Skill file not found: {skill_file}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print("Publishing Skill Abstraction")
+        print(f"{'=' * 60}\n")
+
+        with open(file_path) as f:
+            skill_data = json.load(f)
+
+        print(f"Name: {skill_data.get('displayName') or skill_data.get('name')}")
+        print(f"Primitives: {len(skill_data.get('primitives', []))}")
+
+        if not skill_data.get("name"):
+            print("Error: Skill must have a name", file=sys.stderr)
+            sys.exit(1)
+
+        if not skill_data.get("primitives"):
+            print("Warning: Skill has no primitives. Add with: ate skill compose", file=sys.stderr)
+
+        try:
+            response = self._request("POST", "/skills", json=skill_data)
+            skill = response.get("skill", {})
+            print(f"\n✓ Skill published successfully!")
+            print(f"  ID: {skill.get('id')}")
+            print(f"  Status: {skill.get('status')}")
+        except Exception as e:
+            print(f"Error publishing skill: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def skill_test(self, skill_file_or_id: str, params_json: Optional[str] = None,
+                   dry_run: bool = True) -> None:
+        """Test a skill (simulated or real execution)"""
+        print(f"\n{'=' * 60}")
+        print("Testing Skill")
+        print(f"{'=' * 60}\n")
+
+        # Check if it's a file or ID
+        if Path(skill_file_or_id).exists():
+            with open(skill_file_or_id) as f:
+                skill_data = json.load(f)
+            print(f"Testing local skill: {skill_data.get('name')}")
+        else:
+            # Fetch from API
+            response = self._request("GET", f"/skills/{skill_file_or_id}")
+            skill_data = response.get("skill", {})
+            print(f"Testing remote skill: {skill_data.get('name')}")
+
+        params = json.loads(params_json) if params_json else {}
+
+        sequence = skill_data.get("sequence", [])
+        print(f"\nSequence ({len(sequence)} steps):")
+
+        for i, step in enumerate(sequence, 1):
+            prim_name = step.get("primitiveName", step.get("primitiveId"))
+            if dry_run:
+                print(f"  [{i}/{len(sequence)}] Would execute: {prim_name}")
+            else:
+                print(f"  [{i}/{len(sequence)}] Executing: {prim_name}...")
+                # In real mode, would invoke the primitive via protocol
+                time.sleep(0.5)  # Simulate execution
+                print(f"           ✓ Complete")
+
+        print(f"\n{'✓ Dry run complete' if dry_run else '✓ Execution complete'}")
+
+    # ========================================
+    # Phase 3: AI Bridge - Interactive Robot Communication
+    # ========================================
+
+    def bridge_connect(self, port: str, transport: str = "serial",
+                       baud_rate: int = 115200, protocol_id: Optional[str] = None) -> None:
+        """Connect to a robot via serial or BLE and start interactive session"""
+        print(f"\n{'=' * 60}")
+        print("FoodForThought Bridge - Robot Communication Interface")
+        print(f"{'=' * 60}\n")
+
+        if transport == "serial":
+            try:
+                import serial
+            except ImportError:
+                print("Error: pyserial is required. Install with: pip install pyserial", file=sys.stderr)
+                sys.exit(1)
+
+            print(f"Connecting to {port} at {baud_rate} baud...")
+            try:
+                ser = serial.Serial(port, baud_rate, timeout=1)
+                print(f"✓ Connected to {port}")
+                print(f"\nInteractive mode. Type commands to send to robot.")
+                print("Special commands:")
+                print("  .quit     - Exit bridge")
+                print("  .record   - Start recording for primitive creation")
+                print("  .stop     - Stop recording")
+                print("  .save     - Save recorded session")
+                print("  .protocol - Show loaded protocol info")
+                print("-" * 60 + "\n")
+
+                recording = False
+                recorded_commands = []
+
+                while True:
+                    try:
+                        cmd = input("bridge> ").strip()
+                        if not cmd:
+                            continue
+
+                        if cmd == ".quit":
+                            break
+                        elif cmd == ".record":
+                            recording = True
+                            recorded_commands = []
+                            print("Recording started...")
+                            continue
+                        elif cmd == ".stop":
+                            recording = False
+                            print(f"Recording stopped. {len(recorded_commands)} commands recorded.")
+                            continue
+                        elif cmd == ".save":
+                            if recorded_commands:
+                                filename = f"session_{int(time.time())}.json"
+                                with open(filename, "w") as f:
+                                    json.dump({
+                                        "port": port,
+                                        "baud_rate": baud_rate,
+                                        "commands": recorded_commands
+                                    }, f, indent=2)
+                                print(f"Session saved to {filename}")
+                            else:
+                                print("No commands recorded yet.")
+                            continue
+                        elif cmd == ".protocol":
+                            if protocol_id:
+                                self.protocol_get(protocol_id)
+                            else:
+                                print("No protocol loaded. Use --protocol flag to specify.")
+                            continue
+
+                        # Send command to robot
+                        ser.write((cmd + "\n").encode())
+                        if recording:
+                            recorded_commands.append({
+                                "command": cmd,
+                                "timestamp": time.time()
+                            })
+
+                        # Read response
+                        time.sleep(0.1)
+                        response = ser.read_all().decode("utf-8", errors="replace").strip()
+                        if response:
+                            print(f"< {response}")
+                            if recording:
+                                recorded_commands[-1]["response"] = response
+
+                    except KeyboardInterrupt:
+                        break
+
+                ser.close()
+                print("\n✓ Disconnected")
+
+            except Exception as e:
+                print(f"Error connecting to {port}: {e}", file=sys.stderr)
+                sys.exit(1)
+
+        elif transport == "ble":
+            print("BLE bridge requires async operation. Starting BLE session...")
+            self._bridge_ble_connect(port)
+
+    def _bridge_ble_connect(self, address: str) -> None:
+        """Connect to robot via BLE (requires bleak)"""
+        try:
+            import asyncio
+            from bleak import BleakClient
+        except ImportError:
+            print("Error: bleak is required for BLE. Install with: pip install bleak", file=sys.stderr)
+            sys.exit(1)
+
+        async def ble_session():
+            print(f"Connecting to BLE device {address}...")
+            try:
+                async with BleakClient(address) as client:
+                    print(f"✓ Connected to {address}")
+
+                    # List services
+                    print("\nAvailable services:")
+                    for service in client.services:
+                        print(f"  {service.uuid}: {service.description or 'Unknown'}")
+                        for char in service.characteristics:
+                            props = ", ".join(char.properties)
+                            print(f"    └─ {char.uuid} [{props}]")
+
+                    print("\nInteractive mode. Commands:")
+                    print("  read <uuid>         - Read characteristic")
+                    print("  write <uuid> <hex>  - Write to characteristic")
+                    print("  notify <uuid>       - Subscribe to notifications")
+                    print("  .quit               - Exit")
+                    print("-" * 60 + "\n")
+
+                    while True:
+                        try:
+                            cmd = input("ble> ").strip()
+                            if not cmd:
+                                continue
+
+                            if cmd == ".quit":
+                                break
+
+                            parts = cmd.split()
+                            if parts[0] == "read" and len(parts) >= 2:
+                                uuid = parts[1]
+                                try:
+                                    data = await client.read_gatt_char(uuid)
+                                    print(f"< {data.hex()} ({data})")
+                                except Exception as e:
+                                    print(f"Error reading: {e}")
+
+                            elif parts[0] == "write" and len(parts) >= 3:
+                                uuid = parts[1]
+                                hex_data = parts[2]
+                                try:
+                                    data = bytes.fromhex(hex_data)
+                                    await client.write_gatt_char(uuid, data)
+                                    print(f"✓ Written {hex_data}")
+                                except Exception as e:
+                                    print(f"Error writing: {e}")
+
+                            elif parts[0] == "notify" and len(parts) >= 2:
+                                uuid = parts[1]
+                                def callback(sender, data):
+                                    print(f"[{sender}] {data.hex()}")
+                                try:
+                                    await client.start_notify(uuid, callback)
+                                    print(f"✓ Subscribed to {uuid}")
+                                except Exception as e:
+                                    print(f"Error subscribing: {e}")
+
+                            else:
+                                print("Unknown command. Use read/write/notify or .quit")
+
+                        except KeyboardInterrupt:
+                            break
+
+                    print("\n✓ Disconnected")
+
+            except Exception as e:
+                print(f"Error connecting to BLE device: {e}", file=sys.stderr)
+                sys.exit(1)
+
+        asyncio.run(ble_session())
+
+    def bridge_send(self, port: str, command: str, transport: str = "serial",
+                    baud_rate: int = 115200, wait: float = 0.5) -> None:
+        """Send a single command to robot and print response"""
+        if transport == "serial":
+            try:
+                import serial
+            except ImportError:
+                print("Error: pyserial is required. Install with: pip install pyserial", file=sys.stderr)
+                sys.exit(1)
+
+            try:
+                ser = serial.Serial(port, baud_rate, timeout=1)
+                ser.write((command + "\n").encode())
+                time.sleep(wait)
+                response = ser.read_all().decode("utf-8", errors="replace").strip()
+                if response:
+                    print(response)
+                ser.close()
+            except Exception as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            print("BLE send not yet implemented. Use bridge connect for BLE.", file=sys.stderr)
+
+    def bridge_record(self, port: str, output: str, transport: str = "serial",
+                      baud_rate: int = 115200, primitive_name: Optional[str] = None) -> None:
+        """Record a command session for creating a primitive skill"""
+        print(f"\n{'=' * 60}")
+        print("FoodForThought Bridge - Recording Mode")
+        print(f"{'=' * 60}\n")
+
+        if transport != "serial":
+            print("Recording currently only supports serial connections", file=sys.stderr)
+            sys.exit(1)
+
+        try:
+            import serial
+        except ImportError:
+            print("Error: pyserial is required. Install with: pip install pyserial", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"Connecting to {port} at {baud_rate} baud...")
+        try:
+            ser = serial.Serial(port, baud_rate, timeout=1)
+            print(f"✓ Connected and recording to {output}")
+            print(f"\nType commands to send. Ctrl+C to stop and save.\n")
+
+            recorded = {
+                "name": primitive_name or f"recorded_skill_{int(time.time())}",
+                "port": port,
+                "baud_rate": baud_rate,
+                "start_time": time.time(),
+                "commands": []
+            }
+
+            while True:
+                try:
+                    cmd = input(f"[REC] bridge> ").strip()
+                    if not cmd:
+                        continue
+
+                    timestamp = time.time()
+                    ser.write((cmd + "\n").encode())
+                    time.sleep(0.1)
+                    response = ser.read_all().decode("utf-8", errors="replace").strip()
+
+                    entry = {
+                        "command": cmd,
+                        "timestamp": timestamp - recorded["start_time"],
+                        "response": response
+                    }
+                    recorded["commands"].append(entry)
+
+                    if response:
+                        print(f"< {response}")
+
+                except KeyboardInterrupt:
+                    break
+
+            ser.close()
+            recorded["end_time"] = time.time()
+            recorded["duration"] = recorded["end_time"] - recorded["start_time"]
+
+            # Save recording
+            with open(output, "w") as f:
+                json.dump(recorded, f, indent=2)
+
+            print(f"\n✓ Recorded {len(recorded['commands'])} commands")
+            print(f"✓ Saved to {output}")
+            print(f"\nTo create a primitive from this recording:")
+            print(f"  ate primitive create --from-recording {output}")
+
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def bridge_replay(self, recording_file: str, port: str, transport: str = "serial",
+                      baud_rate: int = 115200, speed: float = 1.0) -> None:
+        """Replay a recorded session"""
+        if not Path(recording_file).exists():
+            print(f"Error: Recording file not found: {recording_file}", file=sys.stderr)
+            sys.exit(1)
+
+        with open(recording_file) as f:
+            recording = json.load(f)
+
+        if transport != "serial":
+            print("Replay currently only supports serial connections", file=sys.stderr)
+            sys.exit(1)
+
+        try:
+            import serial
+        except ImportError:
+            print("Error: pyserial is required. Install with: pip install pyserial", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print(f"Replaying: {recording.get('name', recording_file)}")
+        print(f"Commands: {len(recording.get('commands', []))}")
+        print(f"Speed: {speed}x")
+        print(f"{'=' * 60}\n")
+
+        try:
+            ser = serial.Serial(port, baud_rate, timeout=1)
+            commands = recording.get("commands", [])
+
+            prev_timestamp = 0
+            for i, entry in enumerate(commands):
+                timestamp = entry.get("timestamp", 0)
+                delay = (timestamp - prev_timestamp) / speed
+                if delay > 0 and i > 0:
+                    time.sleep(delay)
+                prev_timestamp = timestamp
+
+                cmd = entry.get("command", "")
+                print(f"[{i+1}/{len(commands)}] > {cmd}")
+                ser.write((cmd + "\n").encode())
+
+                time.sleep(0.1)
+                response = ser.read_all().decode("utf-8", errors="replace").strip()
+                if response:
+                    print(f"            < {response}")
+
+            ser.close()
+            print(f"\n✓ Replay complete")
+
+        except Exception as e:
+            print(f"Error during replay: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # =========================================================================
+    # Skill Compiler Commands
+    # =========================================================================
+
+    def compile_skill(
+        self,
+        skill_path: str,
+        output: str = "./output",
+        target: str = "ros2",
+        robot: Optional[str] = None,
+        ate_dir: Optional[str] = None,
+    ) -> None:
+        """
+        Compile a skill specification into a deployable package.
+
+        Args:
+            skill_path: Path to skill.yaml specification
+            output: Output directory for generated files
+            target: Target platform (ros2, docker, python)
+            robot: Path to robot URDF file for hardware config
+            ate_dir: Path to ATE config directory for servo mapping
+        """
+        from pathlib import Path
+        from ate.skill_schema import SkillSpecification
+        from ate.generators import (
+            SkillCodeGenerator,
+            ROS2PackageGenerator,
+            DockerGenerator,
+            generate_hardware_config,
+        )
+
+        skill_path = Path(skill_path)
+        output_path = Path(output)
+
+        if not skill_path.exists():
+            print(f"Error: Skill specification not found: {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print(f"  Skill Compiler v1.0.0")
+        print(f"{'=' * 60}")
+        print(f"  Input:  {skill_path}")
+        print(f"  Output: {output_path}")
+        print(f"  Target: {target}")
+        if robot:
+            print(f"  Robot:  {robot}")
+        print(f"{'=' * 60}\n")
+
+        # Load skill specification
+        print("Loading skill specification...")
+        try:
+            spec = SkillSpecification.from_yaml(str(skill_path))
+        except Exception as e:
+            print(f"Error parsing skill specification: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        # Validate specification
+        print("Validating specification...")
+        errors = spec.validate()
+        if errors:
+            print(f"\nValidation errors:", file=sys.stderr)
+            for error in errors:
+                print(f"  - {error}", file=sys.stderr)
+            sys.exit(1)
+        print(f"  ✓ Specification valid: {spec.name} v{spec.version}")
+        print(f"  ✓ Primitives: {len(spec.primitives)}")
+        print(f"  ✓ Hardware requirements: {len(spec.hardware_requirements)}")
+
+        # Generate skill code
+        print("\nGenerating skill code...")
+        skill_gen = SkillCodeGenerator(spec)
+        skill_files = skill_gen.generate(output_path / "src")
+        print(f"  ✓ Generated {len(skill_files)} files")
+
+        # Generate platform-specific package
+        if target == "ros2":
+            print("\nGenerating ROS2 package...")
+            ros2_gen = ROS2PackageGenerator(spec)
+            ros2_files = ros2_gen.generate(output_path)
+            print(f"  ✓ Generated ROS2 package with {len(ros2_files)} files")
+
+        elif target == "docker":
+            print("\nGenerating Docker configuration...")
+            docker_gen = DockerGenerator(spec)
+            docker_files = docker_gen.generate(output_path)
+            print(f"  ✓ Generated Docker files: {len(docker_files)}")
+
+        elif target == "python":
+            print("\nGenerating Python package...")
+            # Python package is already generated by skill_gen
+            # Just add setup.py
+            setup_content = f'''from setuptools import setup, find_packages
+
+setup(
+    name="{spec.name}",
+    version="{spec.version}",
+    packages=find_packages(),
+    description="{spec.description}",
+    python_requires=">=3.8",
+)
+'''
+            (output_path / "setup.py").write_text(setup_content)
+            print("  ✓ Generated setup.py")
+
+        # Generate hardware config if robot provided
+        if robot or ate_dir:
+            print("\nGenerating hardware configuration...")
+            try:
+                hw_config = generate_hardware_config(
+                    spec,
+                    urdf_path=robot,
+                    ate_dir=ate_dir,
+                )
+                import yaml
+                config_dir = output_path / "config"
+                config_dir.mkdir(parents=True, exist_ok=True)
+                config_path = config_dir / "hardware_config.yaml"
+                with open(config_path, "w") as f:
+                    yaml.dump(hw_config, f, default_flow_style=False)
+                print(f"  ✓ Generated hardware config: {config_path}")
+            except Exception as e:
+                print(f"  ⚠ Warning: Could not generate hardware config: {e}")
+
+        # Copy skill.yaml to output
+        import shutil
+        shutil.copy(skill_path, output_path / "skill.yaml")
+
+        print(f"\n{'=' * 60}")
+        print(f"  ✓ Compilation complete!")
+        print(f"  Output: {output_path.absolute()}")
+        print(f"{'=' * 60}\n")
+
+        # Print next steps
+        print("Next steps:")
+        if target == "ros2":
+            print("  1. cd output && colcon build")
+            print("  2. source install/setup.bash")
+            print(f"  3. ros2 launch {spec.name}_skill skill.launch.py")
+        elif target == "docker":
+            print("  1. cd output && docker build -t skill .")
+            print("  2. docker run skill")
+        elif target == "python":
+            print("  1. cd output && pip install -e .")
+            print(f"  2. python -c 'from {spec.name} import {spec.name.title().replace('_', '')}Skill'")
+
+    def test_compiled_skill(
+        self,
+        skill_path: str,
+        mode: str = "sim",
+        robot_port: Optional[str] = None,
+        params: Optional[str] = None,
+    ) -> None:
+        """
+        Test a compiled skill in simulation or on hardware.
+
+        Args:
+            skill_path: Path to compiled skill directory
+            mode: Test mode (sim, hardware, mock)
+            robot_port: Serial port for hardware testing
+            params: JSON parameters for skill execution
+        """
+        from pathlib import Path
+
+        skill_path = Path(skill_path)
+
+        if not skill_path.exists():
+            print(f"Error: Skill directory not found: {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        # Check for skill.yaml
+        skill_yaml = skill_path / "skill.yaml"
+        if not skill_yaml.exists():
+            print(f"Error: skill.yaml not found in {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        print(f"\n{'=' * 60}")
+        print(f"  Skill Test Runner")
+        print(f"{'=' * 60}")
+        print(f"  Skill:  {skill_path}")
+        print(f"  Mode:   {mode}")
+        if robot_port:
+            print(f"  Port:   {robot_port}")
+        print(f"{'=' * 60}\n")
+
+        # Load skill specification
+        from ate.skill_schema import SkillSpecification
+        spec = SkillSpecification.from_yaml(str(skill_yaml))
+
+        print(f"Testing skill: {spec.name} v{spec.version}")
+        print(f"Primitives: {', '.join(spec.primitives)}")
+        print()
+
+        if mode == "mock":
+            print("Running in mock mode (no hardware)...")
+            # Import and run skill with mock drivers
+            try:
+                import importlib.util
+                skill_module_path = skill_path / "src" / f"{spec.name.replace('-', '_')}" / "skill.py"
+                if skill_module_path.exists():
+                    spec_loader = importlib.util.spec_from_file_location("skill", skill_module_path)
+                    module = importlib.util.module_from_spec(spec_loader)
+                    spec_loader.loader.exec_module(module)
+
+                    # Get the skill class
+                    class_name = spec.name.replace('_', ' ').title().replace(' ', '') + "Skill"
+                    skill_class = getattr(module, class_name)
+
+                    # Create instance with mock config
+                    skill = skill_class({"driver": "mock"})
+
+                    # Parse params if provided
+                    input_params = {}
+                    if params:
+                        input_params = json.loads(params)
+
+                    # Get input class
+                    input_class_name = class_name.replace("Skill", "Input")
+                    input_class = getattr(module, input_class_name)
+                    skill_input = input_class(**input_params)
+
+                    # Execute
+                    print("\nExecuting skill...")
+                    result = skill.execute(skill_input)
+                    print(f"\nResult:")
+                    print(f"  Success: {result.success}")
+                    print(f"  Message: {result.message}")
+                    print(f"  Time: {result.execution_time:.3f}s")
+                else:
+                    print(f"Warning: Skill module not found at {skill_module_path}")
+                    print("Running dry-run validation instead...")
+                    print("\n  ✓ Specification valid")
+                    print("  ✓ All primitives available")
+                    print("  ✓ Hardware requirements satisfied (mock)")
+
+            except Exception as e:
+                print(f"Error running skill: {e}", file=sys.stderr)
+                import traceback
+                traceback.print_exc()
+                sys.exit(1)
+
+        elif mode == "sim":
+            print("Simulation testing requires MuJoCo or Gazebo integration.")
+            print("For now, running mock test instead...")
+            self.test_compiled_skill(skill_path, mode="mock", params=params)
+
+        elif mode == "hardware":
+            if not robot_port:
+                print("Error: --robot-port required for hardware mode", file=sys.stderr)
+                sys.exit(1)
+            print(f"Hardware testing on {robot_port}...")
+            print("Note: Full hardware testing requires bridge connection.")
+            print("Consider running: ate bridge serve")
+
+        print(f"\n{'=' * 60}")
+        print(f"  ✓ Test complete")
+        print(f"{'=' * 60}\n")
+
+    def publish_compiled_skill(
+        self,
+        skill_path: str,
+        visibility: str = "public",
+    ) -> None:
+        """
+        Publish a compiled skill to FoodforThought registry.
+
+        Args:
+            skill_path: Path to compiled skill directory
+            visibility: Visibility (public, private, team)
+        """
+        from pathlib import Path
+
+        skill_path = Path(skill_path)
+
+        if not skill_path.exists():
+            print(f"Error: Skill directory not found: {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        # Check for skill.yaml
+        skill_yaml = skill_path / "skill.yaml"
+        if not skill_yaml.exists():
+            print(f"Error: skill.yaml not found in {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        # Load skill specification
+        from ate.skill_schema import SkillSpecification
+        spec = SkillSpecification.from_yaml(str(skill_yaml))
+
+        print(f"\n{'=' * 60}")
+        print(f"  Publishing Skill to FoodforThought")
+        print(f"{'=' * 60}")
+        print(f"  Name:       {spec.name}")
+        print(f"  Version:    {spec.version}")
+        print(f"  Visibility: {visibility}")
+        print(f"{'=' * 60}\n")
+
+        # Prepare upload payload
+        skill_data = spec.to_dict()
+        skill_data["visibility"] = visibility
+
+        # Include file listing
+        files = []
+        for path in skill_path.rglob("*"):
+            if path.is_file() and not path.name.startswith("."):
+                rel_path = path.relative_to(skill_path)
+                files.append(str(rel_path))
+        skill_data["files"] = files
+
+        print(f"Files to publish: {len(files)}")
+
+        # Upload to API
+        try:
+            response = self._request("POST", "/skills/publish", json=skill_data)
+            skill_id = response.get("skillId", response.get("id", "unknown"))
+            skill_url = f"https://kindly.fyi/skills/{skill_id}"
+
+            print(f"\n✓ Skill published successfully!")
+            print(f"  ID:  {skill_id}")
+            print(f"  URL: {skill_url}")
+
+        except Exception as e:
+            # Mock response for offline testing
+            mock_id = f"sk_{spec.name}_{spec.version.replace('.', '_')}"
+            print(f"\n✓ Skill prepared for publishing (API unavailable)")
+            print(f"  Mock ID: {mock_id}")
+            print(f"  Run with API key to publish: export ATE_API_KEY=your_key")
+
+    def check_skill_compatibility(
+        self,
+        skill_path: str,
+        robot_urdf: Optional[str] = None,
+        robot_ate_dir: Optional[str] = None,
+    ) -> None:
+        """
+        Check if a skill is compatible with a robot.
+
+        Args:
+            skill_path: Path to skill.yaml
+            robot_urdf: Path to robot URDF
+            robot_ate_dir: Path to ATE config directory
+        """
+        from pathlib import Path
+        from ate.skill_schema import SkillSpecification
+        from ate.compatibility import check_compatibility_from_paths
+
+        skill_path = Path(skill_path)
+        if not skill_path.exists():
+            print(f"Error: Skill not found: {skill_path}", file=sys.stderr)
+            sys.exit(1)
+
+        # Determine robot name
+        robot_name = "unknown"
+        if robot_urdf:
+            robot_name = Path(robot_urdf).stem
+        elif robot_ate_dir:
+            robot_name = Path(robot_ate_dir).name
+
+        print(f"\n{'=' * 60}")
+        print(f"  Skill Compatibility Check")
+        print(f"{'=' * 60}")
+        print(f"  Skill: {skill_path}")
+        print(f"  Robot: {robot_name}")
+        print(f"{'=' * 60}\n")
+
+        report = check_compatibility_from_paths(
+            skill_yaml=str(skill_path),
+            robot_urdf=robot_urdf,
+            robot_ate_dir=robot_ate_dir,
+            robot_name=robot_name,
+        )
+
+        print(report)
+
+        if not report.compatible:
+            sys.exit(1)
+
+
+    def data_upload(self, path: str, skill: str, stage: str) -> None:
+        # Upload dataset/sensor logs
+        ATEClient.data_upload(self, path, skill, stage)
+
+
+def login_command():
+    """Interactive login to store API key"""
+    print("Authenticate with FoodforThought")
+    print("1. Go to https://kindly.fyi/settings/keys")
+    print("2. Create a new API key")
+    print("3. Paste it here")
+    
+    try:
+        api_key = getpass.getpass("API Key: ").strip()
+    except KeyboardInterrupt:
+        print("\nLogin cancelled.")
+        sys.exit(1)
+        
+    if not api_key:
+        print("Error: API key cannot be empty", file=sys.stderr)
+        sys.exit(1)
+        
+    if not api_key.startswith("ate_"):
+        print("Warning: API key usually starts with 'ate_'. Please check your key.", file=sys.stderr)
+        if input("Continue anyway? (y/N): ").lower() != "y":
+            sys.exit(1)
+            
+    # Create config directory
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        
+        # Load existing config if present
+        config = {}
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    config = json.load(f)
+            except Exception:
+                pass
+                
+        # Update key
+        config["api_key"] = api_key
+        
+        # Write config
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(config, f, indent=2)
+            
+        print(f"✓ Successfully logged in. Credentials saved to {CONFIG_FILE}")
+        
+    except Exception as e:
+        print(f"Error saving credentials: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    """Main CLI entry point"""
+    parser = argparse.ArgumentParser(description="FoodforThought CLI")
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # init command
+    init_parser = subparsers.add_parser("init", help="Initialize a new repository")
+    init_parser.add_argument("name", help="Repository name")
+    init_parser.add_argument("-d", "--description", default="", help="Repository description")
+    init_parser.add_argument(
+        "-v", "--visibility", choices=["public", "private"], default="public", help="Repository visibility"
+    )
+
+    # clone command
+    clone_parser = subparsers.add_parser("clone", help="Clone a repository")
+    clone_parser.add_argument("repo_id", help="Repository ID")
+    clone_parser.add_argument("target_dir", nargs="?", help="Target directory")
+
+    # commit command
+    commit_parser = subparsers.add_parser("commit", help="Create a commit")
+    commit_parser.add_argument("-m", "--message", required=True, help="Commit message")
+    commit_parser.add_argument("files", nargs="*", help="Files to commit")
+
+    # push command
+    push_parser = subparsers.add_parser("push", help="Push commits to remote")
+    push_parser.add_argument("-b", "--branch", default="main", help="Branch name")
+
+    # deploy command
+    deploy_parser = subparsers.add_parser("deploy", help="Deploy to robot")
+    deploy_parser.add_argument("robot_type", help="Robot type (e.g., unitree-r1)")
+    deploy_parser.add_argument("-r", "--repo-id", help="Repository ID (default: current repo)")
+
+    # test command
+    test_parser = subparsers.add_parser("test", help="Test skills in simulation")
+    test_parser.add_argument("-e", "--environment", default="gazebo", 
+                           choices=["gazebo", "mujoco", "pybullet", "webots"],
+                           help="Simulation environment")
+    test_parser.add_argument("-r", "--robot", help="Robot model to test with")
+    test_parser.add_argument("--local", action="store_true", help="Run simulation locally")
+
+    # benchmark command
+    benchmark_parser = subparsers.add_parser("benchmark", help="Run performance benchmarks")
+    benchmark_parser.add_argument("-t", "--type", default="all",
+                                choices=["speed", "accuracy", "robustness", "efficiency", "all"],
+                                help="Benchmark type")
+    benchmark_parser.add_argument("-n", "--trials", type=int, default=10, help="Number of trials")
+    benchmark_parser.add_argument("--compare", help="Compare with baseline (repository ID)")
+
+    # adapt command
+    adapt_parser = subparsers.add_parser("adapt", help="Adapt skills between robots")
+    adapt_parser.add_argument("source_robot", help="Source robot model")
+    adapt_parser.add_argument("target_robot", help="Target robot model")
+    adapt_parser.add_argument("-r", "--repo-id", help="Repository ID to adapt")
+    adapt_parser.add_argument("--analyze-only", action="store_true", 
+                            help="Only show compatibility analysis")
+
+    # validate command
+    validate_parser = subparsers.add_parser("validate", help="Validate safety and compliance")
+    validate_parser.add_argument("-c", "--checks", nargs="+", 
+                               choices=["collision", "speed", "workspace", "force", "all"],
+                               default=["all"], help="Safety checks to run")
+    validate_parser.add_argument("--strict", action="store_true", help="Use strict validation")
+    validate_parser.add_argument("-f", "--files", nargs="*", help="Specific files to validate")
+
+    # stream command
+    stream_parser = subparsers.add_parser("stream", help="Stream sensor data")
+    stream_parser.add_argument("action", choices=["start", "stop", "status"],
+                             help="Streaming action")
+    stream_parser.add_argument("-s", "--sensors", nargs="+", 
+                             help="Sensors to stream (e.g., camera, lidar, imu)")
+    stream_parser.add_argument("-o", "--output", help="Output file or URL")
+    stream_parser.add_argument("--format", default="rosbag", 
+                             choices=["rosbag", "hdf5", "json", "live"],
+                             help="Data format")
+
+    # pull command - Pull skill data for training
+    pull_parser = subparsers.add_parser("pull", help="Pull skill data for training")
+    pull_parser.add_argument("skill_id", help="Skill ID to pull")
+    pull_parser.add_argument("-r", "--robot", help="Filter by robot model")
+    pull_parser.add_argument("-f", "--format", default="json",
+                           choices=["json", "rlds", "lerobot"],
+                           help="Output format (default: json)")
+    pull_parser.add_argument("-o", "--output", default="./data",
+                           help="Output directory (default: ./data)")
+
+    # upload command - Upload demonstrations for labeling
+    upload_parser = subparsers.add_parser("upload", help="Upload demonstrations for labeling")
+    upload_parser.add_argument("path", help="Path to video file")
+    upload_parser.add_argument("-r", "--robot", required=True, 
+                             help="Robot model in the video")
+    upload_parser.add_argument("-t", "--task", required=True,
+                             help="Task being demonstrated")
+    upload_parser.add_argument("-p", "--project", help="Project ID to associate with")
+
+    # check-transfer command - Check skill transfer compatibility
+    check_transfer_parser = subparsers.add_parser("check-transfer", 
+                                                  help="Check skill transfer compatibility")
+    check_transfer_parser.add_argument("-s", "--skill", help="Skill ID to check (optional)")
+    check_transfer_parser.add_argument("--from", dest="source", required=True,
+                                      help="Source robot model")
+    check_transfer_parser.add_argument("--to", dest="target", required=True,
+                                      help="Target robot model")
+    check_transfer_parser.add_argument("--min-score", type=float, default=0.0,
+                                      help="Minimum score threshold (0.0-1.0)")
+
+    # labeling-status command - Check labeling job status
+    labeling_status_parser = subparsers.add_parser("labeling-status",
+                                                   help="Check labeling job status")
+    labeling_status_parser.add_argument("job_id", help="Labeling job ID")
+
+    # parts command - Manage hardware parts
+    parts_parser = subparsers.add_parser("parts", help="Manage hardware parts catalog")
+    parts_subparsers = parts_parser.add_subparsers(dest="parts_action", help="Parts action")
+    
+    # parts list
+    parts_list_parser = parts_subparsers.add_parser("list", help="List available parts")
+    parts_list_parser.add_argument("-c", "--category", 
+                                   choices=["gripper", "sensor", "actuator", "controller", 
+                                           "end-effector", "camera", "lidar", "force-torque"],
+                                   help="Filter by category")
+    parts_list_parser.add_argument("-m", "--manufacturer", help="Filter by manufacturer")
+    parts_list_parser.add_argument("-s", "--search", help="Search by name or part number")
+    
+    # parts check
+    parts_check_parser = parts_subparsers.add_parser("check", 
+                                                     help="Check part compatibility for skill")
+    parts_check_parser.add_argument("skill_id", help="Skill ID to check")
+    
+    # parts require
+    parts_require_parser = parts_subparsers.add_parser("require", 
+                                                       help="Add part dependency to skill")
+    parts_require_parser.add_argument("part_id", help="Part ID to require")
+    parts_require_parser.add_argument("-s", "--skill", required=True, help="Skill ID")
+    parts_require_parser.add_argument("-v", "--version", default="1.0.0", 
+                                      help="Minimum version (default: 1.0.0)")
+    parts_require_parser.add_argument("--required", action="store_true",
+                                      help="Mark as required (not optional)")
+
+    # deps command - Dependency management
+    deps_parser = subparsers.add_parser("deps", help="Dependency management")
+    deps_subparsers = deps_parser.add_subparsers(dest="deps_action", help="Deps action")
+    
+    # deps audit
+    deps_audit_parser = deps_subparsers.add_parser("audit",
+                                                   help="Verify all dependencies compatible")
+    deps_audit_parser.add_argument("-s", "--skill", help="Skill ID (default: current repo)")
+
+    # protocol command - Protocol registry management
+    protocol_parser = subparsers.add_parser("protocol", help="Manage protocol registry")
+    protocol_subparsers = protocol_parser.add_subparsers(dest="protocol_action", help="Protocol action")
+
+    # protocol list
+    protocol_list_parser = protocol_subparsers.add_parser("list", help="List protocols")
+    protocol_list_parser.add_argument("-r", "--robot", help="Filter by robot model")
+    protocol_list_parser.add_argument("-t", "--transport",
+                                      choices=["ble", "serial", "wifi", "can", "i2c", "spi", "mqtt", "ros2"],
+                                      help="Filter by transport type")
+    protocol_list_parser.add_argument("--verified", action="store_true", help="Show only verified protocols")
+    protocol_list_parser.add_argument("-s", "--search", help="Search in command format and notes")
+
+    # protocol get
+    protocol_get_parser = protocol_subparsers.add_parser("get", help="Get protocol details")
+    protocol_get_parser.add_argument("protocol_id", help="Protocol ID")
+
+    # protocol init
+    protocol_init_parser = protocol_subparsers.add_parser("init", help="Initialize new protocol template")
+    protocol_init_parser.add_argument("robot_model", help="Robot model name (e.g., hiwonder-mechdog-pro)")
+    protocol_init_parser.add_argument("-t", "--transport", required=True,
+                                      choices=["ble", "serial", "wifi", "can", "i2c", "spi", "mqtt", "ros2"],
+                                      help="Transport type")
+    protocol_init_parser.add_argument("-o", "--output", default="./protocol",
+                                      help="Output directory (default: ./protocol)")
+
+    # protocol push
+    protocol_push_parser = protocol_subparsers.add_parser("push", help="Upload protocol to FoodForThought")
+    protocol_push_parser.add_argument("file", nargs="?", help="Path to protocol.json (default: ./protocol.json)")
+
+    # protocol scan-serial
+    protocol_subparsers.add_parser("scan-serial", help="Scan for serial ports")
+
+    # protocol scan-ble
+    protocol_subparsers.add_parser("scan-ble", help="Scan for BLE devices")
+
+    # primitive command - Primitive skills management
+    primitive_parser = subparsers.add_parser("primitive", help="Manage primitive skills")
+    primitive_subparsers = primitive_parser.add_subparsers(dest="primitive_action", help="Primitive action")
+
+    # primitive list
+    primitive_list_parser = primitive_subparsers.add_parser("list", help="List primitive skills")
+    primitive_list_parser.add_argument("-r", "--robot", help="Filter by robot model")
+    primitive_list_parser.add_argument("-c", "--category",
+                                       choices=["body_pose", "arm", "gripper", "locomotion",
+                                               "head", "sensing", "manipulation", "navigation"],
+                                       help="Filter by category")
+    primitive_list_parser.add_argument("--status",
+                                       choices=["experimental", "tested", "verified", "deprecated"],
+                                       help="Filter by status")
+    primitive_list_parser.add_argument("--tested", action="store_true",
+                                       help="Show only tested/verified primitives")
+
+    # primitive get
+    primitive_get_parser = primitive_subparsers.add_parser("get", help="Get primitive details")
+    primitive_get_parser.add_argument("primitive_id", help="Primitive ID")
+
+    # primitive test
+    primitive_test_parser = primitive_subparsers.add_parser("test", help="Submit test result")
+    primitive_test_parser.add_argument("primitive_id", help="Primitive ID to test")
+    primitive_test_parser.add_argument("-p", "--params", required=True,
+                                       help="Parameters used in test as JSON (e.g., '{\"pitch\": 15}')")
+    primitive_test_parser.add_argument("-r", "--result", required=True,
+                                       choices=["pass", "fail", "partial"],
+                                       help="Test result")
+    primitive_test_parser.add_argument("-n", "--notes", help="Test notes")
+    primitive_test_parser.add_argument("-v", "--video", help="Video URL of test")
+
+    # primitive deps (nested subcommand for dependency management)
+    primitive_deps_parser = primitive_subparsers.add_parser("deps", help="Manage primitive dependencies")
+    primitive_deps_subparsers = primitive_deps_parser.add_subparsers(dest="primitive_deps_action",
+                                                                     help="Dependency action")
+
+    # primitive deps show
+    primitive_deps_show_parser = primitive_deps_subparsers.add_parser("show", help="Show dependencies")
+    primitive_deps_show_parser.add_argument("primitive_id", help="Primitive ID")
+
+    # primitive deps add
+    primitive_deps_add_parser = primitive_deps_subparsers.add_parser("add", help="Add dependency")
+    primitive_deps_add_parser.add_argument("primitive_id", help="Primitive ID (the one that depends)")
+    primitive_deps_add_parser.add_argument("required_id", help="Required primitive ID")
+    primitive_deps_add_parser.add_argument("-t", "--type", default="requires",
+                                           choices=["requires", "extends", "overrides", "optional"],
+                                           help="Dependency type (default: requires)")
+    primitive_deps_add_parser.add_argument("--min-status", default="tested",
+                                           choices=["experimental", "tested", "verified"],
+                                           help="Minimum required status (default: tested)")
+
+    # primitive init
+    primitive_init_parser = primitive_subparsers.add_parser("init", help="Initialize primitive skill template")
+    primitive_init_parser.add_argument("name", help="Primitive name (e.g., move_joint, grip_close)")
+    primitive_init_parser.add_argument("-p", "--protocol", help="Protocol ID to link to")
+    primitive_init_parser.add_argument("-r", "--from-recording", help="Import from recording file")
+    primitive_init_parser.add_argument("-c", "--category", default="motion",
+                                       choices=["body_pose", "arm", "gripper", "locomotion",
+                                               "head", "sensing", "manipulation", "navigation"],
+                                       help="Primitive category (default: motion)")
+    primitive_init_parser.add_argument("-o", "--output", default=".", help="Output directory")
+
+    # primitive push
+    primitive_push_parser = primitive_subparsers.add_parser("push", help="Publish primitive to FoodforThought")
+    primitive_push_parser.add_argument("primitive_file", help="Path to .primitive.json file")
+
+    # skill command - Skill abstractions (composed from primitives)
+    skill_parser = subparsers.add_parser("skill", help="Manage skill abstractions (Layer 2)")
+    skill_subparsers = skill_parser.add_subparsers(dest="skill_action", help="Skill action")
+
+    # skill init
+    skill_init_parser = skill_subparsers.add_parser("init", help="Initialize a new skill abstraction")
+    skill_init_parser.add_argument("name", help="Skill name (e.g., pick_and_place)")
+    skill_init_parser.add_argument("-r", "--robot", help="Target robot model")
+    skill_init_parser.add_argument("-t", "--template", default="basic",
+                                   choices=["basic", "pick_place", "navigation", "inspection"],
+                                   help="Skill template (default: basic)")
+    skill_init_parser.add_argument("-o", "--output", default=".", help="Output directory")
+
+    # skill compose
+    skill_compose_parser = skill_subparsers.add_parser("compose", help="Add primitives to skill")
+    skill_compose_parser.add_argument("skill_file", help="Path to .skill.json file")
+    skill_compose_parser.add_argument("primitives", nargs="+", help="Primitive IDs to add")
+
+    # skill list
+    skill_list_parser = skill_subparsers.add_parser("list", help="List skill abstractions")
+    skill_list_parser.add_argument("-r", "--robot", help="Filter by robot model")
+    skill_list_parser.add_argument("--status",
+                                   choices=["experimental", "tested", "verified"],
+                                   help="Filter by status")
+
+    # skill get
+    skill_get_parser = skill_subparsers.add_parser("get", help="Get skill details")
+    skill_get_parser.add_argument("skill_id", help="Skill ID")
+
+    # skill push
+    skill_push_parser = skill_subparsers.add_parser("push", help="Publish skill to FoodforThought")
+    skill_push_parser.add_argument("skill_file", help="Path to .skill.json file")
+
+    # skill test
+    skill_test_parser = skill_subparsers.add_parser("test", help="Test a skill")
+    skill_test_parser.add_argument("skill", help="Skill file or ID")
+    skill_test_parser.add_argument("-p", "--params", help="Skill parameters as JSON")
+    skill_test_parser.add_argument("--execute", action="store_true",
+                                   help="Actually execute (default is dry run)")
+
+    # bridge command - Interactive robot communication
+    bridge_parser = subparsers.add_parser("bridge", help="Interactive robot communication bridge")
+    bridge_subparsers = bridge_parser.add_subparsers(dest="bridge_action", help="Bridge action")
+
+    # bridge connect
+    bridge_connect_parser = bridge_subparsers.add_parser("connect",
+                                                          help="Connect to robot interactively")
+    bridge_connect_parser.add_argument("port", help="Serial port or BLE address")
+    bridge_connect_parser.add_argument("-t", "--transport", default="serial",
+                                       choices=["serial", "ble"],
+                                       help="Transport type (default: serial)")
+    bridge_connect_parser.add_argument("-b", "--baud", type=int, default=115200,
+                                       help="Baud rate for serial (default: 115200)")
+    bridge_connect_parser.add_argument("-p", "--protocol", help="Protocol ID for command hints")
+
+    # bridge send
+    bridge_send_parser = bridge_subparsers.add_parser("send", help="Send single command")
+    bridge_send_parser.add_argument("port", help="Serial port or BLE address")
+    bridge_send_parser.add_argument("command", help="Command to send")
+    bridge_send_parser.add_argument("-t", "--transport", default="serial",
+                                    choices=["serial", "ble"],
+                                    help="Transport type (default: serial)")
+    bridge_send_parser.add_argument("-b", "--baud", type=int, default=115200,
+                                    help="Baud rate for serial (default: 115200)")
+    bridge_send_parser.add_argument("-w", "--wait", type=float, default=0.5,
+                                    help="Wait time for response in seconds (default: 0.5)")
+
+    # bridge record
+    bridge_record_parser = bridge_subparsers.add_parser("record",
+                                                         help="Record session for primitive creation")
+    bridge_record_parser.add_argument("port", help="Serial port or BLE address")
+    bridge_record_parser.add_argument("-o", "--output", default="./recording.json",
+                                      help="Output file (default: ./recording.json)")
+    bridge_record_parser.add_argument("-t", "--transport", default="serial",
+                                      choices=["serial", "ble"],
+                                      help="Transport type (default: serial)")
+    bridge_record_parser.add_argument("-b", "--baud", type=int, default=115200,
+                                      help="Baud rate for serial (default: 115200)")
+    bridge_record_parser.add_argument("-n", "--name", help="Primitive skill name")
+
+    # bridge replay
+    bridge_replay_parser = bridge_subparsers.add_parser("replay", help="Replay a recorded session")
+    bridge_replay_parser.add_argument("recording", help="Path to recording file")
+    bridge_replay_parser.add_argument("port", help="Serial port or BLE address")
+    bridge_replay_parser.add_argument("-t", "--transport", default="serial",
+                                      choices=["serial", "ble"],
+                                      help="Transport type (default: serial)")
+    bridge_replay_parser.add_argument("-b", "--baud", type=int, default=115200,
+                                      help="Baud rate for serial (default: 115200)")
+    bridge_replay_parser.add_argument("-s", "--speed", type=float, default=1.0,
+                                      help="Playback speed multiplier (default: 1.0)")
+
+    # bridge serve - WebSocket server for Artifex integration
+    bridge_serve_parser = bridge_subparsers.add_parser("serve",
+        help="Start WebSocket server for Artifex Desktop integration",
+        description="""Start the ATE Bridge Server for Artifex Desktop integration.
+
+This server enables sim-to-real transfer by bridging Artifex Desktop to physical robot hardware.
+
+WORKFLOW:
+1. Start this server: ate bridge serve -v
+2. Connect your robot via USB serial
+3. In Artifex Desktop, use the Hardware panel or AI tools to connect
+4. Control your robot directly from the Artifex interface
+
+CAPABILITIES:
+- Serial port discovery and robot connection
+- Real-time servo state monitoring (position, velocity, temperature, load)
+- Joint control with URDF-to-servo mapping
+- Trajectory execution
+- Skill deployment and execution
+
+EXAMPLE:
+    ate bridge serve -p 8765 -v
+
+The server listens on ws://localhost:8765 by default.
+Artifex Desktop will auto-connect when the Hardware panel is opened.""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    bridge_serve_parser.add_argument("-p", "--port", type=int, default=8765,
+                                     help="WebSocket port (default: 8765)")
+    bridge_serve_parser.add_argument("-v", "--verbose", action="store_true",
+                                     help="Enable verbose logging (shows all messages)")
+
+    # generate command - Generate skill from text description
+    generate_parser = subparsers.add_parser("generate",
+                                           help="Generate skill scaffolding from text description")
+    generate_parser.add_argument("description",
+                                help="Natural language task description (e.g., 'pick up box and place on pallet')")
+    generate_parser.add_argument("-r", "--robot", default="ur5",
+                                help="Target robot model (default: ur5)")
+    generate_parser.add_argument("-o", "--output", default="./new-skill",
+                                help="Output directory (default: ./new-skill)")
+
+    # compile command - Compile skill specification to deployable package
+    compile_parser = subparsers.add_parser("compile",
+        help="Compile skill.yaml into deployable package (ROS2, Docker, Python)",
+        description="""Compile a skill specification into a deployable package.
+
+The skill compiler transforms a skill.yaml specification into:
+- Python skill implementation with primitives wrappers
+- ROS2 package with action/service interfaces
+- Docker container for deployment
+- Hardware configuration mapping
+
+EXAMPLES:
+    ate compile skill.yaml
+    ate compile skill.yaml --target docker
+    ate compile skill.yaml --target ros2 --robot my_arm.urdf
+    ate compile skill.yaml --ate-dir ./robot_config
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    compile_parser.add_argument("skill_path",
+                               help="Path to skill.yaml specification")
+    compile_parser.add_argument("-o", "--output", default="./output",
+                               help="Output directory (default: ./output)")
+    compile_parser.add_argument("-t", "--target", default="ros2",
+                               choices=["ros2", "docker", "python"],
+                               help="Target platform (default: ros2)")
+    compile_parser.add_argument("-r", "--robot",
+                               help="Path to robot URDF for hardware config")
+    compile_parser.add_argument("--ate-dir",
+                               help="Path to ATE config directory for servo mapping")
+
+    # test-skill command - Test compiled skill
+    test_skill_parser = subparsers.add_parser("test-skill",
+        help="Test a compiled skill in simulation or on hardware",
+        description="""Test a compiled skill package.
+
+MODES:
+    mock     - Run with mock hardware drivers (no hardware needed)
+    sim      - Run in MuJoCo/Gazebo simulation (requires setup)
+    hardware - Run on physical robot (requires bridge connection)
+
+EXAMPLES:
+    ate test-skill ./output --mode mock
+    ate test-skill ./output --mode hardware --robot-port /dev/ttyUSB0
+    ate test-skill ./output --mode mock --params '{"pick_pose": [0.5, 0, 0.3]}'
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    test_skill_parser.add_argument("skill_path",
+                                   help="Path to compiled skill directory")
+    test_skill_parser.add_argument("-m", "--mode", default="mock",
+                                   choices=["sim", "hardware", "mock"],
+                                   help="Test mode (default: mock)")
+    test_skill_parser.add_argument("--robot-port",
+                                   help="Robot serial port for hardware mode")
+    test_skill_parser.add_argument("-p", "--params",
+                                   help="Skill parameters as JSON string")
+
+    # publish-skill command - Publish compiled skill to registry
+    publish_skill_parser = subparsers.add_parser("publish-skill",
+        help="Publish compiled skill to FoodforThought registry",
+        description="""Publish a compiled skill package to FoodforThought.
+
+The skill will be uploaded to the skill registry and made available
+for other users to discover and deploy.
+
+EXAMPLES:
+    ate publish-skill ./output
+    ate publish-skill ./output --visibility private
+    ate publish-skill ./output --visibility team
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    publish_skill_parser.add_argument("skill_path",
+                                      help="Path to compiled skill directory")
+    publish_skill_parser.add_argument("-v", "--visibility", default="public",
+                                      choices=["public", "private", "team"],
+                                      help="Visibility (default: public)")
+
+    # check-compatibility command - Check skill-robot compatibility
+    check_compat_parser = subparsers.add_parser("check-compatibility",
+        help="Check if a skill is compatible with a robot",
+        description="""Check if a skill specification is compatible with a robot.
+
+Analyzes hardware requirements, kinematic constraints, and primitive
+support to determine if a skill can run on a given robot.
+
+EXAMPLES:
+    ate check-compatibility skill.yaml --robot-urdf my_arm.urdf
+    ate check-compatibility skill.yaml --ate-dir ./robot_config
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    check_compat_parser.add_argument("skill_path",
+                                     help="Path to skill.yaml")
+    check_compat_parser.add_argument("--robot-urdf",
+                                     help="Path to robot URDF")
+    check_compat_parser.add_argument("--ate-dir",
+                                     help="Path to ATE config directory")
+
+    # publish-protocol command - Convenient alias for protocol push
+    publish_protocol_parser = subparsers.add_parser("publish-protocol",
+                                                    help="Publish a robot protocol to FoodForThought (alias for 'protocol push')")
+    publish_protocol_parser.add_argument("file", nargs="?",
+                                         help="Path to protocol.json (default: ./protocol.json)")
+
+    # workflow command - Workflow/pipeline management
+    workflow_parser = subparsers.add_parser("workflow", help="Manage skill workflows/pipelines")
+    workflow_subparsers = workflow_parser.add_subparsers(dest="workflow_action", help="Workflow action")
+    
+    # workflow validate
+    workflow_validate_parser = workflow_subparsers.add_parser("validate", 
+                                                              help="Validate workflow YAML")
+    workflow_validate_parser.add_argument("path", help="Path to workflow YAML file")
+    
+    # workflow run
+    workflow_run_parser = workflow_subparsers.add_parser("run", help="Run a workflow")
+    workflow_run_parser.add_argument("path", help="Path to workflow YAML file")
+    workflow_run_parser.add_argument("--sim", action="store_true", 
+                                    help="Run in simulation mode")
+    workflow_run_parser.add_argument("--dry-run", action="store_true",
+                                    help="Show execution plan without running")
+    
+    # workflow export
+    workflow_export_parser = workflow_subparsers.add_parser("export", 
+                                                           help="Export workflow to other formats")
+    workflow_export_parser.add_argument("path", help="Path to workflow YAML file")
+    workflow_export_parser.add_argument("-f", "--format", default="ros2",
+                                       choices=["ros2", "json"],
+                                       help="Export format (default: ros2)")
+    workflow_export_parser.add_argument("-o", "--output", help="Output file path")
+
+    # team command - Team collaboration
+    team_parser = subparsers.add_parser("team", help="Team collaboration management")
+    team_subparsers = team_parser.add_subparsers(dest="team_action", help="Team action")
+    
+    # team create
+    team_create_parser = team_subparsers.add_parser("create", help="Create a new team")
+    team_create_parser.add_argument("name", help="Team name")
+    team_create_parser.add_argument("-d", "--description", help="Team description")
+    
+    # team invite
+    team_invite_parser = team_subparsers.add_parser("invite", help="Invite user to team")
+    team_invite_parser.add_argument("email", help="Email of user to invite")
+    team_invite_parser.add_argument("-t", "--team", required=True, help="Team slug")
+    team_invite_parser.add_argument("-r", "--role", default="member",
+                                   choices=["owner", "admin", "member", "viewer"],
+                                   help="Role to assign (default: member)")
+    
+    # team list
+    team_subparsers.add_parser("list", help="List teams you belong to")
+    
+    # team share (skill share with team)
+    team_share_parser = team_subparsers.add_parser("share", help="Share skill with team")
+    team_share_parser.add_argument("skill_id", help="Skill ID to share")
+    team_share_parser.add_argument("-t", "--team", required=True, help="Team slug")
+
+    # data command - Dataset management
+    data_parser = subparsers.add_parser("data", help="Dataset and telemetry management")
+    data_subparsers = data_parser.add_subparsers(dest="data_action", help="Data action")
+    
+    # data upload
+    data_upload_parser = data_subparsers.add_parser("upload", help="Upload sensor data")
+    data_upload_parser.add_argument("path", help="Path to data directory or file")
+    data_upload_parser.add_argument("-s", "--skill", required=True, help="Associated skill ID")
+    data_upload_parser.add_argument("--stage", default="raw",
+                                   choices=["raw", "annotated", "skill-abstracted", "production"],
+                                   help="Data stage (default: raw)")
+    
+    # data list
+    data_list_parser = data_subparsers.add_parser("list", help="List datasets")
+    data_list_parser.add_argument("-s", "--skill", help="Filter by skill ID")
+    data_list_parser.add_argument("--stage", help="Filter by stage")
+    
+    # data promote
+    data_promote_parser = data_subparsers.add_parser("promote", help="Promote dataset stage")
+    data_promote_parser.add_argument("dataset_id", help="Dataset ID")
+    data_promote_parser.add_argument("--to", required=True, dest="to_stage",
+                                    choices=["annotated", "skill-abstracted", "production"],
+                                    help="Target stage")
+    
+    # data export
+    data_export_parser = data_subparsers.add_parser("export", help="Export dataset")
+    data_export_parser.add_argument("dataset_id", help="Dataset ID")
+    data_export_parser.add_argument("-f", "--format", default="rlds",
+                                   choices=["json", "rlds", "lerobot", "hdf5"],
+                                   help="Export format (default: rlds)")
+    data_export_parser.add_argument("-o", "--output", default="./export",
+                                   help="Output directory")
+
+    # deploy command - Enhanced deployment management
+    deploy_subparsers = deploy_parser.add_subparsers(dest="deploy_action", help="Deploy action")
+    
+    # deploy config (hybrid edge/cloud deployment)
+    deploy_config_parser = deploy_subparsers.add_parser("config", 
+                                                        help="Deploy using config file")
+    deploy_config_parser.add_argument("config_path", help="Path to deploy.yaml")
+    deploy_config_parser.add_argument("-t", "--target", required=True, 
+                                     help="Target fleet or robot")
+    deploy_config_parser.add_argument("--dry-run", action="store_true",
+                                     help="Show plan without deploying")
+    
+    # deploy status
+    deploy_status_parser = deploy_subparsers.add_parser("status",
+                                                        help="Check deployment status")
+    deploy_status_parser.add_argument("target", help="Target fleet or robot")
+
+    # robot-setup command - Interactive wizard for robot discovery and primitive skill generation
+    robot_setup_parser = subparsers.add_parser("robot-setup",
+                                                help="Interactive wizard to discover robot and generate primitive skills")
+    robot_setup_parser.add_argument("-p", "--port", help="Serial port (skip device selection)")
+    robot_setup_parser.add_argument("-o", "--output", default="./robot",
+                                    help="Output directory for generated files (default: ./robot)")
+    robot_setup_parser.add_argument("--skip-labeling", action="store_true",
+                                    help="Skip labeling entirely (use generic servo_N names)")
+    robot_setup_parser.add_argument("--robot-type",
+                                    choices=["quadruped", "quadruped_with_arm", "hexapod",
+                                            "6dof_arm", "humanoid_basic", "humanoid",
+                                            "humanoid_advanced", "humanoid_full", "custom"],
+                                    help="Force robot type for AI-suggested labels")
+    robot_setup_parser.add_argument("--non-interactive", action="store_true",
+                                    help="Run without user prompts (use defaults and AI suggestions)")
+    robot_setup_parser.add_argument("--push", action="store_true",
+                                    help="Auto-push generated primitives to FoodforThought (requires FOODFORTHOUGHT_TOKEN)")
+    robot_setup_parser.add_argument("--api-url",
+                                    help="FoodforThought API URL (defaults to https://kindlyrobotics.com)")
+    robot_setup_parser.add_argument("--scan-only", action="store_true",
+                                    help="Only scan for devices, don't run full wizard")
+
+    # marketplace command - Skill Marketplace ("npm for robot skills")
+    marketplace_parser = subparsers.add_parser("marketplace",
+        help="Skill Marketplace - discover, install, and publish robot skills",
+        description="""Skill Marketplace - "npm for robot skills"
+
+Discover community-contributed skills, install them for your robot,
+and publish your own skills to share with others.
+
+EXAMPLES:
+    ate marketplace search "pick and place"
+    ate marketplace show pick-and-place
+    ate marketplace install pick-and-place --robot my-arm
+    ate marketplace publish ./my-skill
+    ate marketplace report pick-and-place my-arm --works
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    marketplace_subparsers = marketplace_parser.add_subparsers(dest="marketplace_action", help="Marketplace action")
+
+    # marketplace search
+    marketplace_search_parser = marketplace_subparsers.add_parser("search",
+        help="Search for skills in the marketplace")
+    marketplace_search_parser.add_argument("query", help="Search query")
+    marketplace_search_parser.add_argument("-c", "--category",
+        choices=["manipulation", "navigation", "perception", "locomotion",
+                 "interaction", "inspection", "assembly", "pick_and_place",
+                 "cleaning", "logistics", "other"],
+        help="Filter by category")
+    marketplace_search_parser.add_argument("-r", "--robot-type", help="Filter by robot type")
+    marketplace_search_parser.add_argument("-l", "--license", help="Filter by license (mit, apache2, etc.)")
+    marketplace_search_parser.add_argument("-p", "--pricing", choices=["free", "paid"],
+        help="Filter by pricing")
+    marketplace_search_parser.add_argument("-s", "--sort", default="downloads",
+        choices=["downloads", "rating", "recent", "executions", "installs"],
+        help="Sort results (default: downloads)")
+    marketplace_search_parser.add_argument("--limit", type=int, default=20,
+        help="Number of results (default: 20)")
+
+    # marketplace show
+    marketplace_show_parser = marketplace_subparsers.add_parser("show",
+        help="Show detailed information about a skill")
+    marketplace_show_parser.add_argument("slug", help="Skill slug/name")
+
+    # marketplace install
+    marketplace_install_parser = marketplace_subparsers.add_parser("install",
+        help="Install a skill from the marketplace")
+    marketplace_install_parser.add_argument("skill_name", help="Skill name or slug")
+    marketplace_install_parser.add_argument("-v", "--version", help="Specific version to install")
+    marketplace_install_parser.add_argument("-r", "--robot", help="Target robot ID for compatibility check")
+    marketplace_install_parser.add_argument("-o", "--output", help="Output directory (default: ./<skill_name>)")
+
+    # marketplace publish
+    marketplace_publish_parser = marketplace_subparsers.add_parser("publish",
+        help="Publish a skill to the marketplace")
+    marketplace_publish_parser.add_argument("path", help="Path to skill directory")
+    marketplace_publish_parser.add_argument("--no-public", action="store_true",
+        help="Keep skill private (not listed publicly)")
+
+    # marketplace report
+    marketplace_report_parser = marketplace_subparsers.add_parser("report",
+        help="Report skill compatibility with a robot")
+    marketplace_report_parser.add_argument("skill_name", help="Skill name or slug")
+    marketplace_report_parser.add_argument("robot", help="Robot ID")
+    marketplace_report_parser.add_argument("--works", dest="works", action="store_true",
+        help="Report that skill works on this robot")
+    marketplace_report_parser.add_argument("--no-works", dest="works", action="store_false",
+        help="Report that skill does NOT work on this robot")
+    marketplace_report_parser.add_argument("-n", "--notes", help="Additional notes")
+    marketplace_report_parser.add_argument("-v", "--version", help="Version tested")
+    marketplace_report_parser.set_defaults(works=None)
+
+    # marketplace list (installed)
+    marketplace_subparsers.add_parser("installed", help="List installed skills")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # login command
+    subparsers.add_parser("login", help="Authenticate with FoodforThought")
 
     client = ATEClient()
 
+    if args.command == "login":
+        login_command()
+        return
+
     if args.command == "init":
         result = client.init(args.name, args.description, args.visibility)
         print(f"Created repository: {result['repository']['id']}")
@@ -1712,9 +3910,107 @@ def main():
         else:
             deps_parser.print_help()
 
+    elif args.command == "protocol":
+        if args.protocol_action == "list":
+            client.protocol_list(args.robot, args.transport, args.verified, args.search)
+        elif args.protocol_action == "get":
+            client.protocol_get(args.protocol_id)
+        elif args.protocol_action == "init":
+            client.protocol_init(args.robot_model, args.transport, args.output)
+        elif args.protocol_action == "push":
+            client.protocol_push(args.file)
+        elif args.protocol_action == "scan-serial":
+            client.protocol_scan_serial()
+        elif args.protocol_action == "scan-ble":
+            client.protocol_scan_ble()
+        else:
+            protocol_parser.print_help()
+
+    elif args.command == "primitive":
+        if args.primitive_action == "list":
+            client.primitive_list(args.robot, args.category, args.status, args.tested)
+        elif args.primitive_action == "get":
+            client.primitive_get(args.primitive_id)
+        elif args.primitive_action == "test":
+            client.primitive_test(args.primitive_id, args.params, args.result, args.notes, args.video)
+        elif args.primitive_action == "init":
+            client.primitive_init(args.name, args.protocol, args.from_recording, args.category, args.output)
+        elif args.primitive_action == "push":
+            client.primitive_push(args.primitive_file)
+        elif args.primitive_action == "deps":
+            if args.primitive_deps_action == "show":
+                client.primitive_deps_show(args.primitive_id)
+            elif args.primitive_deps_action == "add":
+                client.primitive_deps_add(args.primitive_id, args.required_id, args.type, args.min_status)
+            else:
+                primitive_deps_parser.print_help()
+        else:
+            primitive_parser.print_help()
+
+    elif args.command == "skill":
+        if args.skill_action == "init":
+            client.skill_init(args.name, args.robot, args.template, args.output)
+        elif args.skill_action == "compose":
+            client.skill_compose(args.skill_file, args.primitives)
+        elif args.skill_action == "list":
+            client.skill_list(args.robot, args.status)
+        elif args.skill_action == "get":
+            client.skill_get(args.skill_id)
+        elif args.skill_action == "push":
+            client.skill_push(args.skill_file)
+        elif args.skill_action == "test":
+            client.skill_test(args.skill, args.params, not args.execute)
+        else:
+            skill_parser.print_help()
+
+    elif args.command == "bridge":
+        if args.bridge_action == "connect":
+            client.bridge_connect(args.port, args.transport, args.baud, args.protocol)
+        elif args.bridge_action == "send":
+            client.bridge_send(args.port, args.command, args.transport, args.baud, args.wait)
+        elif args.bridge_action == "record":
+            client.bridge_record(args.port, args.output, args.transport, args.baud, args.name)
+        elif args.bridge_action == "replay":
+            client.bridge_replay(args.recording, args.port, args.transport, args.baud, args.speed)
+        elif args.bridge_action == "serve":
+            from ate.bridge_server import run_bridge_server
+            run_bridge_server(port=args.port, verbose=args.verbose)
+        else:
+            bridge_parser.print_help()
+
     elif args.command == "generate":
         client.generate(args.description, args.robot, args.output)
 
+    elif args.command == "compile":
+        client.compile_skill(
+            args.skill_path,
+            args.output,
+            args.target,
+            args.robot,
+            getattr(args, 'ate_dir', None)
+        )
+
+    elif args.command == "test-skill":
+        client.test_compiled_skill(
+            args.skill_path,
+            args.mode,
+            args.robot_port,
+            args.params
+        )
+
+    elif args.command == "publish-skill":
+        client.publish_compiled_skill(args.skill_path, args.visibility)
+
+    elif args.command == "check-compatibility":
+        client.check_skill_compatibility(
+            args.skill_path,
+            args.robot_urdf,
+            getattr(args, 'ate_dir', None)
+        )
+
+    elif args.command == "publish-protocol":
+        client.publish_protocol(args.file)
+
     elif args.command == "workflow":
         if args.workflow_action == "validate":
             client.workflow_validate(args.path)
@@ -1760,6 +4056,93 @@ def main():
         else:
             deploy_parser.print_help()
 
+    elif args.command == "robot-setup":
+        from ate.robot_setup import run_wizard, RobotSetupWizard
+
+        if args.scan_only:
+            # Just scan for devices
+            try:
+                import serial.tools.list_ports
+                print("\nScanning for serial ports...\n")
+                ports = list(serial.tools.list_ports.comports())
+
+                if not ports:
+                    print("No serial ports found.")
+                else:
+                    print(f"Found {len(ports)} port(s):\n")
+                    for port in ports:
+                        print(f"  Port: {port.device}")
+                        if port.description:
+                            print(f"    Description: {port.description}")
+                        if port.manufacturer:
+                            print(f"    Manufacturer: {port.manufacturer}")
+                        if port.vid and port.pid:
+                            print(f"    VID:PID: {port.vid:04x}:{port.pid:04x}")
+                        if port.serial_number:
+                            print(f"    Serial: {port.serial_number}")
+                        print()
+            except ImportError:
+                print("Error: pyserial not installed. Run: pip install pyserial")
+                sys.exit(1)
+        else:
+            # Run full wizard
+            success = run_wizard(
+                port=args.port,
+                output=args.output,
+                skip_labeling=args.skip_labeling,
+                robot_type=getattr(args, 'robot_type', None),
+                non_interactive=getattr(args, 'non_interactive', False),
+                push=getattr(args, 'push', False),
+                api_url=getattr(args, 'api_url', None)
+            )
+            sys.exit(0 if success else 1)
+
+    elif args.command == "marketplace":
+        from ate.marketplace import (
+            search_skills, show_skill, install_skill,
+            publish_skill, report_compatibility, list_installed
+        )
+
+        if args.marketplace_action == "search":
+            search_skills(
+                query=args.query,
+                category=args.category,
+                robot_type=getattr(args, 'robot_type', None),
+                license_type=args.license,
+                pricing=args.pricing,
+                sort=args.sort,
+                limit=args.limit,
+            )
+        elif args.marketplace_action == "show":
+            show_skill(args.slug)
+        elif args.marketplace_action == "install":
+            install_skill(
+                skill_name=args.skill_name,
+                version=args.version,
+                robot=args.robot,
+                output_dir=args.output,
+            )
+        elif args.marketplace_action == "publish":
+            publish_skill(
+                path=args.path,
+                public=not args.no_public,
+            )
+        elif args.marketplace_action == "report":
+            if args.works is None:
+                print("Error: Must specify --works or --no-works", file=sys.stderr)
+                sys.exit(1)
+            report_compatibility(
+                skill_name=args.skill_name,
+                robot=args.robot,
+                works=args.works,
+                notes=args.notes,
+                version=args.version,
+            )
+        elif args.marketplace_action == "installed":
+            list_installed()
+        else:
+            marketplace_parser.print_help()
+
 
 if __name__ == "__main__":
     main()