Cassette Build Report 044 — Sixty-Four Pages Were Not a Memory Budget
S17's scheduler passed hostile-client tests while its cache counted pages instead of bytes and its generated capability contract sat outside the product path.
Scope note: This report covers S17’s scheduler, cache, and negotiated capability boundary. It distinguishes executed hostile-schedule evidence from two specification gaps; it does not claim that the later compiler and trainer bindings were already live.
S17 had one of the strongest fixtures Cassette had built. It drove competing clients, lease epochs, queue limits, cache identity, and an alias race. Eighteen guard removals failed independently.
The two findings that mattered were not in that battery.
Opus 5 Max first called the broker’s page cache a second residency authority. That was the large claim, and it was arguable. The broker’s cache served cross-run switching. The pager already owned certified execution residency. Two scopes existed.
Then Opus read Q65. The contract’s prefetch term C was measured in bytes. The broker’s cache limit was a count of pages. The cache, prefetch, and eviction paths did not perform byte arithmetic. A sixty-four-page cache could hold sixty-four small tail pages or sixty-four four-mebibyte pages. Those are different amounts of memory.
The smaller finding was in the capability record. Nineteen Q77 fields lived as authored Python tuples in broker.py. A generated capability_profile.json existed, was hash-tracked, and was consumed by no product module. The record crossing the client boundary was the record without the generated validator.
Kimi K3 Max reproduced the S17 baseline and six high-consequence mutations. Five died. The scheduler’s serial dispatch made the sixth exclusion guard structurally redundant. Kimi also confirmed that the page-count implementation treated sixty-four tail pages and sixty-four full pages identically by construction. That was evidence of the unit mismatch, not the missing failing fixture that would make the gap red.
The distinction matters. A mutation can prove that a guard is load-bearing. It cannot remove a byte term that was never written.
The repaired broker makes the contract’s unit visible:
required = sum(authority.page_lengths[page] for page in pages)
if required > authority.cache_budget_bytes:
_reject(
"MEMORY_BUDGET_EXCEEDED",
object_id,
f"required cache pages need {required} bytes; Q47 admitted {authority.cache_budget_bytes}",
invariant="Q47/Q65: cache admission is denominated in bytes",
)
The byte-denominated cache admission in broker.py is implemented evidence for the repaired boundary. It derives page lengths from one verified root index and compares their sum with the admitted byte budget. It does not prove that the future compiler supplies the right schedule; S19 owns that binding, and S24 owns the later real-model replay.
The generated capability records received the same treatment. The schema became an admitted Q77 authority rather than a file that existed beside the handwritten tuples. The product validates the record before negotiation, and the fixture attacks the generated shape rather than merely exercising a successful client.
This was a useful comparison between the reviewers. Opus reached for the broad architectural claim, then corrected it by reading the unit named in Q65. Kimi confirmed the runtime behavior and named the missing fixture honestly. Neither review alone closed the specification. Drew’s decision was to keep the scope small: make the cache count what the contract counts, make the capability boundary generated and used, and leave absent producers named for the steps that own them.
S17 therefore closed on two different kinds of evidence. The hostile scheduler tests proved the behavior already present. The byte calculation and generated contract made the written boundary agree with that behavior. A page is an object. It is not a memory unit until its length has entered the calculation.
