boost-skill-cli 1.2.45__tar.gz → 1.2.46__tar.gz

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/CLAUDE.md

@@ -158,6 +158,22 @@ line coverage. Target `boost_cli/core` behavior with assertions, not just import
   93 MB), and must `update-index --refresh` first, because git silently declines
   to remove a path whose stat data looks dirty and otherwise reports success
   having changed nothing.
+- **Tapping many registries goes through `registry.add_many`, and the reason is
+  the config file.** `add` ends in `config.load()` -> append -> `config.save()`,
+  which is read-modify-write on one JSON file: run it from N threads and taps
+  vanish at random. `add_many` clones in a `ThreadPoolExecutor` and writes the
+  config **once**, on one thread, after every clone has finished
+  (`tests/unit/test_registry_parallel.py` asserts the single write and the
+  concurrency separately). It is worth it because a clone is *latency*, not
+  bandwidth or CPU: ~1.6 s whether one runs or twelve, so `boost tap --catalog`
+  was 463 x 1.6 s = 13 minutes of waiting and is now **2 min 10 s** for the same
+  463 registries. Scanning stays serial on the caller's thread — it is 3 ms per
+  registry and writes a per-tap cache file, so parallelising it buys nothing and
+  scrambles output order. Cleanup after a failed clone must tolerate a
+  directory that was never created: `util.rmtree`'s read-only retry hook calls
+  `chmod` on the missing path and raises `FileNotFoundError`, which out of a worker thread
+  turns one 404 into a crashed catalog tap.
+
 - **`~/.boost/cache/` holds boost's own indexes, not just tap catalogs.**
   `paths.INTERNAL_CACHE_FILES` names them. `boost clean` sweeps `cache/*.json`
   whose stem is not a configured tap, which described `rag_index.json` and

{boost_skill_cli-1.2.45/boost_skill_cli.egg-info → boost_skill_cli-1.2.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.45
+Version: 1.2.46
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -210,6 +210,11 @@ boost tap --catalog --category java           # Spring Boot / Kotlin / JVM packs
 boost tap --catalog --category security       # filter by category
 ```
 
+Taps clone in parallel — eight at once by default, `--jobs N` (or
+`BOOST_TAP_JOBS`) to change it, capped at 16 because it is someone else's
+server. A clone is network latency rather than bandwidth, so the whole catalog
+measures **2 min 10 s for 463 registries** where one-at-a-time took 13 minutes.
+
 Every `est_items` is measured from the repository's file tree rather than
 estimated, so `--limit` ranks by real size. Items are counted once however many
 agents a repository renders them for, so a pack shipping a copy in `.claude/`,

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/README.md

@@ -168,6 +168,11 @@ boost tap --catalog --category java           # Spring Boot / Kotlin / JVM packs
 boost tap --catalog --category security       # filter by category
 ```
 
+Taps clone in parallel — eight at once by default, `--jobs N` (or
+`BOOST_TAP_JOBS`) to change it, capped at 16 because it is someone else's
+server. A clone is network latency rather than bandwidth, so the whole catalog
+measures **2 min 10 s for 463 registries** where one-at-a-time took 13 minutes.
+
 Every `est_items` is measured from the repository's file tree rather than
 estimated, so `--limit` ranks by real size. Items are counted once however many
 agents a repository renders them for, so a pack shipping a copy in `.claude/`,

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/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.45'
-__version_tuple__ = version_tuple = (1, 2, 45)
+__version__ = version = '1.2.46'
+__version_tuple__ = version_tuple = (1, 2, 46)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/boost_cli/commands/quickstart.py

@@ -40,27 +40,39 @@ def _tap_defaults(pins: dict[str, dict], dry_run: bool) -> list[str]:
     ordering that produces a commit mismatch on every registry that moved since
     the last shard run.
     """
-    existing = {t.name for t in registry.list_taps()}
-    names = []
-    for default in config.DEFAULT_TAPS:
-        name = str(default["name"])
-        names.append(name)
-        if name in existing:
+    names = [str(d["name"]) for d in config.DEFAULT_TAPS]
+    commits = {name: str(pins[name].get("commit")) for name in names
+               if name in pins}
+    if dry_run:
+        existing = {t.name for t in registry.list_taps()}
+        for name in names:
+            if name in existing:
+                out.info(out.role("%s already tapped" % name, "muted"))
+                continue
+            at = commits.get(name)
+            out.info("would tap %s%s" % (name, " @ %s" % at[:7] if at else ""))
+        return names
+    # One pool, one config write: seven sequential clones is ~11 s of waiting
+    # for work that takes ~2 s done together, and the first thing a new user
+    # sees should not be a progress bar.
+    with spin.Spinner("tapping %d registries" % len(names)):
+        results = registry.add_many([str(d["url"]) for d in config.DEFAULT_TAPS],
+                                    curated=True, pins=commits)
+    for res in results:
+        name = res["name"]
+        if res.get("skipped"):
             out.info(out.role("%s already tapped" % name, "muted"))
             continue
-        row = pins.get(name)
-        at = str(row.get("commit")) if row else None
-        if dry_run:
-            out.info("would tap %s%s" % (name, " @ %s" % at[:7] if at else ""))
+        if not res.get("ok"):
+            out.warn("could not tap %s: %s" % (name, res.get("error", "")))
             continue
         try:
-            with spin.Spinner("tapping %s" % name):
-                tap = registry.add(str(default["url"]), curated=True, at=at)
-                entries = catalog.rebuild_tap(tap)
+            entries = catalog.rebuild_tap(res["tap"])
         except BoostError as exc:
-            out.warn("could not tap %s: %s" % (name, exc.message))
+            out.warn("could not index %s: %s" % (name, exc.message))
             continue
-        journal.log("tap", tap.name)
+        journal.log("tap", name)
+        at = commits.get(name)
         out.ok("tapped %s (%d items)%s"
                % (name, len(entries), " @ %s" % at[:7] if at else ""))
     return names

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/boost_cli/commands/taps.py

@@ -44,22 +44,44 @@ def _tap_catalog(args) -> int:
         out.dim("%d registries · ~%d items (dry run — nothing tapped)"
                 % (len(selection), sum(e.get("est_items") or 0 for e in selection)))
         return 0
-    existing = {t.name for t in registry.list_taps()}
+    focus = {str(e["name"]): e.get("focus", "") for e in selection}
+    return _tap_all([str(e["url"]) for e in selection], jobs=args.jobs,
+                    focus=focus)
+
+
+def _tap_all(urls: list[str], jobs: int | None,
+             focus: dict[str, str] | None = None,
+             pins: dict[str, str] | None = None) -> int:
+    """Clone many registries at once, then scan each one that arrived.
+
+    The split is the whole optimisation. Cloning is network latency — 1.6 s per
+    registry whether one runs or twelve — so it goes wide; scanning is 3 ms per
+    registry and writes a per-tap cache file, so it stays on this thread where
+    its output can be printed in order and its errors belong to one tap.
+    """
+    focus = focus or {}
+    results = registry.add_many(urls, curated=True, pins=pins, jobs=jobs)
     rc = 0
-    for e in selection:
-        if e["name"] in existing:
-            out.info(out.role("%s already tapped" % e["name"], "muted"))
+    for res in results:
+        name = res["name"]
+        if res.get("skipped"):
+            out.info(out.role("%s already tapped" % name, "muted"))
+            continue
+        if not res.get("ok"):
+            out.warn("could not tap %s: %s" % (name, res.get("error", "")))
+            rc = 1
             continue
+        tap = res["tap"]
         try:
-            tap = registry.add(str(e["url"]), curated=True)
             entries = catalog.rebuild_tap(tap)
         except BoostError as err:
-            out.warn("could not tap %s: %s" % (e["name"], err.message))
+            out.warn("could not index %s: %s" % (name, err.message))
             rc = 1
             continue
         journal.log("tap", tap.name)
-        out.ok("tapped %s (%d items) — %s"
-               % (tap.name, len(entries), e.get("focus", "")))
+        note = focus.get(name) or ""
+        out.ok("tapped %s (%d items)%s"
+               % (tap.name, len(entries), " — %s" % note if note else ""))
     return rc
 
 
@@ -104,6 +126,10 @@ def cmd_tap(argv) -> int:
     p.add_argument("--at", metavar="SHA",
                    help="pin the clone to one 40-character commit, as a "
                         "published vector shard requires")
+    p.add_argument("--jobs", type=int, metavar="N",
+                   help="clone this many registries at once (default %d, max "
+                        "%d)" % (registry.DEFAULT_TAP_JOBS,
+                                 registry.MAX_TAP_JOBS))
     args = p.parse_args(argv)
     if args.at and not args.spec:
         p.error("--at pins one registry, so it needs a SPEC")
@@ -114,24 +140,13 @@ def cmd_tap(argv) -> int:
     if args.catalog:
         rc |= _tap_catalog(args)
     if args.defaults:
-        existing = {t.name for t in registry.list_taps()}
-        for default in config.DEFAULT_TAPS:
-            if default["name"] in existing:
-                out.info(out.role("%s already tapped" % default["name"], "muted"))
-                continue
-            try:
-                tap = registry.add(str(default["url"]), curated=True)
-                entries = catalog.rebuild_tap(tap)
-            except BoostError as e:
-                out.warn("could not tap %s: %s" % (default["name"], e.message))
-                rc = 1
-                continue
-            journal.log("tap", tap.name)
-            # "items", not "skills": the defaults now carry rules and
-            # workflows, so a pure rules registry reported "257 skills"
-            # immediately after the README promised three kinds.
-            out.ok("tapped %s (%d items) — %s"
-                   % (tap.name, len(entries), default.get("focus", "")))
+        # "items", not "skills": the defaults now carry rules and workflows, so
+        # a pure rules registry reported "257 skills" immediately after the
+        # README promised three kinds. `_tap_all` says items.
+        rc |= _tap_all([str(d["url"]) for d in config.DEFAULT_TAPS],
+                       jobs=args.jobs,
+                       focus={str(d["name"]): str(d.get("focus", ""))
+                              for d in config.DEFAULT_TAPS})
     if args.spec:
         with spin.Spinner("cloning %s" % args.spec):
             tap = registry.add(args.spec, curated=args.curated, at=args.at)

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/boost_cli/core/registry.py

@@ -4,6 +4,9 @@
 from __future__ import annotations
 
 import difflib
+import os
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -206,6 +209,149 @@ def add(spec: str, curated: bool = False, at: str | None = None) -> Tap:
     return tap
 
 
+#: Default concurrency for :func:`add_many`. Tapping is network-latency bound,
+#: not bandwidth or CPU bound: a clone of a catalog registry measures ~1.6 s
+#: whether one runs or twelve do, so the wall time of `boost tap --catalog` was
+#: 463 x 1.6 s ~= 13 minutes of mostly waiting. Measured on the real catalog,
+#: 40 registries went from 58 s serial to 6.4 s at 12 workers with the per-repo
+#: median unchanged (1.55 s -> 1.46 s), which is what says the concurrency is
+#: not being paid for somewhere else.
+DEFAULT_TAP_JOBS = 8
+
+#: Politeness ceiling. Nothing in the measurements argues for more, and this is
+#: someone else's server: past this the risk of being throttled outweighs a
+#: wall-time gain that is already asymptotic.
+MAX_TAP_JOBS = 16
+
+
+def tap_jobs(requested: int | None = None) -> int:
+    """How many clones to run at once, clamped to something defensible."""
+    if requested is None:
+        env = os.environ.get("BOOST_TAP_JOBS")
+        requested = int(env) if env and env.isdigit() else DEFAULT_TAP_JOBS
+    return max(1, min(int(requested), MAX_TAP_JOBS))
+
+
+def _discard(tap: Tap) -> None:
+    """Remove a rejected clone, tolerating one that was never created.
+
+    `add` only ever deleted a directory it had just cloned successfully, so it
+    could call `rmtree` unguarded. Here the failure may be the clone itself —
+    at which point the path does not exist, and `util.rmtree`'s read-only retry
+    hook chmods a missing file and raises `FileNotFoundError` out of the worker
+    thread, turning "this one registry 404'd" into a crashed catalog tap.
+    """
+    # Cleanup is best-effort: the caller's real error is the one worth
+    # reporting, and a leftover directory is a smaller problem than losing it
+    # behind a cleanup failure.
+    with suppress(OSError):
+        if tap.path.exists():
+            util.rmtree(tap.path)
+
+
+def _clone_one(spec: str, curated: bool, at: str | None) -> dict:
+    """Clone one tap without touching config. Never raises.
+
+    Config is deliberately left alone: `config.load()` -> mutate -> `save()` is
+    read-modify-write on a single JSON file, so running it from N threads loses
+    taps at random. :func:`add_many` writes once, on one thread, after every
+    clone has finished.
+    """
+    try:
+        name, url = parse_spec(spec)
+    except BoostError as exc:
+        return {"spec": spec, "name": spec, "ok": False, "error": exc.message}
+    tap = Tap(name=name, url=url, curated=curated)
+    try:
+        if tap.path.exists():
+            util.rmtree(tap.path)
+        gitutil.clone_shallow(url, tap.path)
+        if at:
+            gitutil.checkout_commit(tap.path, at)
+        problems = policy.check_tap_signing(tap.path)
+        if problems:
+            _discard(tap)
+            return {"spec": spec, "name": name, "ok": False,
+                    "error": "failed provenance policy: %s" % "; ".join(problems)}
+    except BoostError as exc:
+        # Leave no half-added tap behind, exactly as `add` does: a clone that
+        # failed its pin or its policy check is not a tap, and a directory that
+        # looks like one would be indexed on the next scan.
+        _discard(tap)
+        return {"spec": spec, "name": name, "ok": False, "error": exc.message}
+    return {"spec": spec, "name": name, "url": url, "ok": True, "tap": tap}
+
+
+def add_many(specs: list[str], curated: bool = False,
+             pins: dict[str, str] | None = None, jobs: int | None = None,
+             on_done=None) -> list[dict]:
+    """Clone many taps at once and register them in a single config write.
+
+    Returns one result dict per spec, in the order given, each with ``ok`` and
+    either ``tap`` or ``error``. One registry's failure never costs another its
+    clone — a catalog tap of 463 repos that aborted on the first 404 would be
+    worse than useless.
+
+    `pins` maps a tap name to the commit to check out, for published vector
+    shards (see ``core.shards``).
+    """
+    if not specs:
+        return []
+    paths.ensure_dirs()
+    pins = pins or {}
+    existing = {t.name for t in list_taps()}
+    results: list[dict] = []
+    todo: list[str] = []
+    for spec in specs:
+        try:
+            name, _url = parse_spec(spec)
+        except BoostError as exc:
+            results.append({"spec": spec, "name": spec, "ok": False,
+                            "error": exc.message})
+            continue
+        if name in existing:
+            results.append({"spec": spec, "name": name, "ok": False,
+                            "skipped": True, "error": "already tapped"})
+            continue
+        # Guard against the same registry appearing twice in one selection:
+        # two threads cloning into one directory is a corrupt clone, not a race
+        # anyone would enjoy debugging.
+        existing.add(name)
+        todo.append(spec)
+
+    def work(spec: str) -> dict:
+        name, _url = parse_spec(spec)
+        return _clone_one(spec, curated, pins.get(name))
+
+    with ThreadPoolExecutor(max_workers=tap_jobs(jobs)) as pool:
+        for res in pool.map(work, todo):
+            results.append(res)
+            if on_done is not None:
+                on_done(res)
+
+    # One read-modify-write, after every clone: N threads doing this each would
+    # lose taps, and 463 sequential rewrites of the same file is its own cost.
+    fresh = [r for r in results if r.get("ok")]
+    if fresh:
+        cfg = config.load()
+        rows = cfg.setdefault("taps", [])
+        for r in fresh:
+            rows.append({"name": r["name"], "url": r["url"],
+                         "curated": curated})
+        config.save(cfg)
+    # First occurrence, not last: a dict comprehension over `specs` keeps the
+    # LAST index for a repeated spec, which pushed the duplicate — and so its
+    # whole position — to the end and reordered everything in between.
+    order: dict[str, int] = {}
+    for i, spec in enumerate(specs):
+        order.setdefault(spec, i)
+    # Ties are the repeats themselves; report the clone before the "already
+    # tapped" note about it.
+    results.sort(key=lambda r: (order.get(r["spec"], len(order)),
+                                bool(r.get("skipped"))))
+    return results
+
+
 def remove(name: str) -> Tap:
     """Deregister a tap and delete its clone and cache file.
 

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.45
+Version: 1.2.46
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -210,6 +210,11 @@ boost tap --catalog --category java           # Spring Boot / Kotlin / JVM packs
 boost tap --catalog --category security       # filter by category
 ```
 
+Taps clone in parallel — eight at once by default, `--jobs N` (or
+`BOOST_TAP_JOBS`) to change it, capped at 16 because it is someone else's
+server. A clone is network latency rather than bandwidth, so the whole catalog
+measures **2 min 10 s for 463 registries** where one-at-a-time took 13 minutes.
+
 Every `est_items` is measured from the repository's file tree rather than
 estimated, so `--limit` ranks by real size. Items are counted once however many
 agents a repository renders them for, so a pack shipping a copy in `.claude/`,

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/boost_skill_cli.egg-info/SOURCES.txt

@@ -761,6 +761,7 @@ tests/unit/test_registries_fresh.py
 tests/unit/test_registry.py
 tests/unit/test_registry_categories.py
 tests/unit/test_registry_control_chars.py
+tests/unit/test_registry_parallel.py
 tests/unit/test_release_guard.py
 tests/unit/test_release_preflight.py
 tests/unit/test_required_checks.py

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/docs/commands.html

@@ -142,7 +142,7 @@
     </div>
     <div class="group" data-group="tap">
       <div class="group-h">Taps &amp; registries</div>
-      <a class="cmd-link" href="#cmd-tap" data-search="tap add a github repo as a skill registry  --defaults --catalog --type {skill,rule,workflow} --category category --limit n --include-lists --dry-run --curated --at sha spec">tap</a>
+      <a class="cmd-link" href="#cmd-tap" data-search="tap add a github repo as a skill registry  --defaults --catalog --type {skill,rule,workflow} --category category --limit n --include-lists --dry-run --curated --at sha --jobs n spec">tap</a>
       <a class="cmd-link" href="#cmd-untap" data-search="untap remove a registry tap  -f, --force name">untap</a>
       <a class="cmd-link" href="#cmd-taps" data-search="taps list all configured registry taps  --json">taps</a>
       <a class="cmd-link" href="#cmd-outdated" data-search="outdated show skills with available updates  --json">outdated</a>
@@ -624,10 +624,10 @@
         </div>
       </section>
       <h2 class="group-h" id="grp-tap">Taps &amp; registries</h2>
-      <section class="cmd" id="cmd-tap" data-search="tap add a github repo as a skill registry  --defaults --catalog --type {skill,rule,workflow} --category category --limit n --include-lists --dry-run --curated --at sha spec">
+      <section class="cmd" id="cmd-tap" data-search="tap add a github repo as a skill registry  --defaults --catalog --type {skill,rule,workflow} --category category --limit n --include-lists --dry-run --curated --at sha --jobs n spec">
         <h3><span class="cname">tap</span><span class="gtag">tap</span></h3>
         <p class="summary">Add a GitHub repo as a skill registry</p>
-        <pre class="syn">boost tap [--defaults] [--catalog] [--type {skill,rule,workflow}] [--category CATEGORY] [--limit N] [--include-lists] [--dry-run] [--curated] [--at SHA] [spec]</pre>
+        <pre class="syn">boost tap [--defaults] [--catalog] [--type {skill,rule,workflow}] [--category CATEGORY] [--limit N] [--include-lists] [--dry-run] [--curated] [--at SHA] [--jobs N] [spec]</pre>
         <div class="args-h">Arguments</div>
         <div class="args">
           <div class="arg"><code>spec</code><span>owner/repo, a git URL, or a local directory</span></div>
@@ -643,6 +643,7 @@
           <div class="arg"><code>--dry-run</code><span>with --catalog: print what would be tapped, tap nothing</span></div>
           <div class="arg"><code>--curated</code><span>mark the tap as curated (★ in listings)</span></div>
           <div class="arg"><code>--at SHA</code><span>pin the clone to one 40-character commit, as a published vector shard requires</span></div>
+          <div class="arg"><code>--jobs N</code><span>clone this many registries at once (default 8, max 16)</span></div>
         </div>
       </section>
       <section class="cmd" id="cmd-untap" data-search="untap remove a registry tap  -f, --force name">

{boost_skill_cli-1.2.45 → boost_skill_cli-1.2.46}/tests/functional/test_cli_quickstart.py

@@ -70,6 +70,76 @@ class TestQuickstartWithoutTheExtra:
         assert "would tap" in res.out
 
 
+class TestQuickstartTapping:
+    """The real tap path, with the network replaced rather than the command."""
+
+    @pytest.fixture()
+    def fake_taps(self, monkeypatch):
+        """`add_many` answers with one of each outcome, in order."""
+        from boost_cli.core import catalog, config, registry
+
+        class FakeTap:
+            def __init__(self, name):
+                self.name = name
+                self.safe_name = name.replace("/", "__")
+
+        names = [str(d["name"]) for d in config.DEFAULT_TAPS]
+        calls = {}
+
+        def add_many(urls, curated=False, pins=None, jobs=None, on_done=None):
+            calls["pins"] = pins
+            calls["urls"] = list(urls)
+            out = []
+            for i, name in enumerate(names):
+                if i == 0:
+                    out.append({"spec": name, "name": name, "ok": False,
+                                "skipped": True, "error": "already tapped"})
+                elif i == 1:
+                    out.append({"spec": name, "name": name, "ok": False,
+                                "error": "repository not found"})
+                else:
+                    out.append({"spec": name, "name": name, "ok": True,
+                                "tap": FakeTap(name)})
+            return out
+
+        monkeypatch.setattr(registry, "add_many", add_many)
+        monkeypatch.setattr(catalog, "rebuild_tap", lambda tap: [{"name": "x"}])
+        monkeypatch.setattr("boost_cli.core.rag.build",
+                            lambda *a, **k: {"entries": 3})
+        return calls
+
+    def test_it_reports_each_outcome_and_survives_a_bad_registry(
+            self, boost, fake_taps):
+        res = boost("quickstart", "--no-vectors")
+        both = res.out + res.err
+        assert "already tapped" in both
+        # One registry failing must not stop the other six.
+        assert "repository not found" in both
+        assert both.count("tapped ") >= 2
+        assert "ready" in both
+
+    def test_shard_commits_are_passed_as_pins(self, boost, fake_taps,
+                                              manifest, monkeypatch):
+        from boost_cli.core import dense, embed, shards
+        monkeypatch.setattr(dense, "have_backend", lambda: True)
+        monkeypatch.setattr(embed, "provider", lambda: "local")
+        monkeypatch.setattr(embed, "model", lambda: SPACE["model"])
+        monkeypatch.setattr(embed, "dimension", lambda: 384)
+        monkeypatch.setattr(shards, "sync",
+                            lambda *a, **k: [])
+        boost("quickstart")
+        # The manifest names a/b, which is not a default tap, so no pin applies
+        # — but the pins dict must still have been threaded through rather than
+        # dropped, or a pinned registry would be tapped at HEAD.
+        assert fake_taps["pins"] == {}
+
+    def test_the_urls_tapped_are_the_default_registries(self, boost,
+                                                        fake_taps):
+        from boost_cli.core import config
+        boost("quickstart", "--no-vectors")
+        assert fake_taps["urls"] == [str(d["url"]) for d in config.DEFAULT_TAPS]
+
+
 class TestFetchShards:
     def test_no_taps_is_a_clear_error_not_a_fetch(self, boost, manifest):
         res = boost("reindex", "--fetch-shards", expect=1)