bantamkit 0.33.0__tar.gz → 0.34.0__tar.gz

{bantamkit-0.33.0 → bantamkit-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bantamkit
-Version: 0.33.0
+Version: 0.34.0
 Summary: bantamweight tooling — harness primitives that lift small-model agents
 License-Expression: MIT
 Requires-Python: >=3.11
@@ -50,6 +50,63 @@ The uv equivalent is `uvx --from "bantamkit[mcp]" bantamkit-mcp`. uv is not
 installed on the machine this README was measured on, so unlike every other
 command here that one is the documented form rather than a measured one.
 
+> **AMENDED 2026-09-15 (job51) — `pipx run` launches online, and it is offline only while
+> pipx's own cache lasts.** The first form above is fine to try the server. As the command a
+> host runs on every launch, it has a cost. Measured with pipx 1.11.1 and `bantamkit 0.33.0`,
+> with the network cut by pointing the proxy variables at a closed port:
+>
+> ```bash
+> PIPX_HOME=<scratch> https_proxy=http://127.0.0.1:1 HTTPS_PROXY=http://127.0.0.1:1 \
+>   http_proxy=http://127.0.0.1:1 HTTP_PROXY=http://127.0.0.1:1 PIP_PROXY=http://127.0.0.1:1 \
+>   PIP_RETRIES=0 PIP_TIMEOUT=5 pipx run --spec "bantamkit[mcp]==0.33.0" bantamkit-mcp --assets-root
+> ```
+>
+> On a `PIPX_HOME` that had never run it, this exited 1 in 1.33 s. After one run online into
+> the same `PIPX_HOME`, the same command exited 0 in 0.47 s. So a `pipx run` host entry needs
+> the package index on a new machine, after the cache is cleared, and whenever pipx decides
+> its cached environment is stale. That last one is pipx's policy and was not measured here.
+> For a host, install into an environment you keep, as in the next section.
+
+### Install once, run offline
+
+Install into an environment you keep, then let `--install` record that environment's console
+script:
+
+```bash
+python -m venv <env>
+<env>/bin/pip install "bantamkit[mcp]"
+<env>/bin/bantamkit-mcp --install cursor     # or claude, claude-desktop, copilot
+```
+
+After that, no launch needs the network. `--install` writes the absolute path of the console
+script you ran. Measured 2026-09-15 on macOS arm64 against `bantamkit 0.33.0`,
+`<env>/bin/bantamkit-mcp --install cursor` wrote `"command": "<env>/bin/bantamkit-mcp", "args": []`.
+That command answered `initialize` and `tools/list` with 12 tools under the PATH a GUI app
+inherits on macOS, `/usr/bin:/bin:/usr/sbin:/sbin`. The Windows layout (`<env>\Scripts\`) was
+not measured.
+
+**For a machine with no network at all, carry a wheelhouse.** On a connected machine with the
+**same operating system, CPU architecture and Python minor version** as the target:
+
+```bash
+python -m pip download "bantamkit[mcp]==0.33.0" -d wheels
+```
+
+With Python 3.12.13 on macOS arm64 that wrote 33 files. One of them is
+`pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl`, which is built for CPython 3.12 on
+arm64 macOS and nothing else. That is why the two machines must match. Copy `wheels/` across,
+then on the target:
+
+```bash
+python -m venv <env>
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.33.0"
+<env>/bin/bantamkit-mcp --install cursor
+```
+
+Measured in a fresh venv with `PIP_INDEX_URL=http://127.0.0.1:1/` (a closed port): the install
+finished in 1.69 s, and the installed console script served the 12 tools as above. To move to
+a newer version, repeat the download and the install with the new version number.
+
 ### Connect it to a host
 
 **One command, and it writes the entry for you:**
@@ -80,6 +137,14 @@ hand. Every host runs the same command; only the file and the key around it chan
 you installed with `pip` into an environment you keep, replace the `command`/`args` pair
 with the absolute path to the `bantamkit-mcp` console script in that environment.
 
+**Prefer that absolute form over the `pipx run` lines below.** A `pipx run` entry needs the
+package index whenever pipx's cache is cold (measured in the amendment under *Install and
+run*). An entry that names a kept console script needs nothing at launch:
+
+```json
+{"mcpServers": {"bantamkit": {"command": "/absolute/path/to/env/bin/bantamkit-mcp", "args": []}}}
+```
+
 **Claude Code** — one command, no file to edit. `-s user` makes it available in every
 project; drop it for this project only.
 

{bantamkit-0.33.0 → bantamkit-0.34.0}/README.md

@@ -33,6 +33,63 @@ The uv equivalent is `uvx --from "bantamkit[mcp]" bantamkit-mcp`. uv is not
 installed on the machine this README was measured on, so unlike every other
 command here that one is the documented form rather than a measured one.
 
+> **AMENDED 2026-09-15 (job51) — `pipx run` launches online, and it is offline only while
+> pipx's own cache lasts.** The first form above is fine to try the server. As the command a
+> host runs on every launch, it has a cost. Measured with pipx 1.11.1 and `bantamkit 0.33.0`,
+> with the network cut by pointing the proxy variables at a closed port:
+>
+> ```bash
+> PIPX_HOME=<scratch> https_proxy=http://127.0.0.1:1 HTTPS_PROXY=http://127.0.0.1:1 \
+>   http_proxy=http://127.0.0.1:1 HTTP_PROXY=http://127.0.0.1:1 PIP_PROXY=http://127.0.0.1:1 \
+>   PIP_RETRIES=0 PIP_TIMEOUT=5 pipx run --spec "bantamkit[mcp]==0.33.0" bantamkit-mcp --assets-root
+> ```
+>
+> On a `PIPX_HOME` that had never run it, this exited 1 in 1.33 s. After one run online into
+> the same `PIPX_HOME`, the same command exited 0 in 0.47 s. So a `pipx run` host entry needs
+> the package index on a new machine, after the cache is cleared, and whenever pipx decides
+> its cached environment is stale. That last one is pipx's policy and was not measured here.
+> For a host, install into an environment you keep, as in the next section.
+
+### Install once, run offline
+
+Install into an environment you keep, then let `--install` record that environment's console
+script:
+
+```bash
+python -m venv <env>
+<env>/bin/pip install "bantamkit[mcp]"
+<env>/bin/bantamkit-mcp --install cursor     # or claude, claude-desktop, copilot
+```
+
+After that, no launch needs the network. `--install` writes the absolute path of the console
+script you ran. Measured 2026-09-15 on macOS arm64 against `bantamkit 0.33.0`,
+`<env>/bin/bantamkit-mcp --install cursor` wrote `"command": "<env>/bin/bantamkit-mcp", "args": []`.
+That command answered `initialize` and `tools/list` with 12 tools under the PATH a GUI app
+inherits on macOS, `/usr/bin:/bin:/usr/sbin:/sbin`. The Windows layout (`<env>\Scripts\`) was
+not measured.
+
+**For a machine with no network at all, carry a wheelhouse.** On a connected machine with the
+**same operating system, CPU architecture and Python minor version** as the target:
+
+```bash
+python -m pip download "bantamkit[mcp]==0.33.0" -d wheels
+```
+
+With Python 3.12.13 on macOS arm64 that wrote 33 files. One of them is
+`pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl`, which is built for CPython 3.12 on
+arm64 macOS and nothing else. That is why the two machines must match. Copy `wheels/` across,
+then on the target:
+
+```bash
+python -m venv <env>
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.33.0"
+<env>/bin/bantamkit-mcp --install cursor
+```
+
+Measured in a fresh venv with `PIP_INDEX_URL=http://127.0.0.1:1/` (a closed port): the install
+finished in 1.69 s, and the installed console script served the 12 tools as above. To move to
+a newer version, repeat the download and the install with the new version number.
+
 ### Connect it to a host
 
 **One command, and it writes the entry for you:**
@@ -63,6 +120,14 @@ hand. Every host runs the same command; only the file and the key around it chan
 you installed with `pip` into an environment you keep, replace the `command`/`args` pair
 with the absolute path to the `bantamkit-mcp` console script in that environment.
 
+**Prefer that absolute form over the `pipx run` lines below.** A `pipx run` entry needs the
+package index whenever pipx's cache is cold (measured in the amendment under *Install and
+run*). An entry that names a kept console script needs nothing at launch:
+
+```json
+{"mcpServers": {"bantamkit": {"command": "/absolute/path/to/env/bin/bantamkit-mcp", "args": []}}}
+```
+
 **Claude Code** — one command, no file to edit. `-s user` makes it available in every
 project; drop it for this project only.
 

{bantamkit-0.33.0 → bantamkit-0.34.0}/src/bantamkit/__init__.py

@@ -29,4 +29,4 @@ from bantamkit.structured import StructuredOutputError, extract_json, structured
 # file as its dynamic version source, so the wheel's metadata and the string the MCP
 # server advertises are the same committed bytes, and neither is a function of when
 # someone last ran `pip`.
-__version__ = "0.33.0"
+__version__ = "0.34.0"

{bantamkit-0.33.0 → bantamkit-0.34.0}/src/bantamkit/eventlog.py

@@ -69,6 +69,8 @@ from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
 
+from bantamkit.memory.store import ensure_bantamkit_gitignore
+
 #: Environment switch. Unset or `off`/`0`/`false`/`no`/empty -> disabled. `on`/`1`/
 #: `true`/`yes` -> the default file inside the memory store. Anything else is taken as
 #: the literal path of the log file.
@@ -276,7 +278,28 @@ class EventLog:
         intent, not a live path.
         """
         assert self.path is not None
+        # AUDIT FINDING (J51-1): this `mkdir(parents=True)` can bring a whole `.bantamkit`
+        # directory into existence on its own -- `BANTAMKIT_EVENT_LOG=on` with a project
+        # store that was never saved to reaches here first -- entirely bypassing
+        # `MemoryStore._ensure_dirs`, which is the only other place a `.bantamkit`
+        # directory gets created. Without this call a store built that way would never get
+        # its self-ignoring `.gitignore`. Cheap and idempotent: a no-op unless one of
+        # `self.path`'s ancestors is literally named `.bantamkit`.
+        #
+        # USER RULING #2 (J51-8a): the ignore file is written only when THIS call is what
+        # creates `.bantamkit`, so existence has to be checked BEFORE the mkdir below --
+        # after it, the directory unconditionally exists and the question is unanswerable.
+        bantamkit_dir = None
+        for parent in self.path.parents:
+            if parent.name == ".bantamkit":
+                bantamkit_dir = parent
+                break
+        bantamkit_dir_existed_before = bantamkit_dir is not None and bantamkit_dir.exists()
         self.path.parent.mkdir(parents=True, exist_ok=True)
+        if bantamkit_dir is not None:
+            ensure_bantamkit_gitignore(
+                bantamkit_dir, created=not bantamkit_dir_existed_before
+            )
         try:
             size = self.path.stat().st_size
         except FileNotFoundError:

{bantamkit-0.33.0 → bantamkit-0.34.0}/src/bantamkit/hostinstall.py

@@ -15,10 +15,12 @@ convenience — a file the host owns and rewrites is a file we should not be mer
 hand.
 
 WHAT THIS WRITES IS WHAT IS RUNNING. The command recorded is this interpreter's own
-`bantamkit-mcp` console script, by absolute path. The Node distribution records
-`npx -y bantamkit-mcp` for the same reason: the thing installed should be the thing that
-answers, and neither side should send a host looking for the other's runtime. The two
-outputs therefore DIFFER by construction and that difference is ruled in `docs/porting.md`.
+`bantamkit-mcp` console script, by absolute path. Since J51-4, the Node side records its
+own absolute command the same way -- `<absolute node> <absolute dist/cli.js>` of the kept
+install under `~/.bantamkit/mcp` -- for the same reason: the thing installed should be the
+thing that answers, and neither side should send a host looking for the other's runtime.
+The two outputs therefore DIFFER by construction (different interpreter, different path)
+and that difference is ruled in `docs/porting.md`.
 
 WHY IT NEVER PROMPTS. An overwrite is exactly the moment a program wants to ask, and asking
 requires a terminal. Measured repeatedly on this machine: Claude Code's `!` channel has no

{bantamkit-0.33.0 → bantamkit-0.34.0}/src/bantamkit/memory/__init__.py

@@ -30,6 +30,7 @@ from bantamkit.memory.layers import (
     resolve_project_store,
 )
 from bantamkit.memory.store import (
+    BANTAMKIT_GITIGNORE_TEXT,
     DEFAULT_INDEX_BUDGET,
     INDEX_PRESSURE_PERCENT,
     RECALL_MIN_SCORE_RATIO,
@@ -40,5 +41,6 @@ from bantamkit.memory.store import (
     MemoryStore,
     MemoryValidationError,
     SaveResult,
+    ensure_bantamkit_gitignore,
     undegraded_index_ceiling,
 )

{bantamkit-0.33.0 → bantamkit-0.34.0}/src/bantamkit/memory/store.py

@@ -252,6 +252,67 @@ def _mtime_date(path: Path) -> str:
     return date.fromtimestamp(path.stat().st_mtime).isoformat()
 
 
+# The exact bytes written into a `.bantamkit/.gitignore` the first time such a directory
+# is brought into existence (user ruling 2026-09-15, `.shiftwork/notes-job51/P0-probes.md`).
+# Both runtimes hold this text byte-for-byte -- a conformance case pins it against this
+# literal -- so it is spelled once, here, rather than re-typed at each call site.
+BANTAMKIT_GITIGNORE_TEXT = (
+    "# Created by bantamkit: this directory is local state. Delete this file to commit it.\n"
+    "*\n"
+)
+
+
+def ensure_bantamkit_gitignore(directory: Path, *, created: bool) -> None:
+    """Best-effort, idempotent: give `directory` a self-ignoring `.gitignore` if it is
+    literally named `.bantamkit` AND `created` says THIS CALLER'S OWN mkdir is what just
+    brought it into existence.
+
+    USER RULING #2 (2026-09-15, after J51-8 measured the fallout of the first rule): the
+    ignore file is written only when bantamkit itself creates the `.bantamkit` directory.
+    An existing `.bantamkit` -- made by an earlier bantamkit, by hand, or checked out from
+    git; with or without a `.gitignore` already in it -- is never given one. That is why
+    `created` is the caller's job, not this function's: only the caller knows whether
+    `.bantamkit` existed immediately before ITS mkdir, because by the time this function
+    runs the directory unconditionally exists either way. (Was: written whenever the
+    ignore file itself was absent, regardless of whether `.bantamkit` predated the call --
+    which meant deleting the file never stuck, and a store a team already commits would
+    silently start ignoring new fact files after an upgrade. `P0-probes.md` ruling 4.)
+
+    THE PROPERTY, not the mechanism: whenever a `.bantamkit` directory is brought into
+    existence -- by `MemoryStore._ensure_dirs`, or by anything else in this runtime that
+    creates one, such as `EventLog._append`'s own `mkdir` when the event log is on and
+    the project store was never saved to -- this is the one place that decides whether it
+    gets ignored. A second creator that skipped this call, or that got `created` wrong,
+    would leave a `.bantamkit` that git can see (or ignore one it should not), which is
+    the whole bug this closes.
+
+    NEVER REWRITES. A `.gitignore` that already exists -- whatever its bytes -- is left
+    exactly as it is, kept as a second guard even when `created` is `True`: an operator
+    who deleted it to commit the directory keeps that decision, and this never diffs its
+    own output against what is on disk.
+
+    NEVER RAISES. Failing to write the ignore file must never be why a fact does not get
+    saved -- the parent write (`save`, `compact`, an event record) still has to succeed
+    exactly as it does today. A missing ignore file is not worth a lost fact, so an
+    unwritable filesystem, a permissions error, or the directory disappearing under this
+    call are all swallowed the same way `EventLog.record` already swallows its own
+    `OSError`.
+
+    NEVER CREATES `directory` ITSELF. `write_text` fails into a missing parent exactly
+    like any other `OSError` here, so calling this before `directory` exists is a no-op,
+    not a way to bring `.bantamkit` into existence early.
+    """
+    if directory.name != ".bantamkit" or not created:
+        return
+    gitignore = directory / ".gitignore"
+    if gitignore.exists():
+        return
+    try:
+        gitignore.write_text(BANTAMKIT_GITIGNORE_TEXT, encoding="utf-8")
+    except OSError:
+        pass
+
+
 class MemoryStore:
     def __init__(
         self,
@@ -341,6 +402,11 @@ class MemoryStore:
         mkdir's internals. `self.root` is the path the caller named and both sides agree on
         it, which is what lets one conformance case pin this line byte for byte.
         """
+        # Checked BEFORE the mkdir, per user ruling #2: this is the one moment that can
+        # tell whether `.bantamkit` already existed. After the mkdir it unconditionally
+        # exists either way, so the answer has to be captured now or not at all.
+        bantamkit_dir = self.root.parent
+        bantamkit_dir_existed_before = bantamkit_dir.exists()
         try:
             (self.root / "facts").mkdir(parents=True, exist_ok=True)
             (self.root / "archive").mkdir(parents=True, exist_ok=True)
@@ -349,6 +415,7 @@ class MemoryStore:
                 f"memory store could not be created: {self.root}; the directory is not"
                 " there and this filesystem would not make it, so nothing was written"
             ) from e
+        ensure_bantamkit_gitignore(bantamkit_dir, created=not bantamkit_dir_existed_before)
 
     # ---- ops ----
 

bantamkit-0.34.0/tests/test_bantamkit_gitignore.py

@@ -0,0 +1,236 @@
+"""J51-1 / J51-8a: a `.bantamkit` directory ignores itself in git — but ONLY the one
+bantamkit itself brings into existence.
+
+User ruling 2026-09-15 (`.shiftwork/notes-job51/P0-probes.md`): `.bantamkit` stays out of
+git by default via a self-ignoring `.bantamkit/.gitignore` (`*`), never by editing the
+repository's own `.gitignore`. The property, from `.shiftwork/briefs-job51/J51-1.md`,
+AS AMENDED by user ruling #2 (2026-09-15, `.shiftwork/briefs-job51/J51-8a.md`) after J51-8
+measured that a deleted ignore file came back on the next save and that a store a team
+already commits would silently start ignoring new fact files after an upgrade:
+
+1. The ignore file is written IF AND ONLY IF, in this call, the `.bantamkit` directory
+   did not exist immediately before the directories were made and exists afterwards.
+   "Did not exist" is decided by checking the `.bantamkit` directory itself BEFORE the
+   mkdir — never the `.gitignore` file, never `memory/`. (Was: written whenever the
+   store's directories are brought into existence and the ignore file itself is absent,
+   regardless of whether `.bantamkit` already existed — J51-8 measured this makes
+   deletion not stick.)
+2. A `.bantamkit` directory that already existed — made by an earlier bantamkit, by hand,
+   or checked out from git; with or without a `.gitignore` — is never given one. In
+   particular, an existing `.gitignore` is never rewritten (unchanged from J51-1).
+3. Writing it is best-effort: an unwritable `.gitignore` never fails the write that
+   triggered it.
+4. A store whose parent is not named `.bantamkit` gets no `.gitignore` anywhere.
+5. End-to-end: a fresh `git init` directory shows nothing under `.bantamkit` in
+   `git status --porcelain --untracked-files=all` after a `memory_save`.
+6. Consequence of 1: deleting the file after bantamkit created it, then saving again,
+   leaves it deleted — the file's own first line ("Delete this file to commit it") is
+   now true.
+
+Also covers the bypass this audit found: `EventLog._append`'s own
+`self.path.parent.mkdir(parents=True, exist_ok=True)` can bring a `.bantamkit` directory
+into existence WITHOUT ever calling `MemoryStore._ensure_dirs` — e.g. when
+`BANTAMKIT_EVENT_LOG=on` and the project store has never been saved to. That path must
+carry the same gitignore-write (and the same "only if `.bantamkit` did not already
+exist" gate), or a `.bantamkit` created that way is never ignored, or is ignored when it
+should not be.
+"""
+
+import shutil
+import subprocess
+
+import pytest
+
+from bantamkit.eventlog import EventLog, default_path
+from bantamkit.memory import Memory, MemoryStore
+from bantamkit.memory.store import BANTAMKIT_GITIGNORE_TEXT, ensure_bantamkit_gitignore
+
+
+def test_property_1_gitignore_written_when_store_root_parent_is_dot_bantamkit(tmp_path):
+    root = tmp_path / ".bantamkit" / "memory"
+    MemoryStore(root)  # create=True by default; brings facts/ and archive/ into existence
+
+    gitignore = tmp_path / ".bantamkit" / ".gitignore"
+    assert gitignore.exists()
+    assert gitignore.read_bytes() == BANTAMKIT_GITIGNORE_TEXT.encode("utf-8")
+
+
+def test_property_1_also_fires_on_save_not_only_construction(tmp_path):
+    root = tmp_path / ".bantamkit" / "memory"
+    store = MemoryStore(root, create=False)
+    gitignore = tmp_path / ".bantamkit" / ".gitignore"
+    assert not gitignore.exists()
+
+    store.save("project", "widget-cache", "one line", "body", ())
+
+    assert gitignore.exists()
+    assert gitignore.read_text(encoding="utf-8") == BANTAMKIT_GITIGNORE_TEXT
+
+
+def test_property_2_an_existing_gitignore_is_never_rewritten(tmp_path):
+    root = tmp_path / ".bantamkit" / "memory"
+    bantamkit_dir = tmp_path / ".bantamkit"
+    bantamkit_dir.mkdir()
+    gitignore = bantamkit_dir / ".gitignore"
+    gitignore.write_text("operator's own content\n", encoding="utf-8")
+
+    store = MemoryStore(root)
+    store.save("project", "widget-cache", "one line", "body", ())
+    store.compact()
+
+    assert gitignore.read_text(encoding="utf-8") == "operator's own content\n"
+
+
+def test_property_3_unwritable_gitignore_is_best_effort(tmp_path, monkeypatch):
+    root = tmp_path / ".bantamkit" / "memory"
+
+    from pathlib import Path
+
+    real_write_text = Path.write_text
+
+    def refuse(self, *args, **kwargs):
+        if self.name == ".gitignore":
+            raise OSError("simulated: read-only filesystem")
+        return real_write_text(self, *args, **kwargs)
+
+    monkeypatch.setattr(Path, "write_text", refuse)
+
+    store = MemoryStore(root)  # must not raise
+    result = store.save("project", "widget-cache", "one line", "body", ())  # must not raise
+
+    assert result.status == "saved"
+    assert not (tmp_path / ".bantamkit" / ".gitignore").exists()
+
+
+def test_property_4_store_not_under_dot_bantamkit_gets_no_gitignore(tmp_path):
+    root = tmp_path / "somewhere" / "mem"
+    MemoryStore(root)
+
+    assert not (tmp_path / "somewhere" / ".gitignore").exists()
+    assert not (tmp_path / ".gitignore").exists()
+
+
+def test_ensure_bantamkit_gitignore_is_a_noop_off_a_non_bantamkit_directory(tmp_path):
+    """API change for J51-8a: `created` is now a required keyword — the caller must say
+    whether ITS OWN mkdir is what brought `directory` into existence. Passed `True` here
+    on purpose: the name check must refuse even when the caller claims a fresh creation.
+    """
+    directory = tmp_path / "not-bantamkit"
+    directory.mkdir()
+    ensure_bantamkit_gitignore(directory, created=True)
+    assert list(directory.iterdir()) == []
+
+
+def test_property_1_amended_existing_bantamkit_without_gitignore_gets_none_on_save(tmp_path):
+    """J51-8a (a): a `.bantamkit` that already existed — with no `.gitignore` in it —
+    never gets one, even though the ignore file itself is absent. FAILS on the
+    pre-J51-8a source, which writes whenever the file is absent.
+    """
+    bantamkit_dir = tmp_path / ".bantamkit"
+    bantamkit_dir.mkdir()
+    gitignore = bantamkit_dir / ".gitignore"
+    assert not gitignore.exists()
+
+    root = bantamkit_dir / "memory"
+    store = MemoryStore(root)
+    store.save("project", "widget-cache", "one line", "body", ())
+
+    assert not gitignore.exists()
+
+
+def test_property_1_amended_deleting_the_gitignore_after_creation_stays_deleted(tmp_path):
+    """J51-8a (b): bantamkit creates `.bantamkit` itself, so the ignore file is written —
+    delete it, save again, and it must stay deleted. FAILS on the pre-J51-8a source,
+    which rewrites it on the next save because the file is absent.
+    """
+    root = tmp_path / ".bantamkit" / "memory"
+    gitignore = tmp_path / ".bantamkit" / ".gitignore"
+
+    store = MemoryStore(root)
+    assert gitignore.exists()
+
+    gitignore.unlink()
+    store.save("project", "widget-cache", "one line", "body", ())
+
+    assert not gitignore.exists()
+
+
+def test_eventlog_amended_existing_bantamkit_without_gitignore_gets_none(tmp_path):
+    """J51-8a (c), condition (a): the event-log creator follows the same rule — a
+    `.bantamkit` that already existed, with no `.gitignore`, is left alone.
+    """
+    bantamkit_dir = tmp_path / ".bantamkit"
+    bantamkit_dir.mkdir()
+    gitignore = bantamkit_dir / ".gitignore"
+    assert not gitignore.exists()
+
+    store_root = bantamkit_dir / "memory"
+    log = EventLog(default_path(store_root))
+    log.record("memory_save", "saved", {"budget": 1, "index_bytes": 1})
+
+    assert log.write_failed is False
+    assert not gitignore.exists()
+
+
+def test_eventlog_amended_deleting_the_gitignore_after_creation_stays_deleted(tmp_path):
+    """J51-8a (c), condition (b): the event-log creator brought `.bantamkit` into
+    existence itself, so deleting the ignore file it wrote must stick on the next append.
+    """
+    store_root = tmp_path / ".bantamkit" / "memory"
+    gitignore = tmp_path / ".bantamkit" / ".gitignore"
+
+    log = EventLog(default_path(store_root))
+    log.record("memory_save", "saved", {"budget": 1, "index_bytes": 1})
+    assert gitignore.exists()
+
+    gitignore.unlink()
+    log.record("memory_save", "saved", {"budget": 1, "index_bytes": 1})
+
+    assert not gitignore.exists()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is not on PATH")
+def test_property_5_end_to_end_git_status_is_clean_under_dot_bantamkit(tmp_path):
+    subprocess.run(["git", "init", "-q"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True
+    )
+    subprocess.run(["git", "config", "user.name", "test"], cwd=tmp_path, check=True)
+
+    memory = Memory(tmp_path / ".bantamkit" / "memory")
+    outcome = memory.save_outcome("project", "widget-cache", "one line", "body", ())
+    assert outcome.status == "saved"
+
+    result = subprocess.run(
+        ["git", "status", "--porcelain", "--untracked-files=all"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+        encoding="utf-8",
+    )
+    bantamkit_lines = [line for line in result.stdout.splitlines() if ".bantamkit" in line]
+    assert bantamkit_lines == []
+
+
+def test_eventlog_mkdir_bypass_still_gets_the_gitignore(tmp_path):
+    """The finding: `EventLog._append` mkdir's a `.bantamkit` tree on its own when the
+    project store was never saved to. That must not skip the gitignore write.
+    """
+    store_root = tmp_path / ".bantamkit" / "memory"
+    assert not (tmp_path / ".bantamkit").exists()
+
+    log = EventLog(default_path(store_root))
+    log.record("memory_save", "saved", {"budget": 1, "index_bytes": 1})
+
+    assert log.write_failed is False
+    gitignore = tmp_path / ".bantamkit" / ".gitignore"
+    assert gitignore.exists()
+    assert gitignore.read_text(encoding="utf-8") == BANTAMKIT_GITIGNORE_TEXT
+
+
+def test_eventlog_path_unrelated_to_dot_bantamkit_writes_no_gitignore(tmp_path):
+    log = EventLog(tmp_path / "custom" / "log.jsonl")
+    log.record("memory_save", "saved", {"budget": 1, "index_bytes": 1})
+
+    assert log.write_failed is False
+    assert not list(tmp_path.glob("**/.gitignore"))