rabbit-brain 0.6.0__tar.gz

rabbit_brain-0.6.0/.cargo/config.toml

@@ -0,0 +1,10 @@
+# rb.exe and rabbit-brain.exe carry the C runtime in themselves, so they start where the Visual C++ Redistributable is
+# not installed (a venv does not bring it); cargo reads this file when it runs from the repository or below it
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
+
+# rb reads the ordinary tables of a SQLite database (rb run add --from, rb compile): the parts of the SQLite built into it
+# that serve other uses (full-text search, R*Tree, dbstat, stat4, soundex, column metadata, loading extensions) are left
+# out, about 0.5 MB of the binary; the variable set in the environment wins
+[env]
+LIBSQLITE3_FLAGS = "-USQLITE_ENABLE_FTS3 -USQLITE_ENABLE_FTS3_PARENTHESIS -USQLITE_ENABLE_FTS5 -USQLITE_ENABLE_RTREE -USQLITE_ENABLE_DBSTAT_VTAB -USQLITE_ENABLE_STAT4 -USQLITE_SOUNDEX -USQLITE_ENABLE_COLUMN_METADATA -USQLITE_ENABLE_LOAD_EXTENSION -DSQLITE_OMIT_LOAD_EXTENSION"

rabbit_brain-0.6.0/.github/scripts/check-attribution.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Fail when a commit or a pull request credits a coding agent.
+
+A commit fails when its author or committer is an agent identity, or when its message carries a co-author trailer
+that names an agent, an agent session trailer, a generated-with footer or an agent session link. A pull request fails
+when its title or body carries any of these. Names and addresses are matched whole: an identity is an agent's when its
+name is an agent's name or its address is an agent's, a co-author trailer when its name starts with an agent's name or
+its address is an agent's, and a footer only as a line of its own. A contributor whose name or address only contains
+an agent's name passes. With no revisions, the GitHub Actions event names what to check: the commits a push adds, or a
+pull request's commits over its base, with its title and body. Revisions name commits as git rev-list takes them, for
+a check before pushing:
+
+    python .github/scripts/check-attribution.py origin/main..HEAD
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+
+# Matched whole: the names agents commit under, and the addresses (Anthropic's, and an agent's GitHub app).
+AGENT_NAME = r"(?:claude(?: code)?|codex|chatgpt|cursor agent)(?: ?\[bot\])?"
+AGENT_EMAIL = (r"(?:noreply@anthropic\.com"
+               r"|(?:\d+\+)?(?:claude|codex|chatgpt|copilot|cursor|gemini)[a-z-]*\[bot\]@users\.noreply\.github\.com)")
+AGENT_IDENTITY = re.compile(rf"{AGENT_NAME}[ \t]*<[^<>]*>|[^<>]*<{AGENT_EMAIL}>", re.IGNORECASE)
+AGENT_TEXT = (
+    ("a co-author trailer that names an agent", re.compile(
+        rf"^[ \t]*co-authored-by:[ \t]*(?:(?:claude|codex|chatgpt|copilot|cursor|gemini)\b|[^<\n]*<{AGENT_EMAIL}>)",
+        re.IGNORECASE | re.MULTILINE)),
+    ("an agent session trailer", re.compile(r"^[ \t]*(?:claude|codex)-session:", re.IGNORECASE | re.MULTILINE)),
+    ("a generated-with footer", re.compile(
+        r"^[ \t]*[^\w\n]*[ \t]*generated[ \t]+(?:with|by)[ \t]+\[?(?:claude(?: code)?|codex|chatgpt)\]?"
+        r"(?:\([^)\n]*\))?\.?[ \t]*$", re.IGNORECASE | re.MULTILINE)),
+    ("an agent session link", re.compile(r"claude\.ai/code/session", re.IGNORECASE)),
+)
+COMMIT_ID = re.compile(r"[0-9a-f]{40}|[0-9a-f]{64}")
+DELETED = re.compile(r"0+")
+
+
+class CheckError(Exception):
+    pass
+
+
+def has_commit(repo, rev):
+    return subprocess.run(["git", "-C", str(repo), "cat-file", "-e", f"{rev}^{{commit}}"],
+                          stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False).returncode == 0
+
+
+def commits(repo, revisions):
+    """(id, author, committer, message) for every commit the revisions name, with identities as recorded."""
+    result = subprocess.run(
+        ["git", "-C", str(repo), "-c", "log.showSignature=false", "log", "--no-use-mailmap", "-z",
+         "--format=%H%x00%an <%ae>%x00%cn <%ce>%x00%B", *revisions, "--"],
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+    if result.returncode:
+        raise CheckError("git could not list the commits to check")
+    fields = result.stdout.decode("utf-8", "replace").split("\0")
+    if fields[-1] == "":
+        fields.pop()
+    # Four fields per commit, each led by its id; anything else is output this check does not understand.
+    if len(fields) % 4 or not all(COMMIT_ID.fullmatch(field) for field in fields[::4]):
+        raise CheckError("git log output could not be read")
+    return [tuple(fields[n:n + 4]) for n in range(0, len(fields), 4)]
+
+
+def event_revisions(repo, name, event, ref):
+    """The revisions of the commits the event adds, or None when it adds none."""
+    if name == "pull_request":
+        base, head = event["pull_request"]["base"]["sha"], event["pull_request"]["head"]["sha"]
+        if has_commit(repo, base) and has_commit(repo, head):
+            return [head, "--not", base]
+        # The checkout of a pull request is its merge commit: the base tip, then the head.
+        if has_commit(repo, "HEAD^2"):
+            return ["HEAD^2", "--not", "HEAD^1"]
+        raise CheckError("the pull request's commits are not in the checkout")
+    if name == "push":
+        before, after = event.get("before") or "", event.get("after") or ""
+        if not after or DELETED.fullmatch(after):
+            return None
+        if before and not DELETED.fullmatch(before) and has_commit(repo, before):
+            return [after, "--not", before]
+        # A new branch or tag, or a forced push whose old tip is gone: what the default branch does not hold yet.
+        default = (event.get("repository") or {}).get("default_branch") or ""
+        known = f"refs/remotes/origin/{default}"
+        if default and ref != f"refs/heads/{default}" and has_commit(repo, known):
+            return [after, "--not", known]
+        return [after]
+    raise CheckError(f"no rule for the {name or 'unnamed'} event")
+
+
+def normalized(text):
+    """The text with every line break as a newline, so a line of its own reads the same from any platform."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def findings(found, text):
+    """What credits an agent. Nothing from a commit or a pull request is quoted, only commit ids."""
+    out = []
+    for commit, author, committer, message in found:
+        if AGENT_IDENTITY.fullmatch(author) or AGENT_IDENTITY.fullmatch(committer):
+            out.append(f"commit {commit[:12]}: the author or committer is an agent identity")
+        out += [f"commit {commit[:12]}: the message carries {what}"
+                for what, rule in AGENT_TEXT if rule.search(normalized(message))]
+    out += [f"the pull request's title or body carries {what}"
+            for what, rule in AGENT_TEXT if rule.search(normalized(text))]
+    return out
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("revisions", nargs="*",
+                        help="commits to check, as git rev-list takes them (default: the event's)")
+    parser.add_argument("--repo", type=Path, default=Path("."),
+                        help="the git checkout (default: the current directory)")
+    args = parser.parse_args(argv)
+    try:
+        text = None
+        revisions = args.revisions
+        if not revisions:
+            name, path = os.environ.get("GITHUB_EVENT_NAME", ""), os.environ.get("GITHUB_EVENT_PATH", "")
+            if not path:
+                raise CheckError("no revisions given and no GitHub Actions event to read")
+            with open(path, encoding="utf-8") as source:
+                event = json.load(source)
+            revisions = event_revisions(args.repo, name, event, os.environ.get("GITHUB_REF", ""))
+            if name == "pull_request":
+                pull = event["pull_request"]
+                text = "\n".join(part for part in (pull.get("title"), pull.get("body")) if isinstance(part, str))
+        found = commits(args.repo, revisions) if revisions else []
+        problems = findings(found, text or "")
+    except CheckError as error:
+        print(f"Attribution check failed: {error}.", file=sys.stderr)
+        return 2
+    except (OSError, ValueError, LookupError, TypeError, AttributeError):
+        print("Attribution check failed: the event or the commits could not be read.", file=sys.stderr)
+        return 2
+    if problems:
+        for problem in problems:
+            print(f"Attribution check failed: {problem}.", file=sys.stderr)
+        print("Commit under your own name, remove what is named above, and push again.", file=sys.stderr)
+        return 1
+    checked = f"{len(found)} commit{'' if len(found) == 1 else 's'}"
+    print(f"Attribution check passed: {checked}"
+          + (", and the pull request's title and body." if text is not None else "."))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rabbit_brain-0.6.0/.github/scripts/check-public-content.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""Check committed files and unpacked distributions against the release denylist.
+
+The denylist comes from RB_RELEASE_DENYLIST, one literal phrase per line. Nothing
+from that list, matching content, or matching filenames is printed. Missing
+configuration and unreadable inputs are failures, not successful scans.
+
+--source names the top level of a git checkout; the files committed at HEAD are
+checked as git stores them, whatever the working tree holds.
+
+--history also checks what a push or a pull request adds: every commit message,
+tag message, file and file name in its history, and a pull request's title and
+body. With no revisions it reads the GitHub Actions event from the step's
+environment (GITHUB_EVENT_NAME, GITHUB_REF and the SCAN_* variables the
+workflow sets); with revisions, as git rev-list takes them, it checks those:
+
+    python .github/scripts/check-public-content.py --source . --history origin/main..HEAD
+"""
+
+import argparse
+import codecs
+import gzip
+import os
+from pathlib import Path
+import re
+import stat
+import subprocess
+import sys
+import tarfile
+import zipfile
+import zlib
+
+try:
+    import lzma
+    LZMA_ERRORS = (lzma.LZMAError,)
+except ImportError:  # a Python built without lzma: zipfile refuses an LZMA member with RuntimeError instead
+    LZMA_ERRORS = ()
+
+OBJECT_ID = re.compile(r"[0-9a-f]{40}|[0-9a-f]{64}")
+NO_OBJECT = re.compile(r"0+")      # the id an event gives a ref that did not exist before, or no longer does
+
+
+class ScanError(Exception):
+    pass
+
+
+class ContentMatch(Exception):
+    pass
+
+
+def git(root: Path, *args: str) -> bytes:
+    """What git prints for these arguments in the checkout at root; a failure is a scan error that names nothing."""
+    result = subprocess.run(["git", "-C", str(root), *args], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+    if result.returncode:
+        raise ScanError("git could not read the checkout")
+    return result.stdout
+
+
+class Exactly:
+    """The next `size` bytes of a stream, read as a file of their own."""
+
+    def __init__(self, stream, size: int):
+        self.stream, self.left = stream, size
+
+    def read(self, n: int = -1) -> bytes:
+        n = self.left if n < 0 else min(n, self.left)
+        data = self.stream.read(n) if n else b""
+        if len(data) != n:
+            raise ScanError("git stopped before an object was read whole")
+        self.left -= n
+        return data
+
+
+def objects(root: Path, ids):
+    """(id, type, contents as a file) for each object id, as git cat-file --batch gives them, one at a time."""
+    with subprocess.Popen(["git", "-C", str(root), "cat-file", "--batch"], stdin=subprocess.PIPE,
+                          stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) as batch:
+        for oid in ids:
+            batch.stdin.write(oid + b"\n")
+            batch.stdin.flush()
+            header = batch.stdout.readline().split()
+            if len(header) != 3 or header[0] != oid or not header[2].isdigit():
+                raise ScanError("git could not read a committed object")
+            contents = Exactly(batch.stdout, int(header[2]))
+            yield oid, header[1].decode("ascii"), contents
+            while contents.read(65536):
+                pass
+            if batch.stdout.read(1) != b"\n":
+                raise ScanError("git could not read a committed object")
+        batch.stdin.close()
+        if batch.wait():
+            raise ScanError("git could not read a committed object")
+
+
+def has_object(root: Path, rev: str) -> bool:
+    return subprocess.run(["git", "-C", str(root), "cat-file", "-e", rev], stdout=subprocess.DEVNULL,
+                          stderr=subprocess.DEVNULL, check=False).returncode == 0
+
+
+def event_scope(root: Path, environ) -> tuple:
+    """What a GitHub Actions event adds: (revisions as git rev-list takes them, text it carries, what that text is).
+    A push adds its commits, with a pushed tag's own object, and its ref's name; a pull request adds its commits,
+    its title and its body."""
+    def object_id(key):
+        value = environ.get(key, "")
+        if value and not OBJECT_ID.fullmatch(value):
+            raise ScanError(f"{key} is not an object id")
+        return value
+
+    name = environ.get("GITHUB_EVENT_NAME", "")
+    if name == "pull_request":
+        base, head = object_id("SCAN_PR_BASE"), object_id("SCAN_PR_HEAD")
+        text = "\n".join(environ.get(key, "") for key in ("SCAN_PR_TITLE", "SCAN_PR_BODY"))
+        said = "the pull request's title and body"
+        if base and head and has_object(root, base) and has_object(root, head):
+            return [head, "--not", base], text, said
+        # The checkout of a pull request is its merge commit: the base tip, then the head.
+        if has_object(root, "HEAD^2"):
+            return ["HEAD^2", "--not", "HEAD^1"], text, said
+        raise ScanError("the pull request's commits are not in the checkout")
+    if name == "push":
+        ref = environ.get("GITHUB_REF", "")
+        before, after = object_id("SCAN_BEFORE"), object_id("SCAN_AFTER")
+        if not after or NO_OBJECT.fullmatch(after):
+            return [], ref, "the ref's name"                 # a deleted branch or tag adds nothing
+        if not has_object(root, after):
+            raise ScanError("the pushed commits are not in the checkout")
+        if before and not NO_OBJECT.fullmatch(before) and has_object(root, before):
+            return [after, "--not", before], ref, "the ref's name"
+        # A new branch or tag, or a forced push whose old tip is gone: what the default branch does not hold. Never
+        # --not --remotes: the checkout's remote branches hold the pushed commits already.
+        default = environ.get("SCAN_DEFAULT_BRANCH", "")
+        known = f"refs/remotes/origin/{default}"
+        if default and ref != f"refs/heads/{default}" and has_object(root, known):
+            return [after, "--not", known], ref, "the ref's name"
+        return [after], ref, "the ref's name"
+    raise ScanError(f"no rule for the {name or 'unnamed'} event")
+
+
+class Scanner:
+    def __init__(self, words: str):
+        self.phrases = tuple(line.strip().casefold() for line in words.splitlines() if line.strip())
+        if not self.phrases:
+            raise ScanError("RB_RELEASE_DENYLIST is missing or empty; content was not checked")
+        self.overlap = max(map(len, self.phrases)) - 1
+        self.files = 0
+        self.commits = self.tags = self.blobs = 0
+
+    def text(self, value: str):
+        folded = value.casefold()
+        if any(phrase in folded for phrase in self.phrases):
+            raise ContentMatch("blocked content found; matching text and path omitted")
+
+    def stream(self, source, *, count=True):
+        # Compiled Rust strings and the source documents are UTF-8. Incremental
+        # decoding preserves text and phrases that cross a read boundary; binary
+        # bytes outside UTF-8 are ignored without skipping the rest of the file.
+        decoder = codecs.getincrementaldecoder("utf-8")(errors="ignore")
+        tail = ""
+        while True:
+            block = source.read(65536)
+            value = tail + decoder.decode(block, final=not block).casefold()
+            self.text(value)
+            tail = value[-self.overlap:] if self.overlap else ""
+            if not block:
+                break
+        if count:
+            self.files += 1
+
+    def source(self, root: Path):
+        # A subdirectory would leave the rest of the checkout unchecked.
+        top = os.fsdecode(git(root, "rev-parse", "--show-toplevel").strip())
+        if not top or not os.path.samefile(top, root):
+            raise ScanError("--source is not the top level of a git checkout; the files outside it were not checked")
+        listing = git(root, "ls-tree", "-r", "-z", "--full-tree", "HEAD")
+        blobs = []
+        for entry in filter(None, listing.split(b"\0")):
+            info, _, name = entry.partition(b"\t")
+            mode, kind, oid = info.split(b" ")
+            self.text(os.fsdecode(name))
+            # A link's target or a submodule's commit is not a file this check reads; it is reviewed by hand.
+            if kind != b"blob" or mode not in (b"100644", b"100755"):
+                raise ScanError("tracked source contains a non-regular file; review it explicitly")
+            blobs.append(oid)
+        if not blobs:
+            raise ScanError("could not enumerate tracked source files")
+        for _, _, contents in objects(root, blobs):
+            self.stream(contents)
+
+    def history(self, root: Path, revisions):
+        """Every commit message, tag message, file and file name in the history the revisions add."""
+        if git(root, "rev-parse", "--is-shallow-repository").strip() != b"false":
+            raise ScanError("the checkout is shallow, so its history was not checked; fetch all of it (fetch-depth: 0)")
+        ids = []
+        for line in git(root, "rev-list", "--objects", *revisions, "--").splitlines():
+            oid, _, name = line.partition(b" ")
+            if not OBJECT_ID.fullmatch(oid.decode("ascii", "replace")):
+                raise ScanError("git rev-list output could not be read")
+            self.text(os.fsdecode(name))                  # the path a file or folder was first found at
+            ids.append(oid)
+        for oid, kind, contents in objects(root, ids):
+            if kind == "blob":
+                self.stream(contents, count=False)
+                self.blobs += 1
+            elif kind == "tree":
+                # '<mode> <name>\0<id>' for each entry: every name, where rev-list stops a path at a line break
+                tree, at = contents.read(), 0
+                while at < len(tree):
+                    space = tree.index(b" ", at)
+                    end = tree.index(b"\0", space)
+                    self.text(os.fsdecode(tree[space + 1:end]))
+                    at = end + 1 + len(oid) // 2
+            elif kind == "commit":
+                self.text(contents.read().partition(b"\n\n")[2].decode("utf-8", "ignore"))   # its message, as %B
+                self.commits += 1
+            elif kind == "tag":
+                headers, _, message = contents.read().partition(b"\n\n")
+                named = [line for line in headers.split(b"\n") if line.startswith(b"tag ")]
+                self.text(b"\n".join([*named, message]).decode("utf-8", "ignore"))      # its name and message
+                self.tags += 1
+
+    def artifacts(self, root: Path):
+        paths = sorted(root.iterdir())
+        if not paths:
+            raise ScanError("the artifact directory is empty; distributions were not checked")
+        for path in paths:
+            self.text(path.name)
+            if not stat.S_ISREG(path.lstat().st_mode):
+                raise ScanError("the artifact directory contains a non-regular file")
+            before = self.files
+            # Also check archive metadata, including ZIP comments, which is not
+            # exposed as a member. Compressed payloads are checked below.
+            with path.open("rb") as source:
+                self.stream(source, count=False)
+            if path.suffix == ".whl":
+                with zipfile.ZipFile(path) as archive:
+                    for member in archive.infolist():
+                        self.text(member.filename)
+                        if member.is_dir():
+                            continue
+                        if stat.S_ISLNK(member.external_attr >> 16):
+                            raise ScanError("a wheel contains a symbolic link")
+                        with archive.open(member) as source:
+                            self.stream(source)
+            elif path.name.endswith(".tar.gz"):
+                # Read through the gzip trailer too: tar readers may stop at the
+                # end-of-archive marker before verifying its CRC or truncation.
+                with gzip.open(path, "rb") as source:
+                    self.stream(source, count=False)
+                with tarfile.open(path, "r:gz") as archive:
+                    for member in archive:
+                        self.text(member.name)
+                        if member.isdir():
+                            continue
+                        if not member.isfile():
+                            raise ScanError("a source distribution contains a non-regular file")
+                        source = archive.extractfile(member)
+                        if source is None:
+                            raise ScanError("a source distribution member could not be read")
+                        with source:
+                            self.stream(source)
+            else:
+                raise ScanError("unexpected artifact; only wheels and .tar.gz source distributions are accepted")
+            if self.files == before:
+                raise ScanError("a distribution contains no files")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--source", type=Path, required=True,
+                        help="top level of the git checkout whose committed files are checked")
+    parser.add_argument("--artifacts", type=Path, help="directory containing the wheels and sdist to check")
+    parser.add_argument("--history", nargs="*", metavar="REVISION",
+                        help="also check the history these revisions add (default: what the GitHub Actions event adds)")
+    args = parser.parse_args(argv)
+    try:
+        scanner = Scanner(os.environ.get("RB_RELEASE_DENYLIST", ""))
+        scanner.source(args.source)
+        source_count = scanner.files
+        if args.artifacts is not None:
+            scanner.artifacts(args.artifacts)
+        checked = f"{source_count} tracked files, {scanner.files - source_count} distribution members"
+        if args.history is not None:
+            revisions, text, said = (args.history, "", "") if args.history else event_scope(args.source, os.environ)
+            if revisions:
+                scanner.history(args.source, revisions)
+            scanner.text(text)
+            checked += (f", and in the history {scanner.commits} commit messages, {scanner.tags} tag messages and "
+                        f"{scanner.blobs} files" + (f", with {said}" if said else ""))
+        print(f"Public-content check passed: {checked}.")
+        return 0
+    except ContentMatch as error:
+        print(f"Public-content check failed: {error}.", file=sys.stderr)
+        return 1
+    except ScanError as error:
+        print(f"Public-content check failed: {error}.", file=sys.stderr)
+        return 2
+    except (OSError, EOFError, ValueError, RuntimeError, tarfile.TarError, zipfile.BadZipFile, zlib.error,
+            *LZMA_ERRORS):
+        # Exception messages can contain a forbidden path or archive member.
+        print("Public-content check failed: an input could not be read completely; "
+              "no successful audit was produced.", file=sys.stderr)
+        return 2
+    except Exception:
+        # Anything else is a failed check, never a match (exit 1) and never its message.
+        print("Public-content check failed: the check stopped on an unexpected error; "
+              "no successful audit was produced.", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rabbit_brain-0.6.0/.github/scripts/smoke-wheel.py

@@ -0,0 +1,133 @@
+"""Install one native wheel in a clean environment, then use only that installation.
+
+Run with a wheel path or a directory containing exactly one wheel. No source build is
+allowed, and the SDK, executables and their embedded assets are checked outside the repo.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import struct
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import venv
+
+
+def pe_imports(path: Path) -> list[str]:
+    """The DLLs a Windows executable names in its import and delay-load tables, read from its PE headers."""
+    data = path.read_bytes()
+    pe = struct.unpack_from("<I", data, 0x3C)[0]
+    if data[:2] != b"MZ" or data[pe:pe + 4] != b"PE\0\0":
+        raise ValueError(f"{path} is not a Windows executable")
+    sections, optional_size = struct.unpack_from("<H", data, pe + 6)[0], struct.unpack_from("<H", data, pe + 20)[0]
+    optional = pe + 24
+    directories = optional + (96 if struct.unpack_from("<H", data, optional)[0] == 0x10B else 112)   # PE32, else PE32+
+    count = struct.unpack_from("<I", data, directories - 4)[0]
+    # each section: its size and address in memory, then its size and offset in the file
+    table = [struct.unpack_from("<IIII", data, optional + optional_size + 40 * i + 8) for i in range(sections)]
+
+    def offset(rva: int) -> int:
+        for size, address, raw_size, raw in table:
+            if address <= rva < address + max(size, raw_size):
+                return rva - address + raw
+        raise ValueError(f"{path}: address {rva:#x} is in no section")
+
+    names = []
+    for index, width, at_name in ((1, 20, 12), (13, 32, 4)):   # the import table, then the delay-load table
+        rva = struct.unpack_from("<I", data, directories + 8 * index)[0] if index < count else 0
+        at = offset(rva) if rva else None
+        while at is not None and any(data[at:at + width]):
+            start = offset(struct.unpack_from("<I", data, at + at_name)[0])
+            names.append(data[start:data.index(b"\0", start)].decode("ascii"))
+            at += width
+    return names
+
+
+def vc_runtime(executable: Path) -> list[str]:
+    """The Visual C++ runtime DLLs a Windows executable imports, which a venv does not bring."""
+    imported = pe_imports(executable)
+    assert "kernel32.dll" in {dll.lower() for dll in imported}, f"{executable.name}: its import table was not read: {imported}"
+    return [dll for dll in imported if dll.lower().startswith("vcruntime")]
+
+
+def installed_smoke() -> None:
+    import rabbit_brain as rb
+    from rabbit_brain import _rb
+    import rabbit_brain.tui  # noqa: F401 - the terminal UI's dependencies must be installed too
+
+    prefix = Path(sys.prefix).resolve()
+    assert Path(rb.__file__).resolve().is_relative_to(prefix), rb.__file__
+    scripts = Path(sysconfig.get_path("scripts"))
+    suffix = ".exe" if os.name == "nt" else ""
+    binary = scripts / f"rb{suffix}"
+    assert Path(_rb.found()).resolve() == binary.resolve()
+
+    def command(executable: Path, *args: str, input: str | None = None) -> str:
+        return subprocess.run([str(executable), *args], input=input, text=True, encoding="utf-8",
+                              capture_output=True, check=True, timeout=30).stdout
+
+    for name in ("rb", "rabbit-brain"):
+        assert rb.__version__ in command(scripts / f"{name}{suffix}", "version")
+    if os.name == "nt":   # the executables carry their own C runtime (.cargo/config.toml)
+        for name in ("rb", "rabbit-brain"):
+            runtime = vc_runtime(scripts / f"{name}.exe")
+            assert not runtime, f"{name}.exe imports {', '.join(runtime)}: it would not start without the Visual C++ Redistributable"
+    assert "Rabbit Brain" in command(binary, "docs")
+    assert "name: rabbit-brain" in command(binary, "skill")
+
+    state = rb.init("Installed wheel smoke check", path=Path.cwd())
+    exp = state.add_experiment("Packaging check", id="package")
+    artifact = Path("outputs") / "result.txt"
+    artifact.parent.mkdir()
+    artifact.write_text("ready\n", encoding="utf-8")
+    run = exp.record({"score": 1.0}, files=[artifact], command="wheel smoke check")
+    assert run is not None and run.metrics == {"score": 1.0}
+    assert run.files[0].path == "outputs/result.txt"
+    assert rb.open(Path.cwd()).experiment("package").id == exp.id
+
+    messages = [
+        {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
+            "protocolVersion": "2025-06-18", "capabilities": {},
+            "clientInfo": {"name": "wheel-smoke", "version": "1"}}},
+        {"jsonrpc": "2.0", "method": "notifications/initialized"},
+        {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}},
+    ]
+    responses = [json.loads(line) for line in command(
+        binary, "mcp", input="".join(json.dumps(message) + "\n" for message in messages)).splitlines()]
+    assert [message.get("id") for message in responses] == [1, 2], responses
+    assert responses[0]["result"]["serverInfo"]["version"] == rb.__version__
+    assert "context" in {tool["name"] for tool in responses[1]["result"]["tools"]}
+    print(f"Installed wheel OK: rb {rb.__version__}, CLI aliases, SDK, terminal UI, docs, skill and MCP")
+
+
+def main() -> None:
+    if sys.argv[1:] == ["--installed"]:
+        installed_smoke()
+        return
+    if len(sys.argv) != 2:
+        raise SystemExit("usage: python smoke-wheel.py <wheel-or-directory>")
+    supplied = Path(sys.argv[1]).resolve()
+    wheels = list(supplied.glob("*.whl")) if supplied.is_dir() else [supplied]
+    if len(wheels) != 1 or not wheels[0].is_file() or wheels[0].suffix != ".whl":
+        raise SystemExit("expected exactly one native wheel")
+    script = Path(__file__).resolve()
+    with tempfile.TemporaryDirectory(prefix="rb-wheel-smoke-") as directory:
+        root = Path(directory)
+        environment = root / "venv"
+        venv.create(environment, with_pip=True)
+        python = environment / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+        env = {**os.environ, "DO_NOT_TRACK": "1", "PYTHONUTF8": "1"}
+        env.pop("RB_BIN", None)  # a development override must not bypass the installed wheel
+        subprocess.run([str(python), "-m", "pip", "install", "--only-binary=:all:", str(wheels[0])],
+                       cwd=root, env=env, check=True, timeout=300)
+        project = root / "project"
+        project.mkdir()
+        subprocess.run([str(python), "-I", str(script), "--installed"], cwd=project, env=env,
+                       check=True, timeout=120)
+
+
+if __name__ == "__main__":
+    main()