hivekit 0.7.0__tar.gz → 0.8.0__tar.gz

{hivekit-0.7.0 → hivekit-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivekit
-Version: 0.7.0
+Version: 0.8.0
 Summary: Toolkits for using hive agents, including CLI and SDK.
 License: 
                                          Apache License

{hivekit-0.7.0 → hivekit-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hivekit"
-version = "0.7.0"
+version = "0.8.0"
 description = "Toolkits for using hive agents, including CLI and SDK."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -63,7 +63,7 @@ quote-style = "double"
 include-package-data = true
 
 [tool.setuptools.package-data]
-"cli" = ["libs/**/*", "auth/*.svg"]
+"cli" = ["libs/**/*", "auth/*.svg", "skills/**/*"]
 
 [tool.pytest.ini_options]
 pythonpath = ["src"]

{hivekit-0.7.0 → hivekit-0.8.0}/src/cli/config.py

@@ -19,6 +19,7 @@ from pydantic import (
     model_validator,
 )
 
+from cli.utils.config_paths import get_coordinator_overlay_path
 from cli.utils.logger import set_log_level
 from cli.utils.time import unique_suffix
 
@@ -66,6 +67,29 @@ KNOWN_ACCELERATOR_TYPES = frozenset(
 # the CLI before they reach the backend.
 SUPPORTED_ARCHITECTURES = frozenset({"amd64", "arm64"})
 
+# Allowed agent presets and known models for users to select from in the CLI
+# when choosing custom agent ensemble configurations.
+AGENT_PRESETS = frozenset({"low-effort", "medium-effort", "high-effort"})
+KNOWN_MODELS = frozenset(
+    {
+        "anthropic.claude-haiku-4-5",
+        "anthropic.claude-opus-4-6",
+        "anthropic.claude-opus-4-7",
+        "anthropic.claude-opus-4-8",
+        "anthropic.claude-opus-5",
+        "anthropic.claude-sonnet-4-6",
+        "anthropic.claude-sonnet-5",
+        "moonshotai.kimi-k2.5",
+        "nvidia.nemotron-super-3-120b",
+        "openai.gpt-6-astra",
+        "openai.gpt-5.6-luna",
+        "openai.gpt-5.6-sol",
+        "openai.gpt-5.6-terra",
+        "qwen.qwen3-coder-480b-a35b",
+        "zai.glm-4.7-flash",
+    }
+)
+
 
 class ResourceConfig(BaseModel):
     cpu: str = Field(
@@ -435,6 +459,71 @@ class ProviderConfig(BaseModel):
     )
 
 
+class AgentModelConfig(BaseModel):
+    model: str = Field(
+        description="The model this agent runs, named from the registry the Hive "
+        "ships. Run `hive list models` to see the names.",
+    )
+    weight: Optional[float] = Field(
+        default=None,
+        allow_inf_nan=False,
+        description="How heavily this model is drawn on relative to the rest of "
+        "the ensemble. Unset (the default) counts as 1.",
+    )
+
+    @field_validator("model")
+    @classmethod
+    def validate_model(cls, v):
+        if v not in KNOWN_MODELS:
+            raise ValueError(
+                f"Unknown model '{v}'. Known models: {', '.join(sorted(KNOWN_MODELS))}. "
+                "Run `hive list models` to see them."
+            )
+        return v
+
+    @field_validator("weight")
+    @classmethod
+    def validate_weight(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError(f"weight must be greater than 0, got {v}.")
+        return v
+
+
+class AgentsConfig(BaseModel):
+    preset: Optional[str] = Field(
+        default=None,
+        description="A preset agent configuration to run, by name.",
+    )
+    models: Optional[list[AgentModelConfig]] = Field(
+        default=None,
+        description="A custom ensemble of agent models to use in the Hive experiment.",
+    )
+
+    @field_validator("preset")
+    @classmethod
+    def validate_preset(cls, v):
+        if v is not None and v not in AGENT_PRESETS:
+            raise ValueError(
+                f"Unknown preset '{v}'. Valid presets: {', '.join(sorted(AGENT_PRESETS))}."
+            )
+        return v
+
+    @model_validator(mode="after")
+    def validate_exactly_one_way_of_choosing(self):
+        """Fail closed unless exactly one of the two ways is used."""
+        if self.preset and self.models:
+            raise ValueError(
+                "agents names a preset tier or lists models, not both: "
+                "a preset already says which models to run."
+            )
+        if not self.preset and not self.models:
+            raise ValueError(
+                "agents must name a preset or list models. Omit the agents "
+                "section entirely to run the default tier."
+            )
+        return self
+
+
 class RuntimeConfig(BaseModel):
     num_sandboxes: int = Field(
         default=1,
@@ -541,7 +630,10 @@ class HiveConfig(BaseModel):
     coordinator_image_tag: Optional[str] = Field(
         default=None,
         description="The image tag to run the coordinator at, e.g. 'v0.6.0'. Optional — when "
-        "omitted, the backend's default coordinator image is used. This field is ignored in production environments.",
+        "omitted, in a dev environment the tag recorded by `hivectl generate config` in "
+        "~/.hive/coordinator.yaml is used if present. If that file or tag is absent, or in a "
+        "production environment, the backend's default coordinator image is used. This field is "
+        "ignored in production environments.",
     )
     runtime: RuntimeConfig = Field(
         default_factory=RuntimeConfig, description="Runtime configuration for the experiment."
@@ -561,6 +653,12 @@ class HiveConfig(BaseModel):
         "omitted, the default provider is used with no capacity-type constraint.",
     )
     prompt: Optional[PromptConfig] = None
+    agents: Optional[AgentsConfig] = Field(
+        default=None,
+        description="Which agents generate new versions of the code: a preset "
+        "configuration, or a custom ensemble of models you pick. Optional — "
+        "when omitted, the Hive runs its own default tier.",
+    )
     log_level: str = Field(
         default="WARNING",
         json_schema_extra={"enumerated": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]},
@@ -579,6 +677,49 @@ class HiveConfig(BaseModel):
     def raw_yaml(self, value: Optional[str]) -> None:
         self._raw_yaml = value
 
+    @model_validator(mode="before")
+    @classmethod
+    def migrate_coordinator_config_name(cls, values):
+        # The effort-tier coordinator configs are the deprecated spelling of the
+        # matching agents.preset. Accept them, warn, and fold them into the
+        # canonical field. Setting agents too is a fatal error -- the legacy
+        # field would be redundant and we refuse to guess which one wins. Names
+        # outside that set have no agents equivalent, so they pass through under
+        # a plain warning.
+        if not isinstance(values, dict) or "coordinator_config_name" not in values:
+            return values
+        # Copy first: model_validate passes the caller's own dict through, and we
+        # must not mutate it -- not on success, and not on the conflict-raise path.
+        values = dict(values)
+        legacy = values.pop("coordinator_config_name")
+        match legacy:
+            case "high-effort-config" | "medium-effort-config" | "low-effort-config":
+                preset = legacy.removesuffix("-config")
+                if values.get("agents") is not None:
+                    raise ValueError(
+                        f"coordinator_config_name={legacy} and agents are both set. "
+                        "coordinator_config_name is deprecated and now just selects "
+                        f"agents.preset={preset}; set only agents."
+                    )
+                # agents is absent (conflicts raised above), so this never
+                # discards an explicit value.
+                values["agents"] = {"preset": preset}
+                logger.warning(
+                    "coordinator_config_name=%s is deprecated. Running agents.preset=%s "
+                    "instead; set agents.preset (or agents.models) in your config to "
+                    "silence this warning.",
+                    legacy,
+                    preset,
+                )
+            case _:
+                values["coordinator_config_name"] = legacy
+                logger.warning(
+                    "coordinator_config_name=%s is deprecated. Specify the agent/models "
+                    "used under the agents.preset or agents.models fields instead.",
+                    legacy,
+                )
+        return values
+
 
 def _lookup_description(schema: dict, loc: tuple) -> str | None:
     """Walk the JSON schema to find the description for a field at the given location."""
@@ -654,7 +795,7 @@ def validate_repo_files_exist(base_dir: str, repo: RepoConfig, allow_missing: bo
         )
 
 
-def apply_overrides(cfg: dict, overrides: list[str]) -> dict:
+def apply_overrides(cfg: dict, overrides: list[str]) -> set[tuple[str, ...]]:
     """Apply dot-notation overrides to a raw config dict before Pydantic validation.
 
     Supports two forms:
@@ -664,6 +805,9 @@ def apply_overrides(cfg: dict, overrides: list[str]) -> dict:
     Values are coerced via yaml.safe_load, so 4 -> int, true -> bool, etc.
     Type correctness and field existence within typed models are enforced by
     Pydantic at construction time.
+
+    ``cfg`` is edited in place; the key paths the overrides set are returned, so a
+    caller can tell a value the command line asked for from one the file carried.
     """
     overridden_keys: set[tuple[str, ...]] = set()
     for raw in overrides:
@@ -682,7 +826,7 @@ def apply_overrides(cfg: dict, overrides: list[str]) -> dict:
         d[parts[-1]] = value
         overridden_keys.add(tuple(parts))
     _reconcile_num_sandboxes_override(cfg, overridden_keys)
-    return cfg
+    return overridden_keys
 
 
 def _reconcile_num_sandboxes_override(cfg: dict, overridden_keys: set[tuple[str, ...]]) -> None:
@@ -718,17 +862,93 @@ def _reconcile_num_sandboxes_override(cfg: dict, overridden_keys: set[tuple[str,
     del runtime[loser]
 
 
+def _recorded_coordinator_image_tag(overlay_path: str) -> Optional[str]:
+    """Return the coordinator image tag recorded in the overlay file, if any.
+
+    A broken overlay must not stop an experiment the user asked for, so anything
+    unusable is warned about and ignored. An absent, empty or non-scalar tag
+    records nothing; a bool is not a scalar here, being an int subclass.
+    """
+    if not os.path.exists(overlay_path):
+        return None
+    try:
+        with open(overlay_path, "r") as file:
+            overlay = yaml.safe_load(file)
+    except (OSError, yaml.YAMLError) as e:
+        logger.warning("Ignoring %s, which could not be read: %s", overlay_path, e)
+        return None
+    tag = overlay.get("coordinator_image_tag") if isinstance(overlay, dict) else None
+    if tag is None or tag == "":
+        return None
+    if isinstance(tag, bool) or not isinstance(tag, (str, int, float)):
+        logger.warning(
+            "Ignoring coordinator_image_tag: %r in %s, which must be a string or number.",
+            tag,
+            overlay_path,
+        )
+        return None
+    return str(tag)
+
+
+def _resolve_coordinator_image_tag(config_data: dict, overridden: bool) -> None:
+    """Fall back to the coordinator image tag `hivectl generate config` recorded.
+
+    A tag the experiment asked for wins, even an empty one asking for the backend
+    default. Whichever tag is used is logged with where it came from, as is any
+    recorded tag it discards, so which coordinator image runs is never a surprise.
+    """
+    overlay_path = get_coordinator_overlay_path()
+    recorded = _recorded_coordinator_image_tag(overlay_path)
+    if "coordinator_image_tag" not in config_data:
+        if recorded is None:
+            return
+        config_data["coordinator_image_tag"] = recorded
+        logger.warning(
+            "Using coordinator_image_tag=%s recorded in %s by `hivectl generate config`; "
+            "set coordinator_image_tag in the experiment config to override it.",
+            recorded,
+            overlay_path,
+        )
+        return
+    asked_for = config_data["coordinator_image_tag"]
+    source = "a command-line override" if overridden else "the experiment config"
+    # str(): an unquoted digit-only tag loads as an int. None is not compared, or
+    # an explicit null would match the tag "None" rather than discard it.
+    if recorded is not None and (asked_for is None or str(asked_for) != recorded):
+        logger.warning(
+            "Using coordinator_image_tag=%s from %s, discarding coordinator_image_tag=%s "
+            "recorded in %s.",
+            asked_for,
+            source,
+            recorded,
+            overlay_path,
+        )
+    elif asked_for is not None and asked_for != "":
+        logger.warning("Using coordinator_image_tag=%s from %s.", asked_for, source)
+    # An empty tag with nothing to discard asks for the backend's default image,
+    # exactly as setting no tag at all does, so there is nothing to report.
+
+
 def load_config(
     file_path: str,
     overrides: list[str] | None = None,
+    coordinator: bool = True,
 ) -> HiveConfig:
-    """Load configuration from a YAML file."""
+    """Load configuration from a YAML file.
+
+    Pass ``coordinator=False`` when no coordinator will run, so the recorded
+    coordinator image tag is neither filled in nor reported as being used.
+    """
     with open(file_path, "r") as file:
         raw_text = file.read()
     config_data = yaml.safe_load(raw_text)
 
+    overridden_keys: set[tuple[str, ...]] = set()
     if overrides:
-        apply_overrides(config_data, overrides)
+        overridden_keys = apply_overrides(config_data, overrides)
+
+    if coordinator and isinstance(config_data, dict):
+        _resolve_coordinator_image_tag(config_data, ("coordinator_image_tag",) in overridden_keys)
 
     try:
         config = HiveConfig(**config_data)

{hivekit-0.7.0 → hivekit-0.8.0}/src/cli/experiment.py

@@ -129,6 +129,22 @@ def build_experiment_crd(config: HiveConfig) -> Dict[str, Any]:
         if config.prompt.enable_evolution:
             experiment["spec"]["prompt"]["enableEvolution"] = config.prompt.enable_evolution
 
+    # Add optional agent selection
+    if config.agents:
+        agents = {}
+        if config.agents.preset:
+            agents["preset"] = config.agents.preset
+        if config.agents.models:
+            agents["models"] = [
+                {
+                    "model": entry.model,
+                    **({"weight": entry.weight} if entry.weight is not None else {}),
+                }
+                for entry in config.agents.models
+            ]
+        if agents:
+            experiment["spec"]["agents"] = agents
+
     # Add coordinator config
     if config.coordinator_config_name:
         experiment["spec"]["coordinatorConfigName"] = config.coordinator_config_name

{hivekit-0.7.0 → hivekit-0.8.0}/src/cli/http_client.py

@@ -369,16 +369,39 @@ class HttpClient:
         response = self._send("get", "/experiments", "list experiments")
         return response.json()
 
+    def start_repo_download(self, name: str, content_uid: str) -> Dict[str, Any]:
+        """
+        Initiate assembly of the repository at a content snapshot.
+
+        Args:
+            name: Experiment name.
+            content_uid: Content snapshot identifier (a point on the evolution chart).
+
+        Returns:
+            Object with ``status`` ("ready" when already assembled, "started" when
+            assembly was kicked off). ``_send`` treats both 200 and 202 as success.
+        """
+        response = self._send(
+            "post",
+            f"/experiments/{name}/repo-download",
+            "start repo download",
+            params={"contentUid": content_uid},
+        )
+        return response.json()
+
     def get_repo_download_url(self, name: str, content_uid: str) -> Dict[str, Any]:
         """
-        Get a presigned URL to download the repository assembled at a content snapshot.
+        Poll for a presigned URL to download the repository assembled at a content snapshot.
 
         Args:
             name: Experiment name.
             content_uid: Content snapshot identifier (a point on the evolution chart).
 
         Returns:
-            Object with ``url`` (presigned S3 URL) and ``expiresIn`` (seconds).
+            Object with ``url`` (presigned S3 URL) and ``expiresIn`` (seconds) when
+            ready, or ``{"status": "pending"}`` while assembly is still in progress
+            (the server answers a not-yet-ready poll with 202, which ``_send`` does
+            not treat as an error).
         """
         response = self._send(
             "get",

{hivekit-0.7.0 → hivekit-0.8.0}/src/cli/main.py

@@ -29,13 +29,15 @@ from cli.auth.credential_store import create_credential_store
 from cli.auth.session_manager import create_session_manager
 from cli.auth.token_revoker import TokenRevocationError, TokenRevoker
 from cli.completers import config_file_completer, experiment_completer
-from cli.config import load_config, validate_repo_files_exist
+from cli.config import KNOWN_MODELS, load_config, validate_repo_files_exist
 from cli.http_client import (
     HttpClient,
     ShellNotFoundError,
     StreamNotReadyError,
     create_http_client,
 )
+from cli.skills_install import TARGETS as SKILL_TARGETS
+from cli.skills_install import skills_install
 from cli.utils import docker
 from cli.utils.archive import resolve_file_list
 from cli.utils.config_paths import get_config_dir, get_config_path, load_organization_id
@@ -47,6 +49,7 @@ from cli.utils.url_utils import (
     derive_identity_base_url,
     get_api_endpoint,
     get_dashboard_url,
+    get_experiment_url,
 )
 from cli.version import print_version
 
@@ -327,7 +330,7 @@ def create_experiment(args, overrides) -> None:
     experiment_crd["metadata"]["annotations"]["hiverge.ai/config-tmp-id"] = config_tmp_id
 
     try:
-        client.create_experiment(experiment_crd)
+        created = client.create_experiment(experiment_crd)
         logger.info("Created experiment. experiment_name=%s", config.experiment_name)
         console.print(f'experiment "[cyan]{config.experiment_name}[/cyan]" created')
     except Exception as e:
@@ -335,6 +338,30 @@ def create_experiment(args, overrides) -> None:
         console.print(f"[bold red]Error:[/bold red] {e}", highlight=False)
         sys.exit(1)
 
+    url = _experiment_url(created)
+    if url:
+        console.print(f"  • [bold]Dashboard:[/bold] {url}", highlight=False, soft_wrap=True)
+
+
+def _experiment_url(created: dict[str, object]) -> str | None:
+    """
+    Dashboard URL for a just-created experiment, or None if it cannot be built.
+
+    ``created`` is the CRD the server echoes back; the Alphatrion experiment ID
+    the dashboard routes on is its ``hiverge.ai/experiment-id`` label.
+    """
+    try:
+        labels = created["metadata"]["labels"]  # type: ignore[index]
+        experiment_id = labels["hiverge.ai/experiment-id"]
+        if not experiment_id:
+            return None
+        return get_experiment_url(
+            experiment_id=experiment_id, organization_id=load_organization_id()
+        )
+    except Exception:
+        logger.debug("Could not build the dashboard URL for the new experiment", exc_info=True)
+        return None
+
 
 def shell_command(args, overrides) -> None:
     """Create an interactive shell and attach to it.
@@ -408,7 +435,8 @@ def shell_command(args, overrides) -> None:
         # A shell has no experiment; force a throwaway name to satisfy validation.
         overrides = [*overrides, "experiment_name=shell"]
         try:
-            config = load_config(args.config, overrides=overrides)
+            # A shell runs no coordinator, so its image tag does not apply.
+            config = load_config(args.config, overrides=overrides, coordinator=False)
         except Exception as e:
             console.print(
                 f"[bold red]Error:[/bold red] invalid config '{args.config}'.\n{e}", highlight=False
@@ -930,6 +958,14 @@ def list_coordinators(args) -> None:
         return
 
 
+def list_models(args) -> None:
+    """List the models an agent ensemble can name in a config's `agents.models`."""
+    console = Console()
+
+    for model in sorted(KNOWN_MODELS):
+        console.print(model, highlight=False)
+
+
 def get_experiment(args) -> None:
     """Get details of a specific experiment."""
     console = Console()
@@ -1015,6 +1051,19 @@ def get_experiment(args) -> None:
                 console.print(f"    name:  {provider.get('name')}", highlight=False)
             if provider.get("spot") is not None:
                 console.print(f"    spot:  {provider.get('spot')}")
+        # Agents subsection. Only shown when the experiment selected agents.
+        agents = spec.get("agents", {})
+        if agents:
+            console.print("  [bold]agents[/bold]")
+            if agents.get("preset"):
+                console.print(f"    preset:  {agents.get('preset')}", highlight=False)
+            for entry in agents.get("models", []):
+                # One line per model, weight only when the experiment asked for
+                # it, matching what was submitted.
+                details = [f"model: {entry.get('model', 'N/A')}"]
+                if entry.get("weight") is not None:
+                    details.append(f"weight: {entry['weight']}")
+                console.print(f"    - {', '.join(details)}", highlight=False)
         # Status section
         created = metadata.get("creationTimestamp", "N/A")
         age = humanize_time(created)
@@ -1065,6 +1114,32 @@ def get_config(args) -> None:
         console.print(hive_yaml.rstrip("\n"), highlight=False, markup=False)
 
 
+def _poll_repo_download_url(
+    client: HttpClient, name: str, content_uid: str, console: Console
+) -> str:
+    """Poll until the assembled repository is ready, then return its presigned URL.
+
+    Exits the process on timeout. A permanent server failure propagates as an
+    exception raised by ``get_repo_download_url`` (handled by the caller).
+    """
+    timeout = 3600
+    backoff = 1.0
+    backoff_cap = 5.0
+    deadline = time.monotonic() + timeout
+
+    with console.status("Assembling repository..."):
+        while time.monotonic() < deadline:
+            result = client.get_repo_download_url(name, content_uid)
+            url = result.get("url")
+            if url:
+                return url
+            time.sleep(backoff)
+            backoff = min(backoff * 2, backoff_cap)
+
+    console.print("[red]Error: timed out waiting for repository assembly[/red]")
+    sys.exit(1)
+
+
 def download_repo(args) -> None:
     """Download the repository assembled at a content snapshot of an experiment."""
     console = Console()
@@ -1080,21 +1155,46 @@ def download_repo(args) -> None:
 
     try:
         client = _get_http_client(args)
-        result = client.get_repo_download_url(experiment_name, content_uid)
-        url = result.get("url")
-        if not url:
-            console.print("[red]Error: server did not return a download URL[/red]")
-            sys.exit(1)
+
+        # Kick off assembly. A permanent failure (bad args, unauthorized, not
+        # found, internal) raises here and is caught below.
+        client.start_repo_download(experiment_name, content_uid)
+
+        url = _poll_repo_download_url(client, experiment_name, content_uid, console)
+
+        from rich.progress import (
+            BarColumn,
+            DownloadColumn,
+            Progress,
+            TextColumn,
+            TimeRemainingColumn,
+            TransferSpeedColumn,
+        )
 
         # The presigned URL is a plain S3 GET; do not send Hive auth headers to it.
         with requests.get(
             url, stream=True, timeout=300, verify=not getattr(args, "insecure", False)
         ) as resp:
             resp.raise_for_status()
-            with open(output, "wb") as f:
+            # S3 returns Content-Length for the object, so the bar is determinate;
+            # if it were ever absent, total=None degrades to a bytes counter.
+            total = int(resp.headers.get("Content-Length") or 0) or None
+            with (
+                Progress(
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    DownloadColumn(),
+                    TransferSpeedColumn(),
+                    TimeRemainingColumn(),
+                    console=console,
+                ) as progress,
+                open(output, "wb") as f,
+            ):
+                task = progress.add_task("Downloading", total=total)
                 for chunk in resp.iter_content(chunk_size=1 << 16):
                     if chunk:  # skip empty keep-alive chunks
                         f.write(chunk)
+                        progress.update(task, advance=len(chunk))
     except Exception as e:
         console.print(f"[red]Error: Failed to download repo: {e}[/red]")
         sys.exit(1)
@@ -1407,6 +1507,14 @@ def main():
     )
     parser_list_image.set_defaults(func=list_images)
 
+    # list models
+    parser_list_models = list_subparsers.add_parser(
+        "models",
+        aliases=["model"],
+        help="List the models an agent ensemble can name",
+    )
+    parser_list_models.set_defaults(func=list_models)
+
     # delete command
     parser_delete = subparsers.add_parser("delete", help="Delete resources")
     parser_delete.set_defaults(func=lambda _: parser_delete.print_help())
@@ -1497,6 +1605,25 @@ def main():
     )
     parser_logs.set_defaults(func=stream_logs)
 
+    parser_skills = subparsers.add_parser("skills", help="Manage bundled coding-agent skills")
+    parser_skills.set_defaults(func=lambda _: parser_skills.print_help())
+    skills_subparsers = parser_skills.add_subparsers(dest="skills_target")
+    parser_skills_install = skills_subparsers.add_parser(
+        "install",
+        help="Install bundled skills into a coding agent's skills directory",
+    )
+    parser_skills_install.add_argument(
+        "who",
+        nargs="*",
+        choices=list(SKILL_TARGETS),
+        metavar="AGENT",
+        help="agents to install for: " + ", ".join(SKILL_TARGETS),
+    )
+    parser_skills_install.add_argument(
+        "--all", action="store_true", help="install for every supported agent"
+    )
+    parser_skills_install.set_defaults(func=skills_install)
+
     argcomplete.autocomplete(parser)
     args, overrides = parser.parse_known_args()
     if hasattr(args, "func"):