boost-skill-cli 1.2.82__tar.gz → 1.2.84__tar.gz

{boost_skill_cli-1.2.82/boost_skill_cli.egg-info → boost_skill_cli-1.2.84}/PKG-INFO

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

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/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.82'
-__version_tuple__ = version_tuple = (1, 2, 82)
+__version__ = version = '1.2.84'
+__version_tuple__ = version_tuple = (1, 2, 84)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/boost_cli/commands/pkg.py

@@ -1767,8 +1767,12 @@ def cmd_adapt(argv: list[str]) -> int:
     # A skill that declares subagents projects to a runnable multi-agent
     # workflow (a CrewAI Crew / LangGraph StateGraph) when the target supports
     # one; flat skills — and multi-agent targets without a crew path — keep the
-    # single-Agent render.
-    subagents = adapters.discover_subagents(skill_md.parent)
+    # single-Agent render. Subagent discovery only applies to a SKILL.md-rooted
+    # skill: a flat `agents/<name>.md` workflow's "directory" is the registry's
+    # shared agents/ folder, and every sibling workflow living in it is not a
+    # subagent of this one.
+    subagents = (adapters.discover_subagents(skill_md.parent, own_file=skill_md)
+                 if skill_md.name == "SKILL.md" else [])
     crew_size = 0
     if subagents and adapters.supports_multi(args.to):
         primary = adapters.AgentSpec(display, description, body,

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/boost_cli/core/adapters.py

@@ -154,23 +154,27 @@ def parse_tools(meta: dict) -> list[str]:
     return seen
 
 
-def discover_subagents(skill_dir: Path) -> list[AgentSpec]:
+def discover_subagents(skill_dir: Path, own_file: Path | None = None) -> list[AgentSpec]:
     """Discover a skill's subagents for multi-agent adaptation.
 
-    A subagent is a Markdown file (other than ``SKILL.md``) that lives under an
-    ``agents/`` or ``subagents/`` directory anywhere beneath ``skill_dir`` and
-    carries both a frontmatter ``name`` and ``description``. Files are visited in
-    sorted path order so the emitted crew/graph is deterministic. Returns the
-    subagents as :class:`AgentSpec`s — an empty list for a flat single-agent
-    skill or a missing directory.
+    A subagent is a Markdown file (other than ``SKILL.md`` or ``own_file``,
+    the entry being adapted) that lives under an ``agents/`` or ``subagents/``
+    directory strictly beneath ``skill_dir`` — not ``skill_dir`` itself, so a
+    flat item whose own directory happens to be shared (a registry-wide
+    ``agents/`` folder holding one Markdown file per workflow) never treats
+    its siblings as subagents — and carries both a frontmatter ``name`` and
+    ``description``. Files are visited in sorted path order so the emitted
+    crew/graph is deterministic. Returns the subagents as :class:`AgentSpec`s
+    — an empty list for a flat single-agent skill or a missing directory.
     """
     specs: list[AgentSpec] = []
     if not skill_dir or not skill_dir.is_dir():
         return specs
     for path in sorted(skill_dir.rglob("*.md")):
-        if path.name == "SKILL.md":
+        if path.name == "SKILL.md" or path == own_file:
             continue
-        if not (SUBAGENT_DIRS & {part.lower() for part in path.parent.parts}):
+        rel_dirs = {part.lower() for part in path.relative_to(skill_dir).parts[:-1]}
+        if not (SUBAGENT_DIRS & rel_dirs):
             continue
         try:
             meta, body = frontmatter.parse(

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/boost_cli/core/rag.py

@@ -25,6 +25,7 @@ import math
 import os
 import re
 import sqlite3
+import tempfile
 from collections import defaultdict
 from collections.abc import Sequence
 from functools import lru_cache
@@ -41,7 +42,10 @@ from . import ai, catalog, config, frontmatter, gitutil, paths, registry, util
 # v2: `snip` stores a larger head of the matched chunk (not just SNIP_WIDTH
 # chars) so `retrieve` can window it onto the query terms; bump forces a
 # one-time reindex.
-INDEX_VERSION = 6
+# v7: postings interns term text into its own `terms` table instead of
+# repeating it on every posting row — see `_write_postings`; bump forces a
+# one-time reindex so every store gets the smaller layout.
+INDEX_VERSION = 7
 ENGINE = "bm25"
 
 # Chunking defaults (documented in docs/rag-architecture.md §4).
@@ -331,27 +335,66 @@ def _write_postings(postings: dict[str, list[list[int]]]) -> None:
     SQLite is used purely as an indexed key-value store here, not as a search
     engine: BM25 scoring stays in `_bm25` byte for byte, so this changes cold
     start cost and nothing about which results come back.
+
+    Terms are interned into their own table rather than repeated on every
+    posting row. Measured on a real 458-tap store: 18,619,658 posting rows over
+    210,422 distinct terms averaging 6.6 characters — the term string alone was
+    ~123 MB of the 653 MB file, stored on average 88 times over. `postings` now
+    carries an integer `term_id`, and `terms` also carries each term's document
+    frequency (`df`, the length of its posting list) so `stem_expansions` can
+    read it directly instead of re-deriving it with `GROUP BY` on every lookup.
     """
     paths.ensure_dirs()
     final = postings_path()
-    tmp = final.with_suffix(".sqlite.tmp")
-    with contextlib.suppress(OSError):
-        tmp.unlink()
+    # A UNIQUE temp per build, not a fixed `.sqlite.tmp`, and this is a
+    # concurrency fix rather than tidiness. Every build used to write the same
+    # name and unlink it on entry, so a second build starting mid-flight
+    # deleted the first's *finished* file and the first died on the swap:
+    #
+    #   FileNotFoundError: rag_postings.sqlite.tmp -> rag_postings.sqlite
+    #
+    # observed on a real 464-tap install. The loser threw away several minutes
+    # of work and returned a crash report instead of an index. Nothing here is
+    # exotic — `boost search` builds on a cold index, so two terminals is
+    # enough to hit it. Same mkstemp-then-replace shape as
+    # `util.atomic_write_text`, which every other file boost must not lose
+    # already goes through.
+    fd, tmp_name = tempfile.mkstemp(dir=str(final.parent),
+                                    prefix="." + final.name + ".",
+                                    suffix=".tmp")
+    os.close(fd)                # SQLite opens the path itself
+    tmp = Path(tmp_name)
     con = sqlite3.connect(str(tmp))
     try:
         # No durability needed: this file is a derived cache, and a crash
         # mid-build leaves the .tmp behind rather than a torn index.
         con.execute("PRAGMA journal_mode=OFF")
         con.execute("PRAGMA synchronous=OFF")
-        con.execute("CREATE TABLE postings (term TEXT, doc INTEGER, tf INTEGER)")
+        con.execute("CREATE TABLE terms (id INTEGER PRIMARY KEY, "
+                    "term TEXT NOT NULL, df INTEGER NOT NULL)")
+        con.execute("CREATE TABLE postings (term_id INTEGER, doc INTEGER, "
+                    "tf INTEGER)")
+        items = list(postings.items())
+        con.executemany(
+            "INSERT INTO terms (id, term, df) VALUES (?, ?, ?)",
+            ((term_id, term, len(plist))
+             for term_id, (term, plist) in enumerate(items)))
         con.executemany(
-            "INSERT INTO postings (term, doc, tf) VALUES (?, ?, ?)",
-            ((term, doc, tf) for term, plist in postings.items()
+            "INSERT INTO postings (term_id, doc, tf) VALUES (?, ?, ?)",
+            ((term_id, doc, tf) for term_id, (_term, plist) in enumerate(items)
              for doc, tf in plist))
         # Built after the insert: maintaining it per-row is far slower.
-        con.execute("CREATE INDEX postings_term ON postings(term)")
+        con.execute("CREATE UNIQUE INDEX terms_term ON terms(term)")
+        con.execute("CREATE INDEX postings_term_id ON postings(term_id)")
         con.commit()
-    finally:
+    except BaseException:
+        # Never leave a temp behind, and never mask the original error —
+        # `util.atomic_write_text`'s rule, for the same reason.
+        con.close()
+        with contextlib.suppress(OSError):
+            tmp.unlink()
+        raise
+    else:
         con.close()
     tmp.replace(final)          # atomic swap, same as the JSON half
 
@@ -375,8 +418,9 @@ def read_postings(terms: Sequence[str]) -> dict[str, list[list[int]]]:
         # long query can exceed it.
         for i in range(0, len(uniq), 500):
             batch = uniq[i:i + 500]
-            q = ("SELECT term, doc, tf FROM postings WHERE term IN (%s)"  # noqa: S608  interpolates only `?` placeholders; terms are bound params
-                 % ",".join("?" * len(batch)))
+            q = ("SELECT t.term, p.doc, p.tf FROM postings p "  # noqa: S608  interpolates only `?` placeholders; terms are bound params
+                 "JOIN terms t ON p.term_id = t.id "
+                 "WHERE t.term IN (%s)" % ",".join("?" * len(batch)))
             for term, doc, tf in con.execute(q, batch):
                 out[term].append([doc, tf])
     except sqlite3.Error:
@@ -429,12 +473,14 @@ def stem_expansions(terms: Sequence[str]) -> dict[str, str]:
         for term in missing:
             # `tokenize` emits only [a-z0-9]+, and "~" sorts above every
             # character it can produce — so this half-open range is exactly the
-            # terms beginning with `term`, and it rides the postings_term index
-            # instead of scanning. Ties break on the term itself so the choice
-            # is deterministic across machines.
+            # terms beginning with `term`, and it rides the terms_term index
+            # instead of scanning. `df` (document frequency) is stored per term
+            # at build time, so this needs no join and no GROUP BY. Ties break
+            # on the term itself so the choice is deterministic across
+            # machines.
             row = con.execute(
-                "SELECT term FROM postings WHERE term > ? AND term < ? "
-                "GROUP BY term ORDER BY COUNT(*) DESC, term LIMIT 1",
+                "SELECT term FROM terms WHERE term > ? AND term < ? "
+                "ORDER BY df DESC, term LIMIT 1",
                 (term, term + "~")).fetchone()
             if row:
                 out[term] = row[0]
@@ -453,7 +499,9 @@ def _all_postings() -> dict[str, list[list[int]]]:
         return {}
     out: dict[str, list[list[int]]] = defaultdict(list)
     try:
-        for term, doc, tf in con.execute("SELECT term, doc, tf FROM postings"):
+        for term, doc, tf in con.execute(
+                "SELECT t.term, p.doc, p.tf FROM postings p "
+                "JOIN terms t ON p.term_id = t.id"):
             out[term].append([doc, tf])
     except sqlite3.Error:
         return {}

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/boost_skill_cli.egg-info/SOURCES.txt

@@ -352,6 +352,7 @@ docs/roadmap/items/command-reference-docs-site.md
 docs/roadmap/items/completions-complete-only-command-names.md
 docs/roadmap/items/completions-install-could-eat-your-rc-file.md
 docs/roadmap/items/complexity-and-dead-code-radar-xenon-vulture.md
+docs/roadmap/items/concurrent-rag-builds-delete-each-others-temp-index.md
 docs/roadmap/items/consolidate-skill-staleness-drift-logic-into-cor.md
 docs/roadmap/items/coverage-dashboard-codecov-free-for-oss.md
 docs/roadmap/items/coverage-guided-fuzzing-atheris-oss-fuzz.md

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/docs/roadmap/items/audit-adapt-renders-every-sibling-of-a-flat-agents-dir-workflow-as.md

@@ -2,15 +2,15 @@
 id: audit-adapt-renders-every-sibling-of-a-flat-agents-dir-workflow-as
 board: code
 section: internals
-status: planned
+status: shipped
 category: CLI · Bug
 complexity: S
 impact: High
 wow: 2
 note: one flat agents/x.md adapts into a 383 KB crew of 138 Agent()s — including itself, twice
 order: 200
-owner:
-pr:
+owner: loop/adapt-flat-agents-subagent-scope
+pr: 692
 title: "<code>adapt</code> renders every sibling of a flat <code>agents/</code>-dir workflow as a 138-agent crew"
 ---
 <code>adapt actix-expert --to crewai -o x.py</code> prints <em>&ldquo;&#10003; adapted actix-expert &rarr; x.py (crew of 138 &middot; claude-haiku-4-5-20251001)&rdquo;</em> and writes a <b>383 KB</b> render containing <b>138 <code>Agent()</code> + 138 <code>Task()</code></b> &mdash; <code>actix_expert</code>, then <code>actix_expert_1</code> (the item itself, again), then android-expert, angular-expert, &hellip; every sibling in the registry's <code>agents/</code> directory. <code>--to agents-sdk</code> announces <em>&ldquo;note: actix-expert declares 137 subagent(s)&rdquo;</em>. The item is one flat frontmatter file declaring nothing.

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/docs/roadmap/items/audit-install-local-writes-empties-the-repo-s-mcp-json-silently-of.md

@@ -2,7 +2,7 @@
 id: audit-install-local-writes-empties-the-repo-s-mcp-json-silently-of
 board: code
 section: dx
-status: inflight
+status: shipped
 category: CLI · Bug
 complexity: S
 impact: High

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/docs/roadmap/items/audit-tap-dry-run-is-silently-ignored-outside-catalog-spec-and-def.md

@@ -2,7 +2,7 @@
 id: audit-tap-dry-run-is-silently-ignored-outside-catalog-spec-and-def
 board: code
 section: dx
-status: inflight
+status: shipped
 category: Safety · Bug
 complexity: S
 impact: High

boost_skill_cli-1.2.84/docs/roadmap/items/concurrent-rag-builds-delete-each-others-temp-index.md

@@ -0,0 +1,17 @@
+---
+id: concurrent-rag-builds-delete-each-others-temp-index
+board: code
+section: internals
+status: shipped
+category: Reliability · Bug
+complexity: S
+impact: High
+wow: 3
+note: two overlapping rag.build() runs share one .tmp name; the second unlinks the first's finished 644 MB file and the first dies on replace()
+order: 308
+owner: loop/postings-temp-race
+pr: 693
+title: "Two concurrent <code>rag.build()</code> runs delete each other's temp index"
+---
+Observed on a real 464-tap install during <code>boost update --shards</code>, at boost 1.2.80:
+<code>FileNotFoundError: [Errno&nbsp;2] No such file or directory: '~/.boost/cache/rag_postings.sqlite.tmp' -&gt; '~/.boost/cache/rag_postings.sqlite'</code>, raised from <code>tmp.replace(final)</code> in <code>_write_postings</code>. <code>_write_postings</code> wrote every build to the <b>same</b> fixed temp path and unlinked it on entry, so a second build starting mid-flight deleted the first's <em>completed</em> file: A builds its 644&nbsp;MB temp &rarr; B enters and <code>unlink()</code>s it &rarr; A crashes on the swap. Confirmed by timestamps &mdash; the crash landed at 21:25 and a fresh <code>.tmp</code> appeared at 21:26, which then swapped in cleanly, so the index was never corrupt and the loser simply threw away several minutes of work and returned a crash report. It needs no exotic setup: <code>boost search</code> builds on a cold index, so two terminals is enough, and <code>_ingest_shards</code> rebuilds the index for any tap that moved. Fixed by giving each build its own <code>tempfile.mkstemp</code> name and unlinking it on failure &mdash; the same shape <code>util.atomic_write_text</code> already uses for every other file boost must not lose.

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/docs/roadmap/items/shrink-the-published-index.md

@@ -2,13 +2,14 @@
 id: shrink-the-published-index
 board: code
 section: planned
-status: planned
+status: inflight
 category: Performance · Storage
 complexity: M
 impact: Med
 wow: 3
 note: 653 MB of postings holds 1.4 MB of distinct terms — the term string is stored 88 times over
 order: 100
+owner: loop/shrink-postings-index
 title: shrink the keyword index before publishing it — structure first, then compression
 ---
 <a href="#publish-the-keyword-index">publish-the-keyword-index</a> is worth doing only if the
@@ -58,3 +59,17 @@ for the many-small-registries case, where per-shard compression has little conte
 — on the real store, with import-side decode time beside each. That table is what tells
 <a href="#publish-the-keyword-index">publish-the-keyword-index</a> what to ship, and it is worth
 having even if publishing is declined: the on-disk win applies to every install today.
+
+<b>Progress (PR pending).</b> The structural half shipped: <code>_write_postings</code> now
+interns terms into their own <code>terms(id, term, df)</code> table, with <code>postings</code>
+carrying an integer <code>term_id</code> instead of repeating the term string on every row —
+exactly the "structure first" change this card calls the bigger win, and it bumps
+<code>INDEX_VERSION</code> so every store picks it up on its next rebuild.
+<code>stem_expansions</code> now reads the precomputed <code>df</code> column directly instead of
+a <code>GROUP BY COUNT(*)</code> over <code>postings</code> on every prefix lookup. Not done: the
+delta/varint doc-id encoding, and the full raw/interned/delta+varint &times;
+none/gzip/zstd comparison table with import-side decode times on a real multi-hundred-MB store —
+this sandbox has no such store to measure against, only a small synthetic one (interning alone cut
+a 1.8M-posting/20k-term synthetic store from 63.6&nbsp;MB to 47.9&nbsp;MB, directionally consistent
+with the real-store estimate above but not a substitute for it). Left as follow-on work before this
+card can be called shipped.

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/docs/roadmap.html

@@ -133,7 +133,7 @@
       <div class="stat"><b>20</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>11</b><span>Planned</span></div>
-      <div class="stat"><b>404</b><span>Loop finds</span></div>
+      <div class="stat"><b>405</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -1078,7 +1078,7 @@ is not obviously the right trade, and at the compressed sizes measured there it
       </article>
 
       <article class="cap rcard" id="shrink-the-published-index">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Performance · Storage</span></div>
+        <div class="head"><span class="pill inflight">In flight</span><span class="cat">Performance · Storage</span></div>
         <h3>shrink the keyword index before publishing it — structure first, then compression</h3>
         <p><a href="#publish-the-keyword-index">publish-the-keyword-index</a> is worth doing only if the
 artifact is small enough to ship weekly. This card is the measurement that decides it, and the
@@ -1126,7 +1126,21 @@ for the many-small-registries case, where per-shard compression has little conte
 <b>Deliverable.</b> A measured comparison — raw, interned, delta+varint, each &times; none/gzip/zstd
 — on the real store, with import-side decode time beside each. That table is what tells
 <a href="#publish-the-keyword-index">publish-the-keyword-index</a> what to ship, and it is worth
-having even if publishing is declined: the on-disk win applies to every install today.</p>
+having even if publishing is declined: the on-disk win applies to every install today.
+
+<b>Progress (PR pending).</b> The structural half shipped: <code>_write_postings</code> now
+interns terms into their own <code>terms(id, term, df)</code> table, with <code>postings</code>
+carrying an integer <code>term_id</code> instead of repeating the term string on every row —
+exactly the "structure first" change this card calls the bigger win, and it bumps
+<code>INDEX_VERSION</code> so every store picks it up on its next rebuild.
+<code>stem_expansions</code> now reads the precomputed <code>df</code> column directly instead of
+a <code>GROUP BY COUNT(*)</code> over <code>postings</code> on every prefix lookup. Not done: the
+delta/varint doc-id encoding, and the full raw/interned/delta+varint &times;
+none/gzip/zstd comparison table with import-side decode times on a real multi-hundred-MB store —
+this sandbox has no such store to measure against, only a small synthetic one (interning alone cut
+a 1.8M-posting/20k-term synthetic store from 63.6&nbsp;MB to 47.9&nbsp;MB, directionally consistent
+with the real-store estimate above but not a substitute for it). Left as follow-on work before this
+card can be called shipped.</p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Med</b></span>
@@ -5325,15 +5339,16 @@ row has at least one referent.</p></details>
       </article>
 
       <article class="cap rcard" id="audit-adapt-renders-every-sibling-of-a-flat-agents-dir-workflow-as">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">CLI · Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">CLI · Bug</span></div>
         <h3><code>adapt</code> renders every sibling of a flat <code>agents/</code>-dir workflow as a 138-agent crew</h3>
+        <details class="cardbody"><summary>Write-up</summary>
         <p><code>adapt actix-expert --to crewai -o x.py</code> prints <em>&ldquo;&#10003; adapted actix-expert &rarr; x.py (crew of 138 &middot; claude-haiku-4-5-20251001)&rdquo;</em> and writes a <b>383 KB</b> render containing <b>138 <code>Agent()</code> + 138 <code>Task()</code></b> &mdash; <code>actix_expert</code>, then <code>actix_expert_1</code> (the item itself, again), then android-expert, angular-expert, &hellip; every sibling in the registry's <code>agents/</code> directory. <code>--to agents-sdk</code> announces <em>&ldquo;note: actix-expert declares 137 subagent(s)&rdquo;</em>. The item is one flat frontmatter file declaring nothing.
 
 The mechanism: <code>cmd_adapt</code> (<code>boost_cli/commands/pkg.py:1737</code>) passes <code>skill_md.parent</code> to <code>discover_subagents</code> (<code>boost_cli/core/adapters.py:157-186</code>). For a SKILL.md-rooted skill that parent is the skill's own directory and the feature works as shipped (<code>adapt brainstorming --to crewai</code> renders a single agent). For a flat <code>agents/&lt;x&gt;.md</code> workflow the parent <em>is</em> the registry-wide <code>agents/</code> dir, so all 137 siblings become a fabricated crew &mdash; and since the exclusion at <code>adapters.py:170-173</code> skips only <code>SKILL.md</code>, the adapted item is re-included as one of its own subagents.
 
 Fix per the verified recommendation: run <code>discover_subagents</code> only when the resolved item is SKILL.md-rooted (<code>skill_md.name == 'SKILL.md'</code>), and harden <code>discover_subagents</code> to skip the entry's own file and require the <code>agents/</code>/<code>subagents/</code> dir to be strictly beneath <code>skill_dir</code>. Add a unit test adapting a bare <code>agents/&lt;x&gt;.md</code> item that asserts a single-<code>Agent()</code> render. Update <code>docs/adapters.html</code> (subagent-discovery wording).
 
-Found by the 2026-08 CLI audit (cluster <code>adapt-subagent-misdetect</code>); repro in the audit log. Verified 2026-08-31: reproduced, defect in the shipped multi-agent adapter feature (whose design intended skill-declared subagents only), not a duplicate of it.</p>
+Found by the 2026-08 CLI audit (cluster <code>adapt-subagent-misdetect</code>); repro in the audit log. Verified 2026-08-31: reproduced, defect in the shipped multi-agent adapter feature (whose design intended skill-declared subagents only), not a duplicate of it.</p></details>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>
@@ -5614,6 +5629,20 @@ repro run needed. Absolute date of verification: 2026-08-31.</p></details>
           <span class="m">a quickstart rerun re-downloads every shard the store already holds at that commit</span>
         </div>
       </article>
+
+      <article class="cap rcard" id="concurrent-rag-builds-delete-each-others-temp-index">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Reliability · Bug</span></div>
+        <h3>Two concurrent <code>rag.build()</code> runs delete each other's temp index</h3>
+        <details class="cardbody"><summary>Write-up</summary>
+        <p>Observed on a real 464-tap install during <code>boost update --shards</code>, at boost 1.2.80:
+<code>FileNotFoundError: [Errno&nbsp;2] No such file or directory: '~/.boost/cache/rag_postings.sqlite.tmp' -&gt; '~/.boost/cache/rag_postings.sqlite'</code>, raised from <code>tmp.replace(final)</code> in <code>_write_postings</code>. <code>_write_postings</code> wrote every build to the <b>same</b> fixed temp path and unlinked it on entry, so a second build starting mid-flight deleted the first's <em>completed</em> file: A builds its 644&nbsp;MB temp &rarr; B enters and <code>unlink()</code>s it &rarr; A crashes on the swap. Confirmed by timestamps &mdash; the crash landed at 21:25 and a fresh <code>.tmp</code> appeared at 21:26, which then swapped in cleanly, so the index was never corrupt and the loser simply threw away several minutes of work and returned a crash report. It needs no exotic setup: <code>boost search</code> builds on a cold index, so two terminals is enough, and <code>_ingest_shards</code> rebuilds the index for any tap that moved. Fixed by giving each build its own <code>tempfile.mkstemp</code> name and unlinking it on failure &mdash; the same shape <code>util.atomic_write_text</code> already uses for every other file boost must not lose.</p></details>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">two overlapping rag.build() runs share one .tmp name; the second unlinks the first's finished 644 MB file and the first dies on replace()</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>
@@ -11826,8 +11855,9 @@ Found by the 2026-08 CLI audit (cluster <code>kinds-reported-as-skills</code>);
       </article>
 
       <article class="cap rcard" id="audit-install-local-writes-empties-the-repo-s-mcp-json-silently-of">
-        <div class="head"><span class="pill inflight">In flight</span><span class="cat">CLI · Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">CLI · Bug</span></div>
         <h3><code>install --local</code> writes the repo's <code>.mcp.json</code> silently — the 'recorded N servers' report never runs</h3>
+        <details class="cardbody"><summary>Write-up</summary>
         <p>Installing a skill that declares an MCP server with <code>--local</code> prints
 <em>&ldquo;&#10003; copied into this repo &rarr; claude-code &middot; windsurf &middot; cursor &middot;
 gemini / &#10003; project lock updated (.boost/skill-lock.json) / commit .boost/ to share these with
@@ -11853,7 +11883,7 @@ asserting the <em>&ldquo;recorded 1 MCP server in .mcp.json&rdquo;</em> line for
 uninstall side. Docs: fix <code>docs/roadmap/items/mcp-servers-ignore-install-scope.md</code>, which
 describes the recorded-report as reachable; no flag change, so <code>docs/commands.html</code> only
 needs regenerating if a summary moves. Found by the 2026-08 CLI audit (cluster
-<code>mcp-project-scope-report</code>); repro in the audit log.</p>
+<code>mcp-project-scope-report</code>); repro in the audit log.</p></details>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>
@@ -11982,15 +12012,16 @@ Found by the 2026-08 CLI audit (cluster <code>qualifier-rejected-elsewhere</code
       </article>
 
       <article class="cap rcard" id="audit-tap-dry-run-is-silently-ignored-outside-catalog-spec-and-def">
-        <div class="head"><span class="pill inflight">In flight</span><span class="cat">Safety · Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Safety · Bug</span></div>
         <h3><code>tap --dry-run</code> is silently ignored outside <code>--catalog</code>: SPEC and <code>--defaults</code> clone for real</h3>
+        <details class="cardbody"><summary>Write-up</summary>
         <p>On a pristine HOME, <code>boost tap --dry-run expo/skills</code> printed <code>&#10003; Tapped expo/skills (26 items)</code>, exit 0 in 1.56&nbsp;s &mdash; and the clone exists and <code>config.json</code> gained the row. <code>tap --defaults --dry-run</code> cloned five registries (<code>&#10003; tapped trailofbits/skills (124 items) &hellip;</code>) and grew the config from 21 to 26 taps. The multi-spec path is the same: <code>tap --dry-run expo/skills anthropics/skills</code> answered with <code>already tapped</code> lines, proving registry code ran. Help does say <em>&ldquo;with --catalog: print what would be tapped, tap nothing&rdquo;</em> &mdash; documented-narrow, but a flag literally named <code>--dry-run</code> that clones repos and writes config is a safety hole regardless of wording.
 
 The source confirms the shape: <code>taps.py</code> consults <code>args.dry_run</code> only inside <code>_tap_catalog</code> (<code>boost_cli/commands/taps.py:38</code>); <code>cmd_tap</code>'s defaults, single-spec and multi-spec branches (<code>taps.py:144-166</code>) never read it. Not a duplicate of the roadmap's <em>dry-run-promised-a-link-nobody-makes</em>, which is about <code>install --dry-run</code>.
 
 Fix, per the verified recommendation: in <code>cmd_tap</code>, when <code>args.dry_run</code> and (<code>args.spec</code> or <code>args.defaults</code>), print the parsed <code>(name, url)</code> per spec &mdash; or the <code>DEFAULT_TAPS</code> list &mdash; and return 0 <em>before</em> <code>registry.add</code>/<code>_tap_all</code>; update the <code>--dry-run</code> help text; add a unit test that <code>--dry-run SPEC</code> writes nothing. Docs: regenerate <code>docs/commands.html</code> after the help-text change.
 
-Found by the 2026-08 CLI audit (cluster <code>tap-dry-run-ignored</code>); repro in the audit log. Verified against source 2026-08-31.</p>
+Found by the 2026-08 CLI audit (cluster <code>tap-dry-run-ignored</code>); repro in the audit log. Verified against source 2026-08-31.</p></details>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/tests/functional/test_cli_adapt.py

@@ -3,6 +3,8 @@
 """Functional tests: `boost adapt` — render a skill as framework source."""
 from __future__ import annotations
 
+import subprocess
+
 
 def test_adapt_installed_skill_to_crewai_stdout(boost, installed):
     r = boost("adapt", installed, "--to", "crewai")
@@ -130,3 +132,41 @@ def test_multi_agent_target_without_crew_falls_back_with_note(boost, installed):
     assert "reviewer = Agent(" not in r.out
     assert "declares 2 subagent" in r.err
     compile(r.out, "<sdk>", "exec")
+
+
+# --- flat agents/-dir workflow item: not a multi-agent skill --------------
+
+def _flat_agents_tap(tmp_path):
+    """A registry whose agents/ directory holds one Markdown file per
+    stand-alone workflow item, no SKILL.md anywhere — the shape that made
+    `adapt` mistake every sibling workflow for a subagent of the one being
+    adapted."""
+    tap = tmp_path / "flat-tap"
+    agents = tap / "agents"
+    agents.mkdir(parents=True)
+    (agents / "actix-expert.md").write_text(
+        "---\nname: actix-expert\ndescription: Actix web framework expert\n---\n"
+        "Body for actix.\n", encoding="utf-8")
+    (agents / "android-expert.md").write_text(
+        "---\nname: android-expert\ndescription: Android expert\n---\n"
+        "Body for android.\n", encoding="utf-8")
+    run = lambda *a: subprocess.run(a, cwd=tap, check=True, capture_output=True)
+    run("git", "init", "-q")
+    run("git", "config", "user.email", "fixture@boost.test")
+    run("git", "config", "user.name", "Boost Fixture")
+    run("git", "add", "-A")
+    run("git", "commit", "-qm", "flat agents fixture")
+    return tap
+
+
+def test_flat_agents_dir_workflow_adapts_as_single_agent(boost, tmp_path):
+    tap = _flat_agents_tap(tmp_path)
+    boost("tap", str(tap))
+    r = boost("adapt", "actix-expert", "--to", "crewai", "--model", "none")
+    assert "actix_expert = Agent(" in r.out
+    # the sibling workflow in the same shared agents/ dir must not appear —
+    # neither as a rendered agent nor as a dropped-subagent note
+    assert "android_expert" not in r.out
+    assert "crew of" not in r.out
+    assert r.err == ""
+    compile(r.out, "<crewai>", "exec")

{boost_skill_cli-1.2.82 → boost_skill_cli-1.2.84}/tests/unit/test_adapters_multi.py

@@ -156,6 +156,35 @@ class TestDiscoverSubagents:
         f.write_text("---\nname: wf\ndescription: t\n---\n", encoding="utf-8")
         assert adapters.discover_subagents(f) == []   # not a directory
 
+    def test_shared_dir_itself_named_agents_has_no_subagents(self, tmp_path):
+        # A flat agents/<x>.md workflow item's "skill_dir" (its own file's
+        # parent) IS the registry-wide agents/ folder — siblings sitting
+        # directly inside it are not nested under an agents/subagents dir
+        # *beneath* skill_dir, so none of them count as subagents.
+        shared = tmp_path / "agents"
+        shared.mkdir()
+        (shared / "actix-expert.md").write_text(
+            "---\nname: actix-expert\ndescription: d\n---\nB\n", encoding="utf-8")
+        (shared / "android-expert.md").write_text(
+            "---\nname: android-expert\ndescription: d\n---\nB\n", encoding="utf-8")
+        assert adapters.discover_subagents(shared) == []
+
+    def test_own_file_excluded_even_when_nested(self, tmp_path):
+        # Defense in depth: the entry being adapted never counts as one of
+        # its own subagents, even if it happens to sit under a nested
+        # agents/subagents dir that legitimately holds other subagents.
+        _skill(tmp_path, {
+            "self.md": "---\nname: self\ndescription: d\n---\nB\n",
+            "helper.md": "---\nname: helper\ndescription: d\n---\nB\n",
+        })
+        own = tmp_path / "agents" / "self.md"
+        specs = adapters.discover_subagents(tmp_path, own_file=own)
+        assert [s.name for s in specs] == ["helper"]
+
+    def test_own_file_none_does_not_exclude_anything(self, tmp_path):
+        _skill(tmp_path, {"a.md": "---\nname: a\ndescription: x\n---\nB\n"})
+        assert [s.name for s in adapters.discover_subagents(tmp_path, own_file=None)] == ["a"]
+
 
 # --- helpers: idents & tool union ----------------------------------------