boost-skill-cli 1.2.38__tar.gz → 1.2.39__tar.gz

{boost_skill_cli-1.2.38/boost_skill_cli.egg-info → boost_skill_cli-1.2.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.38
+Version: 1.2.39
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1000,9 +1000,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/README.md

@@ -282,9 +282,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.38'
-__version_tuple__ = version_tuple = (1, 2, 38)
+__version__ = version = '1.2.39'
+__version_tuple__ = version_tuple = (1, 2, 39)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/boost_cli/core/ai.py

@@ -2,9 +2,21 @@
 # SPDX-License-Identifier: GPL-3.0-only
 """Optional AI bridge for the Intelligence commands and --smart ranking.
 
-Strategy: prefer the `claude` CLI if on PATH, else the Anthropic API via
-urllib when ANTHROPIC_API_KEY is set, else return None so every caller
-degrades to its non-AI fallback.
+Strategy: use the first assistant CLI on PATH that `core/aihost.py` knows —
+Claude first, then Gemini — else the Anthropic API via urllib when
+ANTHROPIC_API_KEY is set, else return None so every caller degrades to its
+non-AI fallback.
+
+The second CLI is why `aihost` exists. Before it, a user running Gemini got the
+heuristic fallback from every AI-assisted command even with a perfectly good
+assistant installed, because this module only ever spelled "claude". The
+per-backend differences that would otherwise be bugs — Gemini has no
+`--append-system-prompt`, and `ai.model` holds a Claude id that `gemini -m`
+would reject — are handled there, as data.
+
+The direct-API path stays Anthropic-only. Someone using Gemini CLI has the
+binary by definition, so the CLI route is the one that matters; a second HTTP
+client is a separate change with its own wire format and error taxonomy.
 """
 from __future__ import annotations
 
@@ -15,7 +27,7 @@ import subprocess
 import urllib.error
 import urllib.request
 
-from . import config, logs, nethttp
+from . import aihost, config, logs, nethttp
 
 API_URL = "https://api.anthropic.com/v1/messages"
 
@@ -30,22 +42,33 @@ def enabled() -> bool:
 
 
 def available() -> bool:
-    """Return True when AI is enabled and a backend exists: the `claude`
-
-    CLI on PATH or ANTHROPIC_API_KEY set.
-    """
+    """Return True when AI is enabled and some backend exists."""
     return enabled() and (has_cli() or bool(os.environ.get("ANTHROPIC_API_KEY")))
 
 
+def cli_backend() -> str | None:
+    """The first assistant CLI on PATH, in `aihost` preference order."""
+    for name in aihost.backends():
+        if shutil.which(aihost.cli(name)):
+            return name
+    return None
+
+
 def has_cli() -> bool:
-    """Return True when the `claude` CLI is on PATH."""
-    return shutil.which("claude") is not None
+    """Return True when any assistant CLI `aihost` knows is on PATH."""
+    return cli_backend() is not None
 
 
 def fallback_note() -> str:
-    """Return the one-line hint shown when a command degrades to heuristics."""
-    return ("AI features need the `claude` CLI on PATH or ANTHROPIC_API_KEY set "
-            "— using the heuristic fallback")
+    """Return the one-line hint shown when a command degrades to heuristics.
+
+    Names every CLI that would work, not just Claude's — telling a Gemini user
+    to install Claude is a worse answer than telling them boost could not find
+    either.
+    """
+    clis = " or ".join("`%s`" % aihost.cli(n) for n in aihost.backends())
+    return ("AI features need one of %s on PATH, or ANTHROPIC_API_KEY set "
+            "— using the heuristic fallback" % clis)
 
 
 def ask(prompt: str, system: str | None = None, model: str | None = None,
@@ -54,8 +77,9 @@ def ask(prompt: str, system: str | None = None, model: str | None = None,
     if not enabled():
         return None
     model = model or str(config.get("ai.model"))
-    if has_cli():
-        text = _ask_cli(prompt, system, model, timeout)
+    backend = cli_backend()
+    if backend:
+        text = _ask_cli(backend, prompt, system, model, timeout)
         if text:
             return text
     if os.environ.get("ANTHROPIC_API_KEY"):
@@ -88,26 +112,27 @@ def _stderr_excerpt(text: str | None) -> str:
     return (s[:STDERR_LOG_CHARS] + "...") if len(s) > STDERR_LOG_CHARS else s
 
 
-def _ask_cli(prompt: str, system: str | None, model: str,
+def _ask_cli(backend: str, prompt: str, system: str | None, model: str,
              timeout: int) -> str | None:
-    cmd = ["claude", "-p", "--model", model, "--output-format", "text"]
-    if system:
-        cmd += ["--append-system-prompt", system]
+    cmd = aihost.argv(backend, model, system)
+    # A backend with no system flag takes the text folded into the prompt.
+    body = aihost.fold_system(backend, system, prompt)
+    who = "%s CLI" % aihost.cli(backend)
     try:
-        proc = subprocess.run(cmd, input=prompt, capture_output=True,
+        proc = subprocess.run(cmd, input=body, capture_output=True,
                               text=True, timeout=timeout)
     except (subprocess.TimeoutExpired, OSError) as e:
         # The exception TYPE only, never str(e): TimeoutExpired stringifies the
-        # whole argv, which carries the --append-system-prompt text with it.
-        _log_failure("claude CLI", type(e).__name__)
+        # whole argv, which carries the system-prompt text with it.
+        _log_failure(who, type(e).__name__)
         return None
     if proc.returncode != 0:
-        _log_failure("claude CLI", "exit %d: %s"
+        _log_failure(who, "exit %d: %s"
                      % (proc.returncode, _stderr_excerpt(proc.stderr)))
         return None
     out = proc.stdout.strip()
     if not out:
-        _log_failure("claude CLI", "empty reply")
+        _log_failure(who, "empty reply")
         return None
     return out
 

boost_skill_cli-1.2.39/boost_cli/core/aihost.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# Copyright the boost contributors.
+# SPDX-License-Identifier: GPL-3.0-only
+"""Per-assistant-CLI facts for the AI bridge — a pure table, like `hookhost`.
+
+`core/ai.py` knew exactly one backend: the `claude` CLI, or the Anthropic API
+via ANTHROPIC_API_KEY. Every AI-assisted command therefore degraded to its
+heuristic fallback for a user running Gemini CLI, even though Gemini exposes
+the same headless contract. Skills, MCP, rules, workflows and hooks all fan out
+across hosts; this was the last surface that did not, and it is the one a user
+notices, because the fallback is visibly worse prose.
+
+Three per-backend facts do the work, and each is a difference that would
+otherwise be a bug:
+
+* **The system prompt.** Claude takes `--append-system-prompt`. Gemini has no
+  equivalent, so the system text has to be folded into the prompt body. Passing
+  an unknown flag would make every call fail with a usage error rather than
+  degrade — the one outcome worse than having no AI at all.
+* **The model id.** `ai.model` defaults to a Claude model name, and handing
+  that to `gemini -m` is an error, not a fallback. A backend only receives a
+  model id it owns; otherwise the flag is omitted and the CLI picks its own
+  default.
+* **Order.** Claude is first, and that is behaviour rather than taste: someone
+  with both CLIs installed had Claude answering before this table existed, and
+  reordering would silently change every result they get.
+
+The direct-API path in `ai.py` stays Anthropic-only. A user of Gemini CLI has
+the `gemini` binary by definition, so the CLI route is the one that matters
+here; a second HTTP client is a separate, larger change with its own wire
+format and error taxonomy.
+"""
+from __future__ import annotations
+
+from ..errors import BoostError
+
+CLAUDE = "claude"
+GEMINI = "gemini"
+
+#: Ordered: the first installed backend wins. See the module docstring on why
+#: Claude must stay at the front.
+BACKENDS: dict[str, dict] = {
+    CLAUDE: {
+        "cli": "claude",
+        "label": "Claude Code",
+        "prompt_flag": "-p",
+        "model_flag": "--model",
+        # Model ids this backend accepts. `ai.model` is a Claude id today, so
+        # this is what keeps it from being handed to another CLI.
+        "model_prefixes": ("claude", "sonnet", "opus", "haiku"),
+        "output_flags": ("--output-format", "text"),
+        "system_flag": "--append-system-prompt",
+        "key_env": "ANTHROPIC_API_KEY",
+    },
+    GEMINI: {
+        "cli": "gemini",
+        "label": "Gemini CLI",
+        "prompt_flag": "-p",
+        "model_flag": "-m",
+        "model_prefixes": ("gemini",),
+        "output_flags": ("-o", "text"),
+        # No equivalent flag. `fold_system` puts the text in the prompt.
+        "system_flag": "",
+        "key_env": "GEMINI_API_KEY",
+    },
+}
+
+
+def backends() -> list[str]:
+    """Known backend ids, in preference order."""
+    return list(BACKENDS)
+
+
+def spec(name: str) -> dict:
+    """The table row for ``name``, or a BoostError naming the alternatives."""
+    try:
+        return BACKENDS[name]
+    except KeyError:
+        raise BoostError(
+            "unknown AI backend %r" % name,
+            hint="use one of: %s" % ", ".join(backends())) from None
+
+
+def cli(name: str) -> str:
+    """The executable to run for ``name``."""
+    return str(spec(name)["cli"])
+
+
+def label(name: str) -> str:
+    """Display name for ``name`` (``gemini`` -> "Gemini CLI")."""
+    return str(spec(name)["label"])
+
+
+def key_env(name: str) -> str:
+    """The API-key environment variable ``name`` reads."""
+    return str(spec(name)["key_env"])
+
+
+def takes_system_flag(name: str) -> bool:
+    """Whether ``name`` accepts a separate system prompt."""
+    return bool(spec(name)["system_flag"])
+
+
+def owns_model(name: str, model: str | None) -> bool:
+    """Whether ``model`` is an id ``name`` clearly owns."""
+    if not model:
+        return False
+    return model.lower().startswith(tuple(spec(name)["model_prefixes"]))
+
+
+def accepts_model(name: str, model: str | None) -> bool:
+    """Whether to hand ``model`` to ``name``.
+
+    The rule is "not another vendor's", not "one of mine". An id that no
+    backend claims — a custom alias, a pinned snapshot, anything a user passes
+    to `--model` — goes through untouched, because refusing it would silently
+    drop an override the user asked for. Only an id another backend plainly
+    owns is withheld: `ai.model` defaults to a Claude name, and `gemini -m
+    claude-sonnet-4-5` is an error rather than a fallback.
+    """
+    if not model:
+        return False
+    if owns_model(name, model):
+        return True
+    return not any(owns_model(other, model)
+                   for other in backends() if other != name)
+
+
+def fold_system(name: str, system: str | None, prompt: str) -> str:
+    """The prompt to send, with ``system`` folded in when there is no flag.
+
+    Returned unchanged for a backend that takes a system flag, so Claude's
+    request is byte-for-byte what it has always been.
+    """
+    if not system or takes_system_flag(name):
+        return prompt
+    return "%s\n\n%s" % (system, prompt)
+
+
+def argv(name: str, model: str | None, system: str | None) -> list[str]:
+    """The command line for ``name``, minus the prompt (which goes on stdin).
+
+    ``model`` is passed unless another backend plainly owns the id (see
+    `accepts_model`), and ``system`` only when this backend has a flag for one
+    — `fold_system` handles the other case.
+    """
+    row = spec(name)
+    cmd = [str(row["cli"]), str(row["prompt_flag"])]
+    if accepts_model(name, model):
+        cmd += [str(row["model_flag"]), str(model)]
+    cmd += [str(x) for x in row["output_flags"]]
+    if system and row["system_flag"]:
+        cmd += [str(row["system_flag"]), system]
+    return cmd

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.38
+Version: 1.2.39
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -1000,9 +1000,14 @@ the C4 diagrams in [`docs/architecture/`](docs/architecture/README.md).
 | Team & Collaboration | cohort · profile · protocol · pulse · replay · who |
 
 The AI-assisted commands (`search --smart`, `explain`, `distill`, `infer`,
-`absorb`, `evolve`, `simulate`) call the `claude` CLI when it is on your PATH,
-or use `ANTHROPIC_API_KEY`, and fall back to plain heuristics when neither is
-available.
+`absorb`, `evolve`, `simulate`) use whichever assistant CLI you already have —
+`claude` first, then `gemini` — or `ANTHROPIC_API_KEY`, and fall back to plain
+heuristics when none is available. boost handles the differences: Gemini takes
+no separate system prompt, so it is folded into the message, and a model id
+belonging to another vendor is never passed through.
+
+The retrieval and faithfulness evals were measured against Claude, so treat
+those floors as Claude-measured rather than a claim about every backend.
 
 ## boost as an MCP server
 

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/boost_skill_cli.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ boost_cli/core/__init__.py
 boost_cli/core/adapters.py
 boost_cli/core/agents.py
 boost_cli/core/ai.py
+boost_cli/core/aihost.py
 boost_cli/core/bmad.py
 boost_cli/core/bootstrap.py
 boost_cli/core/browse.py
@@ -202,6 +203,7 @@ docs/roadmap/items/accessibility-audit-pa11y-ci-axe-core.md
 docs/roadmap/items/actionlint-skips-shellcheck-silently.md
 docs/roadmap/items/adapter-conformance-langgraph-leg-never-ran.md
 docs/roadmap/items/agents-field-records-the-request-not-the-links.md
+docs/roadmap/items/ai-backend-fanout.md
 docs/roadmap/items/ai-bridge-silent-failure-logging.md
 docs/roadmap/items/ambiguous-tap-short-name-resolution.md
 docs/roadmap/items/atomic-corruption-safe-lock-file-writes.md
@@ -637,6 +639,7 @@ tests/unit/test_adapters_multi.py
 tests/unit/test_adapters_runner.py
 tests/unit/test_agents.py
 tests/unit/test_ai.py
+tests/unit/test_aihost.py
 tests/unit/test_bmad_core.py
 tests/unit/test_boost_first_offer.py
 tests/unit/test_bootstrap.py

boost_skill_cli-1.2.39/docs/roadmap/items/ai-backend-fanout.md

@@ -0,0 +1,42 @@
+---
+id: ai-backend-fanout
+board: code
+section: shipped
+status: shipped
+category: Agents · Parity
+complexity: S
+impact: High
+wow: 4
+note: the last surface that only spoke Claude — and the one a user can see
+order: 13
+owner: loop/ai-backends
+pr:
+title: A Gemini user got the heuristic fallback from every AI command
+---
+Skills, MCP, rules, workflows and hooks all fan out across agents. <code>core/ai.py</code>
+did not: it knew the <code>claude</code> CLI, or <code>ANTHROPIC_API_KEY</code>, and nothing
+else. So <code>explain</code>, <code>search --smart</code>, <code>distill</code>,
+<code>infer</code>, <code>absorb</code>, <code>evolve</code> and <code>simulate</code> all
+degraded to their heuristic fallbacks for a user running Gemini CLI — with a perfectly good
+assistant installed. <b>This was the last Claude-only surface, and the one a user actually
+sees</b>, because the difference between the two paths is the difference between synthesised
+prose and a structural summary.
+<code>core/aihost.py</code> is the table, built like <code>hookhost</code>: per-backend facts
+as data, testable without spending a token or running a subprocess. Three of those facts are
+differences that would otherwise be bugs. <b>Gemini has no
+<code>--append-system-prompt</code></b>, so the system text is folded into the prompt body —
+passing an unknown flag would make every call fail with a usage error rather than degrade,
+which is the one outcome worse than having no AI at all. <b><code>ai.model</code> holds a
+Claude id</b>, and <code>gemini -m claude-sonnet-4-5</code> is an error, not a fallback. And
+<b>Claude stays first</b>, which is behaviour rather than taste: anyone with both CLIs had
+Claude answering before this existed, and reordering would silently change every result.
+<b>An existing test caught a real regression.</b> The first model rule asked "does this backend
+own the id", which quietly dropped an explicit <code>--model m-x</code> override on Claude.
+<code>test_cli_explicit_model_and_timeout</code> went red and was right to. The corrected rule
+is <b>"not another vendor's"</b>, not "one of mine": an id no backend claims — a custom alias, a
+pinned snapshot — goes through untouched, and only an id another backend plainly owns is
+withheld.
+<b>Scoped honestly.</b> The direct-API path stays Anthropic-only; someone using Gemini CLI has
+the binary by definition, and a second HTTP client is a separate change with its own wire
+format and error taxonomy. The eval floors were measured against Claude, and the README now
+says so rather than implying the numbers describe every backend.

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/docs/roadmap.html

@@ -130,10 +130,10 @@
   <section class="block reveal">
     <div class="stats">
       <!-- ROADMAP:stats -->
-      <div class="stat"><b>18</b><span>Shipped</span></div>
+      <div class="stat"><b>19</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>7</b><span>Planned</span></div>
-      <div class="stat"><b>281</b><span>Loop finds</span></div>
+      <div class="stat"><b>282</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -465,6 +465,45 @@ had quietly stopped being true; it says what is actually so now.</p></details>
         </div>
       </article>
 
+      <article class="cap rcard" id="ai-backend-fanout">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · Parity</span></div>
+        <h3>A Gemini user got the heuristic fallback from every AI command</h3>
+        <details class="cardbody"><summary>Write-up</summary>
+        <p>Skills, MCP, rules, workflows and hooks all fan out across agents. <code>core/ai.py</code>
+did not: it knew the <code>claude</code> CLI, or <code>ANTHROPIC_API_KEY</code>, and nothing
+else. So <code>explain</code>, <code>search --smart</code>, <code>distill</code>,
+<code>infer</code>, <code>absorb</code>, <code>evolve</code> and <code>simulate</code> all
+degraded to their heuristic fallbacks for a user running Gemini CLI — with a perfectly good
+assistant installed. <b>This was the last Claude-only surface, and the one a user actually
+sees</b>, because the difference between the two paths is the difference between synthesised
+prose and a structural summary.
+<code>core/aihost.py</code> is the table, built like <code>hookhost</code>: per-backend facts
+as data, testable without spending a token or running a subprocess. Three of those facts are
+differences that would otherwise be bugs. <b>Gemini has no
+<code>--append-system-prompt</code></b>, so the system text is folded into the prompt body —
+passing an unknown flag would make every call fail with a usage error rather than degrade,
+which is the one outcome worse than having no AI at all. <b><code>ai.model</code> holds a
+Claude id</b>, and <code>gemini -m claude-sonnet-4-5</code> is an error, not a fallback. And
+<b>Claude stays first</b>, which is behaviour rather than taste: anyone with both CLIs had
+Claude answering before this existed, and reordering would silently change every result.
+<b>An existing test caught a real regression.</b> The first model rule asked "does this backend
+own the id", which quietly dropped an explicit <code>--model m-x</code> override on Claude.
+<code>test_cli_explicit_model_and_timeout</code> went red and was right to. The corrected rule
+is <b>"not another vendor's"</b>, not "one of mine": an id no backend claims — a custom alias, a
+pinned snapshot — goes through untouched, and only an id another backend plainly owns is
+withheld.
+<b>Scoped honestly.</b> The direct-API path stays Anthropic-only; someone using Gemini CLI has
+the binary by definition, and a second HTTP client is a separate change with its own wire
+format and error taxonomy. The eval floors were measured against Claude, and the README now
+says so rather than implying the numbers describe every backend.</p></details>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★★</b></span>
+          <span class="m">the last surface that only spoke Claude — and the one a user can see</span>
+        </div>
+      </article>
+
       <article class="cap rcard" id="reuse-helpers-kill-minor-dead-work">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Tech-debt</span></div>
         <h3>Reuse helpers; kill minor dead work</h3>

boost_skill_cli-1.2.39/tests/unit/test_aihost.py

@@ -0,0 +1,109 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: GPL-3.0-only
+"""The AI bridge must reach whichever assistant CLI the user actually has.
+
+`core/ai.py` knew one backend: the `claude` CLI, or ANTHROPIC_API_KEY. Every
+AI-assisted command -- `explain`, `search --smart`, `distill`, `infer`,
+`absorb`, `evolve`, `simulate` -- therefore degraded to its heuristic fallback
+for someone running Gemini CLI, even though Gemini exposes the same headless
+contract (`-p`, `-m`, `-o text`). Skills, MCP, rules, workflows and hooks all
+fan out across hosts; this was the last surface that did not, and it is the one
+a user notices, because the fallback is visibly worse prose.
+
+The table lives apart from the calling code for the same reason `hookhost` does:
+a per-backend fact is data, and a test can assert on data without running a
+subprocess or spending a token.
+"""
+from __future__ import annotations
+
+import pytest
+
+from boost_cli.core import aihost
+
+
+class TestTable:
+    def test_claude_is_first(self):
+        """Preference order is behaviour: Claude must keep winning.
+
+        Someone with both CLIs installed had Claude answering before this
+        existed. Reordering would silently change every AI result they get.
+        """
+        assert aihost.backends()[0] == aihost.CLAUDE
+
+    def test_every_backend_is_complete(self):
+        for name in aihost.backends():
+            spec = aihost.spec(name)
+            assert spec["cli"], name
+            assert spec["prompt_flag"], name
+            assert spec["label"], name
+
+    def test_unknown_backend_names_the_alternatives(self):
+        with pytest.raises(Exception) as e:
+            aihost.spec("copilot")
+        # BoostError keeps the actionable half in `hint`, not in str(); a test
+        # that only reads str() would pass on an error with no way forward.
+        hint = getattr(e.value, "hint", "") or ""
+        assert "claude" in hint and "gemini" in hint, hint
+
+
+class TestArgv:
+    def test_claude_argv_is_byte_for_byte_what_it_always_was(self):
+        """The existing command line is a contract; a refactor must not move it."""
+        argv = aihost.argv(aihost.CLAUDE, model="sonnet", system="SYS")
+        assert argv[:2] == ["claude", "-p"]
+        assert "--model" in argv and "sonnet" in argv
+        assert "--output-format" in argv and "text" in argv
+        assert "--append-system-prompt" in argv and "SYS" in argv
+
+    def test_gemini_argv_uses_its_own_flags(self):
+        argv = aihost.argv(aihost.GEMINI, model=None, system=None)
+        assert argv[0] == "gemini"
+        assert "-p" in argv
+        assert "-o" in argv and "text" in argv
+
+    def test_a_backend_without_a_system_flag_never_invents_one(self):
+        """Gemini has no --append-system-prompt; the caller must fold it in.
+
+        Passing an unknown flag would make every call fail with a usage error
+        rather than degrade, which is the one outcome worse than no AI at all.
+        """
+        argv = aihost.argv(aihost.GEMINI, model=None, system="SYS")
+        assert "--append-system-prompt" not in argv
+        assert "SYS" not in argv
+
+    def test_a_claude_model_id_is_never_handed_to_gemini(self):
+        """`ai.model` defaults to a Claude id; passing it to gemini is an error."""
+        argv = aihost.argv(aihost.GEMINI, model="claude-sonnet-4-5", system=None)
+        assert "claude-sonnet-4-5" not in argv
+
+
+class TestFolding:
+    def test_system_is_folded_into_the_prompt_when_unsupported(self):
+        folded = aihost.fold_system(aihost.GEMINI, "SYS", "ASK")
+        assert "SYS" in folded and "ASK" in folded
+        assert folded.index("SYS") < folded.index("ASK")
+
+    def test_system_is_left_alone_when_the_backend_takes_a_flag(self):
+        assert aihost.fold_system(aihost.CLAUDE, "SYS", "ASK") == "ASK"
+
+
+class TestModelRule:
+    """"Not another vendor's", not "one of mine" — an override must survive."""
+
+    def test_an_unknown_id_reaches_the_backend(self):
+        """A custom alias or pinned snapshot is the user's business, not ours.
+
+        The first version of this rule asked "does this backend own the id",
+        which silently dropped `--model m-x` on Claude. An existing test caught
+        it; this pins the corrected rule.
+        """
+        assert aihost.accepts_model(aihost.CLAUDE, "m-x") is True
+        assert "m-x" in aihost.argv(aihost.CLAUDE, model="m-x", system=None)
+
+    def test_another_vendors_id_is_withheld(self):
+        assert aihost.accepts_model(aihost.GEMINI, "claude-sonnet-4-5") is False
+        assert aihost.accepts_model(aihost.CLAUDE, "gemini-2.5-pro") is False
+
+    def test_its_own_id_is_accepted(self):
+        assert aihost.accepts_model(aihost.GEMINI, "gemini-2.5-pro") is True
+        assert aihost.accepts_model(aihost.CLAUDE, "claude-opus-4") is True

{boost_skill_cli-1.2.38 → boost_skill_cli-1.2.39}/tests/unit/test_mutation_hardening.py

@@ -13,7 +13,16 @@ from datetime import UTC, datetime, timedelta
 
 import pytest
 
-from boost_cli.core import ai, catalog, frontmatter, gitutil, journal, store, util
+from boost_cli.core import (
+    ai,
+    aihost,
+    catalog,
+    frontmatter,
+    gitutil,
+    journal,
+    store,
+    util,
+)
 from boost_cli.core import output as out
 from boost_cli.errors import BoostError
 
@@ -82,9 +91,23 @@ class TestExactStrings:
     """Kills string-literal mutants in user-facing messages."""
 
     def test_ai_fallback_note_verbatim(self):
+        # The note names every CLI that would work, built from `aihost`'s
+        # table rather than hardcoded: telling a Gemini user to install Claude
+        # is a worse answer than saying boost could not find either. Still
+        # asserted verbatim, because the point of this class is to kill
+        # string-literal mutants in what the user actually reads.
         assert ai.fallback_note() == (
-            "AI features need the `claude` CLI on PATH or ANTHROPIC_API_KEY "
-            "set — using the heuristic fallback")
+            "AI features need one of `claude` or `gemini` on PATH, or "
+            "ANTHROPIC_API_KEY set — using the heuristic fallback")
+
+    def test_fallback_note_names_every_backend(self):
+        """A backend added to the table must appear in the note, not silently.
+
+        The verbatim assertion above would still pass if the note were
+        hardcoded; this one fails if the sentence stops being derived.
+        """
+        for name in aihost.backends():
+            assert "`%s`" % aihost.cli(name) in ai.fallback_note(), name
 
     def test_missing_git_hint_verbatim(self, monkeypatch):
         monkeypatch.setattr(gitutil.shutil, "which", lambda _: None)