superqode 0.2.76__tar.gz → 0.2.78__tar.gz

{superqode-0.2.76 → superqode-0.2.78}/CHANGELOG.md

@@ -7,6 +7,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.78] - 2026-08-07
+
+### Fixed
+
+- The vendor model picker keeps the highlighted row on screen and accepts a
+  click anywhere on the row. Both were fine for a vendor with a handful of
+  models and broke on a longer catalog.
+- ACP sessions report the connected agent as the active harness in the status
+  bar instead of the native profile.
+
+### Added
+
+- `:prime local` registers the local model servers SuperQode can see with Prime
+  Agent, leaving providers it did not discover untouched.
+- `:prime login` hands the terminal to Prime Agent for its own sign-in.
+- `:prime models` opens the model picker, and `:prime model <provider/id>` sets
+  one directly.
+
+## [0.2.77] - 2026-08-07
+
+Fixes the Prime Agent connection shipped in 0.2.76. Connecting without first
+choosing a model launched the agent with a model literally named `auto`, which
+sent the session to a provider the user had never selected and failed on a
+missing key. Prime Agent also now appears in the Subscriptions group of
+`:connect`, because what its login buys is a model on a plan you already pay
+for.
+
+### Fixed
+
+- Prime Agent connects when no model has been chosen. `auto` is SuperQode's
+  internal marker for "no model selected", and the Prime route forwarded it as
+  a real model id, so every default connection ran
+  `prime-agent --mode acp --model auto` and reported "No API key found" for
+  whichever provider Prime resolved that against. The marker now resolves to
+  unset in `split_selector`, so a bare `:prime connect` starts Prime on its own
+  default and a pinned selection is still honored. `default` and `none` are
+  treated the same way, and a provider with an unset model keeps the provider.
+
+### Added
+
+- Prime Agent is listed under `:connect` in Subscriptions alongside Codex,
+  Cursor, Muse Code and Grok. It reaches the same ACP route as `:prime connect`,
+  and readiness detects the binary together with any credential, whether that is
+  Prime's own auth file, a provider key in the environment, or a local provider
+  in `models.json`.
+- Documentation states that this login cannot be run from SuperQode. Prime Agent
+  has no `login` subcommand and exposes `/login` only inside its own interactive
+  terminal, so the flow is to run `prime-agent`, sign in there, and return.
+  SuperQode then detects the stored credential.
+
+### Notes
+
+- Prime Agent is deliberately excluded from the subscription key-stripping
+  policy. That policy exists for vendors like Muse Code, where an environment
+  key silently overrides an account session. Prime Agent's auth file takes
+  priority over environment variables, so there is no billing diversion to
+  prevent, and stripping keys would break its documented environment-key route.
+
 ## [0.2.76] - 2026-08-07
 
 Prime Intellect's Prime Agent is a supported coding agent. It connects over ACP

{superqode-0.2.76 → superqode-0.2.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.2.76
+Version: 0.2.78
 Summary: Agent Engineering for your code factory
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-0.2.76 → superqode-0.2.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "0.2.76"
+version = "0.2.78"
 description = "Agent Engineering for your code factory"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "0.2.76"
+__version__ = "0.2.78"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/constants.py

@@ -397,7 +397,7 @@ COMMANDS = [
     ":prime help",
     ":prime connect",
     ":prime models",
-    ":prime model",
+    ":prime local",
     ":prime depth",
     ":prime goal",
     ":prime autonomous",

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/agent_run.py

@@ -1941,7 +1941,10 @@ class AgentRunMixin:
             from superqode.providers import prime_agent as prime
 
             opts = self._prime_opts()
-            selector = (model or "").strip() or opts.model
+            requested = (model or "").strip()
+            if requested.lower() in {"auto", "default", "none"}:
+                requested = ""
+            selector = requested or opts.model
             command = prime.acp_command(selector, options=opts)
             acp_extra_env = opts.env()
             model_display = f"prime/{selector}" if selector else "prime/default"

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/commands_impl.py

@@ -3211,6 +3211,8 @@ class CommandImplMixin:
                 self._prime_connect(rest, log)
             else:
                 self._show_prime_model_picker(log)
+        elif sub in ("local", "sync"):
+            self._prime_local_cmd(log)
         elif sub == "depth":
             self._prime_depth_cmd(rest, log)
         elif sub == "goal":
@@ -3230,7 +3232,7 @@ class CommandImplMixin:
         elif sub == "update":
             self._prime_update(log)
         elif sub in ("login", "auth"):
-            self._show_prime_login(log)
+            self._prime_login_cmd(log)
         elif sub in ("help", "?"):
             self._show_prime_help(log)
         else:
@@ -3311,6 +3313,84 @@ class CommandImplMixin:
         if pinned:
             log.add_info(f"Prime Agent launch: {', '.join(pinned)}")
 
+    def _prime_login_cmd(self, log) -> None:
+        """Hand the terminal to Prime Agent so its own ``/login`` can run.
+
+        Prime exposes no login subcommand and no authentication call over ACP
+        or RPC, so SuperQode cannot drive the OAuth itself. Suspending for the
+        vendor's own terminal is as close as its surface allows, and it keeps
+        the user inside SuperQode rather than sending them elsewhere.
+        """
+        from superqode.providers import prime_agent as prime
+
+        if not prime.is_installed():
+            log.add_error("Prime Agent is not installed.")
+            log.add_info(f"  Install: {prime.INSTALL_HINT}")
+            return
+
+        started = self._begin_subscription_login(
+            "prime-agent",
+            log,
+            on_success=lambda: self._show_prime_status(log),
+            reason=(
+                "Prime Agent needs a provider before it can call a model. "
+                "Prime has no login subcommand, so SuperQode hands over the "
+                "terminal and its full session opens. Run /login, then QUIT "
+                "Prime with /quit or Ctrl+C: SuperQode resumes only when Prime "
+                "exits."
+            ),
+        )
+        if not started:
+            log.add_info("Prime Agent already has a credential.")
+            self._show_prime_status(log)
+
+    def _prime_local_cmd(self, log) -> None:
+        """Register the local model servers SuperQode can see with Prime Agent."""
+        from superqode.providers import prime_agent as prime
+
+        if not prime.is_installed():
+            log.add_error("Prime Agent is not installed.")
+            log.add_info(f"  Install: {prime.INSTALL_HINT}")
+            return
+        self.run_worker(self._prime_local_async(log), exclusive=False)
+
+    async def _prime_local_async(self, log) -> None:
+        """Scan for local servers, then merge them into Prime's models.json."""
+        from superqode.providers import prime_agent as prime
+        from superqode.providers.local.discovery import quick_scan
+
+        log.add_info("Scanning for local model servers...")
+        try:
+            found = await quick_scan()
+        except Exception as exc:  # noqa: BLE001 - discovery is best-effort
+            log.add_error(f"Local discovery failed: {exc}")
+            return
+
+        discovered: dict[str, tuple[str, list[str]]] = {}
+        for provider in found.values():
+            name = prime.local_provider_name(getattr(provider, "provider_type", None))
+            models = [prime.local_model_id(m) for m in (getattr(provider, "models", None) or [])]
+            if not name or not models:
+                continue
+            host = str(getattr(provider, "host", "") or "").rstrip("/")
+            discovered[name] = (f"{host}/v1", models)
+
+        if not discovered:
+            log.add_error("No local model servers found.")
+            log.add_info("  Start one (for example `ollama serve`) and run :prime local again.")
+            return
+
+        providers, models, path = await asyncio.to_thread(prime.merge_local_models, discovered)
+        if not models:
+            log.add_error("Found local servers but no chat models to register.")
+            return
+        log.add_success(f"Registered {models} local model(s) from {providers} provider(s)")
+        for name, (base_url, ids) in sorted(discovered.items()):
+            usable = [m for m in ids if prime.is_chat_model(m)]
+            log.add_info(f"  {name}: {len(usable)} model(s) at {base_url}")
+        log.add_info(f"  Written to {path}")
+        log.add_info("  Run :prime models to pick one.")
+
     def _prime_depth_cmd(self, rest: str, log) -> None:
         """Set Prime's recursion depth for the next launch."""
         raw = (rest or "").strip()

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/connect.py

@@ -416,6 +416,23 @@ class ConnectMixin:
                     reason="A local Grok subscription login is required.",
                 )
                 return
+            # Prime Agent has no login subcommand, so the handoff runs the
+            # binary bare and the user signs in with its own `/login`.
+            if getattr(profile, "id", "") == "prime-agent":
+                from superqode.providers import prime_agent as prime
+
+                if prime.is_installed():
+                    self._begin_subscription_login(
+                        "prime-agent",
+                        log,
+                        on_success=lambda: self._connect_acp_cmd("prime-agent", log),
+                        reason=(
+                            "Prime Agent needs a provider before it can call a model. "
+                            "SuperQode will hand over the terminal; run /login there, "
+                            "then quit."
+                        ),
+                    )
+                    return
             log.add_info(f"{profile.label} needs setup: {profile.unavailable_hint}")
             return
         if conn == "copilot":
@@ -2696,6 +2713,27 @@ class ConnectMixin:
                         self._auto_select_codex_model(model_hint, agent, log)
                     else:
                         self._show_codex_models_selection(agent, log)
+                elif self.current_agent in ("prime-agent", "prime"):
+                    # Prime fixes its model at launch, so the selection lives in
+                    # the pinned launch options rather than in the ACP session.
+                    # The generic branch below reads a "model" key the catalog
+                    # entry does not have, which left the badge empty and made a
+                    # picked model look like it had not been applied.
+                    hint = (model_hint or "").strip()
+                    if hint and hint.lower() not in {"auto", "default", "none"}:
+                        self._prime_set_opts(model=hint)
+                    opts = self._prime_opts()
+                    self.current_model = opts.model
+                    self.current_provider = "prime"
+                    self._awaiting_model_selection = False
+
+                    badge = self.query_one("#mode-badge", ModeBadge)
+                    badge.agent = self.current_agent
+                    badge.mode = ""
+                    badge.role = ""
+                    badge.model = self.current_model or "Prime default"
+                    badge.provider = self.current_provider
+                    badge.execution_mode = "acp"
                 elif self.current_agent == "grok":
                     # Grok Build owns the subscription and model catalog. Keep
                     # the default unset so its signed-in account decides; an

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/dialogs.py

@@ -943,9 +943,11 @@ class DialogsMixin:
         t.append("  :prime connect [model]     ", style=THEME["cyan"])
         t.append("connect Prime Agent over ACP\n", style=THEME["muted"])
         t.append("  :prime models [search]     ", style=THEME["cyan"])
-        t.append("list the model catalog\n", style=THEME["muted"])
-        t.append("  :prime model [name]        ", style=THEME["cyan"])
-        t.append("pick a model (picker) or set provider/model\n", style=THEME["muted"])
+        t.append("pick a model, optionally filtered\n", style=THEME["muted"])
+        t.append("  :prime model <provider/id> ", style=THEME["cyan"])
+        t.append("set a model directly, without the picker\n", style=THEME["muted"])
+        t.append("  :prime local               ", style=THEME["cyan"])
+        t.append("register local model servers with Prime\n", style=THEME["muted"])
         t.append("  :prime depth [n]           ", style=THEME["cyan"])
         t.append("recursion depth via RLM_MAX_DEPTH\n", style=THEME["muted"])
         t.append("  :prime goal [text]         ", style=THEME["cyan"])

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/helpers.py

@@ -143,9 +143,16 @@ class HelpersMixin(
         try:
             from superqode.app.widgets import ColorfulStatusBar
 
-            pure = getattr(self, "_pure_mode", None)
             harness = ""
-            if pure is not None:
+            # An ACP agent owns its own loop, tools and prompt. Falling through
+            # to the native profile below labelled every vendor session "Core"
+            # in the status bar while the connection card correctly said the
+            # vendor owned it.
+            if getattr(self, "current_mode", "") == "agent":
+                harness = str(getattr(self, "current_agent", "") or "")
+
+            pure = getattr(self, "_pure_mode", None)
+            if not harness and pure is not None:
                 runtime_name = str(getattr(pure, "runtime_name", "") or "")
                 connected = bool(getattr(getattr(pure, "session", None), "connected", False))
                 if connected and runtime_name in getattr(

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/model_catalog.py

@@ -952,6 +952,13 @@ class ModelCatalogMixin:
             status.update_byok_status()
             status.active_runtime = "acp"
             status.active_model = model or ""
+            # The agent owns its loop, tools and prompt, so it is the active
+            # harness. Leaving this field alone kept the startup value, which
+            # showed "h core" for every ACP session while the connection card
+            # correctly named the vendor.
+            agent = str(getattr(self, "current_agent", "") or "").strip()
+            if agent:
+                status.active_harness = agent
         except Exception:  # noqa: BLE001
             pass
 
@@ -1025,61 +1032,22 @@ class ModelCatalogMixin:
         self._show_provider_models("grok-cli", log, use_picker=False)
 
     def _show_prime_models(self, log, search: str = "") -> None:
-        """Discover Prime Agent models off the Textual event loop."""
-        self.run_worker(self._show_prime_models_async(log, search), exclusive=False)
+        """``:prime models`` opens the selectable picker, like the other agents."""
+        self._show_prime_model_picker(log, search)
 
-    async def _show_prime_models_async(self, log, search: str = "") -> None:
-        """List the models the installed Prime Agent reports for its logins."""
-        from superqode.providers import prime_agent as prime
-
-        if not prime.is_installed():
-            t = Text()
-            t.append("\n  Prime Agent is not installed\n\n", style=f"bold {THEME['warning']}")
-            t.append("  Install: ", style=THEME["muted"])
-            t.append(f"{prime.INSTALL_HINT}\n", style=THEME["cyan"])
-            log.write_feedback(t)
-            return
-
-        models = await asyncio.to_thread(prime.list_models, search)
-
-        t = Text()
-        heading = f"\n  Prime Agent models{f' matching {search!r}' if search else ''}\n\n"
-        t.append(heading, style=f"bold {THEME['text']}")
-        if not models:
-            t.append("  No models available.\n\n", style=THEME["warning"])
-            t.append("  Prime owns its own credentials. Log in first:\n", style=THEME["muted"])
-            t.append("    prime-agent\n    /login\n", style=THEME["cyan"])
-            log.write_feedback(t)
-            return
-
-        current = self._prime_opts().model
-        last_provider = ""
-        for info in models:
-            if info.provider != last_provider:
-                t.append(f"\n  {info.provider}\n", style=THEME["muted"])
-                last_provider = info.provider
-            selected = info.id == current
-            t.append("  ▸ " if selected else "    ", style=THEME["success"])
-            t.append(f"{info.model:28s}", style=THEME["cyan"])
-            t.append(f"{info.context:>6s}  ", style=THEME["muted"])
-            traits = ", ".join(
-                [n for n, on in (("thinking", info.thinking), ("images", info.images)) if on]
-            )
-            t.append(f"{traits}\n", style=THEME["dim"])
-
-        t.append("\n  Source: ", style=THEME["muted"])
-        t.append("`prime-agent model list`\n", style=THEME["text"])
-        t.append("  Select with ", style=THEME["muted"])
-        t.append(":prime model", style=THEME["cyan"])
-        t.append(" (picker) or ", style=THEME["muted"])
-        t.append(":prime model <provider/model>\n", style=THEME["cyan"])
-        log.write_feedback(t)
-
-    def _show_prime_model_picker(self, log) -> None:
+    def _show_prime_model_picker(self, log, search: str = "") -> None:
         """Interactive picker over Prime's catalog; Enter connects."""
-        self.run_worker(self._show_prime_model_picker_async(log), exclusive=False)
+        self.run_worker(self._show_prime_model_picker_async(log, search), exclusive=False)
 
-    async def _show_prime_model_picker_async(self, log) -> None:
+    def _prime_model_label(self, info) -> str:
+        """One picker row: provider, model, context, and what it supports."""
+        traits = ", ".join(
+            [name for name, on in (("thinking", info.thinking), ("images", info.images)) if on]
+        )
+        detail = f"{info.context:>6s}" + (f"  {traits}" if traits else "")
+        return f"{info.provider:16s} {info.model:30s} {detail}"
+
+    async def _show_prime_model_picker_async(self, log, search: str = "") -> None:
         """Probe the catalog off-thread, then open the vendor picker."""
         from superqode.providers import prime_agent as prime
 
@@ -1088,21 +1056,27 @@ class ModelCatalogMixin:
             log.add_info(f"  Install: {prime.INSTALL_HINT}")
             return
 
-        models = await asyncio.to_thread(prime.list_models)
+        models = await asyncio.to_thread(prime.list_models, search)
+        if not models and search:
+            log.add_info(f"No Prime Agent model matches {search!r}. Showing the full catalog.")
+            models = await asyncio.to_thread(prime.list_models, "")
         if not models:
             log.add_error("Prime Agent reported no models.")
             log.add_info("  Log in first: run `prime-agent`, then `/login`.")
+            log.add_info("  Local models need a provider in ~/.prime/agent/models.json.")
             return
 
-        entries = [(info.id, f"{info.id:44s} {info.context}") for info in models]
-        self._show_vendor_model_picker(
+        entries = [(info.id, self._prime_model_label(info)) for info in models]
+        opened = self._show_vendor_model_picker(
             log,
-            title="Select Prime Agent Model",
+            title=f"Select Prime Agent Model{f'  ({search})' if search else ''}",
             entries=entries,
             on_choose=lambda chosen: self._prime_connect(chosen, log),
             current=self._prime_opts().model,
-            retry_hint="Run :prime model to choose again.",
+            retry_hint="Run :prime models to choose again.",
         )
+        if not opened:
+            log.add_error("No Prime Agent models to choose from.")
 
     def _claude_model_cmd(self, model: str, log) -> None:
         from superqode.runtime.claude_agent_sdk import CLAUDE_MODELS

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/mixins/pickers.py

@@ -684,36 +684,51 @@ class PickerNavigationMixin:
             )
 
         highlighted = self._prompts.index
+        # Vendors with a handful of models fit on one screen; a catalog like
+        # Prime Agent's does not. Numbers are right-aligned so the rows stay a
+        # column, and the highlighted row is scrolled back into view below.
+        number_width = len(str(len(entries)))
         t = Text()
         t.append("\n  ◈ ", style=f"bold {THEME['purple']}")
-        t.append(f"{title}\n\n", style=f"bold {THEME['text']}")
+        t.append(f"{title}", style=f"bold {THEME['text']}")
+        t.append(f"   {len(entries)} models\n\n", style=THEME["muted"])
         for index, (model_id, label) in enumerate(entries):
             num = index + 1
-            if index == highlighted:
-                t.append("  ▶ ", style=f"bold {THEME['success']}")
-                t.append(
-                    f"[{num}] ", style=self._picker_link_style(f"bold {THEME['success']}", num)
-                )
-                t.append(label, style=f"bold {THEME['success']}")
-            else:
-                t.append(f"    [{num}] ", style=self._picker_link_style(THEME["dim"], num))
-                t.append(label, style=f"bold {THEME['text']}")
+            is_highlighted = index == highlighted
+            # The whole row is the click target, not just the number. A mouse
+            # user aims at the name they are reading.
+            style = f"bold {THEME['success']}" if is_highlighted else THEME["dim"]
+            link = self._picker_link_style(style, num)
+            handle = self._picker_link_style(
+                f"bold {THEME['success']}" if is_highlighted else f"bold {THEME['text']}",
+                num,
+                handle=True,
+            )
+            t.append("  ", style="")
+            self._append_picker_dot(t, num, highlighted=is_highlighted)
+            t.append(f"[{num:>{number_width}}] ", style=link)
+            t.append(label, style=handle)
             # Show the id only when it adds information beyond the label.
-            if model_id and model_id != label:
+            if model_id and model_id != label and model_id not in label:
                 t.append(f"  {model_id}", style=THEME["muted"])
             if current and model_id == current:
                 t.append("  ◀ active", style=THEME["muted"])
+            if is_highlighted:
+                self._append_picker_arrow(t, num)
             t.append("\n", style="")
         t.append("\n  💡 ", style=THEME["muted"])
         t.append("↑↓", style=THEME["cyan"])
         t.append(" navigate  ", style=THEME["dim"])
         t.append("Enter", style=THEME["cyan"])
-        t.append(" select  •  or type a number\n", style=THEME["dim"])
+        t.append(" select  •  click a row  •  or type a number\n", style=THEME["dim"])
 
         log.auto_scroll = False
         log.clear()
         log.write(t)
         log.auto_scroll = True
+        # Without this the highlight walks off the bottom of a long catalog and
+        # the user cannot see what is selected.
+        self._scroll_to_highlighted_item(log, highlighted, len(entries))
         self.set_timer(0.05, self._ensure_input_focus)
         return True
 

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/app/welcome.py

@@ -284,7 +284,7 @@ def render_welcome(
 
 
 #: Harness ids whose product name is not simply the id capitalised.
-_HARNESS_NAME_OVERRIDES = {"pipy": "PiPy"}
+_HARNESS_NAME_OVERRIDES = {"pipy": "PiPy", "prime-agent": "Prime Agent"}
 
 
 def _harness_display_name(name) -> str:

{superqode-0.2.76 → superqode-0.2.78}/src/superqode/providers/connection_profiles.py

@@ -269,6 +269,37 @@ def _muse_signed_in() -> bool:
     return bool(data.get("providers")) if isinstance(data, dict) else False
 
 
+def _prime_agent_signed_in() -> bool:
+    """A stored Prime Agent credential exists, from its own ``/login``.
+
+    Prime reads ``~/.prime/agent/auth.json`` for both OAuth subscriptions and
+    API keys. Provider names are enough to answer this; the values are not read.
+    """
+    from superqode.providers import prime_agent
+
+    if prime_agent.auth_providers():
+        return True
+    # Prime also accepts provider keys straight from the environment, so a
+    # session can be ready with no auth file at all.
+    return any(
+        _env_key_set(name)
+        for name in ("ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "PRIME_API_KEY")
+    ) or bool(prime_agent.custom_providers())
+
+
+def _prime_agent_ready() -> bool:
+    """Prime Agent is installed and has some way to reach a model."""
+    from superqode.providers import prime_agent
+
+    return prime_agent.is_installed() and _prime_agent_signed_in()
+
+
+def _prime_agent_present() -> bool:
+    from superqode.providers import prime_agent
+
+    return prime_agent.is_installed()
+
+
 def _muse_cli_ready() -> bool:
     """Muse Code is installed and holds a credential it can actually use."""
     if shutil.which("muse") is None:
@@ -672,6 +703,28 @@ _AGENT_PROFILES: List[ConnectionProfile] = [
             "`curl -fsSL https://dev.meta.ai/install.sh | bash`, then run `muse login`"
         ),
     ),
+    ConnectionProfile(
+        id="prime-agent",
+        harness_openness="open",
+        model_openness="multi-model",
+        transport="ACP",
+        label="Prime Agent (RLM)",
+        description=(
+            "Prime Intellect's RLM coding agent over ACP, on a provider you already "
+            "pay for (ChatGPT, Claude, GitHub Copilot) or a local model. Commands: :prime"
+        ),
+        # The agent itself is free and MIT. What the login buys is the upstream
+        # model, so this sits with the vendor accounts rather than with BYOK.
+        connector="acp",
+        menu=CONNECT_MENU_VENDORS,
+        acp_agent="prime-agent",
+        detect=_prime_agent_ready,
+        product_detect=_prime_agent_present,
+        unavailable_hint=(
+            "install with `curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh`, "
+            "then run `prime-agent` and use its `/login`"
+        ),
+    ),
     ConnectionProfile(
         id="grok",
         harness_openness="closed",