bantamkit 0.31.0__tar.gz → 0.32.0__tar.gz

{bantamkit-0.31.0 → bantamkit-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bantamkit
-Version: 0.31.0
+Version: 0.32.0
 Summary: bantamweight tooling — harness primitives that lift small-model agents
 License-Expression: MIT
 Requires-Python: >=3.11

{bantamkit-0.31.0 → bantamkit-0.32.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.31.0"
+__version__ = "0.32.0"

{bantamkit-0.31.0 → bantamkit-0.32.0}/src/bantamkit/memory/component.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 from collections.abc import Iterator
 from contextlib import ExitStack, contextmanager
 from dataclasses import dataclass
@@ -153,6 +154,22 @@ def _profile_store() -> Path:
     return Path.home() / ".bantamkit" / "memory"
 
 
+def _same_directory(a: Path, b: Path) -> bool:
+    """Whether two paths name ONE directory, symlinks and `/var` vs `/private/var` included.
+
+    Realpath, not string equality, and that distinction is measured rather than tidy: on
+    macOS the walk up from a cwd under `/var` returns `/private/var/...` while `Path.home()`
+    returns `/var/...`, so two spellings of one directory compare unequal as strings. The
+    Stop hook already compares the same two roots the same way and for the same reason
+    (`tools/hooks/bantamkit-hook.mjs`). When the resolution itself fails, an absolute-path
+    comparison is the honest fallback: it can only under-report a match, never invent one.
+    """
+    try:
+        return os.path.realpath(a) == os.path.realpath(b)
+    except OSError:
+        return a.absolute() == b.absolute()
+
+
 def _layer_label(root: Path) -> str:
     if root.parent.name == ".bantamkit":
         return root.parent.parent.name
@@ -201,7 +218,16 @@ class Memory:
             mem._layers.append(
                 (f"extra:{_layer_label(grant)}", MemoryStore(grant, k=k, create=False), False)
             )
-        mem._layers.append(("profile", MemoryStore(_profile_store(), k=k, create=False), False))
+        # ONE DIRECTORY IS ONE LAYER. The walk above starts at the cwd and climbs, so a
+        # session with no `.bantamkit` anywhere above it resolves `~/.bantamkit/memory` —
+        # the profile store — as its PROJECT store. Binding that directory a second time
+        # gave `dream` the same store twice: every fact collided with itself, was merged
+        # into itself, and the "profile copy" that was archived was the same file. It
+        # archived 20 of 20 of the user's real facts on 2026-09-10. Such a session has one
+        # layer, and `dream_outcome` already has a true thing to say about that.
+        profile_root = _profile_store()
+        if not _same_directory(profile_root, project_root):
+            mem._layers.append(("profile", MemoryStore(profile_root, k=k, create=False), False))
         return mem
 
     def setup(self, agent: Agent) -> None:

{bantamkit-0.31.0 → bantamkit-0.32.0}/src/bantamkit/shiftwork.py

@@ -19,7 +19,10 @@ asset, same discipline:
   allowed, when `job.roles` names that role (AS-2) — a validation-time refusal
   taken BEFORE the log line is appended, so a rejected model never leaves an
   orphan accounting line behind; a role the map omits, or a checkpoint with no
-  map, is unconstrained and behaves exactly as it did before the map existed;
+  map, is unconstrained and behaves exactly as it did before the map existed.
+  J47-4: a role the map DOES name whose value is not a list of model identifiers
+  is refused there too — an unreadable declaration allows no model, and the
+  refusal is the same structured one, taken in the same place;
 * every clock-out appends one line to `<checkpoint>.log.jsonl` beside the
   checkpoint (unit, role, status, ts, plus orchestrator-reported accounting)
   — the driver-log shape, so the history ring's 5-entry cap never loses
@@ -154,12 +157,31 @@ def _model_refusal(document: dict, unit_id: str, unit: dict, accounting: dict |
     the sentence says so. Measured, not asserted: the conformance corpus and
     both runtimes' tests drive this through a `BANTAMKIT_ASSETS` pack whose
     schema has no `minItems`, which is the only way to reach the branch at all.
+
+    AND A DECLARATION THIS CODE CANNOT READ IS NOT A LICENCE (J47-4). The same
+    ruling, one step further out: a role the map names is constrained by what it
+    NAMES, and a value that is not a list of model identifiers names nothing, so
+    it allows nothing. What made this a second case rather than a corollary is
+    that `", ".join(allowed)` answered for every shape without ever deciding one
+    — over a string it iterated CHARACTERS and refused while misquoting the
+    checkpoint back at its author, and over a number, a null, a bool or a list
+    holding a non-string it raised `TypeError` straight out of `clock_out`, which
+    is the one exit the ruling forbids: not a structured refusal, so not an
+    answer at all. Fail CLOSED and say only what is true — the declaration cannot
+    be read, therefore no model is allowed — without rendering the unreadable
+    value into the sentence. `[]` is untouched by this: an empty list IS a list
+    of model identifiers, and it keeps the sentence J46-10 pinned.
     """
     role = unit["role"]
     roles = document["job"].get("roles", {})
     if role not in roles:
         return None
     allowed = roles[role]
+    if not isinstance(allowed, list) or not all(isinstance(m, str) for m in allowed):
+        return (
+            f"unit {unit_id} in role {role} cannot clock out: job.roles.{role} "
+            f"is not a list of model identifiers, so it allows no model"
+        )
     names = ", ".join(allowed)
     offered = (accounting or {}).get("model")
     if offered is None:
@@ -189,7 +211,10 @@ def clock_out(
     (driver parity); anything else is a structured error. When `job.roles` names
     the unit's role, `accounting["model"]` must be one of that role's models,
     spelled exactly; a wrong or missing model is refused here, before any
-    mutation and before the accounting line. Mutations: set the
+    mutation and before the accounting line. Extended 2026-09-11 (job47): so is a
+    `job.roles` value for that role that is not a list of model identifiers —
+    an unreadable declaration allows no model, and it is refused in the same
+    place, by the same structured return, writing nothing. Mutations: set the
     unit's status, advance `plan.cursor` to the first non-terminal unit
     (v1-linear, `depends_on` is ignored), shallow-merge `handoff_patch` into
     `handoff`, push `history_entry` onto the 5-entry ring. The mutated

{bantamkit-0.31.0 → bantamkit-0.32.0}/tests/test_memory_dream.py

@@ -776,6 +776,67 @@ def test_a_memory_with_no_profile_layer_says_so_rather_than_failing(tmp_path: Pa
     assert "no profile layer is bound" in outcome.reply
 
 
+def test_one_directory_is_one_layer_when_the_walk_lands_on_the_profile_store(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The 2026-09-10 incident, as a node. A cwd with no `.bantamkit` anywhere above it
+    walks up to `~/.bantamkit/memory`, so the PROJECT store resolves to the profile store
+    and `dream` is handed the same directory twice: every fact collides with itself, is
+    merged into itself, and the "profile copy" — the same file — is archived. It archived
+    20 of 20 of the user's real facts. The property is that one directory is one layer, so
+    such a session has a single layer and the existing `no-profile-layer` outcome is the
+    true thing to say about it.
+    """
+    home = tmp_path / "home"
+    (home / "work").mkdir(parents=True)
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: home))
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.delenv("BANTAMKIT_MEMORY_DIR", raising=False)
+    profile = MemoryStore(home / ".bantamkit" / "memory")
+    profile.save(
+        "project", "alpha-routing-rule", "how the alpha router picks a shard", "hash by tenant"
+    )
+
+    memory = Memory.layered(start=home / "work")
+    outcome = memory.dream_outcome(dry_run=False)
+
+    assert memory.store.root.resolve() == profile.root.resolve()  # the walk landed on it
+    assert outcome.status == "no-profile-layer"
+    assert (outcome.merged, outcome.consumed) == (0, 0)
+    assert [fact.name for fact in profile._facts()] == ["alpha-routing-rule"]
+    assert list((profile.root / "archive").glob("*.md")) == []
+    assert [label for label, _, _ in memory._layers] == ["project"]
+
+
+def test_one_directory_is_one_layer_through_a_symlinked_home(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Two spellings of one directory are still one directory, so the comparison resolves.
+
+    Without this node a string comparison passes the node above: `tmp_path` hands back an
+    already-resolved path and both spellings agree. The case that forced the Stop hook to
+    use `fs.realpathSync` is exactly this one — macOS `/var` vs `/private/var`, where the
+    walk up from the cwd returns the resolved spelling and `Path.home()` returns the link.
+    """
+    real = tmp_path / "real-home"
+    (real / "work").mkdir(parents=True)
+    link = tmp_path / "linked-home"
+    link.symlink_to(real, target_is_directory=True)
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: link))
+    monkeypatch.setenv("HOME", str(link))
+    monkeypatch.delenv("BANTAMKIT_MEMORY_DIR", raising=False)
+    profile = MemoryStore(link / ".bantamkit" / "memory")
+    profile.save("user", "beta-timezone", "which timezone the operator works in", "Asia/Bangkok")
+
+    memory = Memory.layered(start=real / "work")
+    outcome = memory.dream_outcome(dry_run=False)
+
+    assert str(memory.store.root) != str(profile.root)  # the two spellings really differ
+    assert outcome.status == "no-profile-layer"
+    assert [fact.name for fact in profile._facts()] == ["beta-timezone"]
+    assert list((profile.root / "archive").glob("*.md")) == []
+
+
 def test_the_outcome_status_is_read_off_the_decision_not_the_reply(tmp_path: Path) -> None:
     """The same seam `SaveOutcome`, `RecallOutcome` and `CompactOutcome` have: a caller that
     wants to tell the outcomes apart must never have to match prose."""

{bantamkit-0.31.0 → bantamkit-0.32.0}/tests/test_shiftwork.py

@@ -713,6 +713,148 @@ def test_an_absent_role_and_an_empty_list_are_different_inputs(
     assert ops.clock_out(str(empty), *args)["result"] == "error"
 
 
+# --- J47-4: a roles value this code cannot read is not a licence -------------
+
+
+def _pack_with_unconstrained_roles_values(tmp_path, schema):
+    """An asset pack whose checkpoint schema no longer says what a roles value IS.
+
+    `additionalProperties: true` on `job.roles` is the loosest the shared asset
+    could ever drift to, so it is the instrument that reaches every non-list
+    shape at once. Same `BANTAMKIT_ASSETS` override the empty-list ruling uses,
+    for the same reason: the check must hold without the schema's help.
+    """
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["job"]["properties"]["roles"]["additionalProperties"] = True
+    root = tmp_path / "anyroles"
+    (root / "schemas").mkdir(parents=True)
+    (root / "schemas" / "shiftwork-checkpoint.json").write_text(
+        json.dumps(mutated), encoding="utf-8"
+    )
+    return root
+
+
+NOT_A_MODEL_LIST = [
+    pytest.param("claude-opus-5", id="str"),
+    pytest.param({"a": 1}, id="dict"),
+    pytest.param(5, id="int"),
+    pytest.param(None, id="null"),
+    pytest.param(True, id="bool"),
+    pytest.param([5], id="list-of-int"),
+    pytest.param(["ok", None], id="list-with-a-non-string"),
+]
+
+
+@pytest.mark.parametrize("value", NOT_A_MODEL_LIST)
+def test_a_roles_value_that_is_not_a_list_of_model_names_refuses_closed(
+    tmp_path, monkeypatch, schema, example, value
+):
+    """The J46-10 ruling's other half. A role the map NAMES is constrained by what
+    it names, and a value this code cannot read as a list of model identifiers
+    names nothing -- so it allows nothing.
+
+    Measured before the fix, with `accounting['model'] = 'haiku'`: `str` and
+    `dict` refused with the declared value mangled into single characters
+    (`', '.join` over a string iterates CHARACTERS), and `int`, `null`, `bool`
+    and a list holding a non-string all died with an uncaught `TypeError` out of
+    `clock_out` -- no structured answer at all, which is the one exit shape the
+    ruling forbids.
+    """
+    monkeypatch.setenv(
+        "BANTAMKIT_ASSETS", str(_pack_with_unconstrained_roles_values(tmp_path, schema))
+    )
+    example["job"]["roles"] = {"implementer": value}
+    path = write_checkpoint(tmp_path, example)
+    before = path.read_bytes()
+    assert ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, ACCOUNTING
+    ) == {
+        "result": "error",
+        "reason": (
+            "unit U3 in role implementer cannot clock out: job.roles.implementer "
+            "is not a list of model identifiers, so it allows no model"
+        ),
+    }
+    # Offering no model is the same refusal: which model was reported cannot
+    # matter when the declaration that would judge it is unreadable.
+    assert ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, {"tokens": 1}
+    ) == {
+        "result": "error",
+        "reason": (
+            "unit U3 in role implementer cannot clock out: job.roles.implementer "
+            "is not a list of model identifiers, so it allows no model"
+        ),
+    }
+    assert path.read_bytes() == before
+    assert read_log(path) == []
+
+
+def test_an_unreadable_roles_value_never_mangles_the_declaration_into_characters(
+    tmp_path, monkeypatch, schema, example
+):
+    """The specific pre-fix defect, pinned so it cannot come back: a string value
+    refused, but rendered `claude-opus-5` as `c, l, a, u, d, e, -, o, p, u, s, -, 5`
+    -- a refusal sentence that misdescribes the checkpoint it is refusing.
+    """
+    monkeypatch.setenv(
+        "BANTAMKIT_ASSETS", str(_pack_with_unconstrained_roles_values(tmp_path, schema))
+    )
+    example["job"]["roles"] = {"implementer": "claude-opus-5"}
+    path = write_checkpoint(tmp_path, example)
+    reason = ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, ACCOUNTING
+    )["reason"]
+    assert "c, l, a, u" not in reason
+
+
+def test_the_relaxed_pack_is_what_lets_a_non_list_roles_value_through(
+    tmp_path, monkeypatch, schema, example
+):
+    """The companion that keeps the tests above honest, the empty-list ruling's own
+    companion by name: with the SHIPPED schema the same document is refused during
+    the read and never reaches the model check, so the two refusals are different
+    sentences and the gate is confirmed to reach the thing it checks.
+    """
+    example["job"]["roles"] = {"implementer": 5}
+    path = write_checkpoint(tmp_path, example)
+    assert ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, ACCOUNTING
+    ) == {
+        "result": "error",
+        "reason": (
+            "checkpoint invalid: JSON does not match schema at "
+            "'job/roles/implementer': 5 is not of type 'array'"
+        ),
+    }
+    monkeypatch.setenv(
+        "BANTAMKIT_ASSETS", str(_pack_with_unconstrained_roles_values(tmp_path, schema))
+    )
+    assert "is not a list of model identifiers" in ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, ACCOUNTING
+    )["reason"]
+
+
+def test_an_empty_list_is_still_the_j46_10_sentence_not_the_unreadable_one(
+    tmp_path, monkeypatch, schema, example
+):
+    """`[]` IS a list of model identifiers -- an empty one. It stays on the J46-10
+    branch with the sentence that ruling pinned, and does not fall into the
+    unreadable-declaration branch added here.
+    """
+    monkeypatch.setenv(
+        "BANTAMKIT_ASSETS", str(_pack_with_unconstrained_roles_values(tmp_path, schema))
+    )
+    example["job"]["roles"] = {"implementer": []}
+    path = write_checkpoint(tmp_path, example)
+    assert ops.clock_out(
+        str(path), "U3", "done", {}, {"unit": "U3", "outcome": "done"}, ACCOUNTING
+    )["reason"] == (
+        "unit U3 in role implementer reported model haiku, "
+        "which job.roles.implementer does not allow: "
+    )
+
+
 # --- MCP flavor: status -----------------------------------------------------