booley-rtl 0.2.2__tar.gz → 0.2.4__tar.gz

{booley_rtl-0.2.2/src/booley_rtl.egg-info → booley_rtl-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: booley-rtl
-Version: 0.2.2
+Version: 0.2.4
 Summary: RTL development harness with ticket-based workflow automation
 Author-email: "A.R." <boldaxolotl@proton.me>
 License-Expression: Apache-2.0
@@ -39,6 +39,7 @@ Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-xdist>=3.8; extra == "dev"
 Requires-Dist: pytest-timeout>=2.3; extra == "dev"
 Requires-Dist: coverage>=7.0; extra == "dev"
 Requires-Dist: ruff==0.15.18; extra == "dev"

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/THIRD_PARTY_NOTICES.md

@@ -64,7 +64,7 @@ THE LIBRARY.
 
 The `bwave` executable statically links Rust crates recorded in
 `crates/bwave/Cargo.lock`. The dependency versions below describe the lockfile at
-Booley 0.2.2. Where a crate offers a choice of licenses, this distribution uses
+Booley 0.2.4. Where a crate offers a choice of licenses, this distribution uses
 the license named by the group.
 
 ### BSD-3-Clause

booley_rtl-0.2.4/VERSION

@@ -0,0 +1 @@
+0.2.4

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/pyproject.toml

@@ -59,6 +59,10 @@ dev = [
     "build>=1.0",
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
+    # Run independent test modules concurrently in CI. loadscope scheduling
+    # keeps each module/class together while tests/conftest.py gives every
+    # worker its own temp root for subprocess-visible caches.
+    "pytest-xdist>=3.8",
     # Bounds every test's wall-clock so a wedged subprocess/stall test fails
     # loudly instead of hanging the whole suite (default applied in tests/conftest.py).
     "pytest-timeout>=2.3",

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/data/docker/build.sh

@@ -65,6 +65,9 @@ echo ">>> Building booley wheel..."
 # build/ is generated packaging state, so always recreate it from the source
 # tree before producing the wheel consumed by Docker.
 rm -rf "$BOOLEY_ROOT/build"
+# Docker COPY and pip expand this glob, so an older version must not survive
+# beside the wheel produced by this run (GitHub issue #66).
+rm -f "$BOOLEY_ROOT"/dist/booley_rtl-*.whl
 # Marker predating the build: the freshness check below proves the wheel the
 # docker COPY layer will pick up was actually (re)written by *this* run, not left
 # over from a previous one. Belt-and-suspenders behind `set -e`: if the wheel
@@ -74,13 +77,15 @@ WHEEL_MARKER="$(mktemp)"
 trap 'rm -f "$STAMP" "$WHEEL_MARKER"' EXIT
 (cd "$BOOLEY_ROOT" && "$PYBUILD" -P -m build --wheel --outdir dist/)
 
-# Newest wheel in dist/ must be newer than the marker, or the COPY would bake a stale wheel.
-FRESH_WHEEL="$(find "$BOOLEY_ROOT/dist" -name 'booley_rtl-*.whl' -newer "$WHEEL_MARKER" -print -quit 2>/dev/null || true)"
-if [ -z "$FRESH_WHEEL" ]; then
-  echo "ERROR: the wheel step produced no fresh dist/booley_rtl-*.whl." >&2
-  echo "       The docker COPY would bake a stale wheel — aborting." >&2
+# Exactly one wheel in dist/ must be newer than the marker, or Docker's glob
+# would either fail to COPY a wheel or pass conflicting versions to pip.
+mapfile -t FRESH_WHEELS < <(find "$BOOLEY_ROOT/dist" -maxdepth 1 -type f -name 'booley_rtl-*.whl' -newer "$WHEEL_MARKER" -print 2>/dev/null)
+if [ "${#FRESH_WHEELS[@]}" -ne 1 ]; then
+  echo "ERROR: the wheel step produced ${#FRESH_WHEELS[@]} fresh dist/booley_rtl-*.whl files; expected exactly one." >&2
+  echo "       The docker COPY requires one unambiguous wheel — aborting." >&2
   exit 1
 fi
+FRESH_WHEEL="${FRESH_WHEELS[0]}"
 echo ">>> Fresh wheel: $(basename "$FRESH_WHEEL")"
 
 # Stamp the same build-fingerprint label `booley init` uses, so an image built

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/data/skills/booley-setup/AGENTS_TEMPLATE.md

@@ -19,6 +19,7 @@ tracks a content-identical root `AGENTS.md` (see `steps/3-agents-md.md`, Step 3)
 ## Booley-Specific Instructions
 
 - Project-specific Booley data lives in `.booley_project/`.
+- This repo is operating in stealth mode. No changes to `.booley_project/` may be visible in the main repo. (Keep only for `[stealth].enabled = true`.)
 - Keep `booley doctor` green. After changing project configuration, EDA-tool Targets, dependencies, or the Session Runtime, fix every finding or add a narrow, reviewed `doctor-waivers.toml` entry for a deliberate constraint. Before handoff, run plain Doctor on the host and plain plus `--deep` in the Session Runtime; leave no active warnings or errors.
 - Keep handoffs and plans under `.booley_project/` (e.g. `.booley_project/plans/`, `.booley_project/handoffs/`), never in the RTL repo. They are agent working notes, not project source, and do not belong in source history.
 - In Interactive Mode, the editor extension uses the user's shared VS Code window attached to this Project's Session Runtime (devcontainer). Use it as the human-facing surface: when useful, open files with `code --goto <path>[:<line>]` and side-by-side diffs with `code --diff <left> <right>` instead of only printing paths.

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/data/skills/booley-setup/steps/3-agents-md.md

@@ -37,6 +37,9 @@ file is high leverage: do not auto-write, pad, or invent facts.
 - When `booley.toml` selects `booley-sandbox-riscv`, keep the template's RISC-V
   reference-docs bullet verbatim so agents can find the image's offline manuals.
   Remove that conditional bullet for every other sandbox image.
+- When `booley.toml` has `[stealth].enabled = true`, keep the template's stealth
+  mode bullet verbatim so agents do not expose `.booley_project/` changes in the
+  main repository. Remove that conditional bullet when stealth mode is disabled.
 - Do not read RTL, testbench, or test contents by default. Stable docs and
   config are enough for this task.
 - Bad content — omit all of it: repo maps and large directory listings;

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/fusesoc/fusesoc_registry.py

@@ -1304,6 +1304,22 @@ def target_source_files(
     *target* is not a single selectable Target (ADR 0030).
     """
     ref = resolve_ref(project_root, target)
+    return target_source_files_for_ref(
+        project_root,
+        ref,
+        include_dependencies=include_dependencies,
+        include_headers=include_headers,
+    )
+
+
+def target_source_files_for_ref(
+    project_root: Path | str,
+    ref: TargetRef,
+    include_dependencies: bool = False,
+    *,
+    include_headers: bool = False,
+) -> CoreSources:
+    """Partition sources for a Target reference already resolved by the caller."""
     doc = read_core(ref.core_file)
     targets = doc.get("targets") or {}
     target_def = targets.get(ref.name) if isinstance(targets, Mapping) else None
@@ -1320,7 +1336,8 @@ def target_source_files(
     )
 
     if include_dependencies:
-        closure = selectable_core_closure(project_root, [target]) or frozenset()
+        token = f"{ref.vlnv}#{ref.name}"
+        closure = selectable_core_closure(project_root, [token]) or frozenset()
         for core_file in sorted(closure):
             if core_file == ref.core_file:
                 continue  # already partitioned above, per the selected Target

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/harness/auto_doctor.py

@@ -18,6 +18,7 @@ import os
 import subprocess
 import sys
 import time
+from collections.abc import Callable
 from dataclasses import asdict
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
@@ -41,6 +42,12 @@ _TIME_FORMAT = MACHINE_TIMESTAMP_FORMAT  # Compatibility for report fixtures.
 _HEALTHY_MAX_AGE = timedelta(days=doctor_stamp.MAX_AGE_DAYS)
 _UNHEALTHY_RETRY_AGE = timedelta(days=1)
 
+Progress = Callable[[str], None]
+
+
+def _ignore_progress(_message: str) -> None:
+    """Accept progress when the caller has no visible sink."""
+
 
 def state_dir(project_dir: Path) -> Path:
     """Return the automatic Doctor runtime directory."""
@@ -204,7 +211,13 @@ def _exception_report(exc: Exception) -> tuple[dict[str, int], list[dict[str, An
     return counts, [finding], 1
 
 
-def _execute(project_root: Path, project_dir: Path, trigger: str) -> dict[str, Any]:
+def _execute(
+    project_root: Path,
+    project_dir: Path,
+    trigger: str,
+    *,
+    progress: Progress | None = None,
+) -> dict[str, Any]:
     """Execute read-only Doctor and persist its structured result."""
     from booley.harness.doctor import run_doctor_result
 
@@ -217,6 +230,7 @@ def _execute(project_root: Path, project_dir: Path, trigger: str) -> dict[str, A
                 project_root,
                 read_only=True,
                 record_clean=False,
+                progress=progress,
             )
         counts = result.counts
         findings = [asdict(finding) for finding in result.findings]
@@ -224,16 +238,21 @@ def _execute(project_root: Path, project_dir: Path, trigger: str) -> dict[str, A
     except Exception as exc:  # noqa: BLE001 — automatic health must record crashes, never break startup
         counts, findings, exit_code = _exception_report(exc)
         output.write(f"\n{findings[0]['message']}\n")
-    return _persist_report(
+    duration_s = time.monotonic() - started
+    report = _persist_report(
         project_root,
         project_dir,
         trigger=trigger,
-        duration_s=time.monotonic() - started,
+        duration_s=duration_s,
         counts=counts,
         findings=findings,
         exit_code=exit_code,
         transcript=output.getvalue(),
     )
+    (progress or _ignore_progress)(
+        f"completed in {duration_s:.1f}s; transcript: {transcript_path(project_dir)}"
+    )
+    return report
 
 
 def _persist_report(
@@ -292,15 +311,30 @@ def record_manual_result(project_root: Path, result: DoctorRunResult) -> dict[st
         return None
 
 
-def run_if_due(project_root: Path, *, trigger: str) -> dict[str, Any] | None:
+def run_if_due(
+    project_root: Path,
+    *,
+    trigger: str,
+    progress: Progress | None = None,
+) -> dict[str, Any] | None:
     """Run one automatic Doctor attempt when stale; never raises."""
     try:
         project_dir = resolve_project_dir(project_root)
         lock_path = state_dir(project_dir) / _RUN_LOCK_NAME
         with _try_lock(lock_path) as acquired:
-            if not acquired or due_reason(project_root) is None:
+            if not acquired:
+                return None
+            reason = due_reason(project_root)
+            if reason is None:
                 return None
-            report = _execute(project_root, project_dir, trigger)
+            emit_progress = progress or _ignore_progress
+            emit_progress(f"starting ({reason})")
+            report = _execute(
+                project_root,
+                project_dir,
+                trigger,
+                progress=emit_progress,
+            )
         _notify_if_changed(project_root, report)
         return report
     except Exception:  # noqa: BLE001 — lifecycle advisory must never block a session or ticket sweep

{booley_rtl-0.2.2 → booley_rtl-0.2.4}/src/booley/harness/booley.py

@@ -1895,18 +1895,18 @@ def _sleep_until_next_ticket(args: argparse.Namespace, project_root: Path) -> bo
     return interruptible_sleep(args.wait)
 
 
-def _ticket_loop(
-    args: argparse.Namespace,
-    project_root: Path,
-    venv_py: str,
-) -> int:
-    """Run the main ticket-processing loop; returns exit code."""
+def _run_automatic_doctor(project_root: Path) -> None:
+    """Run and report the stale startup Doctor without hiding its progress."""
     # Once per sweep (not per ticket): a stale automatic Doctor runs before
     # unattended work begins. It is advisory and fail-soft; the normal
     # preflight remains the blocking gate for ticket execution.
     from booley.harness import auto_doctor
 
-    auto_doctor.run_if_due(project_root, trigger="booley-run")
+    auto_doctor.run_if_due(
+        project_root,
+        trigger="booley-run",
+        progress=lambda message: logger.info("Automatic Doctor — %s", message),
+    )
     health_summary = auto_doctor.consume_changed_summary(project_root, channel="booley-run")
     if health_summary:
         report = auto_doctor.load_report(project_root) or {}
@@ -1914,6 +1914,15 @@ def _ticket_loop(
         emit(health_summary)
     elif auto_doctor.load_report(project_root) is None:
         doctor_stamp.warn_if_stale(project_root, logger.warning)
+
+
+def _ticket_loop(
+    args: argparse.Namespace,
+    project_root: Path,
+    venv_py: str,
+) -> int:
+    """Run the main ticket-processing loop; returns exit code."""
+    _run_automatic_doctor(project_root)
     handle_startup_orphans(project_root)
     os.chdir(str(project_root))
     attempt = 0