Cassette Build Report 061 — The Round Trip Agreed With Itself and Still Failed
Cassette encoded and decoded its own malformed protocol perfectly. A local HTTP observer found five L03 defects outside that agreement.
Scope note: This report covers a separate GPT-6 Astra review on the same Mac and installed runtime as the builder, followed by L03 repair. The reviewer was not blind or independently provisioned. The repaired evidence remains fixture and integration proof, not a claim about real client applications, real models, or physical-drive performance.
Cassette translated a request into its own wire format, translated the result back, and recovered exactly what it had sent. The test passed because both sides shared the same mistake.
I had already received an accepted L03 review after the frozen attempt passed fifteen focused tests and a separate Terra reviewer removed a required page, contradicted a regenerated target, and saw both failures caught at the proper boundaries. Astra closed the stage.
I opened the exact attempt for another review.
That decision produced the most useful protocol lesson in the live build. The new GPT-6 Astra reviewer kept the earlier control intact: three tests still passed in 476 seconds. The result was real. Then the reviewer asked a different question. Could those tests distinguish the failures that L03 itself promised to reject?
Five new challenges said no.
The smallest failure was the clearest. Cassette’s adapter produced a malformed chat event. Cassette’s reverse adapter understood that same malformed event. The round trip was exact. An independent HTTP observer saw that choices was an object keyed by "0" instead of an array. Required chat fields were missing. Response delta events lacked required positions, and one lacked the delta itself. The listener also advertised Ollama model details while returning HTTP 400 from the route that supplied them.
Nothing in the original round trip could discover these defects because the producer and consumer implemented the same nonconforming schema.
The other failures reached deeper: the compiler accepted two protected conditions with different labels but identical observable inputs; image input reached the processor but lost its pixels before the training objective; and memory admission counted one 192-byte parameter window while the objective retained nine adapter windows totaling 400 bytes before gradients and optimizer arrays. The certified conditions became ambiguous at runtime, the advertised image-training route failed when used, and the declared memory limit omitted simultaneous arrays.
Some parts survived. The reviewer independently checked rank-one windows, residual addresses, sequence and preference records, text objectives, updates, clean recovery, and compiled execution. The numerical differences remained small and bounded. This was not a story in which one failure invalidated every result. It was a story in which the evidence had to divide.
Seven L03 outcomes still passed at their stated scope. Five failed. The prior stage closure could not stand.
That is one of the harder habits in agentic work. A polished review tends to become a single object in conversation: accepted or rejected, sound or unsound. The repository needed twelve separate outcomes because the facts did not fail together. Keeping the surviving evidence prevented correction from turning into ritual destruction. Reopening the failed claims prevented the passing arithmetic from becoming cover for a broken protocol.
Astra repaired all five by making client responses use the public shapes, testing actual received HTTP fields instead of Cassette’s reverse adapter, connecting Ollama’s detail route to the broker’s current capability record, and refusing duplicate observable inputs before certification. Image pixels remain attached to the objective and its shifted label positions. Training now passes durable page references and loads the selected factors at their consumers instead of retaining every adapter window at once.
The current protocol test makes the outside observer visible. It opens a real local connection, calls Ollama’s detail route, reads the HTTP response, and checks the returned fields:
detail_reader, detail_writer = await asyncio.open_connection('127.0.0.1', server.sockets[0].getsockname()[1])
detail = canonical_bytes({'model': identity})
detail_writer.write(b'POST /api/show HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: '+str(len(detail)).encode()+b'\r\n\r\n'+detail)
await detail_writer.drain()
response_bytes = await detail_reader.read()
detail_writer.close(); await detail_writer.wait_closed()
headers, chunks = response_bytes.split(b'\r\n\r\n', 1)
assert headers.startswith(b'HTTP/1.1 200 OK'), response_bytes
The excerpt is in public tests/test_l03_execution.py. The decisive shift is modest: the test no longer asks only whether Cassette can read what Cassette wrote.
The repair had its own mistakes. A null image marker in a text embedding triggered the new image rule. An absent detail-route field accidentally matched a canonical request. Astra corrected both and retained the failed logs. Ten focused checks then passed, including image objectives, a finite-difference gradient, durable training updates, compiled image execution, and child recovery. The measured simultaneous adapter arrays fell from the 400 bytes observed by the reviewer to 112 bytes inside the admitted 192-byte window. That number concerns those arrays only. It says nothing about whole-process memory or physical-drive performance.
Then the process itself drifted. Astra ended by saying L03 remained open for another independent review. I corrected it. I had supplied the independent review. The builder had assessed every finding, repaired the failures, and run the required proof. Another review cycle was not part of the established sequence.
This was not an argument against review. I had just demanded more review than the first closeout contained. It was an argument against forgetting where authority came from. Once my supplied review had done its work, the agent could not erase that fact and return the burden to me under a general preference for caution.
The two corrections belong together. In the code, two components agreed because they shared one mistaken representation. In the workflow, the builder asked for another review because it had lost the role of the review already supplied. Both failures came from validating only records produced inside the same process.
L03 closed with the five defects repaired and the surviving seven outcomes preserved. Its protocol checks now inspect received public fields independently, and its workflow recognizes the supplied review as the review that authorized assessment and repair.
