boost-skill-cli 1.2.182__tar.gz → 1.2.184__tar.gz

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/PKG-INFO

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

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/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.182'
-__version_tuple__ = version_tuple = (1, 2, 182)
+__version__ = version = '1.2.184'
+__version_tuple__ = version_tuple = (1, 2, 184)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_cli/commands/configuration.py

@@ -1648,12 +1648,22 @@ def _tool_doctor(args: dict):
         if vals:
             lines.append("%s: %s" % (key, ", ".join(str(v) for v in vals)))
     # sync_plan already reports MISSING rule/workflow materializations; the
-    # digest check adds the drift sync cannot see — content edited in place.
-    mat_issues = ["%s %s: modified since install" % (kind, n)
-                  for kind in ("rule", "workflow")
-                  for n, e in sorted(everything[kind].items())
-                  if (integrity.materialized_status(n, e, kind)
-                      == integrity.STATUS_MODIFIED)]
+    # digest check adds the drift sync cannot see — content edited in place,
+    # and an item that reaches no agent at all. The second is squarely the
+    # same case: sync_plan filters an unwritten row out by design, so an item
+    # whose every row is unwritten is invisible to it. A label map rather
+    # than an equality test, so a status added to one of these and not the
+    # other cannot quietly drop out of the count on the one doctor surface
+    # with no human reading it.
+    _MAT_ISSUE_LABEL = {
+        integrity.STATUS_MODIFIED: "modified since install",
+        integrity.STATUS_UNREACHABLE: "reaches no agent boost writes",
+    }
+    mat_issues = [
+        "%s %s: %s" % (kind, n, _MAT_ISSUE_LABEL[st])
+        for kind in ("rule", "workflow")
+        for n, e in sorted(everything[kind].items())
+        if (st := integrity.materialized_status(n, e, kind)) in _MAT_ISSUE_LABEL]
     lines.extend(mat_issues)
     total = issues + len(mat_issues)
     # A machine with no taps has nothing to disagree about, so every check

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_cli/commands/info.py

@@ -437,6 +437,19 @@ def _info_materialized(name: str, kind: str, entry: dict, as_json: bool) -> int:
         # nothing. Printing the stale agent list here reads as a lie about
         # files that were just removed.
         out.kv("materialized", "(removed — quarantined)")
+    elif integrity.reaches_no_agent(kind, entry):
+        # `agent_names` lists every recorded row, so the dangerous case
+        # advertised the five agents the rule does not reach while the
+        # harmless no-rows case showed none — the two read backwards from
+        # how a user judges risk.
+        # Both halves inflect. One row is the commonest shape by far -- most
+        # items record exactly one -- so a noun-only plural put the ungrammar
+        # on the usual path and hid it on the rare one.
+        rows = len(entry.get("materializations") or [])
+        out.kv("materialized",
+               "(none — %d recorded row%s name%s an agent boost no longer "
+               "writes)" % (rows, "" if rows == 1 else "s",
+                            "s" if rows == 1 else ""))
     else:
         out.kv("materialized",
                ", ".join(lockfile.agent_names(kind, entry)) or "(none)")

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_cli/commands/quality.py

@@ -258,6 +258,11 @@ def _drift_status_materialized(kind: str, name: str, entry: dict) -> str:
         return "store-missing"
     if st == integrity.STATUS_MODIFIED:
         return "local-edits"
+    if st == integrity.STATUS_UNREACHABLE:
+        # Before the tap comparison below, which would otherwise launder an
+        # item that reaches no agent into "in-sync" on the strength of a
+        # source file matching a hash nothing on disk was written from.
+        return "unreachable"
     if entry.get("tap") == "local":
         return "n/a"
     try:
@@ -270,10 +275,15 @@ def _drift_status_materialized(kind: str, name: str, entry: dict) -> str:
     return "in-sync"
 
 
+#: Every word `_drift_status` and `_drift_status_materialized` can return.
+#: The render site subscripts this directly, so a missing key is a KeyError --
+#: not a BoostError, so `boost drift` exits 70 with a crash report rather than
+#: mis-painting one cell. `test_drift_vocabulary_is_covered` pins the two
+#: against each other.
 _DRIFT_ROLE = {"in-sync": "success", "local-edits": "warn",
                "upstream-moved": "accent", "source-missing": "danger",
                "store-missing": "danger", "n/a": "muted",
-               "quarantined": "muted"}
+               "quarantined": "muted", "unreachable": "warn"}
 
 
 def _drift_hint(name: str, status: str, tap: str = "") -> str:
@@ -290,6 +300,12 @@ def _drift_hint(name: str, status: str, tap: str = "") -> str:
         return "boost update" if registry.is_tapped(tap) else "boost tap %s" % tap
     if status == "store-missing":
         return "boost heal"
+    if status == "unreachable":
+        # Not `boost sync`: it filters these rows out by design, so it is a
+        # guaranteed no-op. Not "re-enable the agent" either -- that is wrong
+        # advice for `agents.WITHDRAWN_REASONS`. `doctor` is where
+        # `_mat_remedy` words the split correctly.
+        return "boost doctor"
     return ""
 
 
@@ -744,6 +760,32 @@ def cmd_doctor(argv):
                  % (len(off), _s(len(off)), "s" if len(off) == 1 else "",
                     ", ".join(shown), _mat_remedy(off)),
                  wrap=True)
+    # The per-row note above answers "which row, which agent, why". This
+    # answers a different question the surfaces had nowhere to put: skip every
+    # row an item has and the item reached no agent at all. `rep.note`, not
+    # `rep.warn` -- WARN is documented as restating a fault already counted,
+    # and this one is counted nowhere -- and not `rep.issue`, which would
+    # invert doctor's standing convention that a config-orphaned row is the
+    # user's own decision, named once and never scored. `verify` and `attest`
+    # are the surfaces that fail; doctor's job here is to stop contradicting
+    # its own note.
+    nowhere = [(kind, name)
+               for kind, section in (("rule", rules), ("workflow", workflows))
+               for name, entry in sorted(section.items())
+               if integrity.reaches_no_agent(kind, entry)]
+    if nowhere:
+        # No remedy sentence: every one of these items has at least one row,
+        # so the per-row note above has already printed `_mat_remedy`'s
+        # wording for it, and repeating it verbatim one line later is how a
+        # report teaches the reader to skim past it.
+        rep.note("materialized-nowhere",
+                 "%d item%s reach%s no agent boost writes, so %s installed "
+                 "but loaded by nothing: %s"
+                 % (len(nowhere), _s(len(nowhere)),
+                    "es" if len(nowhere) == 1 else "",
+                    "it is" if len(nowhere) == 1 else "they are",
+                    ", ".join("%s %s" % (k, n) for k, n in nowhere)),
+                 wrap=True)
     if (all_rules or all_workflows) and not mat_issues:
         # Quarantined rules/workflows are excluded above so their stashed-but-
         # removed materializations don't read as rot — but excluding them from
@@ -765,9 +807,15 @@ def cmd_doctor(argv):
             # right above it: "fully materialized" is true of the agents boost
             # writes, and that is now a smaller set than the rows record.
             note += " for every agent boost writes"
+        # Counted over the items that reach at least one agent. The suffix
+        # above is what the note said this line contradicted -- "fully
+        # materialized for every agent boost writes" is trivially true of an
+        # item whose write set is empty, so counting it there is what made
+        # the count true as worded and false as read.
+        n_rules = len(rules) - sum(1 for k, _n in nowhere if k == "rule")
+        n_flows = len(workflows) - sum(1 for k, _n in nowhere if k == "workflow")
         rep.ok("rules-workflows", "%d rule%s and %d workflow%s fully materialized%s"
-               % (len(rules), _s(len(rules)), len(workflows), _s(len(workflows)),
-                  note))
+               % (n_rules, _s(n_rules), n_flows, _s(n_flows), note))
 
     root = paths.store_dir()
     orphans = [c.name for c in sorted(root.iterdir())
@@ -939,7 +987,21 @@ def cmd_doctor(argv):
     # MCP `boost_doctor` tool already refused to say "healthy" here; this is
     # the CLI half of the same rule.
     issues = rep.issues
-    if issues == 0 and not configured:
+    if issues == 0 and nowhere:
+        # Same rule as the no-taps case above, for the same reason: "healthy"
+        # is the one word this machine is not. An item nothing loads is not
+        # an issue -- it is the user's own config, and doctor's convention is
+        # to name that rather than score it -- but `boost health` keys
+        # `needs attention` on it and sends the reader here, so a verdict
+        # reading "healthy" would close that loop with a flat contradiction.
+        # Reported, never fatal: the exit code still turns only on issues.
+        # Ahead of the no-taps branch below on purpose: a machine holding an
+        # installed item is not "ready to set up", and that wording would
+        # bury the more specific fact under a setup prompt.
+        rep.verdict(False,
+                    "%d item%s installed but loaded by nothing — see above"
+                    % (len(nowhere), _s(len(nowhere))))
+    elif issues == 0 and not configured:
         rep.verdict(True, "ready to set up — tap a registry to make boost "
                           "searchable")
     else:
@@ -1750,9 +1812,16 @@ def cmd_health(argv):
     kv("journal (7d)", "%d event%s" % (recent, _s(recent)), recent)
     kv("fingerprint", _fingerprint()[0][:16])
 
+    # The membership rule is "is there anything there", not "has it drifted":
+    # `local-edits` and `upstream-moved` are expected states of a *live*
+    # install, while these three each mean the install reaches nothing --
+    # the store dir is gone, the source is gone, or no agent was ever
+    # written. Leaving `unreachable` out would be the bug this status was
+    # added for, wearing a new word.
     attention = (bool(broken) or not coverage_ok
                  or drift_counts.get("store-missing", 0) > 0
                  or drift_counts.get("source-missing", 0) > 0
+                 or drift_counts.get("unreachable", 0) > 0
                  or not journal.rotation_healthy())
     if args.json:
         print(json.dumps(data | {"ok": not attention,

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_cli/commands/safety.py

@@ -645,14 +645,21 @@ def cmd_attest(argv):
                 # it was written. UNLOCKED (a pre-hash entry) never fails.
                 st = integrity.materialized_status(name, entry, kind)
             rec["sha_ok"] = st not in (integrity.STATUS_MODIFIED,
-                                       integrity.STATUS_MISSING)
+                                       integrity.STATUS_MISSING,
+                                       integrity.STATUS_UNREACHABLE)
             rec["journal"] = ev is not None
             if not rec["sha_ok"]:
                 # A missing store dir / materialized artifact is not a content
                 # change — conflating the two sends the user hunting for
-                # tampering when the remedy is `boost heal`.
-                rec["reason"] = ("missing" if st == integrity.STATUS_MISSING
-                                 else "modified")
+                # tampering when the remedy is `boost heal`. Unreachable is a
+                # third thing again: nothing was tampered with and nothing is
+                # missing, because no artifact was ever written. Folding it
+                # into "modified" would accuse a user of editing a file whose
+                # only act was turning an agent off.
+                rec["reason"] = (
+                    "unreachable" if st == integrity.STATUS_UNREACHABLE
+                    else "missing" if st == integrity.STATUS_MISSING
+                    else "modified")
                 failures += 1
         records.append(rec)
 
@@ -673,7 +680,13 @@ def cmd_attest(argv):
     if args.verify:
         for r in records:
             if not r["sha_ok"]:
-                if r["reason"] == "missing":
+                if r["reason"] == "unreachable":
+                    # Not `boost sync`: it filters these rows out by design,
+                    # so it is a guaranteed no-op. `doctor` is where
+                    # `_mat_remedy` words the per-agent remedy correctly.
+                    msg = ("reaches no agent boost writes — nothing was "
+                           "attested (boost doctor names the agents)")
+                elif r["reason"] == "missing":
                     msg = ("store directory missing (boost heal)"
                            if r["kind"] == "skill"
                            else "materialized file missing")

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_cli/core/integrity.py

@@ -33,6 +33,8 @@ STATUS_MODIFIED = "modified"     # on-disk content no longer matches the lock
 STATUS_MISSING = "missing"       # lock says installed, but the store dir is gone
 STATUS_UNLOCKED = "unlocked"     # present on disk but no lock digest to check
 STATUS_QUARANTINED = "quarantined"  # artifacts removed on purpose; stash holds them
+STATUS_UNREACHABLE = "unreachable"  # rows exist and boost writes none of the
+                                    # agents they name: the item reached nothing
 
 ENFORCE_KEY = "security.enforce_digest"
 COMMIT_KEY = "security.enforce_commit"
@@ -64,6 +66,40 @@ def status(name: str, entry: dict | None = None) -> str:
     return STATUS_OK if util.sha256_dir(sdir) == recorded else STATUS_MODIFIED
 
 
+def reaches_no_agent(kind: str | None, entry: dict) -> bool:
+    """Whether every materialization row names an agent boost no longer writes.
+
+    Skipping such a row is right *per row*: nothing wrote that file and
+    nothing ever will, so reading it as ``MISSING`` reported a fault whose
+    remedy could not run (:func:`agents.materialization_is_written`).
+    Skipping *every* row of an item is a different fact -- the rule reaches
+    no agent, the workflow is in no command palette -- and the loop that
+    skipped them has nothing left to judge, so it fell through to ``OK`` and
+    an install that materialized nowhere read as healthy on every surface but
+    ``doctor``'s note.
+
+    An item with **no rows** is not this case and must keep reading ``OK``: a
+    rule installed before rows existed has nothing to be unreachable about.
+    That is the whole of ``bool(rows)``, and keying on "no row was written"
+    instead would condemn every pre-rows entry on five surfaces at once. A
+    row carrying no ``agent`` counts as written -- ``agents`` answers ``True``
+    for it, preferring a reported gap to a dropped one -- so such an entry is
+    judged by the loop, never condemned here.
+
+    One predicate because two surfaces ask it: :func:`materialized_status`
+    below, and ``boost doctor``, which walks the rows itself rather than
+    re-reading every artifact. Re-deriving it in the command layer is how the
+    two would come to disagree -- the same failure the ``kind`` parameter was
+    added to :func:`materialized_status` to prevent.
+    """
+    rows = entry.get("materializations") or []
+    kind = str(kind or entry.get("kind") or "rule")
+    return bool(rows) and not any(
+        agents.materialization_is_written(kind, entry.get("base"),
+                                          m.get("agent"))
+        for m in rows)
+
+
 def materialized_status(name: str, entry: dict,
                         kind: str | None = None) -> str:
     """Classify a rule/workflow's integrity against its lock entry.
@@ -91,8 +127,17 @@ def materialized_status(name: str, entry: dict,
     from . import rules
     if entry.get("quarantined"):
         return STATUS_QUARANTINED
-    unlocked = False
     kind = str(kind or entry.get("kind") or "rule")
+    # Every row skipped means the item reached nothing. Asked before the loop
+    # rather than after it because each of the three in-loop outcomes needs a
+    # *written* row -- MISSING and MODIFIED return from inside the body and
+    # `unlocked` is only set there -- so this is mutually exclusive with all
+    # of them and there is no precedence to settle. Quarantine still wins
+    # above: those artifacts are gone on purpose, and calling that unreachable
+    # would send the user to a remedy that re-arms what quarantine disarmed.
+    if reaches_no_agent(kind, entry):
+        return STATUS_UNREACHABLE
+    unlocked = False
     for m in entry.get("materializations") or []:
         # A row naming an agent boost no longer writes is a record, not an
         # artifact: nothing wrote that file and nothing ever will, so reading
@@ -202,6 +247,7 @@ def verification_passed(status: str, missing_fields: list, commit_pin: str | Non
 _VERIFY_ROLE_BY_STATUS = {
     STATUS_OK: "success", STATUS_MODIFIED: "warn", STATUS_MISSING: "danger",
     STATUS_UNLOCKED: "warn", STATUS_QUARANTINED: "muted",
+    STATUS_UNREACHABLE: "warn",
 }
 
 

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/docs/roadmap/items/an-item-materialized-nowhere-reads-ok-in-verify-health-drift.md

@@ -2,14 +2,14 @@
 id: an-item-materialized-nowhere-reads-ok-in-verify-health-drift
 board: code
 section: health
-status: planned
+status: inflight
 category: CLI · Bug
 complexity: S
 impact: Low
 wow: 2
 note: a rule whose every materialization row names an agent boost no longer writes reads "ok" in verify and is counted as installed by health — only doctor says otherwise
 order: 354
-owner:
+owner: loop/materialized-nowhere
 pr:
 title: An item materialized <em>nowhere</em> reads <code>ok</code> in <code>verify</code>, <code>health</code> and <code>drift</code>
 ---

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/docs/roadmap/items/shard-weights-do-not-predict-the-job-timeout.md

@@ -101,9 +101,11 @@ eight.
 
 <b>The width stands on that measured 74%. What does not stand is the margin the planner
 prints.</b> On the weights committed since (#1032, a re-timing of the same mutants)
-<code>plan --shards 12</code> says a 25.2-minute median and a 48.0-minute tail, 64% of the cap
-&mdash; so today's pack, asked about the run its own weights were timed from, under-predicts that
-job by <b>7.8 minutes</b>. That is the prospective basis, which is the one that matters before
+<code>plan --shards 12</code> said a 25.2-minute median and a 48.0-minute tail, 64% of the cap
+&mdash; so that pack, asked about the run its own weights were timed from, under-predicted that
+job by <b>7.8 minutes</b>. (#1038 has since re-timed the weights from the twelve-shard run on
+<code>6fd38785</code>; <code>plan</code> now prints 26.2 / 50.1 min, 67% of the cap. That era's
+shortfall is against <em>that</em> run's jobs, not the 55.8 above.) That is the prospective basis, which is the one that matters before
 the next run and is <em>not</em> comparable to the replay figures above. Scored on the observed
 median at the committed <code>TAIL_MULTIPLIER</code> the pack is 34.6 &times; 1.91 = 66.0 min,
 <b>88% of the cap</b>.

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/docs/roadmap/items/the-shard-model-has-no-per-job-fixed-cost.md

@@ -71,8 +71,9 @@ those two runs took 7.8 and 8.6 min) and per-job mutant collection are the candi
 neither has been measured. Measuring them would turn the 14-27 range into a mechanism.
 
 <b>Why it matters even though nothing is red.</b> Twelve sits at 74% of the cap empirically and
-the gate passes. But <code>plan</code> reports 64% on the committed pack against that same
-measured 74%, and goes on reporting 48% at sixteen, where the real floor is <code>C &times;
+the gate passes. But <code>plan</code> reported 64% on #1032's pack against that same
+measured 74%, and goes on reporting around half the cap at sixteen &mdash; 48% on #1032's weights, 50% on
+#1038's &mdash; where the real floor is <code>C &times;
 TAIL_MULTIPLIER</code> however many shards are added. So the one question the planner exists to
 answer &mdash; "is this width safe?" &mdash; is answered optimistically for every width above the
 fitted one, and the answer gets more optimistic the further you go. Until C is fitted,

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/docs/roadmap.html

@@ -3807,7 +3807,7 @@ step at the top of the command whose failure degrades the agent-dependent sectio
       </article>
 
       <article class="cap rcard" id="an-item-materialized-nowhere-reads-ok-in-verify-health-drift">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">CLI · Bug</span></div>
+        <div class="head"><span class="pill inflight">In flight</span><span class="cat">CLI · Bug</span></div>
         <h3>An item materialized <em>nowhere</em> reads <code>ok</code> in <code>verify</code>, <code>health</code> and <code>drift</code></h3>
         <p><b>Found by the second review of</b> <code>sync-repairs-a-disabled-agents-row-every-run</code>.
 That item fixed a row for an agent boost no longer writes being read as a <em>missing artifact</em>:
@@ -7928,8 +7928,9 @@ those two runs took 7.8 and 8.6 min) and per-job mutant collection are the candi
 neither has been measured. Measuring them would turn the 14-27 range into a mechanism.
 
 <b>Why it matters even though nothing is red.</b> Twelve sits at 74% of the cap empirically and
-the gate passes. But <code>plan</code> reports 64% on the committed pack against that same
-measured 74%, and goes on reporting 48% at sixteen, where the real floor is <code>C &times;
+the gate passes. But <code>plan</code> reported 64% on #1032's pack against that same
+measured 74%, and goes on reporting around half the cap at sixteen &mdash; 48% on #1032's weights, 50% on
+#1038's &mdash; where the real floor is <code>C &times;
 TAIL_MULTIPLIER</code> however many shards are added. So the one question the planner exists to
 answer &mdash; "is this width safe?" &mdash; is answered optimistically for every width above the
 fitted one, and the answer gets more optimistic the further you go. Until C is fitted,

{boost_skill_cli-1.2.182 → boost_skill_cli-1.2.184}/scripts/mutation_shards.py

@@ -240,20 +240,37 @@ RUNNER_WORKERS = 4
 #: against.
 #:
 #: **What the gate is actually running on, which is the operational part.**
-#: On the committed pack ``plan --shards 12`` prints a 25.2-minute median and
-#: a 48.0-minute tail, 64% of the cap. Observed: a 34.6-minute median, 37%
-#: higher, and a worst job of 55.8 — so today's pack, asked about the run its
-#: own weights were timed from, under-predicts that job by **7.8 minutes**.
+#: Every **planner** figure in this paragraph is measured on **#1032's
+#: weights** (the observed ones -- 34.6, 55.8, 66.0, 88%, 74% and the 12
+#: points -- are job durations, and do not move when the weights do), the
+#: pack as committed when it was written, and is dated rather than live for
+#: the reason the paragraph itself ends on: a refresh moves the printed
+#: number without moving the real one, so a live reading here would go
+#: quietly wrong the next time one lands. On that pack ``plan --shards 12``
+#: printed a 25.2-minute median and a 48.0-minute tail, 64% of the cap.
+#: Observed: a 34.6-minute median, 37% higher, and a worst job of 55.8 — so
+#: that pack, asked about the run its own weights were timed from,
+#: under-predicted that job by **7.8 minutes**.
 #: That is the prospective basis — what ``plan`` will say before the next
 #: run — and it is not the same question as what the gate printed at the
 #: time, which is answered under :data:`TAIL_MULTIPLIER`. Score the committed
 #: :data:`TAIL_MULTIPLIER` against the observed median instead and the
 #: committed pack is 34.6 x 1.91 = **66.0 min, 88% of the cap**, past the
-#: 80% :data:`HEADROOM` gate ``plan`` reports it clearing with 36 points in
+#: 80% :data:`HEADROOM` gate ``plan`` reported it clearing with 36 points in
 #: hand. Twelve still stands on measurement — 55.8 is 74% of 75 — but the
 #: margin is nearer 12 points than 36, and a weights refresh moves the
 #: printed number without moving the real one.
 #:
+#: **That refresh has since landed, which is why the above is dated.** #1038
+#: re-timed the weights from the twelve-shard ``ci`` run on ``6fd38785``, and
+#: ``plan --shards 12`` now prints a 26.2-minute median and a 50.1-minute
+#: tail, 67% of the cap. The shortfall for *that* era has to be scored
+#: against that run's own observed jobs, which this file does not record
+#: yet — so do not subtract the new tail from the 55.8 above. That number
+#: belongs to ``58ace415``/``d7027cf8``, and pairing it with a tail timed on
+#: a different run is the two-bases conflation this docstring already warns
+#: about one paragraph up.
+#:
 #: **It is not CI setup, and the 0.6 min above is still true.** Stepping all
 #: 24 twelve-shard jobs through the job API, everything that is not ``mutate
 #: shard`` is a median 0.5 min. So the fixed cost is inside mutmut, where
@@ -264,7 +281,8 @@ RUNNER_WORKERS = 4
 #: **Until it is, do not use ``plan`` to justify a width above twelve.**
 #: Through the origin the model divides the time by every shard added, and
 #: goes on saying so past the point where the fixed cost dominates — sixteen
-#: reports 48% of the cap, where the real floor is ``C x TAIL_MULTIPLIER``
+#: reports around half the cap (48% on #1032's weights, 50% on #1038's),
+#: where the real floor is ``C x TAIL_MULTIPLIER``
 #: however many shards are thrown at it. That is no longer only a comment:
 #: ``test_the_committed_width_has_actually_run`` fails the build if
 #: :data:`SHARDS` is raised past a width that has been observed.