boost-skill-cli 1.2.83__tar.gz → 1.2.85__tar.gz

{boost_skill_cli-1.2.83/boost_skill_cli.egg-info → boost_skill_cli-1.2.85}/PKG-INFO

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

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85}/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.83'
-__version_tuple__ = version_tuple = (1, 2, 83)
+__version__ = version = '1.2.85'
+__version_tuple__ = version_tuple = (1, 2, 85)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85}/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.83 → boost_skill_cli-1.2.85}/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.83 → boost_skill_cli-1.2.85}/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
@@ -345,9 +346,24 @@ def _write_postings(postings: dict[str, list[list[int]]]) -> None:
     """
     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
@@ -371,7 +387,14 @@ def _write_postings(postings: dict[str, list[list[int]]]) -> None:
         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
 

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85}/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.83 → boost_skill_cli-1.2.85}/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.83 → boost_skill_cli-1.2.85}/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.85/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.83 → boost_skill_cli-1.2.85}/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>
@@ -5339,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>
@@ -5628,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>
@@ -11840,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
@@ -11867,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>

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85}/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.83 → boost_skill_cli-1.2.85}/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 ----------------------------------------
 

{boost_skill_cli-1.2.83 → boost_skill_cli-1.2.85}/tests/unit/test_rag.py

@@ -14,6 +14,7 @@ import math
 import os
 import sqlite3
 from pathlib import Path
+from unittest import mock
 
 import pytest
 
@@ -1620,3 +1621,106 @@ class TestPostingsInterning:
                             "VALUES (999, 'test', 1)")
         finally:
             con.close()
+
+
+class TestConcurrentPostingsBuildsDoNotDestroyEachOther:
+    """Two `rag.build()` runs must not delete each other's temp file.
+
+    `_write_postings` writes to a temp beside the final path and swaps it in.
+    While that temp had a FIXED name and was unlinked on entry, a second build
+    starting mid-flight deleted the first's finished file, and the first then
+    raised `FileNotFoundError` out of `tmp.replace(final)` — observed on a real
+    464-tap install:
+
+        FileNotFoundError: rag_postings.sqlite.tmp -> rag_postings.sqlite
+          at rag.py in _write_postings, tmp.replace(final)
+
+    The loser's work is thrown away and the user gets a crash report rather
+    than a result, on a command whose whole job is to rebuild that file.
+    `boost search` auto-builds on a cold index, so two terminals is enough.
+    """
+
+    def test_a_second_build_does_not_delete_the_first_s_temp(self, sandbox):
+        # A writes its temp; B runs to completion in the middle; A must still
+        # be able to swap its own file in.
+        seen: list = []
+        real_connect = rag.sqlite3.connect
+
+        def connect_then_run_a_rival(path, *a, **kw):
+            con = real_connect(path, *a, **kw)
+            if not seen:
+                seen.append(path)
+                # A rival build, start to finish, while this one is open.
+                rag._write_postings({"beta": [[1, 1]]})
+            return con
+
+        with mock.patch.object(rag.sqlite3, "connect",
+                               side_effect=connect_then_run_a_rival):
+            rag._write_postings({"alpha": [[0, 1]]})
+
+        # No crash is the headline, and the file the outer build wrote is the
+        # one that must be standing.
+        assert rag.postings_path().exists()
+        assert rag.read_postings(["alpha"])["alpha"] == [[0, 1]]
+
+    def test_each_build_uses_its_own_temp_path(self, sandbox):
+        # The mechanism, pinned directly: a shared constant temp name is what
+        # made the race possible, so two builds must not name the same file.
+        names: list[str] = []
+        real_connect = rag.sqlite3.connect
+
+        def record(path, *a, **kw):
+            names.append(str(path))
+            return real_connect(path, *a, **kw)
+
+        with mock.patch.object(rag.sqlite3, "connect", side_effect=record):
+            rag._write_postings({"alpha": [[0, 1]]})
+            rag._write_postings({"beta": [[1, 1]]})
+
+        assert len(names) == 2
+        assert names[0] != names[1], (
+            "both builds wrote %s — a fixed temp name lets one delete the "
+            "other's finished file" % names[0])
+
+    def test_no_temp_files_are_left_behind(self, sandbox):
+        rag._write_postings({"alpha": [[0, 1]]})
+        leftovers = list(rag.postings_path().parent.glob("*.tmp*"))
+        assert leftovers == [], "left %s behind" % leftovers
+
+    def test_a_failed_build_cleans_up_and_leaves_the_old_index_standing(
+            self, sandbox):
+        """A build that raises must not leave a temp behind or eat the error.
+
+        The cleanup path is the whole reason the temp is unique: if a failing
+        build left its file, the directory would fill with one per crash, and
+        a swallowed exception would report success for an index that was never
+        written. `util.atomic_write_text` makes the same two guarantees.
+        """
+        rag._write_postings({"alpha": [[0, 1]]})       # an index worth keeping
+        before = rag.postings_path().read_bytes()
+
+        closed: list[bool] = []
+
+        class Boom:
+            def execute(self, *a, **kw):
+                raise RuntimeError("disk went away")
+
+            def executemany(self, *a, **kw):  # pragma: no cover - unreached
+                raise RuntimeError("disk went away")
+
+            def commit(self):  # pragma: no cover - unreached
+                pass
+
+            def close(self):
+                closed.append(True)
+
+        with (mock.patch.object(rag.sqlite3, "connect", return_value=Boom()),
+              pytest.raises(RuntimeError, match="disk went away")):
+            rag._write_postings({"beta": [[1, 1]]})
+
+        assert closed, "the connection was leaked on the failure path"
+        assert list(rag.postings_path().parent.glob("*.tmp*")) == []
+        # The swap never happened, so the previous index is still the one on
+        # disk — a failed rebuild must not cost you the index you had.
+        assert rag.postings_path().read_bytes() == before
+        assert rag.read_postings(["alpha"])["alpha"] == [[0, 1]]