boost-skill-cli 1.0.200__tar.gz → 1.0.201__tar.gz

{boost_skill_cli-1.0.200/boost_skill_cli.egg-info → boost_skill_cli-1.0.201}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.200
+Version: 1.0.201
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/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.200'
-__version_tuple__ = version_tuple = (1, 0, 200)
+__version__ = version = '1.0.201'
+__version_tuple__ = version_tuple = (1, 0, 201)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.200
+Version: 1.0.201
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

boost_skill_cli-1.0.201/docs/roadmap/items/finish-mutation-hardening-across-core.md

@@ -0,0 +1,31 @@
+---
+id: finish-mutation-hardening-across-core
+board: code
+section: planned
+status: shipped
+category: Testing
+complexity: L
+impact: Med
+wow: 2
+note: behavioral gaps closed
+order: 1
+owner: loop/mutation-hardening
+pr: 225
+title: Finish mutation hardening across <code>core/</code>
+---
+Audited the surviving mutants across all ten listed modules — catalog, util,
+           ai, registry, lockfile, policy, config, output, agents, paths — and
+           killed every one that reflected a real behavioral coverage gap: the
+           <code>search</code> desc-bonus accumulation and <code>classify_workflow</code>
+           signature logic; <code>score_skill</code> signal detection and the
+           <code>rel_time</code> bucket boundaries; <code>registry.remove</code> keeping
+           other taps; a 3-level <code>config.unset</code> slicing bug; the untested
+           <code>lockfile.remove_rule</code>/<code>remove_workflow</code> returns and
+           corrupt-history skip; the entirely-untested <code>policy.check_capabilities</code>;
+           and <code>confirm()</code>'s safe default. The residual survivors are
+           <b>equivalent mutants</b> — encoding defaults, macOS case-folding (killed
+           on CI's Linux runner), <code>+=</code> vs <code>=</code> on a zero-init score,
+           <code>//</code> vs <code>/</code> under <code>%d</code>, dead defensive defaults
+           carried by <code>DEFAULTS</code>, and test-double-stubbed plumbing kwargs —
+           none of which represents a missing assertion. The required mutation gate
+           stays green with margin.

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/docs/roadmap.html

@@ -459,17 +459,29 @@ message, so routing it through the helper would change user-facing errors.</p>
 
       <!-- ROADMAP:cards section=planned -->
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Testing</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Testing</span></div>
         <h3>Finish mutation hardening across <code>core/</code></h3>
-        <p>Work down the remaining survivor counts, biggest first: catalog&nbsp;(27),
-           util&nbsp;(26), ai&nbsp;(21), registry&nbsp;(20), lockfile&nbsp;(13),
-           policy&nbsp;(12), config&nbsp;(9), output&nbsp;(8), agents&nbsp;(6),
-           paths&nbsp;(4).</p>
+        <p>Audited the surviving mutants across all ten listed modules — catalog, util,
+           ai, registry, lockfile, policy, config, output, agents, paths — and
+           killed every one that reflected a real behavioral coverage gap: the
+           <code>search</code> desc-bonus accumulation and <code>classify_workflow</code>
+           signature logic; <code>score_skill</code> signal detection and the
+           <code>rel_time</code> bucket boundaries; <code>registry.remove</code> keeping
+           other taps; a 3-level <code>config.unset</code> slicing bug; the untested
+           <code>lockfile.remove_rule</code>/<code>remove_workflow</code> returns and
+           corrupt-history skip; the entirely-untested <code>policy.check_capabilities</code>;
+           and <code>confirm()</code>'s safe default. The residual survivors are
+           <b>equivalent mutants</b> — encoding defaults, macOS case-folding (killed
+           on CI's Linux runner), <code>+=</code> vs <code>=</code> on a zero-init score,
+           <code>//</code> vs <code>/</code> under <code>%d</code>, dead defensive defaults
+           carried by <code>DEFAULTS</code>, and test-double-stubbed plumbing kwargs —
+           none of which represents a missing assertion. The required mutation gate
+           stays green with margin.</p>
         <div class="meta">
           <span class="m">Complexity <b>L</b></span>
           <span class="m">Impact <b>Med</b></span>
           <span class="m">Wow <b class="wow">★★</b></span>
-          <span class="m">~146 survivors</span>
+          <span class="m">behavioral gaps closed</span>
         </div>
       </article>
 

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_agents.py

@@ -72,3 +72,10 @@ class TestEnsureAgentDirs:
         assert (sandbox / ".claude" / "skills").is_dir()
         assert (sandbox / ".windsurf" / "skills").is_dir()
         assert not (sandbox / ".cursor" / "skills").exists()
+
+    def test_is_idempotent_when_dirs_exist(self, sandbox):
+        # a second call over already-existing dirs must not raise — pins
+        # exist_ok=True (a False/dropped flag would raise FileExistsError).
+        agents.ensure_agent_dirs()
+        agents.ensure_agent_dirs()
+        assert (sandbox / ".claude" / "skills").is_dir()

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_ai.py

@@ -202,7 +202,9 @@ class TestAskApi:
         monkeypatch.setenv("ANTHROPIC_API_KEY", "sekret")
         captured = _with_api(monkeypatch, {"content": [{"type": "text", "text": "x"}]})
         assert ai.ask("p") == "x"
-        assert "system" not in json.loads(captured["req"].data.decode())
+        body = json.loads(captured["req"].data.decode())
+        assert "system" not in body
+        assert body["max_tokens"] == 1500   # the ask() default budget (pins 1500)
 
     def test_api_urlerror_returns_none(self, ai_on, monkeypatch):
         _without_cli(monkeypatch)
@@ -226,6 +228,7 @@ class TestAskAuthor:
         assert ai.ask_author("p", system="s") == "authored"
         assert calls[0]["cmd"][2:4] == ["--model", AUTHOR_MODEL]
         assert calls[0]["cmd"][-2:] == ["--append-system-prompt", "s"]
+        assert calls[0]["input"] == "p"   # the prompt is forwarded, not dropped
         assert calls[0]["timeout"] == 240
 
     def test_author_api_max_tokens(self, ai_on, monkeypatch):

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_catalog.py

@@ -287,6 +287,26 @@ class TestScanRulesAndWorkflows:
         # a bare prompt .md with no dir marker and no subagent frontmatter
         assert catalog._classify_workflow(Path("prompts/idea.md"), {}) is False
 
+    def test_classify_workflow_signature_needs_name_and_description(self):
+        # Outside a workflow dir, the frontmatter signature requires BOTH a name
+        # AND a description AND a workflow meta key. (Pins the `and` between
+        # name/description — an `or` would classify a name-only file.)
+        loose = Path("prompts/agent.md")
+        full = {"name": "a", "description": "d", "tools": ["x"]}
+        assert catalog._classify_workflow(loose, full) is True
+        assert catalog._classify_workflow(loose, {"name": "a", "tools": ["x"]}) is False
+        assert catalog._classify_workflow(
+            loose, {"description": "d", "tools": ["x"]}) is False
+
+    def test_classify_workflow_signature_needs_a_workflow_meta_key(self):
+        # name+description alone do NOT make a loose .md a workflow — it needs one
+        # of the subagent/slash-command keys. (Pins `WORKFLOW_META_KEYS & set` —
+        # a `|` would make the set truthy for any frontmatter.)
+        loose = Path("prompts/agent.md")
+        assert catalog._classify_workflow(loose, {"name": "a", "description": "d"}) is False
+        assert catalog._classify_workflow(
+            loose, {"name": "a", "description": "d", "model": "opus"}) is True
+
     def test_mixed_kinds_all_present(self, tmp_path):
         root = tmp_path / "tap"
         write_skill(root / "skills" / "s", "---\nname: s\n---")
@@ -445,6 +465,16 @@ class TestResolveOne:
         assert ei.value.message == "no skill named 'brainstorm' in any tap"
         assert ei.value.hint == "closest matches: brainstorming"
 
+    def test_miss_hint_caps_at_three_joined_by_comma(self, sandbox):
+        # Five near-matches, but the hint lists exactly the top THREE, comma-
+        # joined. (Pins `search(name)[:3]` and the `", "` join separator.)
+        _fake_taps(("t", [_entry("planner-%d" % i, "t") for i in range(5)]))
+        with pytest.raises(BoostError) as ei:
+            catalog.resolve_one("planner")
+        listed = ei.value.hint.replace("closest matches: ", "").split(", ")
+        assert len(listed) == 3
+        assert all(n.startswith("planner-") for n in listed)
+
     def test_miss_no_close_match_no_hint(self, sandbox):
         _fake_taps(("t", [_entry("brainstorming", "t")]))
         with pytest.raises(BoostError) as ei:
@@ -525,6 +555,16 @@ class TestSearchRanking:
         assert [(m["name"], s) for m, s in catalog.search("planning", entries=[e])] \
             == [("x", 2)]
 
+    def test_desc_bonus_adds_to_name_score_not_replaces(self):
+        # An entry that matches BOTH the name and the description must accrue the
+        # description bonus (+30) ON TOP of the name-tier score, never reset to
+        # it. name "fmt-tool" starts-with "fmt" (+80) + token "fmt" in name (+12)
+        # + desc "a fmt helper" contains "fmt" (+30) + token in desc (+6) + token
+        # in blob (+2) = 130. (Pins `score += 30`, not `score = 30`.)
+        e = _entry("fmt-tool", "t", desc="a fmt helper")
+        assert [(m["name"], s) for m, s in catalog.search("fmt", entries=[e])] \
+            == [("fmt-tool", 130)]
+
 
 class TestMetaText:
     def test_flattens_keys_and_values_lowercased(self):

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_config.py

@@ -80,6 +80,15 @@ class TestSaveRoundtrip:
         assert json.loads(raw) == {"a": 1}
         assert raw.endswith("\n")
 
+    def test_save_is_pretty_printed_and_preserves_key_order(self, sandbox):
+        # 2-space indent and insertion order (sort_keys=False) — the config file
+        # is human-edited, so it must stay readable and stable, not compacted or
+        # alphabetized. Pins indent=2 and sort_keys=False.
+        config.save({"zeta": 1, "alpha": 2})
+        raw = paths.config_path().read_text(encoding="utf-8")
+        assert '\n  "zeta": 1' in raw                 # 2-space indent, not compact
+        assert raw.index('"zeta"') < raw.index('"alpha"')   # insertion, not sorted
+
 
 class TestCaching:
     def test_reads_only_once_when_file_unchanged(self, sandbox, monkeypatch):
@@ -198,6 +207,15 @@ class TestUnset:
         assert config.unset("never.was.here") is False
         assert config.unset("absent_top") is False
 
+    def test_unset_deeply_nested_key_targets_the_leaf(self, sandbox):
+        # a 3-level key exercises the parent-walk `parts[:-1]` and leaf `parts[-1]`
+        # correctly — a 2-level key can't tell them from `parts[:1]` / `parts[1]`.
+        cfg = config.load()
+        cfg["deep"] = {"mid": {"leaf": 1, "keep": 2}}
+        config.save(cfg)
+        assert config.unset("deep.mid.leaf") is True
+        assert config.load()["deep"]["mid"] == {"keep": 2}   # only leaf removed
+
     def test_path_through_scalar_returns_false(self, sandbox):
         assert config.unset("ai.model.sub") is False
 

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_lockfile.py

@@ -182,3 +182,33 @@ class TestHistory:
             lockfile.history_read("20990101T000000Z")
         assert ei.value.message == "no lock history entry 20990101T000000Z"
         assert ei.value.hint == "list entries with `boost replay`"
+
+    def test_history_list_skips_corrupt_without_stopping(self, sandbox):
+        # a corrupt snapshot that sorts BEFORE a valid one must be skipped, not
+        # halt the scan — pins the `continue` (a `break` would drop the later
+        # valid entry). The seed in _seed_history can't catch this because its
+        # corrupt file is newest, hence last.
+        paths.ensure_dirs()
+        d = paths.lock_history_dir()
+        (d / "lock-20200101T000000Z.json").write_text("not json", encoding="utf-8")
+        (d / "lock-20200102T000000Z.json").write_text(
+            json.dumps({"updated": "v", "skills": {"x": {}}}), encoding="utf-8")
+        assert [e["id"] for e in lockfile.history_list()] == ["20200102T000000Z"]
+
+
+class TestRulesAndWorkflows:
+    def test_rule_roundtrip_and_remove(self, sandbox):
+        lockfile.set_rule("r", {"v": "1"})
+        assert lockfile.get_rule("r") == {"v": "1"}
+        assert lockfile.installed_rules() == {"r": {"v": "1"}}
+        assert lockfile.remove_rule("r") is True       # present -> True
+        assert lockfile.get_rule("r") is None
+        assert lockfile.remove_rule("r") is False       # absent -> False
+
+    def test_workflow_roundtrip_and_remove(self, sandbox):
+        lockfile.set_workflow("w", {"v": "2"})
+        assert lockfile.get_workflow("w") == {"v": "2"}
+        assert lockfile.installed_workflows() == {"w": {"v": "2"}}
+        assert lockfile.remove_workflow("w") is True    # present -> True
+        assert lockfile.get_workflow("w") is None
+        assert lockfile.remove_workflow("w") is False    # absent -> False

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_output.py

@@ -844,6 +844,12 @@ class TestConfirm:
         monkeypatch.setattr(sys, "stdin", FakeStream(tty=False))
         assert output.confirm("go?", default=False) is False
 
+    def test_default_is_false_when_unspecified(self, monkeypatch):
+        # safety: with no explicit default, an unattended (non-tty) confirm must
+        # NOT proceed — pins the `default: bool = False` signature default.
+        monkeypatch.setattr(sys, "stdin", FakeStream(tty=False))
+        assert output.confirm("delete everything?") is False
+
     def _tty(self, monkeypatch, answer):
         monkeypatch.setattr(sys, "stdin", FakeStream(tty=True))
         prompts = []

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_paths.py

@@ -143,6 +143,19 @@ class TestRepoRoot:
         assert root == Path(paths.__file__).resolve().parent.parent.parent
 
 
+class TestPackageAndStatePaths:
+    def test_package_root_is_the_boost_cli_dir(self):
+        root = paths.package_root()
+        assert root.name == "boost_cli"
+        assert (root / "core" / "paths.py").is_file()
+        assert root == Path(paths.__file__).resolve().parent.parent
+
+    def test_trusted_keys_path_name_and_location(self, sandbox):
+        p = paths.trusted_keys_path()
+        assert p.name == "trusted_keys.json"
+        assert p.parent == paths.state_dir()
+
+
 class TestLauncher:
     def test_prefers_console_script_on_path(self, monkeypatch):
         monkeypatch.setattr("boost_cli.core.paths.shutil.which",

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_policy.py

@@ -153,6 +153,41 @@ class TestCheckInstall:
         assert policy.check_install({}, 0) == []
 
 
+class TestCheckCapabilities:
+    def test_declared_denied_capability_violates(self, sandbox):
+        set_policy(denied_capabilities=["network"])
+        v = policy.check_capabilities({"capabilities": ["network"]}, "body")
+        assert v == ["declares the 'network' capability, denied by policy"]
+
+    def test_declared_but_not_denied_is_allowed(self, sandbox):
+        set_policy(denied_capabilities=["shell"])
+        assert policy.check_capabilities({"capabilities": ["network"]}, "body") == []
+
+    def test_empty_denylist_short_circuits(self, sandbox):
+        # no denied capabilities -> allowed regardless of what the skill declares
+        set_policy(denied_capabilities=[])
+        assert policy.check_capabilities({"capabilities": ["network", "shell"]}, "x") == []
+
+    def test_master_switch_bypasses(self, sandbox):
+        set_policy(denied_capabilities=["network"])
+        cfg = config.load()
+        cfg["policy_enforce"] = False
+        config.save(cfg)
+        assert policy.check_capabilities({"capabilities": ["network"]}, "body") == []
+
+    def test_detected_only_needs_strict_flag(self, sandbox):
+        # a body that *looks* like it uses the network but doesn't declare it:
+        # denied, yet only enforced when enforce_detected_capabilities is on.
+        body = "import requests\nrequests.get('https://example.com')\n"
+        set_policy(denied_capabilities=["network"],
+                   enforce_detected_capabilities=False)
+        assert policy.check_capabilities({}, body) == []
+        set_policy(denied_capabilities=["network"],
+                   enforce_detected_capabilities=True)
+        v = policy.check_capabilities({}, body)
+        assert v == ["looks like it uses 'network' (detected), denied by policy"]
+
+
 class TestCheckTapSigning:
     def test_off_by_default(self, sandbox, tmp_path):
         clone = tmp_path / "c"

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_registry.py

@@ -207,6 +207,19 @@ class TestAddRemove:
         assert not tap.cache_file.exists()
         assert config.get("taps") == []
 
+    def test_remove_only_drops_the_named_tap(self, sandbox):
+        # Removing one of several taps must leave the others in config. Pins the
+        # `cfg["taps"] = [t ... if t["name"] != tap.name]` rewrite and its
+        # `config.save(cfg)` — a wrong key, empty default, or save(None) would
+        # blow away the survivors instead of keeping them.
+        cfg = config.load()
+        cfg["taps"] = [{"name": "one", "url": "u1", "curated": False},
+                       {"name": "two", "url": "u2", "curated": False},
+                       {"name": "three", "url": "u3", "curated": False}]
+        config.save(cfg)
+        registry.remove("two")
+        assert [t["name"] for t in config.get("taps")] == ["one", "three"]
+
     def test_remove_unknown_raises(self, sandbox):
         with pytest.raises(BoostError):
             registry.remove("nope")

{boost_skill_cli-1.0.200 → boost_skill_cli-1.0.201}/tests/unit/test_util.py

@@ -73,6 +73,22 @@ class TestRelTime:
     def test_55_days_is_seven_weeks(self):
         assert util.rel_time(iso_ago(55 * 86400)) == "7w ago"
 
+    def test_exactly_60_seconds_rolls_to_minutes(self):
+        # the seconds bucket is `secs < 60`; at 60 it must roll to minutes.
+        # (Pins the 60 boundary literal — a 61 would keep it "60s ago".)
+        assert util.rel_time(iso_ago(60)) == "1m ago"
+
+    def test_exactly_3600_seconds_rolls_to_hours(self):
+        # the minutes bucket is `secs < 3600`; at one hour it rolls to hours.
+        # (Pins the 3600 boundary — a 3601 would say "60m ago".)
+        assert util.rel_time(iso_ago(3600)) == "1h ago"
+
+    def test_60_days_is_absolute_date_not_weeks(self):
+        # past the `secs < 604800 * 8` (eight-week) cutoff, output is a date, not
+        # "8w ago". (Pins the *8 multiplier — a *9 would extend weeks to 60 days.)
+        then = datetime.now(timezone.utc) - timedelta(days=60)
+        assert util.rel_time(then.strftime(ISO_FMT)) == then.strftime("%Y-%m-%d")
+
     def test_100_days_is_absolute_date(self):
         then = datetime.now(timezone.utc) - timedelta(days=100)
         assert util.rel_time(then.strftime(ISO_FMT)) == then.strftime("%Y-%m-%d")
@@ -377,6 +393,62 @@ class TestScoreSkill:
         d = make_skill(tmp_path, text)
         assert util.score_skill(d) == (95, [])
 
+    def test_48001_chars_is_penalized(self, tmp_path):
+        # one char over the 48_000 cutoff (`> 48_000`) crosses into the penalty;
+        # pins the boundary against a `> 48_001` off-by-one.
+        base = full_text()
+        text = base + "P" * (48_001 - len(base))
+        assert len(text) == 48_001
+        d = make_skill(tmp_path, text)
+        score, notes = util.score_skill(d)
+        assert score == 85
+        assert "very large SKILL.md (>48KB) — consider splitting" in notes
+
+    def test_heading_on_a_later_line_still_counts(self, tmp_path):
+        # the heading probe uses re.MULTILINE, so a heading below the first line
+        # must still register (no "no markdown headings" note). Pins re.M — a
+        # dropped flag would only match a heading at the very start of the body.
+        body = ("Intro prose that runs on for a while so the body clears the two "
+                "hundred character minimum comfortably and then some more.\n\n"
+                "## Later Heading\n\n- a bullet keeps the examples check happy.\n")
+        d = make_skill(tmp_path, full_text(body=body))
+        _score, notes = util.score_skill(d)
+        assert "no markdown headings in body" not in notes
+
+    def test_code_fence_alone_satisfies_examples(self, tmp_path):
+        # a ``` fence with NO numbered list and NO bullet must satisfy the
+        # examples check. Pins the leading `"```" in body or ...` term (an `and`
+        # or a corrupted literal would demand a list too).
+        body = ("# Heading\n\nProse padding to exceed two hundred characters so the "
+                "length bonus applies and nothing else trips a note here today.\n\n"
+                "```bash\necho hello\n```\n")
+        d = make_skill(tmp_path, full_text(body=body))
+        _score, notes = util.score_skill(d)
+        assert "no examples, steps, or code blocks" not in notes
+
+    def test_numbered_list_below_first_line_satisfies_examples(self, tmp_path):
+        # a numbered list (not on the first line, no fence, no bullet) satisfies
+        # the examples check via re.MULTILINE. Pins the `^\d+\. ` probe + its flag.
+        body = ("# Heading\n\nSome prose padding to comfortably exceed the two "
+                "hundred character minimum for the length bonus to apply now.\n\n"
+                "1. The first and only concrete step in this body.\n")
+        d = make_skill(tmp_path, full_text(body=body))
+        _score, notes = util.score_skill(d)
+        assert "no examples, steps, or code blocks" not in notes
+
+    def test_license_file_on_disk_adds_five_over_a_plain_extra(self, tmp_path):
+        # a LICENSE *file* (not just frontmatter) earns the license +5 on top of
+        # the extras +5 any sidecar earns. Isolating vs a plain extra pins the
+        # "LICENSE" filename literal against a corrupted/renamed check.
+        # minimal bodies keep both scores well below the 100 cap so the +5 shows
+        (tmp_path / "a").mkdir()
+        (tmp_path / "b").mkdir()
+        licensed = make_skill(tmp_path / "a", "hi",
+                              extra_files={"LICENSE": "MIT\n"})
+        plain = make_skill(tmp_path / "b", "hi",
+                          extra_files={"notes.md": "x\n"})
+        assert util.score_skill(licensed)[0] - util.score_skill(plain)[0] == 5
+
 
 class TestAtomicWriteText:
     def test_writes_content(self, tmp_path):

boost_skill_cli-1.0.200/docs/roadmap/items/finish-mutation-hardening-across-core.md

@@ -1,19 +0,0 @@
----
-id: finish-mutation-hardening-across-core
-board: code
-section: planned
-status: planned
-category: Testing
-complexity: L
-impact: Med
-wow: 2
-note: ~146 survivors
-order: 1
-owner:
-pr:
-title: Finish mutation hardening across <code>core/</code>
----
-Work down the remaining survivor counts, biggest first: catalog&nbsp;(27),
-           util&nbsp;(26), ai&nbsp;(21), registry&nbsp;(20), lockfile&nbsp;(13),
-           policy&nbsp;(12), config&nbsp;(9), output&nbsp;(8), agents&nbsp;(6),
-           paths&nbsp;(4).