bantamkit 0.35.2__tar.gz → 0.35.3__tar.gz

{bantamkit-0.35.2 → bantamkit-0.35.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bantamkit
-Version: 0.35.2
+Version: 0.35.3
 Summary: Memory MCP server for Claude Code, Cursor, VS Code Copilot and Claude Desktop, plus a Python library that lifts small-model agents. Install once, run offline.
 Project-URL: Homepage, https://github.com/Ink01101011/bantamkit
 Project-URL: Repository, https://github.com/Ink01101011/bantamkit
@@ -23,7 +23,7 @@ Requires-Dist: hatchling>=1.24; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
 Provides-Extra: mcp
-Requires-Dist: mcp<3,>=2.0; extra == 'mcp'
+Requires-Dist: mcp<2.1,>=2.0; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 # bantamkit — memory MCP server for Claude Code, Cursor, VS Code Copilot and Claude Desktop (Python)
@@ -97,9 +97,9 @@ CPU architecture and Python minor version** (some wheels, such as `pydantic_core
 one platform only), copy `wheels/` across, and install from it:
 
 ```bash
-python -m pip download "bantamkit[mcp]==0.35.2" -d wheels
+python -m pip download "bantamkit[mcp]==0.35.3" -d wheels
 python -m venv <env>
-<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.35.2"
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.35.3"
 <env>/bin/bantamkit-mcp --install cursor
 ```
 

{bantamkit-0.35.2 → bantamkit-0.35.3}/README.md

@@ -69,9 +69,9 @@ CPU architecture and Python minor version** (some wheels, such as `pydantic_core
 one platform only), copy `wheels/` across, and install from it:
 
 ```bash
-python -m pip download "bantamkit[mcp]==0.35.2" -d wheels
+python -m pip download "bantamkit[mcp]==0.35.3" -d wheels
 python -m venv <env>
-<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.35.2"
+<env>/bin/pip install --no-index --find-links wheels "bantamkit[mcp]==0.35.3"
 <env>/bin/bantamkit-mcp --install cursor
 ```
 

bantamkit-0.35.3/_assets/tools/shiftwork_clock_out.json

@@ -0,0 +1,150 @@
+{
+  "name": "shiftwork_clock_out",
+  "description": "Shift-work clock-out: record a finished unit — set its status, advance plan.cursor, merge handoff_patch, push history_entry onto the 5-entry ring — validating the whole mutated document against the checkpoint schema BEFORE an atomic write (a failure writes nothing and returns result=error). `unit_id` must be `plan.cursor`, the one unit clock_in briefs; any other id is refused (`unit X is not the cursor unit Y`). `handoff_patch` and `history_entry` are both required arguments: `handoff_patch` is shallow-merged into `handoff` and takes only its four keys (pass `{}` to leave it unchanged); `history_entry` needs `unit` and `outcome`; `status` is one of the five unit statuses — a value outside these shapes is refused by the schema check, nothing written. Every success appends one accounting line (unit, role, status, ts, briefed, plus your accounting fields, e.g. tokens/duration_ms/model) to <checkpoint>.log.jsonl, beside the brief lines clock_in writes (a brief line carries `event` and no `status`). `accounting` is optional: null, the default, logs a line with no cost figures at all; a non-null line must fit the accounting shape below. `briefed` is written by the runtime, never taken from you — a self-reported value is overwritten by the measured one: true when a brief was issued for this unit since its LAST clock-out (not ever), so a unit re-run inline after a blocked clock-out reads false. A brief is not a precondition: a unit that was never clocked in still clocks out, with briefed=false. If the checkpoint's job.roles names this unit's role, accounting.model must be one of that role's model identifiers, spelled exactly — a model that is not on the list, or none reported at all, is refused before anything is written; a role job.roles omits, and a checkpoint carrying no job.roles, are unconstrained.",
+  "surfaces": [
+    "mcp"
+  ],
+  "parameters": {
+    "properties": {
+      "checkpoint": {
+        "title": "Checkpoint",
+        "type": "string"
+      },
+      "unit_id": {
+        "title": "Unit Id",
+        "type": "string",
+        "description": "The unit being clocked out. Must equal plan.cursor — the single-pointer contract: clock_in briefs only the cursor unit and clock_out accepts only it."
+      },
+      "status": {
+        "title": "Status",
+        "type": "string",
+        "enum": [
+          "todo",
+          "in_progress",
+          "done",
+          "blocked",
+          "dropped"
+        ],
+        "description": "The unit's new status; the same five values the checkpoint schema allows on plan.units[].status."
+      },
+      "handoff_patch": {
+        "title": "Handoff Patch",
+        "type": "object",
+        "additionalProperties": false,
+        "description": "Shallow-merged into `handoff`: only these four keys exist there, and a key outside them is refused by the schema check. Required; `{}` leaves `handoff` unchanged.",
+        "properties": {
+          "next_action": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Imperative first move — zero re-derivation."
+          },
+          "open_questions": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "description": "The autonomy switch: empty = driver keeps cycling, non-empty = STOP and ask."
+          },
+          "do_not": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "description": "Negative space — near-mistakes past sessions made."
+          },
+          "notes": {
+            "type": "string",
+            "description": "Free-form prose for the next session, one string; the empty string clears it."
+          }
+        }
+      },
+      "history_entry": {
+        "title": "History Entry",
+        "type": "object",
+        "required": [
+          "unit",
+          "outcome"
+        ],
+        "additionalProperties": true,
+        "description": "Pushed onto the 5-entry `history` ring; `unit` and `outcome` are required, `notes` optional, other keys pass through.",
+        "properties": {
+          "unit": {
+            "type": "string",
+            "minLength": 1
+          },
+          "outcome": {
+            "type": "string",
+            "minLength": 1
+          },
+          "notes": {
+            "type": "string"
+          }
+        }
+      },
+      "accounting": {
+        "anyOf": [
+          {
+            "type": "object",
+            "description": "Per-unit cost. Written verbatim, beside ts/unit/role/status, as one line of <checkpoint>.log.jsonl - the ledger the N-sessions experiment reads. The keys named here have fixed meanings so a reader holding only the ledger knows what each number counts, in which unit, and which model produced it; any other key passes through unchanged (a refused key is friction, not safety). Lines written before this schema existed may spell these differently; the schema governs new writes only.",
+            "properties": {
+              "tokens": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "Tokens the unit consumed as the harness's subagent counter reports them: every class it reports (input, output, cache creation) summed, EXCLUDING cache reads. In a non-null accounting line it is required — a line without it is refused before anything is written; only `accounting: null`, the default, is exempt, and that logs no cost at all. A rounded self-estimate is allowed only if `note` says it is one; a unit whose cost is unknown cannot be compared with any other."
+              },
+              "cache_read_tokens": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "Tokens the unit's requests served from prompt cache, kept OUT of `tokens` because they dominate a real session's traffic and would swamp the work signal. Optional: omit it when the harness reports no such figure - a written 0 means the unit read nothing from cache."
+              },
+              "duration_ms": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "Wall-clock from spawning the subagent to its final message, in whole milliseconds. In a non-null line it is required, and it is the only duration key with a defined meaning: older lines carry `duration`, `duration_min` or `duration_s`, which this schema neither reads nor renames."
+              },
+              "model": {
+                "type": "string",
+                "description": "The exact identifier of the model the subagent actually ran on (e.g. `claude-sonnet-5`) and nothing else - a caveat about how it was chosen belongs in `note`. Not required here: when the checkpoint's job.roles names this unit's role, clock_out already requires it and refuses a value off that role's list, spelled exactly; a checkpoint with no job.roles leaves it optional. This schema does not change that gate."
+              },
+              "tool_uses": {
+                "type": "integer",
+                "minimum": 0,
+                "description": "Tool calls the subagent made, as the harness counts them. Optional; it is the denominator that makes `tokens` comparable across units of different size (per-unit cost is linear in tool calls, not in unit length)."
+              },
+              "note": {
+                "type": "string",
+                "description": "Free text for what the fields above cannot say: that `tokens` is an estimate, that this is a retry or a second scope under the same unit id, what a harness counter excludes. Anything that is not a model identifier goes here, not in `model`."
+              }
+            },
+            "required": [
+              "tokens",
+              "duration_ms"
+            ],
+            "additionalProperties": true
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "title": "Accounting"
+      }
+    },
+    "required": [
+      "checkpoint",
+      "unit_id",
+      "status",
+      "handoff_patch",
+      "history_entry"
+    ],
+    "type": "object",
+    "title": "shiftwork_clock_outArguments"
+  },
+  "output_schema": {
+    "type": "object",
+    "additionalProperties": true,
+    "title": "shiftwork_clock_outDictOutput"
+  }
+}

bantamkit-0.35.3/_assets/tools/shiftwork_plan.json

@@ -0,0 +1,25 @@
+{
+  "name": "shiftwork_plan",
+  "description": "Shift-work plan: read-only batch view of a checkpoint — which units its `depends_on` graph permits to run in parallel. Answers `{\"result\": \"plan\", \"batches\", \"ready\", \"sequence\", \"width\", \"cursor\"}`: `ready` is `batches[0]`, the units whose dependencies are all satisfied, and `width` is the largest batch length, the widest fan-out. Only `cursor` can be clocked: shiftwork_clock_in briefs it and shiftwork_clock_out refuses every other id, so a `ready` member beyond the cursor is what the graph permits, not a unit the clock accepts yet. Units with status `done` or `dropped` are satisfied — dropped from the graph, and edges pointing at them treated as already resolved; `todo`, `in_progress` and `blocked` stay in it. Every unit has priority 0, because the checkpoint schema has no priority field, so order inside a batch is `plan.units` order. Same refusal sentences as `work_plan` for a duplicate id, an unknown dependency or a cycle, and the same refusals `shiftwork_status` gives for a checkpoint it cannot read. It reports what the dependency graph permits; it does not move the cursor, which is echoed unchanged so the single-pointer contract and the batch view can be read side by side. An orchestrator stays responsible for what it actually dispatches: `depends_on` encodes logical order, not file contention. Never mutates.",
+  "surfaces": [
+    "mcp"
+  ],
+  "parameters": {
+    "properties": {
+      "checkpoint": {
+        "title": "Checkpoint",
+        "type": "string"
+      }
+    },
+    "required": [
+      "checkpoint"
+    ],
+    "type": "object",
+    "title": "shiftwork_planArguments"
+  },
+  "output_schema": {
+    "type": "object",
+    "additionalProperties": true,
+    "title": "shiftwork_planDictOutput"
+  }
+}

{bantamkit-0.35.2 → bantamkit-0.35.3}/pyproject.toml

@@ -69,7 +69,12 @@ dependencies = ["httpx>=0.27", "jsonschema>=4.21", "pyyaml>=6.0"]
 # without this declaration the bar would silently skip in exactly the environment
 # CI runs (`pip install -e "runtime-py[dev,mcp]"`). Declared here so it runs.
 dev = ["pytest>=8.0", "ruff>=0.4", "hatchling>=1.24"]
-mcp = ["mcp>=2.0,<3"]
+# Upper bound measured, not guessed: 2.0.0 and 2.0.1 wrap a tool crash as
+# `Error executing tool <name>: <exc>`, which runtime-ts/src/mcp/server.ts mirrors.
+# 2.1.0 added an UnexpectedToolError branch that drops the `: <exc>` suffix, so the
+# crash text stops reaching the client and `--suite workplan` goes red on the
+# reference while the port still carries it. Raise this only together with the port.
+mcp = ["mcp>=2.0,<2.1"]
 
 [project.scripts]
 bantamkit-mcp = "bantamkit.mcpserver:main"

{bantamkit-0.35.2 → bantamkit-0.35.3}/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.35.2"
+__version__ = "0.35.3"

{bantamkit-0.35.2 → bantamkit-0.35.3}/src/bantamkit/mcpserver.py

@@ -1907,6 +1907,25 @@ def build_server(memory: Memory, log: EventLog | None = None) -> Any:
 
     @server.resource("bantamkit://skills/{name}")
     def skill_resource(name: str) -> str:
+        # A skill that pairs with a tool is served on that tool's surfaces and no other. The
+        # pairing is the one `filegraph.py` spells: `load_tool("file_graph")` beside
+        # `load_skill("file-graph")` — the skill's name with `-` for `_`. `file-graph` is the
+        # eval agent's system-prompt snippet telling it to call `file_graph`, a tool whose
+        # asset claims only `agent`; handing that text to an MCP client sends it to a tool
+        # `tools/list` does not carry and `tools/call` refuses as unknown (job60 row 46).
+        # Same sentence and same error code on both runtimes; `tools/conformance/suites/
+        # instructions.mjs` reads every skill on disk over `resources/read` and resolves the
+        # tools it names against `tools/list`.
+        paired = name.replace("-", "_")
+        try:
+            asset = load_tool_asset(paired)
+        except AssetNotFound:
+            asset = None
+        if asset is not None and "mcp" not in asset["surfaces"]:
+            raise ResourceError(
+                f"skill asset {name} is not served here: it pairs with tool {paired}, "
+                f"whose asset claims surfaces {asset['surfaces']}, not mcp"
+            )
         try:
             return load_skill(name)
         except AssetNotFound:

{bantamkit-0.35.2 → bantamkit-0.35.3}/src/bantamkit/memory/store.py

@@ -133,7 +133,7 @@ _FACTS_UNREADABLE = (
 _ARCHIVE_UNREADABLE = (
     "an archive that could not be listed is not an empty archive, and answering "
     "'nothing is archived' here is what makes compaction look like deletion — the "
-    "facts compact() moved are still on disk under this path"
+    "facts that compaction moved are still on disk under this path"
 )
 # The same distinction one syscall down, for `restore`, which stats one named path
 # instead of listing (see `archived()` for why). A refused stat is not an absent file,
@@ -1310,5 +1310,5 @@ class MemoryStore:
         if size > self.index_budget:
             raise MemoryBudgetExceeded(
                 f"memory index is {size} bytes, budget is {self.index_budget}: "
-                f"run compact() or tersen descriptions"
+                f"compact the store or tersen descriptions"
             )

{bantamkit-0.35.2 → bantamkit-0.35.3}/tests/data/served-tool-surface.json

@@ -187,7 +187,7 @@
       }
     },
     "shiftwork_clock_out": {
-      "description": "Shift-work clock-out: record a finished unit — set its status, advance plan.cursor, merge handoff_patch, push history_entry onto the 5-entry ring — validating the whole mutated document against the checkpoint schema BEFORE an atomic write (a failure writes nothing and returns result=error). Every success appends one accounting line (unit, role, status, ts, briefed, plus your accounting fields, e.g. tokens/duration_ms/model) to <checkpoint>.log.jsonl, beside the brief lines clock_in writes (a brief line carries `event` and no `status`). `briefed` is written by the runtime, never taken from you — a self-reported value is overwritten by the measured one: true when a brief was issued for this unit since its LAST clock-out (not ever), so a unit re-run inline after a blocked clock-out reads false. It records; it never refuses — a unit that was never clocked in still clocks out, with briefed=false. If the checkpoint's job.roles names this unit's role, accounting.model must be one of that role's model identifiers, spelled exactly — a model that is not on the list, or none reported at all, is refused before anything is written; a role job.roles omits, and a checkpoint carrying no job.roles, are unconstrained.",
+      "description": "Shift-work clock-out: record a finished unit — set its status, advance plan.cursor, merge handoff_patch, push history_entry onto the 5-entry ring — validating the whole mutated document against the checkpoint schema BEFORE an atomic write (a failure writes nothing and returns result=error). `unit_id` must be `plan.cursor`, the one unit clock_in briefs; any other id is refused (`unit X is not the cursor unit Y`). `handoff_patch` and `history_entry` are both required arguments: `handoff_patch` is shallow-merged into `handoff` and takes only its four keys (pass `{}` to leave it unchanged); `history_entry` needs `unit` and `outcome`; `status` is one of the five unit statuses — a value outside these shapes is refused by the schema check, nothing written. Every success appends one accounting line (unit, role, status, ts, briefed, plus your accounting fields, e.g. tokens/duration_ms/model) to <checkpoint>.log.jsonl, beside the brief lines clock_in writes (a brief line carries `event` and no `status`). `accounting` is optional: null, the default, logs a line with no cost figures at all; a non-null line must fit the accounting shape below. `briefed` is written by the runtime, never taken from you — a self-reported value is overwritten by the measured one: true when a brief was issued for this unit since its LAST clock-out (not ever), so a unit re-run inline after a blocked clock-out reads false. A brief is not a precondition: a unit that was never clocked in still clocks out, with briefed=false. If the checkpoint's job.roles names this unit's role, accounting.model must be one of that role's model identifiers, spelled exactly — a model that is not on the list, or none reported at all, is refused before anything is written; a role job.roles omits, and a checkpoint carrying no job.roles, are unconstrained.",
       "inputSchema": {
         "properties": {
           "checkpoint": {
@@ -196,21 +196,76 @@
           },
           "unit_id": {
             "title": "Unit Id",
-            "type": "string"
+            "type": "string",
+            "description": "The unit being clocked out. Must equal plan.cursor — the single-pointer contract: clock_in briefs only the cursor unit and clock_out accepts only it."
           },
           "status": {
             "title": "Status",
-            "type": "string"
+            "type": "string",
+            "enum": [
+              "todo",
+              "in_progress",
+              "done",
+              "blocked",
+              "dropped"
+            ],
+            "description": "The unit's new status; the same five values the checkpoint schema allows on plan.units[].status."
           },
           "handoff_patch": {
-            "additionalProperties": true,
             "title": "Handoff Patch",
-            "type": "object"
+            "type": "object",
+            "additionalProperties": false,
+            "description": "Shallow-merged into `handoff`: only these four keys exist there, and a key outside them is refused by the schema check. Required; `{}` leaves `handoff` unchanged.",
+            "properties": {
+              "next_action": {
+                "type": "string",
+                "minLength": 1,
+                "description": "Imperative first move — zero re-derivation."
+              },
+              "open_questions": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "description": "The autonomy switch: empty = driver keeps cycling, non-empty = STOP and ask."
+              },
+              "do_not": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "description": "Negative space — near-mistakes past sessions made."
+              },
+              "notes": {
+                "type": "string",
+                "description": "Free-form prose for the next session, one string; the empty string clears it."
+              }
+            }
           },
           "history_entry": {
-            "additionalProperties": true,
             "title": "History Entry",
-            "type": "object"
+            "type": "object",
+            "required": [
+              "unit",
+              "outcome"
+            ],
+            "additionalProperties": true,
+            "description": "Pushed onto the 5-entry `history` ring; `unit` and `outcome` are required, `notes` optional, other keys pass through.",
+            "properties": {
+              "unit": {
+                "type": "string",
+                "minLength": 1
+              },
+              "outcome": {
+                "type": "string",
+                "minLength": 1
+              },
+              "notes": {
+                "type": "string"
+              }
+            }
           },
           "accounting": {
             "anyOf": [
@@ -221,7 +276,7 @@
                   "tokens": {
                     "type": "integer",
                     "minimum": 0,
-                    "description": "Tokens the unit consumed as the harness's subagent counter reports them: every class it reports (input, output, cache creation) summed, EXCLUDING cache reads. Required, because a unit whose cost is unknown cannot be compared with any other; a rounded self-estimate is allowed only if `note` says it is one."
+                    "description": "Tokens the unit consumed as the harness's subagent counter reports them: every class it reports (input, output, cache creation) summed, EXCLUDING cache reads. In a non-null accounting line it is required — a line without it is refused before anything is written; only `accounting: null`, the default, is exempt, and that logs no cost at all. A rounded self-estimate is allowed only if `note` says it is one; a unit whose cost is unknown cannot be compared with any other."
                   },
                   "cache_read_tokens": {
                     "type": "integer",
@@ -231,7 +286,7 @@
                   "duration_ms": {
                     "type": "integer",
                     "minimum": 0,
-                    "description": "Wall-clock from spawning the subagent to its final message, in whole milliseconds. Required, and the only duration key with a defined meaning: older lines carry `duration`, `duration_min` or `duration_s`, which this schema neither reads nor renames."
+                    "description": "Wall-clock from spawning the subagent to its final message, in whole milliseconds. In a non-null line it is required, and it is the only duration key with a defined meaning: older lines carry `duration`, `duration_min` or `duration_s`, which this schema neither reads nor renames."
                   },
                   "model": {
                     "type": "string",
@@ -498,7 +553,7 @@
       }
     },
     "shiftwork_plan": {
-      "description": "Shift-work plan: read-only batch view of a checkpoint — which units its `depends_on` graph permits to run in parallel. Answers `{\"result\": \"plan\", \"batches\", \"ready\", \"sequence\", \"width\", \"cursor\"}`: `ready` is `batches[0]`, the units dispatchable right now, and `width` is the largest batch length, the widest fan-out. Units with status `done` or `dropped` are satisfied — dropped from the graph, and edges pointing at them treated as already resolved; `todo`, `in_progress` and `blocked` stay in it. Every unit has priority 0, because the checkpoint schema has no priority field, so order inside a batch is `plan.units` order. Same refusal sentences as `work_plan` for a duplicate id, an unknown dependency or a cycle, and the same refusals `shiftwork_status` gives for a checkpoint it cannot read. It reports what the dependency graph permits; it does not move the cursor, which is echoed unchanged so the single-pointer contract and the batch view can be read side by side. An orchestrator stays responsible for what it actually dispatches: `depends_on` encodes logical order, not file contention. Never mutates.",
+      "description": "Shift-work plan: read-only batch view of a checkpoint — which units its `depends_on` graph permits to run in parallel. Answers `{\"result\": \"plan\", \"batches\", \"ready\", \"sequence\", \"width\", \"cursor\"}`: `ready` is `batches[0]`, the units whose dependencies are all satisfied, and `width` is the largest batch length, the widest fan-out. Only `cursor` can be clocked: shiftwork_clock_in briefs it and shiftwork_clock_out refuses every other id, so a `ready` member beyond the cursor is what the graph permits, not a unit the clock accepts yet. Units with status `done` or `dropped` are satisfied — dropped from the graph, and edges pointing at them treated as already resolved; `todo`, `in_progress` and `blocked` stay in it. Every unit has priority 0, because the checkpoint schema has no priority field, so order inside a batch is `plan.units` order. Same refusal sentences as `work_plan` for a duplicate id, an unknown dependency or a cycle, and the same refusals `shiftwork_status` gives for a checkpoint it cannot read. It reports what the dependency graph permits; it does not move the cursor, which is echoed unchanged so the single-pointer contract and the batch view can be read side by side. An orchestrator stays responsible for what it actually dispatches: `depends_on` encodes logical order, not file contention. Never mutates.",
       "inputSchema": {
         "properties": {
           "checkpoint": {

{bantamkit-0.35.2 → bantamkit-0.35.3}/tests/test_mcpserver.py

@@ -231,6 +231,28 @@ def test_missing_resource_errors_name_the_asset(tmp_path):
     run(scenario())
 
 
+def test_a_skill_paired_with_an_agent_only_tool_is_not_served(tmp_path):
+    """`file-graph` is `file_graph`'s system-prompt snippet; that tool claims only `agent`.
+
+    Served over MCP it told the client to call a tool `tools/list` does not carry (job60
+    row 46). The pairing is the one `filegraph.py` spells — the skill's name with `-` for
+    `_` — and the refusal names the surfaces the tool's asset does claim.
+    """
+
+    async def scenario():
+        async with Client(make_server(tmp_path)) as c:
+            with pytest.raises(
+                MCPError,
+                match=(
+                    r"skill asset file-graph is not served here: it pairs with tool "
+                    r"file_graph, whose asset claims surfaces \['agent'\], not mcp"
+                ),
+            ):
+                await c.read_resource("bantamkit://skills/file-graph")
+
+    run(scenario())
+
+
 def test_resource_templates_listed(tmp_path):
     async def scenario():
         async with Client(make_server(tmp_path)) as c:

{bantamkit-0.35.2 → bantamkit-0.35.3}/tests/test_tool_manifest.py

@@ -33,7 +33,7 @@ pytest.importorskip("mcp")
 from mcp import ClientSession  # noqa: E402
 from mcp.client.stdio import StdioServerParameters, stdio_client  # noqa: E402
 
-from bantamkit.assets import assets_root, load_tool  # noqa: E402
+from bantamkit.assets import assets_root, load_schema, load_tool  # noqa: E402
 
 SRC = Path(__file__).resolve().parents[1] / "src"
 
@@ -492,3 +492,50 @@ def test_the_advertised_surface_is_read_from_the_asset_pack_at_startup(tmp_path)
     assert not _surface_differences(expected, wire), "\n".join(
         _surface_differences(expected, wire)
     )
+
+
+# ---------------------------------------------------------------------------
+# J60-F2: the sub-schemas `shiftwork_clock_out` SERVES are a second copy of what the checkpoint
+# schema ENFORCES at write time. Until job60 the served `inputSchema` said `status: string`,
+# `history_entry: {additionalProperties: true}` and `handoff_patch: {additionalProperties: true}`
+# while the writer refused `finished`, `{}` and any fifth handoff key — a host read one contract
+# and hit another (job59 rows 28/29/30). The served copy exists because both servers serve
+# `asset["parameters"]` verbatim and validate arguments from a signature, never from the asset;
+# so the asset is disclosure, the checkpoint schema is enforcement, and this node is what keeps
+# the two saying the same thing. The running-surface version of the same check is
+# `tools/conformance/suites/instructions.mjs` clause (b).
+
+
+def test_clock_out_serves_the_sub_schemas_the_checkpoint_writer_enforces():
+    served = _asset("shiftwork_clock_out")["parameters"]
+    writer = load_schema("shiftwork-checkpoint")["properties"]
+    props = served["properties"]
+
+    status = writer["plan"]["properties"]["units"]["items"]["properties"]["status"]
+    assert props["status"]["enum"] == status["enum"]
+
+    history_item = writer["history"]["items"]
+    assert sorted(props["history_entry"]["required"]) == sorted(history_item["required"])
+    assert props["history_entry"]["additionalProperties"] is history_item["additionalProperties"]
+
+    handoff = writer["handoff"]
+    assert props["handoff_patch"]["additionalProperties"] is False
+    assert handoff["additionalProperties"] is False
+    assert set(props["handoff_patch"]["properties"]) == set(handoff["properties"])
+    # A patch is a shallow merge: it may omit keys the whole document requires.
+    assert "required" not in props["handoff_patch"]
+
+    # The tool requires both objects, and the description says so in the same sentence that
+    # names `handoff_patch` — the row-56 disclosure — rather than leaving `required` to be
+    # discovered by a refused call.
+    assert {"handoff_patch", "history_entry"} <= set(served["required"])
+    description = _asset("shiftwork_clock_out")["description"]
+    assert "never refuses" not in description
+    assert any(
+        "handoff_patch" in sentence and "required" in sentence.lower()
+        for sentence in description.replace(";", ".").split(". ")
+    )
+    assert any(
+        "unit_id" in sentence and "cursor" in sentence
+        for sentence in description.replace(";", ".").split(". ")
+    )

bantamkit-0.35.2/_assets/tools/shiftwork_clock_out.json

@@ -1,95 +0,0 @@
-{
-  "name": "shiftwork_clock_out",
-  "description": "Shift-work clock-out: record a finished unit — set its status, advance plan.cursor, merge handoff_patch, push history_entry onto the 5-entry ring — validating the whole mutated document against the checkpoint schema BEFORE an atomic write (a failure writes nothing and returns result=error). Every success appends one accounting line (unit, role, status, ts, briefed, plus your accounting fields, e.g. tokens/duration_ms/model) to <checkpoint>.log.jsonl, beside the brief lines clock_in writes (a brief line carries `event` and no `status`). `briefed` is written by the runtime, never taken from you — a self-reported value is overwritten by the measured one: true when a brief was issued for this unit since its LAST clock-out (not ever), so a unit re-run inline after a blocked clock-out reads false. It records; it never refuses — a unit that was never clocked in still clocks out, with briefed=false. If the checkpoint's job.roles names this unit's role, accounting.model must be one of that role's model identifiers, spelled exactly \u2014 a model that is not on the list, or none reported at all, is refused before anything is written; a role job.roles omits, and a checkpoint carrying no job.roles, are unconstrained.",
-  "surfaces": [
-    "mcp"
-  ],
-  "parameters": {
-    "properties": {
-      "checkpoint": {
-        "title": "Checkpoint",
-        "type": "string"
-      },
-      "unit_id": {
-        "title": "Unit Id",
-        "type": "string"
-      },
-      "status": {
-        "title": "Status",
-        "type": "string"
-      },
-      "handoff_patch": {
-        "additionalProperties": true,
-        "title": "Handoff Patch",
-        "type": "object"
-      },
-      "history_entry": {
-        "additionalProperties": true,
-        "title": "History Entry",
-        "type": "object"
-      },
-      "accounting": {
-        "anyOf": [
-          {
-            "type": "object",
-            "description": "Per-unit cost. Written verbatim, beside ts/unit/role/status, as one line of <checkpoint>.log.jsonl - the ledger the N-sessions experiment reads. The keys named here have fixed meanings so a reader holding only the ledger knows what each number counts, in which unit, and which model produced it; any other key passes through unchanged (a refused key is friction, not safety). Lines written before this schema existed may spell these differently; the schema governs new writes only.",
-            "properties": {
-              "tokens": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "Tokens the unit consumed as the harness's subagent counter reports them: every class it reports (input, output, cache creation) summed, EXCLUDING cache reads. Required, because a unit whose cost is unknown cannot be compared with any other; a rounded self-estimate is allowed only if `note` says it is one."
-              },
-              "cache_read_tokens": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "Tokens the unit's requests served from prompt cache, kept OUT of `tokens` because they dominate a real session's traffic and would swamp the work signal. Optional: omit it when the harness reports no such figure - a written 0 means the unit read nothing from cache."
-              },
-              "duration_ms": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "Wall-clock from spawning the subagent to its final message, in whole milliseconds. Required, and the only duration key with a defined meaning: older lines carry `duration`, `duration_min` or `duration_s`, which this schema neither reads nor renames."
-              },
-              "model": {
-                "type": "string",
-                "description": "The exact identifier of the model the subagent actually ran on (e.g. `claude-sonnet-5`) and nothing else - a caveat about how it was chosen belongs in `note`. Not required here: when the checkpoint's job.roles names this unit's role, clock_out already requires it and refuses a value off that role's list, spelled exactly; a checkpoint with no job.roles leaves it optional. This schema does not change that gate."
-              },
-              "tool_uses": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "Tool calls the subagent made, as the harness counts them. Optional; it is the denominator that makes `tokens` comparable across units of different size (per-unit cost is linear in tool calls, not in unit length)."
-              },
-              "note": {
-                "type": "string",
-                "description": "Free text for what the fields above cannot say: that `tokens` is an estimate, that this is a retry or a second scope under the same unit id, what a harness counter excludes. Anything that is not a model identifier goes here, not in `model`."
-              }
-            },
-            "required": [
-              "tokens",
-              "duration_ms"
-            ],
-            "additionalProperties": true
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "title": "Accounting"
-      }
-    },
-    "required": [
-      "checkpoint",
-      "unit_id",
-      "status",
-      "handoff_patch",
-      "history_entry"
-    ],
-    "type": "object",
-    "title": "shiftwork_clock_outArguments"
-  },
-  "output_schema": {
-    "type": "object",
-    "additionalProperties": true,
-    "title": "shiftwork_clock_outDictOutput"
-  }
-}

bantamkit-0.35.2/_assets/tools/shiftwork_plan.json

@@ -1,25 +0,0 @@
-{
-  "name": "shiftwork_plan",
-  "description": "Shift-work plan: read-only batch view of a checkpoint — which units its `depends_on` graph permits to run in parallel. Answers `{\"result\": \"plan\", \"batches\", \"ready\", \"sequence\", \"width\", \"cursor\"}`: `ready` is `batches[0]`, the units dispatchable right now, and `width` is the largest batch length, the widest fan-out. Units with status `done` or `dropped` are satisfied — dropped from the graph, and edges pointing at them treated as already resolved; `todo`, `in_progress` and `blocked` stay in it. Every unit has priority 0, because the checkpoint schema has no priority field, so order inside a batch is `plan.units` order. Same refusal sentences as `work_plan` for a duplicate id, an unknown dependency or a cycle, and the same refusals `shiftwork_status` gives for a checkpoint it cannot read. It reports what the dependency graph permits; it does not move the cursor, which is echoed unchanged so the single-pointer contract and the batch view can be read side by side. An orchestrator stays responsible for what it actually dispatches: `depends_on` encodes logical order, not file contention. Never mutates.",
-  "surfaces": [
-    "mcp"
-  ],
-  "parameters": {
-    "properties": {
-      "checkpoint": {
-        "title": "Checkpoint",
-        "type": "string"
-      }
-    },
-    "required": [
-      "checkpoint"
-    ],
-    "type": "object",
-    "title": "shiftwork_planArguments"
-  },
-  "output_schema": {
-    "type": "object",
-    "additionalProperties": true,
-    "title": "shiftwork_planDictOutput"
-  }
-}