boost-skill-cli 1.2.63__tar.gz → 1.2.64__tar.gz

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/.gitignore

@@ -281,3 +281,10 @@ node_modules/
 # config). Written into the repo root by the language-server tooling, not by
 # boost, and specific to one developer's machine.
 .serena/
+
+# A SQLite artifact from a tool that passed ":memory:" as a path rather than as
+# the in-memory sentinel. Junk either way, and on Windows it is worse than junk:
+# a colon cannot appear in a filename there, so committing it makes `git
+# checkout` fail with exit 128 and every Windows CI job dies before it runs a
+# single test.
+:memory:*

{boost_skill_cli-1.2.63/boost_skill_cli.egg-info → boost_skill_cli-1.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.63
+Version: 1.2.64
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/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.63'
-__version_tuple__ = version_tuple = (1, 2, 63)
+__version__ = version = '1.2.64'
+__version_tuple__ = version_tuple = (1, 2, 64)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.63
+Version: 1.2.64
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/boost_skill_cli.egg-info/SOURCES.txt

@@ -592,6 +592,7 @@ tests/eval/recommend.jsonl
 tests/eval/taps-scale.txt
 tests/eval/taps.txt
 tests/eval/tool_calls.jsonl
+tests/eval/fixtures/claude_init_event.jsonl
 tests/functional/test_bmad_all_hosts.py
 tests/functional/test_capabilities_policy.py
 tests/functional/test_cli_adapt.py
@@ -719,6 +720,7 @@ tests/unit/test_eval_grading.py
 tests/unit/test_eval_metrics.py
 tests/unit/test_eval_stats_summary.py
 tests/unit/test_eval_tools.py
+tests/unit/test_eval_tools_probe.py
 tests/unit/test_failure_alerting_covers_unattended.py
 tests/unit/test_faithfulness.py
 tests/unit/test_frontmatter.py

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/docs/roadmap/items/tool-call-eval-tier.md

@@ -7,7 +7,7 @@ category: Quality · Eval
 complexity: L
 impact: High
 wow: 4
-note: Claude Code arm shipped in #616; the second host arm is unwritten and the card stays open for it
+note: the Claude Code probe was broken and its finding was an artifact; fixed, second host still unwritten
 owner:
 order: 96
 title: a Tier 3 eval for tool-call behaviour, floored in <b>both</b> directions
@@ -61,22 +61,44 @@ N runs per prompt with an interval rather than a single pass/fail, the way
 <code>golden-set-statistical-power</code> established for retrieval — a one-shot replay cannot tell
 a wording regression from a sampling wobble.
 
-<b>Where this stands (2026-08-30).</b> The Claude Code arm shipped in #616:
+<b>Where this stands (2026-08-31), and a correction.</b> The Claude Code arm shipped in #616:
 <code>scripts/eval_tools.py</code>, a 16-prompt set halved into should-call and should-NOT-call,
-Wilson intervals over N runs, and a verdict that floors call rate <em>and</em> ceilings false
-calls. Its first real run measured <b>3/3 false calls</b> &mdash; boost's tools fired on "What is
-the difference between a Python list and a tuple?", which the shipped skip list excuses by name.
-Call rate alone would have scored that a perfect 1.00, which is the whole argument for flooring
-both directions, now with a number behind it.
+Wilson intervals over N runs, and a verdict that floors call rate <em>and</em> ceilings false calls.
 
-<b>The card stays open because "per host, never averaged" is the binding requirement and only one
-host has been driven.</b> Gemini CLI is not installed on the machine this was built on, and its
-successor Antigravity CLI (<code>agy</code>, which boost already supports as its fifth agent
-target and which has boost registered) cannot be driven from a sandbox: it starts a local
-language server and dies on <code>listen tcp 127.0.0.1:0: bind: operation not permitted</code>.
-Shipping an arm for a host nobody drove would put a number next to a measurement that never
-happened &mdash; the exact unfalsifiable claim this tier exists to retire. The <code>owner</code>
-is cleared rather than left on a merged branch, so the second arm is claimable.
+<b>Its probe was broken, and the finding this card recorded was an artifact of it.</b> An earlier
+revision of this card reported &ldquo;3/3 false calls &mdash; boost's tools fired on <em>What is the
+difference between a Python list and a tuple?</em>&rdquo;. They did not fire. <code>called_boost()</code>
+substring-scanned the raw event stream, and <code>claude -p --output-format stream-json --verbose</code>
+opens with a <code>system</code>/<code>init</code> event enumerating <em>every tool available to the
+session</em> &mdash; which on any machine where boost is registered contains
+<code>mcp__boost__boost_search</code> and the other three CONSULT names. So the check returned
+<code>true</code> on every run, including runs with no tool call at all. Measured directly:
+<code>Say OK and nothing else.</code> produced zero <code>tool_use</code> blocks and scored as a
+boost consult.
+
+Two consequences shipped with it. <code>make eval-tools</code> could never pass &mdash; eight
+no-call rows &times; three runs is 24 forced trues, so the false-call rate's lower bound sat at
+1.00 against a 0.20 ceiling, red on every machine forever. And the tier built to retire
+unfalsifiable claims had produced one. <b>The lesson is the tier's own:</b> the existing tests
+passed because they fed hand-written one-line fragments with no <code>init</code> event &mdash; a
+fixture the author invented could not catch the author's wrong model of the input. The probe now
+parses the NDJSON and counts only <code>tool_use</code> blocks inside <code>assistant</code>
+events, and the regression test drives a <b>captured real stream</b>.
+
+<b>The second host arm is still unwritten, and should stay that way until the fixed probe is
+re-run.</b> Building arm two on a probe that cannot tell an offer from a call would produce two
+hosts scoring an identical, meaningless 1.00. When it is built, the candidate is <b>Gemini CLI
+proper</b>, not Antigravity CLI: the delivery claim below is about Gemini's Node bundle, and
+<code>agy</code> is a third mode again &mdash; it receives boost's <code>instructions</code> and
+writes them to <code>~/.gemini/antigravity-cli/mcp/boost/instructions.md</code>, pointing the agent
+at the file rather than inlining it. Substituting it would measure a different mechanism than the
+one this card argues about.
+
+<b>Cost, now measured.</b> Two trivial runs on a real host reported <code>$0.657</code> and
+<code>$0.682</code> of <code>total_cost_usd</code>, so 16 prompts &times; 3 runs is roughly
+<b>$30&ndash;50 per host per invocation</b> on a machine with a crowded tool surface.
+<code>--strict-mcp-config</code> with a boost-only config cuts that sharply and controls the
+surface confound in the same move.
 
 <b>What it unlocks.</b> The first honest answer to "did that description edit help", a baseline the
 next surface change can regress against, and a way to retire claims that survive only because

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/docs/roadmap.html

@@ -865,22 +865,44 @@ N runs per prompt with an interval rather than a single pass/fail, the way
 <code>golden-set-statistical-power</code> established for retrieval — a one-shot replay cannot tell
 a wording regression from a sampling wobble.
 
-<b>Where this stands (2026-08-30).</b> The Claude Code arm shipped in #616:
+<b>Where this stands (2026-08-31), and a correction.</b> The Claude Code arm shipped in #616:
 <code>scripts/eval_tools.py</code>, a 16-prompt set halved into should-call and should-NOT-call,
-Wilson intervals over N runs, and a verdict that floors call rate <em>and</em> ceilings false
-calls. Its first real run measured <b>3/3 false calls</b> &mdash; boost's tools fired on "What is
-the difference between a Python list and a tuple?", which the shipped skip list excuses by name.
-Call rate alone would have scored that a perfect 1.00, which is the whole argument for flooring
-both directions, now with a number behind it.
-
-<b>The card stays open because "per host, never averaged" is the binding requirement and only one
-host has been driven.</b> Gemini CLI is not installed on the machine this was built on, and its
-successor Antigravity CLI (<code>agy</code>, which boost already supports as its fifth agent
-target and which has boost registered) cannot be driven from a sandbox: it starts a local
-language server and dies on <code>listen tcp 127.0.0.1:0: bind: operation not permitted</code>.
-Shipping an arm for a host nobody drove would put a number next to a measurement that never
-happened &mdash; the exact unfalsifiable claim this tier exists to retire. The <code>owner</code>
-is cleared rather than left on a merged branch, so the second arm is claimable.
+Wilson intervals over N runs, and a verdict that floors call rate <em>and</em> ceilings false calls.
+
+<b>Its probe was broken, and the finding this card recorded was an artifact of it.</b> An earlier
+revision of this card reported &ldquo;3/3 false calls &mdash; boost's tools fired on <em>What is the
+difference between a Python list and a tuple?</em>&rdquo;. They did not fire. <code>called_boost()</code>
+substring-scanned the raw event stream, and <code>claude -p --output-format stream-json --verbose</code>
+opens with a <code>system</code>/<code>init</code> event enumerating <em>every tool available to the
+session</em> &mdash; which on any machine where boost is registered contains
+<code>mcp__boost__boost_search</code> and the other three CONSULT names. So the check returned
+<code>true</code> on every run, including runs with no tool call at all. Measured directly:
+<code>Say OK and nothing else.</code> produced zero <code>tool_use</code> blocks and scored as a
+boost consult.
+
+Two consequences shipped with it. <code>make eval-tools</code> could never pass &mdash; eight
+no-call rows &times; three runs is 24 forced trues, so the false-call rate's lower bound sat at
+1.00 against a 0.20 ceiling, red on every machine forever. And the tier built to retire
+unfalsifiable claims had produced one. <b>The lesson is the tier's own:</b> the existing tests
+passed because they fed hand-written one-line fragments with no <code>init</code> event &mdash; a
+fixture the author invented could not catch the author's wrong model of the input. The probe now
+parses the NDJSON and counts only <code>tool_use</code> blocks inside <code>assistant</code>
+events, and the regression test drives a <b>captured real stream</b>.
+
+<b>The second host arm is still unwritten, and should stay that way until the fixed probe is
+re-run.</b> Building arm two on a probe that cannot tell an offer from a call would produce two
+hosts scoring an identical, meaningless 1.00. When it is built, the candidate is <b>Gemini CLI
+proper</b>, not Antigravity CLI: the delivery claim below is about Gemini's Node bundle, and
+<code>agy</code> is a third mode again &mdash; it receives boost's <code>instructions</code> and
+writes them to <code>~/.gemini/antigravity-cli/mcp/boost/instructions.md</code>, pointing the agent
+at the file rather than inlining it. Substituting it would measure a different mechanism than the
+one this card argues about.
+
+<b>Cost, now measured.</b> Two trivial runs on a real host reported <code>$0.657</code> and
+<code>$0.682</code> of <code>total_cost_usd</code>, so 16 prompts &times; 3 runs is roughly
+<b>$30&ndash;50 per host per invocation</b> on a machine with a crowded tool surface.
+<code>--strict-mcp-config</code> with a boost-only config cuts that sharply and controls the
+surface confound in the same move.
 
 <b>What it unlocks.</b> The first honest answer to "did that description edit help", a baseline the
 next surface change can regress against, and a way to retire claims that survive only because
@@ -889,7 +911,7 @@ nobody can check them.</p>
           <span class="m">Complexity <b>L</b></span>
           <span class="m hi">Impact <b>High</b></span>
           <span class="m">Wow <b class="wow">★★★★</b></span>
-          <span class="m">Claude Code arm shipped in</span>
+          <span class="m">the Claude Code probe was broken and its finding was an artifact; fixed, second host still unwritten</span>
         </div>
       </article>
 

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/scripts/eval_tools.py

@@ -191,15 +191,76 @@ def verdict(metrics: dict, floor_call: float, ceiling_false: float) -> list[str]
 
 # ----------------------------------------------------------------- probe
 
+def iter_events(events: str):
+    """Yield the parsed NDJSON objects in a host's stream, skipping junk.
+
+    A stream carries non-JSON lines (warnings, a truncated tail on timeout), and
+    a context note must never fail the run it annotates, so bad lines are
+    skipped rather than raised.
+    """
+    for line in (events or "").splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            yield json.loads(line)
+        except ValueError:
+            continue
+
+
+def tool_calls(events: str) -> list[str]:
+    """Every tool this run actually invoked, in order.
+
+    A *call* is a `tool_use` block inside an `assistant` event. Nothing else
+    counts, and that distinction is the whole measurement.
+    """
+    names = []
+    for ev in iter_events(events):
+        if ev.get("type") != "assistant":
+            continue
+        content = (ev.get("message") or {}).get("content") or []
+        names.extend(b.get("name") or "" for b in content
+                     if isinstance(b, dict) and b.get("type") == "tool_use")
+    return names
+
+
 def called_boost(events: str) -> bool:
-    """Did this run's event stream contain a boost CONSULT tool call?
+    """Did this run actually invoke a boost CONSULT tool?
 
     Reads the host's own stream rather than the model's prose: an agent that
     says "let me check boost" and does not is a miss, and one that calls
-    without narrating is a hit. Substring matching on the bare tool name covers
-    every host's namespacing (`mcp__boost__boost_search`, `mcp_boost_…`).
+    without narrating is a hit.
+
+    **It must not substring-match the raw stream, and the first version did.**
+    `claude -p --output-format stream-json --verbose` opens with a
+    `system`/`init` event enumerating every tool available to the session — on
+    a machine where boost is registered that list contains
+    `mcp__boost__boost_search` and the other three CONSULT names, in every run,
+    including runs with no tool call at all. So the old check returned True
+    unconditionally: `Say OK and nothing else.` scored as a boost consult, and
+    the no-call ceiling could never be met on any machine boost was installed
+    on. `make eval-tools` was guaranteed red, and the one finding this tier had
+    produced was an artifact of its own probe.
+
+    A tool being *offered* is not a tool being *called*, so the parse looks for
+    the call. Matching stays on the bare suffix, which covers every host's
+    namespacing (`mcp__boost__boost_search`, `mcp_boost_…`, `boost/…`).
+    """
+    return any(any(t in name for t in CONSULT_TOOLS)
+               for name in tool_calls(events))
+
+
+def session_surface(events: str) -> tuple[int, int]:
+    """`(tools, mcp_servers)` the host offered this run, from its init event.
+
+    The confound the old probe hid rather than reported: call rate depends far
+    more on how crowded the tool surface is than on any wording edit, and the
+    init event has carried both counts all along.
     """
-    return any(name in events for name in CONSULT_TOOLS)
+    for ev in iter_events(events):
+        if ev.get("type") == "system" and ev.get("subtype") == "init":
+            return len(ev.get("tools") or []), len(ev.get("mcp_servers") or [])
+    return 0, 0
 
 
 def claude_available() -> bool:
@@ -250,6 +311,20 @@ def _print_context() -> None:
               "for rule + descriptions, not descriptions alone.")
 
 
+def _report_surface(tools: int, servers: int) -> None:
+    """How crowded the tool surface was — the other half of the context.
+
+    A call rate depends far more on how many tools competed for the slot than
+    on any wording edit, and the host's init event has carried both counts all
+    along. Printed, never subtracted: the honest move is to say what was in
+    scope, the same rule `_print_context` follows for rules.
+    """
+    if tools:
+        print("         host offered %d tool(s) across %d MCP server(s) this "
+              "run; a rate is for that surface, not for boost alone."
+              % (tools, servers))
+
+
 def _report(host: str, rows: list[dict], metrics: dict,
             reasons: list[str]) -> None:
     c, f = metrics["call_rate"], metrics["false_call_rate"]
@@ -318,12 +393,17 @@ def main(argv: list[str] | None = None) -> int:
         _print_context()
 
     observed: dict[str, list[bool]] = {}
+    surface = (0, 0)
     for r in rows:
         for _ in range(max(1, args.runs)):
             events = run_claude(r["prompt"], args.timeout)
             if events is None:
                 continue
+            if surface == (0, 0):
+                surface = session_surface(events)
             observed.setdefault(r["id"], []).append(called_boost(events))
+    if args.report_context:
+        _report_surface(*surface)
 
     metrics = score_host(rows, observed)
     reasons = verdict(metrics, args.floor_call, args.ceiling_false_call)

boost_skill_cli-1.2.64/tests/eval/fixtures/claude_init_event.jsonl

@@ -0,0 +1,2 @@
+{"type": "system", "subtype": "init", "tools": ["mcp__boost__boost_discover_github", "mcp__boost__boost_doctor", "mcp__boost__boost_info", "mcp__boost__boost_install", "mcp__boost__boost_list", "mcp__boost__boost_read", "mcp__boost__boost_search", "Read", "Bash", "Edit"], "mcp_servers": [{"name": "plugin:context7:context7", "status": "connected"}, {"name": "plugin:playwright:playwright", "status": "failed"}, {"name": "plugin:exa:exa", "status": "connected"}]}
+{"type": "assistant", "message": {"content": [{"type": "text", "text": "OK"}]}}

{boost_skill_cli-1.2.63 → boost_skill_cli-1.2.64}/tests/unit/test_eval_tools.py

@@ -207,28 +207,54 @@ class TestTheVerdictJudgesTheInterval:
         assert MOD.verdict(MOD.score_host(self.ROWS, {}), 0.60, 0.20)
 
 
+def _assistant_call(name: str) -> str:
+    """One `assistant` event carrying one `tool_use` block — a real call.
+
+    These fixtures used to be bare fragments like `{"name":"boost_search"}`,
+    which no host emits. That shape is why this class passed against a probe
+    that substring-scanned the raw stream and therefore answered True on every
+    run: the fixtures had no `system`/`init` event, so the tool *list* the real
+    host sends was never in the input under test. A fixture the author invented
+    cannot catch the author's wrong model of the input, and it did not.
+    `tests/unit/test_eval_tools_probe.py` now drives a captured real stream.
+    """
+    return json.dumps({"type": "assistant", "message": {"content": [
+        {"type": "tool_use", "name": name, "input": {}}]}})
+
+
 class TestTheProbeReadsTheHostNotTheProse:
     def test_a_tool_call_counts(self):
-        assert MOD.called_boost('{"type":"tool_use","name":"boost_search"}')
+        assert MOD.called_boost(_assistant_call("boost_search"))
 
     def test_a_host_prefixed_name_counts(self):
         # Hosts namespace MCP tools differently; matching the bare suffix keeps
         # one list correct across all of them.
-        for name in ("mcp__boost__boost_search", "mcp_boost_boost_search"):
-            assert MOD.called_boost('{"name":"%s"}' % name), name
+        for name in ("mcp__boost__boost_search", "mcp_boost_boost_search",
+                     "boost/boost_search"):
+            assert MOD.called_boost(_assistant_call(name)), name
+
+    def test_being_offered_a_tool_is_not_calling_it(self):
+        # The bug this class missed: the host's init event lists every
+        # available tool, so a stream with no call at all still names them.
+        init = json.dumps({"type": "system", "subtype": "init",
+                           "tools": ["mcp__boost__boost_search",
+                                     "mcp__boost__boost_list"]})
+        assert not MOD.called_boost(init)
 
     def test_narrating_a_check_without_making_one_is_a_miss(self):
         # An agent that says it will check and does not is a miss; the event
         # stream is the record, not the model's account of itself.
-        assert not MOD.called_boost(
-            '{"type":"text","text":"Let me check the skill registry first."}')
+        assert not MOD.called_boost(json.dumps(
+            {"type": "assistant", "message": {"content": [
+                {"type": "text",
+                 "text": "Let me check the skill registry with boost_search."}]}}))
 
     def test_installing_is_not_consulting(self):
         # `boost_install` is downstream of a decision already made. Counting it
         # would let a run that installed without looking score as a check.
         assert "boost_install" in MOD.BOOST_TOOLS
         assert "boost_install" not in MOD.CONSULT_TOOLS
-        assert not MOD.called_boost('{"name":"boost_install"}')
+        assert not MOD.called_boost(_assistant_call("boost_install"))
 
     def test_an_empty_stream_is_a_miss(self):
         assert not MOD.called_boost("")

boost_skill_cli-1.2.64/tests/unit/test_eval_tools_probe.py

@@ -0,0 +1,127 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: Apache-2.0
+"""Unit tests: the tool-call probe must tell an offer from a call.
+
+`scripts/eval_tools.py` scores whether an agent *called* boost. The first
+version answered that with `any(name in events for name in CONSULT_TOOLS)` — a
+substring scan of the whole stream — and it was wrong in the one direction that
+looks like a result.
+
+`claude -p --output-format stream-json --verbose` opens with a `system`/`init`
+event enumerating every tool available to the session. On any machine where
+boost is registered, that list contains `mcp__boost__boost_search` and the
+other three CONSULT names. So the scan matched on every run, including runs
+with no tool call at all, and `called_boost()` returned True unconditionally.
+
+Three things followed, and all three shipped:
+
+1. `make eval-tools` could never pass. Eight no-call rows x 3 runs = 24 forced
+   True, so the false-call rate's lower bound sat at 1.0 against a 0.20
+   ceiling — red on every machine, forever.
+2. The tier's one recorded finding — "boost's tools fired on 'What is the
+   difference between a Python list and a tuple?'" — was an artifact of its own
+   probe. Measured here: that prompt makes zero tool calls.
+3. The existing tests passed, because they fed hand-written one-line fixtures
+   that had no init event. They pinned substring behaviour against a stream
+   shape the real host does not emit.
+
+So the fixture below is **captured from a real `claude -p` run**, not written
+by hand, and its whole job is to assert False. A test whose input the author
+invented cannot catch an author's wrong model of the input.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "scripts" / "eval_tools.py"
+FIXTURE = ROOT / "tests" / "eval" / "fixtures" / "claude_init_event.jsonl"
+
+pytestmark = pytest.mark.skipif(
+    not SCRIPT.exists() or not FIXTURE.exists(),
+    reason="repo-root scripts/tests not reachable (e.g. mutation sandbox)")
+
+
+def _mod():
+    spec = importlib.util.spec_from_file_location("eval_tools_probe", SCRIPT)
+    m = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(m)
+    return m
+
+
+def _call(name: str) -> str:
+    return json.dumps({"type": "assistant", "message": {"content": [
+        {"type": "tool_use", "name": name, "input": {}}]}})
+
+
+class TestAnOfferIsNotACall:
+    """The captured stream. Zero tool calls, every boost tool name present."""
+
+    def test_the_fixture_really_does_advertise_the_boost_tools(self):
+        # Without this the next test could pass by the fixture being empty.
+        text = FIXTURE.read_text(encoding="utf-8")
+        for name in ("boost_search", "boost_list", "boost_info", "boost_read"):
+            assert name in text, name
+
+    def test_a_run_that_called_nothing_scores_false(self):
+        m = _mod()
+        assert m.called_boost(FIXTURE.read_text(encoding="utf-8")) is False
+
+    def test_and_reports_no_tool_calls(self):
+        m = _mod()
+        assert m.tool_calls(FIXTURE.read_text(encoding="utf-8")) == []
+
+    def test_the_old_substring_check_would_have_said_true(self):
+        # Pins the bug itself, so the fix cannot be quietly reverted into a
+        # scan that passes these tests by accident.
+        text = FIXTURE.read_text(encoding="utf-8")
+        m = _mod()
+        assert any(n in text for n in m.CONSULT_TOOLS)
+
+
+class TestARealCallStillCounts:
+    def test_a_namespaced_call_is_found(self):
+        m = _mod()
+        stream = FIXTURE.read_text(encoding="utf-8") + "\n" + \
+            _call("mcp__boost__boost_search")
+        assert m.called_boost(stream) is True
+        assert m.tool_calls(stream) == ["mcp__boost__boost_search"]
+
+    @pytest.mark.parametrize("name", [
+        "boost_search", "mcp__boost__boost_search",
+        "mcp_boost_boost_search", "boost/boost_search"])
+    def test_every_hosts_namespacing_still_matches(self, name):
+        # The suffix match is what keeps one CONSULT list correct across hosts.
+        assert _mod().called_boost(_call(name)) is True
+
+    def test_install_alone_is_not_a_consult(self):
+        # Installing is downstream of a decision already made; scoring it would
+        # let a run that installed without looking count as a check.
+        assert _mod().called_boost(_call("mcp__boost__boost_install")) is False
+
+    def test_a_non_boost_call_is_not_a_consult(self):
+        assert _mod().called_boost(_call("Read")) is False
+
+
+class TestTheParseSurvivesRealStreams:
+    def test_non_json_lines_are_skipped(self):
+        m = _mod()
+        assert m.called_boost("warning: something\nnot json\n") is False
+
+    def test_a_truncated_tail_does_not_raise(self):
+        # A timeout kills the host mid-line; the probe must still answer.
+        m = _mod()
+        assert m.called_boost(_call("boost_search") + '\n{"type": "assis') is True
+
+    def test_the_surface_is_read_from_the_init_event(self):
+        m = _mod()
+        tools, servers = m.session_surface(FIXTURE.read_text(encoding="utf-8"))
+        assert tools > 0 and servers >= 0
+
+    def test_a_stream_with_no_init_event_reports_zero(self):
+        assert _mod().session_surface(_call("boost_search")) == (0, 0)