boost-skill-cli 1.0.309__tar.gz → 1.0.311__tar.gz

{boost_skill_cli-1.0.309/boost_skill_cli.egg-info → boost_skill_cli-1.0.311}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.309
+Version: 1.0.311
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -956,9 +956,17 @@ A host whose CLI isn't installed is skipped, not an error — name it explicitly
 
 Six tools are exposed: `boost_search`, `boost_list`, `boost_info`,
 `boost_install`, `boost_doctor`, and `boost_discover_github`. The server also
-returns MCP `instructions`, which both hosts load into the model's context — it
-tells the agent *when* boost is relevant, so a matching skill gets found at the
-start of a task rather than after the work is already reconstructed by hand.
+returns MCP `instructions`, which tell the agent *when* boost is relevant, so a
+matching skill gets found at the start of a task rather than after the work is
+already reconstructed by hand.
+
+The two hosts place those instructions differently, and it matters. Claude Code
+loads them as server instructions in the system prompt. Gemini CLI appends them
+to its **memory tier** alongside `GEMINI.md`, and only in a trusted folder — so
+outside one they are dropped silently. Each tool's own description therefore
+repeats its trigger rather than relying on the server text, because a tool
+description is the only part that is always in context at the moment the agent
+chooses a tool.
 
 Verify the wiring with `claude mcp list` or `gemini mcp list` — boost should show
 as **Connected**. (Gemini only connects stdio servers in a trusted folder; run

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/README.md

@@ -238,9 +238,17 @@ A host whose CLI isn't installed is skipped, not an error — name it explicitly
 
 Six tools are exposed: `boost_search`, `boost_list`, `boost_info`,
 `boost_install`, `boost_doctor`, and `boost_discover_github`. The server also
-returns MCP `instructions`, which both hosts load into the model's context — it
-tells the agent *when* boost is relevant, so a matching skill gets found at the
-start of a task rather than after the work is already reconstructed by hand.
+returns MCP `instructions`, which tell the agent *when* boost is relevant, so a
+matching skill gets found at the start of a task rather than after the work is
+already reconstructed by hand.
+
+The two hosts place those instructions differently, and it matters. Claude Code
+loads them as server instructions in the system prompt. Gemini CLI appends them
+to its **memory tier** alongside `GEMINI.md`, and only in a trusted folder — so
+outside one they are dropped silently. Each tool's own description therefore
+repeats its trigger rather than relying on the server text, because a tool
+description is the only part that is always in context at the moment the agent
+chooses a tool.
 
 Verify the wiring with `claude mcp list` or `gemini mcp list` — boost should show
 as **Connected**. (Gemini only connects stdio servers in a trusted folder; run

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.309'
-__version_tuple__ = version_tuple = (1, 0, 309)
+__version__ = version = '1.0.311'
+__version_tuple__ = version_tuple = (1, 0, 311)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/boost_cli/commands/configuration.py

@@ -937,16 +937,24 @@ def _tool_discover_github(args: dict):
                      for h in hits), False
 
 
+# These descriptions do more work than they look like they should. Gemini CLI
+# appends a server's `initialize` instructions to the GEMINI.md *memory* tier
+# (McpClientManager.getMcpInstructions -> categorizeMemoryContents), gated on
+# folder trust — so that block reads as background documentation, sits far from
+# the decision point, and vanishes entirely in an untrusted folder. The function
+# declarations are the only boost text reliably in context at the moment an
+# agent chooses a tool, so each one repeats the trigger, the cost and the
+# miss protocol rather than deferring to the server instructions.
 REGISTRY.register(
     "boost_search",
-    "Find an existing, installable skill instead of improvising one. Reach for "
-    "this at two moments: (1) when starting non-trivial work — check whether a "
-    "vetted skill already covers the task before planning it yourself; (2) as "
-    "the FIRST STOP before writing a skill, subagent, slash-command, rule, or "
-    "any reusable block of agent instructions from scratch. Searches thousands "
-    "of curated AI-agent skills across the configured registries and returns "
-    "ranked matches you can install in one call — don't reinvent one that "
-    "already exists.",
+    "Check whether someone already wrote down how to do this. Searches "
+    "thousands of vetted, installable AI-agent skills across the configured "
+    "registries and returns ranked matches. Worth one call whenever the task "
+    "in front of you has a name you could say out loud — \"set up code "
+    "review\", \"add commit conventions\", \"debug flaky tests\" — and before "
+    "writing a skill, subagent, slash-command or rule from scratch. Read-only, "
+    "no side effects, installs nothing. Returning nothing relevant is a fine "
+    "answer: it means build it yourself.",
     {"type": "object",
      "properties": {"query": {"type": "string",
                               "description": "what the skill should do (a task, "
@@ -955,17 +963,18 @@ REGISTRY.register(
     _tool_search)
 REGISTRY.register(
     "boost_list",
-    "List the skills already installed and usable right now. Check at the "
-    "START of a task to leverage a capability you already have — an installed "
-    "skill is a vetted procedure you can follow immediately, at no cost — and "
-    "again before installing, to avoid duplicating something you have.",
+    "The skills already installed on this machine and usable right now — "
+    "capability you have but may not know about. Read-only, instant, installs "
+    "nothing. Worth a call at the start of any task that will take more than a "
+    "few steps, before planning it from memory.",
     {"type": "object", "properties": {}},
     _tool_list)
 REGISTRY.register(
     "boost_info",
-    "Vet a skill before installing it: its description, source tap, version and "
-    "declared capabilities. Use after boost_search to decide whether a candidate "
-    "fits before boost_install.",
+    "Look up one skill by name: description, source tap, version, and whether "
+    "it is already installed. Use it when you have a name from somewhere else "
+    "and want the details. You do not need this between a search and an "
+    "install — boost_search already returns each match's description.",
     {"type": "object",
      "properties": {"name": {"type": "string", "description": "skill name"}},
      "required": ["name"]},

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/boost_cli/core/mcp.py

@@ -85,52 +85,50 @@ PROTOCOL_VERSION = "2024-11-05"
 # is relevant — the difference between a search tool that sits unused and one an
 # agent reaches for. Framed by the agent's triggers, not boost's nouns.
 #
-# It declares TWO triggers, and the first exists because the second alone was
-# not enough. Framed only as "before you author a skill", agents reached for
-# boost exclusively when they were already about to write one — which is the
-# rarer moment. The common one is starting ordinary work that an installed or
-# installable skill already covers, and nothing was telling them to look. The
-# closing proportion note is load-bearing in the other direction: an unbounded
-# "always check first" turns every trivial turn into a tool call, and an agent
-# that learns to ignore the guidance ignores all of it.
+# ONE benefit, stated once: find a skill for the task in front of you. Earlier
+# passes gave equal billing to "before you author a skill", and that cost more
+# than it bought — authoring is the rarer moment, and an agent handed two
+# triggers matches the one it can recognise fastest, which was the wrong one.
+# Authoring now lives as a clause on boost_search's own description.
+#
+# The trigger is observable rather than a judgement call. "Before non-trivial
+# work" lost to its own escape hatch every time: deciding a task is non-trivial
+# takes judgement, while "this turn looks small" is free, and every turn looks
+# small when it opens. Whether the task has a NAME can be pattern-matched
+# without deciding anything, and a named task is exactly the kind someone has
+# already written down.
+#
+# Three things below are load-bearing, not padding. The stated COST kills the
+# hesitation over an unknown-price call. The MISS PROTOCOL stops a zero-result
+# search reading as a wasted turn — without it one empty search teaches an agent
+# to stop checking. And "the task stays yours" is what makes an agent willing to
+# look at all: one that expects a hit to seize the work is safer not looking.
+# The closing bound names concrete shapes instead of the word "trivial", which
+# an unbounded "always check first" needs or the guidance gets ignored wholesale.
 INSTRUCTIONS = (
-    "boost is a package manager for AI-agent skills: reusable, version-tracked "
-    "capabilities (skills, rules, slash-commands, subagents) from curated "
-    "registries.\n"
-    "\n"
-    "Three moments make boost relevant. The first is the one usually missed:\n"
-    "\n"
-    "1. STARTING A TASK. Before doing non-trivial work — building a feature, "
-    "setting up tooling or CI, reviewing code, debugging a class of problem, "
-    "writing docs — stop and check whether a skill already covers it. Call "
-    "boost_list for what is installed and usable right now, and boost_search "
-    "for what could be. A matching skill is a procedure someone already got "
-    "right and vetted; following it beats reconstructing the same steps from "
-    "memory.\n"
+    "boost is a shared shelf of vetted, version-tracked skills for AI coding "
+    "agents — procedures someone already worked out, ready to follow.\n"
     "\n"
-    "2. AUTHORING. Before you write a new skill, subagent, slash-command, "
-    "rule, or any reusable block of agent instructions — or when the user "
-    "describes a repeatable workflow (\"set up code review\", \"add a commit "
-    "convention\") — call boost_search FIRST to check whether a vetted one "
-    "already exists. Installing beats hand-writing: an installed skill is "
-    "version-pinned, wired into every agent on this machine, policy-governed, "
-    "and shareable with the team.\n"
+    "THE CHECK: if the task in front of you has a name — \"set up code "
+    "review\", \"add commit conventions\", \"write a migration\", \"debug "
+    "flaky tests\" — someone has probably already written it down. Call "
+    "boost_list for what is installed on this machine and boost_search for "
+    "what exists. Both are read-only, take about a second, and install "
+    "nothing.\n"
     "\n"
-    "3. SCOPE GROWTH. A turn that began trivial and grew is still a task "
-    "start — it just did not look like one at the time. When a question "
-    "becomes an investigation, a one-line fix becomes a refactor, or a quick "
-    "check turns into hours of work, run the check at the moment the scope "
-    "changes rather than treating the original framing as settled. The most "
-    "expensive misses are the tasks nobody checked because they were not "
-    "tasks when they began.\n"
+    "Finding nothing is a good outcome, not a wasted call: it tells you to "
+    "build it yourself, now knowing that nothing already covers it. Finding "
+    "something is a head start, not an instruction — read it, take what fits, "
+    "discard the rest. The task stays yours.\n"
     "\n"
-    "Typical flow: boost_search -> boost_info -> boost_install. Only build "
-    "from scratch when a search turns up nothing relevant.\n"
+    "Two moments beat the odds: the first step of anything that will take more "
+    "than a few steps, and the moment a small task turns out to be a large "
+    "one. The second matters because the first only fires at a boundary you "
+    "recognized at the time — a question that became an investigation never "
+    "got one.\n"
     "\n"
-    "Proportion: skip the check for trivial or one-off turns — answering a "
-    "question, a small edit, running a command you were just handed. Checking "
-    "once when a task starts, or when it grows into one, is the habit; "
-    "checking before every tool call is noise."
+    "Flow: boost_search -> boost_install. Skip it for a question, a one-line "
+    "edit, or a command you were just handed."
 )
 
 

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.309
+Version: 1.0.311
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -956,9 +956,17 @@ A host whose CLI isn't installed is skipped, not an error — name it explicitly
 
 Six tools are exposed: `boost_search`, `boost_list`, `boost_info`,
 `boost_install`, `boost_doctor`, and `boost_discover_github`. The server also
-returns MCP `instructions`, which both hosts load into the model's context — it
-tells the agent *when* boost is relevant, so a matching skill gets found at the
-start of a task rather than after the work is already reconstructed by hand.
+returns MCP `instructions`, which tell the agent *when* boost is relevant, so a
+matching skill gets found at the start of a task rather than after the work is
+already reconstructed by hand.
+
+The two hosts place those instructions differently, and it matters. Claude Code
+loads them as server instructions in the system prompt. Gemini CLI appends them
+to its **memory tier** alongside `GEMINI.md`, and only in a trusted folder — so
+outside one they are dropped silently. Each tool's own description therefore
+repeats its trigger rather than relying on the server text, because a tool
+description is the only part that is always in context at the moment the agent
+chooses a tool.
 
 Verify the wiring with `claude mcp list` or `gemini mcp list` — boost should show
 as **Connected**. (Gemini only connects stdio servers in a trusted folder; run

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/boost_skill_cli.egg-info/SOURCES.txt

@@ -251,6 +251,7 @@ docs/roadmap/items/mcp-check-skills-before-starting-a-task.md
 docs/roadmap/items/mcp-hub-diagram-node-text-overflow.md
 docs/roadmap/items/mcp-install-skips-the-injection-scan.md
 docs/roadmap/items/mcp-launch-objc-fork-safety.md
+docs/roadmap/items/mcp-one-benefit-nameable-task.md
 docs/roadmap/items/mcp-register-names-server-before-env.md
 docs/roadmap/items/mcp-search-before-reinventing.md
 docs/roadmap/items/mcp-servers-ignore-install-scope.md

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/docs/roadmap/items/keyless-semantic-search-for-everyone.md

@@ -130,6 +130,27 @@ not reproduce here, though import cost is genuinely machine- and version-depende
 may be real on theirs. 233&nbsp;ms is also very likely <i>faster</i> than the Voyage round trip it
 sits beside, and it is paid only by users who installed the extra.
 
+<b>If step 6 is the tie-break, it needs a method and not just a number.</b> The sibling item already
+produced one cautionary result worth inheriting rather than repeating: its own headline, <b>+11.0
+recall / +15.9 hit@1</b>, did not survive verification. Three failures, none specific to a static
+model, all reachable from here. Its baseline used a kind oracle the live search path does not have,
+so the comparison was never against what a user experiences. The blend weight
+(<code>w_dense=0.7</code>) <em>and</em> the rerank pool depth were both tuned by argmax on the same
+82 queries they were then reported on &mdash; fitting and reporting on one set. And at n=82 on a
+binary metric, the smallest net win reaching <em>p</em>&lt;0.05 is <b>6 queries</b>: its
+<code>hit@1</code> (+13 net) clears that bar, while recall (+9) sits at the resolution floor and
+should not have led.
+
+So four constraints on step 6, whichever backend wins. Report <b>McNemar</b> on paired per-query
+outcomes rather than two independent-looking averages, since the engines are scored on the same
+queries. Hold the blend weight and pool depth <b>out</b> of the query set they are scored on. Lead
+with <code>hit@1</code> &mdash; on a golden set this size, recall moves inside its own noise. And
+measure each engine <b>alone</b> before any fusion, so a hybrid win cannot be quietly credited to
+the embedder that did not earn it. One structural caveat also transfers: a skill's name is only
+~10.5% of a mean-pooled surface vector while 106 description clusters are shared across 270 distinct
+names, so a lift measured on today's corpus may <em>shrink</em> rather than hold as the index grows
+toward 50k items &mdash; an argument for re-measuring at scale before believing any of this.
+
 The static approach still wins on cost and would win outright if the quality gap is small &mdash;
 which is exactly what the eval should decide. Its own card is right that neither should ship a
 retrieval <i>claim</i> before that eval exists.

boost_skill_cli-1.0.311/docs/roadmap/items/mcp-one-benefit-nameable-task.md

@@ -0,0 +1,44 @@
+---
+id: mcp-one-benefit-nameable-task
+board: code
+section: dx
+status: inflight
+category: Interop · Adoption
+complexity: S
+impact: High
+wow: 3
+note: agent reflex
+order: 74
+owner: loop/mcp-nameable-task
+pr: 355
+title: MCP — one benefit, one observable trigger (and stop routing through boost_info)
+---
+Gemini CLI used the boost MCP server only when asked by hand, never on its own.
+Two causes, and neither was fixed by writing more instructions.
+<strong>Placement:</strong> Gemini appends a server's <code>initialize</code>
+<code>instructions</code> to the <em>GEMINI.md memory tier</em>
+(<code>getMcpInstructions</code> → <code>categorizeMemoryContents</code>), gated on
+folder trust — so the block reads as background documentation, sits far from the
+tool-call decision, and is dropped entirely in an untrusted folder. Claude Code puts
+the same text in the system prompt, which is why the gap only showed on Gemini. The
+tool descriptions are the only boost text reliably in context at the decision point,
+so each now repeats the trigger, the cost and the miss protocol instead of deferring
+upward. <strong>Wording:</strong> <a href="#mcp-check-skills-before-starting-a-task">the
+previous pass</a> declared three triggers bounded by a proportionality note, and the
+bound beat the triggers every time — judging work "non-trivial" takes judgement, while
+"this turn looks small" is free, and every turn looks small when it opens. Collapse to
+<strong>one</strong> benefit (find a skill for the task in front of you) and
+<strong>one observable</strong> trigger (<em>does the task have a name?</em>), which an
+agent can pattern-match without deciding anything. Authoring drops from co-equal
+trigger to a clause on <code>boost_search</code> — it is the rarer moment and it was
+crowding out the common one. Three additions are load-bearing, not padding: the stated
+<em>cost</em> (read-only, ~1s, installs nothing) kills the unknown-price hesitation; the
+<em>miss protocol</em> ("finding nothing is a good outcome") stops one empty search
+teaching an agent to quit checking; and "the task stays yours" is what makes an agent
+willing to look, since one that expects a hit to seize the work is safer not looking.
+Finally, drop <code>boost_info</code> from the advertised flow — <code>boost_search</code>
+already returns each hit's description, the only field that changes an install decision,
+so the hop bought a round-trip and a decision point and nothing else. It stays registered
+for looking up a name from elsewhere, and its description now says so. All of it is
+pinned by tests, including negative assertions so authoring and the info hop cannot
+creep back.

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/docs/roadmap.html

@@ -111,7 +111,7 @@
       <div class="stat"><b>16</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>187</b><span>Loop finds</span></div>
+      <div class="stat"><b>188</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -718,6 +718,27 @@ not reproduce here, though import cost is genuinely machine- and version-depende
 may be real on theirs. 233&nbsp;ms is also very likely <i>faster</i> than the Voyage round trip it
 sits beside, and it is paid only by users who installed the extra.
 
+<b>If step 6 is the tie-break, it needs a method and not just a number.</b> The sibling item already
+produced one cautionary result worth inheriting rather than repeating: its own headline, <b>+11.0
+recall / +15.9 hit@1</b>, did not survive verification. Three failures, none specific to a static
+model, all reachable from here. Its baseline used a kind oracle the live search path does not have,
+so the comparison was never against what a user experiences. The blend weight
+(<code>w_dense=0.7</code>) <em>and</em> the rerank pool depth were both tuned by argmax on the same
+82 queries they were then reported on &mdash; fitting and reporting on one set. And at n=82 on a
+binary metric, the smallest net win reaching <em>p</em>&lt;0.05 is <b>6 queries</b>: its
+<code>hit@1</code> (+13 net) clears that bar, while recall (+9) sits at the resolution floor and
+should not have led.
+
+So four constraints on step 6, whichever backend wins. Report <b>McNemar</b> on paired per-query
+outcomes rather than two independent-looking averages, since the engines are scored on the same
+queries. Hold the blend weight and pool depth <b>out</b> of the query set they are scored on. Lead
+with <code>hit@1</code> &mdash; on a golden set this size, recall moves inside its own noise. And
+measure each engine <b>alone</b> before any fusion, so a hybrid win cannot be quietly credited to
+the embedder that did not earn it. One structural caveat also transfers: a skill's name is only
+~10.5% of a mean-pooled surface vector while 106 description clusters are shared across 270 distinct
+names, so a lift measured on today's corpus may <em>shrink</em> rather than hold as the index grows
+toward 50k items &mdash; an argument for re-measuring at scale before believing any of this.
+
 The static approach still wins on cost and would win outright if the quality gap is small &mdash;
 which is exactly what the eval should decide. Its own card is right that neither should ship a
 retrieval <i>claim</i> before that eval exists.</p>
@@ -3914,6 +3935,46 @@ open: <code>zizmor</code> and <code>gitleaks</code> run only in CI and have no M
           <span class="m">fixed — shellcheck is pinned in lint-tools and both gates now assert it is there</span>
         </div>
       </article>
+
+      <article class="cap rcard" id="mcp-one-benefit-nameable-task">
+        <div class="head"><span class="pill inflight">In flight</span><span class="cat">Interop · Adoption</span></div>
+        <h3>MCP — one benefit, one observable trigger (and stop routing through boost_info)</h3>
+        <p>Gemini CLI used the boost MCP server only when asked by hand, never on its own.
+Two causes, and neither was fixed by writing more instructions.
+<strong>Placement:</strong> Gemini appends a server's <code>initialize</code>
+<code>instructions</code> to the <em>GEMINI.md memory tier</em>
+(<code>getMcpInstructions</code> → <code>categorizeMemoryContents</code>), gated on
+folder trust — so the block reads as background documentation, sits far from the
+tool-call decision, and is dropped entirely in an untrusted folder. Claude Code puts
+the same text in the system prompt, which is why the gap only showed on Gemini. The
+tool descriptions are the only boost text reliably in context at the decision point,
+so each now repeats the trigger, the cost and the miss protocol instead of deferring
+upward. <strong>Wording:</strong> <a href="#mcp-check-skills-before-starting-a-task">the
+previous pass</a> declared three triggers bounded by a proportionality note, and the
+bound beat the triggers every time — judging work "non-trivial" takes judgement, while
+"this turn looks small" is free, and every turn looks small when it opens. Collapse to
+<strong>one</strong> benefit (find a skill for the task in front of you) and
+<strong>one observable</strong> trigger (<em>does the task have a name?</em>), which an
+agent can pattern-match without deciding anything. Authoring drops from co-equal
+trigger to a clause on <code>boost_search</code> — it is the rarer moment and it was
+crowding out the common one. Three additions are load-bearing, not padding: the stated
+<em>cost</em> (read-only, ~1s, installs nothing) kills the unknown-price hesitation; the
+<em>miss protocol</em> ("finding nothing is a good outcome") stops one empty search
+teaching an agent to quit checking; and "the task stays yours" is what makes an agent
+willing to look, since one that expects a hit to seize the work is safer not looking.
+Finally, drop <code>boost_info</code> from the advertised flow — <code>boost_search</code>
+already returns each hit's description, the only field that changes an install decision,
+so the hop bought a round-trip and a decision point and nothing else. It stays registered
+for looking up a name from elsewhere, and its description now says so. All of it is
+pinned by tests, including negative assertions so authoring and the info hop cannot
+creep back.</p>
+        <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">agent reflex</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/tests/functional/test_cli_configuration.py

@@ -878,24 +878,32 @@ class TestMcp:
         assert configuration._mcp_tool("nonexistent_tool", {}) == (None, False)
 
     def test_tool_descriptions_are_intent_framed(self, sandbox):
-        # the descriptions must tell an agent WHEN to reach for boost (before
-        # reinventing), not just what each tool does — the discoverability fix.
+        # The descriptions must tell an agent WHEN to reach for boost, not just
+        # what each tool does. On Gemini CLI these carry the whole load: it
+        # appends server `instructions` to the GEMINI.md memory tier, so the
+        # function declarations are the only boost text in context at the
+        # moment the tool-call decision is actually made.
         from boost_cli.commands import configuration
         specs = {s["name"]: s["description"].lower()
                  for s in configuration.REGISTRY.specs()}
-        # search carries BOTH triggers: starting a task, and authoring. The
-        # second alone is why the tool sat unused for ordinary work.
-        assert "starting non-trivial work" in specs["boost_search"]
-        assert "first stop before writing" in specs["boost_search"]
-        assert "reinvent" in specs["boost_search"]
-        # list is the cheap half of the task-start check — leverage what is
-        # already installed, not merely "avoid a duplicate install".
-        assert "start" in specs["boost_list"]
-        assert "leverage" in specs["boost_list"]
+        # search leads with the observable trigger and states its cost; a miss
+        # is named as a real outcome so it does not read as a wasted call.
+        assert "has a name" in specs["boost_search"]
+        assert "read-only" in specs["boost_search"]
+        assert "build it yourself" in specs["boost_search"]
+        # authoring survives ONLY here, as a clause — never as a co-equal
+        # trigger. Promoting it back cost boost its primary use once already.
+        assert "from scratch" in specs["boost_search"]
+        # list is the free half of the check — capability already on the box.
+        assert "installed" in specs["boost_list"]
+        assert "read-only" in specs["boost_list"]
+        assert "more than a few steps" in specs["boost_list"]
         # install points back at the search that should precede it
         assert "boost_search" in specs["boost_install"]
-        # info is framed as the vet-before-install step
-        assert "before" in specs["boost_info"] and "install" in specs["boost_info"]
+        # info is a name lookup, NOT a step between search and install. It has
+        # to say so, or an agent reinstates the hop the flow just dropped.
+        assert "by name" in specs["boost_info"]
+        assert "do not need this between a search and an install" in specs["boost_info"]
 
     def test_discover_github_missing_gh_degrades(self, sandbox, monkeypatch):
         from boost_cli.commands import configuration

{boost_skill_cli-1.0.309 → boost_skill_cli-1.0.311}/tests/unit/test_mcp.py

@@ -110,30 +110,53 @@ class TestHandleRequest:
 
     def test_initialize_returns_server_instructions(self):
         # MCP hosts load `instructions` into the agent's context — this is where
-        # boost earns the "search before reinventing" reflex.
+        # boost earns the "check for a skill before doing the work" reflex.
         resp = mcp.handle_request({"id": 1, "method": "initialize"},
                                   version="9.9.9", registry=_reg_with())
         instr = resp["result"]["instructions"]
         assert instr == mcp.INSTRUCTIONS
         low = instr.lower()
-        # THREE triggers must survive here. Authoring alone was the original
-        # framing and it under-fired: agents reached for boost only when about
-        # to write a skill, never to check whether one already covered the work
-        # in front of them. Dropping any trigger regresses that.
-        assert "starting a task" in low            # trigger 1: leverage first
-        assert "boost_list" in instr               # ...what is already installed
-        assert "before you write a new skill" in low   # trigger 2: authoring
-        assert "boost_search" in instr             # the concrete first action
-        assert "already exists" in low             # the "don't reinvent" frame
-        # Trigger 3 closes the hole the other two leave open: both fire at a
-        # recognized task boundary, so a turn that starts trivial and escalates
-        # is never re-evaluated. Observed in practice — a one-line question grew
-        # into hours of retrieval work and the check never fired, because the
-        # proportionality carve-out below had already excused the opening turn.
-        assert "scope growth" in low               # trigger 3: escalation
-        assert "grows into one" in low             # ...wired into Proportion
+        # ONE trigger, and it must be observable rather than a judgement call.
+        # "Non-trivial work" was the old framing and it lost to its own escape
+        # hatch: deciding a task is non-trivial takes judgement, while "this
+        # turn looks small" is free — and every turn looks small when it opens.
+        # A task having a NAME is something an agent can pattern-match without
+        # deciding anything.
+        assert "has a name" in low
+        assert "boost_list" in instr and "boost_search" in instr
+        # The cost has to be stated. An unknown-cost call with an unknown hit
+        # rate gets skipped, however good the pitch above it.
+        assert "read-only" in low
+        # ...as does the miss protocol. Without it a zero-result search reads as
+        # a wasted turn, so the next task skips the check to avoid repeating it.
+        assert "finding nothing" in low
+        # Non-capturing, and load-bearing rather than merely polite: an agent
+        # that expects a hit to seize the task is safer not looking.
+        assert "the task stays yours" in low
+        # Escalation still has to be caught — both other moments fire at a task
+        # boundary, so a turn that starts small and grows is never re-checked.
+        assert "turns out to be a large one" in low
         # ...and it must stay bounded, or an agent learns to ignore all of it.
-        assert "skip the check for trivial" in low
+        assert "skip it for a question" in low
+
+    def test_instructions_lead_with_using_a_skill_not_authoring_one(self):
+        # Authoring used to be a co-equal numbered trigger, which cost the
+        # instructions their point: boost's primary benefit is finding a skill
+        # for the task in front of you, and "am I about to write a skill?" is
+        # both rarer and a different question. It survives only as a clause on
+        # boost_search's own description, never as a trigger here.
+        low = mcp.INSTRUCTIONS.lower()
+        assert "before you write a new skill" not in low
+        assert "authoring" not in low
+
+    def test_instructions_route_search_straight_to_install(self):
+        # boost_info sat between search and install in the advertised flow, but
+        # search already returns each hit's description — the only field that
+        # changes an install decision — so the hop bought a round-trip and a
+        # decision point and nothing else. It stays a registered tool for
+        # looking up a name from elsewhere; it is not a step.
+        assert "boost_search -> boost_install" in mcp.INSTRUCTIONS
+        assert "boost_info" not in mcp.INSTRUCTIONS
 
     def test_protocol_version_constant(self):
         assert mcp.PROTOCOL_VERSION == "2024-11-05"