Pattern Language Redesign

This sprint was asked to make the normative reference the authority before implementation agents hardened a partial model. The boundary was textual but still load-bearing: every later sprint could test its work against accepted words and closed vocabularies. It passed cleanly, so the cut gave the agent one document contract instead of the whole migration.

This sprint converted the reference contract into author-facing guidance and prompt-contract prose. The task was safe for a fresh agent because it consumed the reference rather than designing new runtime behavior. Its boundary stayed green, so the work functioned as propagation from the contract into nearby prose.

This sprint inserted the versioned reader boundary while the retired path still existed. That made the cut narrow: choose the reader from the declared compatibility surface, keep old behavior stable, and route current files into the new path. The clean boundary meant later schema work did not have to defend against accidental fallback.

This sprint made the new source shape strict before cross-reference resolution existed. The agent could hold the schema because it was a closed deserialization and rejection problem, not runtime execution. Its green boundary established that retired keys were errors rather than compatibility aliases.

This sprint moved from parsed TOML to a resolved definition that execution could consume. Its boundary was author-owned names: resolve them once, validate them once, and leave downstream code with typed ids and enums. The green result gave the runtime milestone a stable data model.

This sprint completed the contract milestone by protecting run reuse and frozen reads. It was scoped around side-effect-free refusal, so a fresh agent could prove the boundary before any production interpreter work. The record shows no repair pressure here, leaving compatibility as a clean handoff to execution.

This sprint created the entry point for resolved patterns without translating them into the retired model. Its useful boundary was the fake-world surface: later semantics could be scripted without production side effects. It passed cleanly and gave the rest of the milestone a runtime host.

This sprint made data flow executable before effects could produce real data. That cut let the agent focus on output presence, value routing, absence, and branchable outcomes. The green boundary meant later effect work could publish outputs into a known state contract.

This sprint attached the three producing step kinds to the state contract behind the world boundary. It was large but coherent because agent, gate, and command all publish through the same declared-output mechanism. Its successful boundary proved that external effects did not need a separate language.

This sprint implemented bounded repetition as directory iteration. The unit was holdable because a task body invocation has one responsibility: receive a task file, run serially, and keep its state separate from its neighbors. Its green run boundary showed that repetition did not require retained milestone or sprint vocabulary.

This sprint added sequential calls, legal recursion, and stop handlers after iteration was already defined. That ordering mattered because calls needed invocation frames and output rebinding rather than a second run model. The green boundary proved recursion and handler dispatch could remain pattern execution.

This sprint made boundary references and replay real after calls and iteration existed. Its boundary was durable reconstruction: replay completed work, rebuild state, and execute only the frontier. The clean pass gave production dispatch a resume contract instead of an in-memory assumption.

This sprint was the milestone integration point. It had to prove that the fake-world contracts could run through production selection, frozen pins, agents, gates, commands, journals, and resume. Its clean boundary left the next milestone free to port the corpus rather than debug missing runtime semantics.

This sprint established selection before replacing the files that would be selected. The boundary was the header binding contract: defaults, names, flags, required parameters, and frozen-pin resume. It stayed green and removed hidden driver knowledge before the corpus relied on it.

This sprint installed the build, milestone, and sprint family together because they call through one another. The record shows the sprint restarted, which fits a corpus integration task where draft spelling had to meet the actual reader. It still finished through the normal gate, leaving later entries a working build family to call.

This sprint installed the roster pattern and recursive acceptance-check pattern after the build family existed. It restarted and reviewed more than once, which locates the pressure in adapting the draft map and loop semantics to the implemented language. The boundary still held because these entries consumed the build family rather than modifying it.

This sprint restored operator-facing variants after the core shapes loaded. Its task was surface binding rather than new execution semantics: flags, prompt ids, and variant declarations had to use the current rules. The green boundary shows the variants did not need special driver behavior.

This sprint closed the corpus milestone by treating parse success as insufficient. It integrated the registry, removed replaced files, and ran a small real build through the installed corpus. The clean boundary gave the deletion milestone evidence that the new corpus could carry production work.

This sprint reopened the contract at the deletion boundary. Its purpose was to close any loopholes before the old model disappeared, so the work was mostly rejection boundaries and vocabulary accounting. It passed cleanly, giving deletion a stricter target.

This sprint turned the closed contract into reader behavior. The boundary was early refusal: reject old inputs and unknown fields before execution could begin. It stayed green, so stricter loading did not depend on the later runtime deletion.

This sprint had repeated starts, which fits the difficult boundary between selection, pins, and reuse. Its unit was still coherent: bind the selected declaration, freeze the closure, and refuse incompatible reuse. The review pressure landed before the runtime deletion, where mistakes were still contained.

This sprint kept production effects current after pins and strict loading were in place. It did not need to delete the old model; it needed the current model to drive real agents, gates, commands, and records. Its clean boundary set up the one-pass deletion.

This sprint is the clearest stress point in the run. The brief records that several agent attempts failed because cutting the final consumers made denied unused code a build error, while keeping consumers alive meant the deletion was incomplete. The work was completed by hand and intentionally left diagram and test repair for the next sprint, so this unit's boundary was not an ordinary green sprint boundary.

This sprint repaired the visible hole left by the deletion. Its brief explicitly warned that the gate had been made green without a real diagram port, so the first boundary was a test that rendered shipped patterns rather than accepting a stub. The sprint hit a red gate and ran troubleshooting, which locates the difficulty in proving the diagram against real current-language declarations.

This sprint came after deletion and diagram repair because only then was the current runtime stable enough to compare. Its boundary was adversarial and narrow: scramble authored names while preserving typed structure. It repeated before passing, which fits a proof that must exclude display labels without hiding behavior.

This sprint made the deletion visible outside the engine after the runtime proof existed. Its boundary was audit-like: exports, website data, prompt catalog references, fixtures, and deleted-vocabulary accounting had to agree with strict current-language behavior. It passed cleanly after the higher-risk deletion work was done.

This sprint handled completed and live run readers before public data exports. Its boundary was record discipline: status, replay, merge, and maintenance code had to consume durable records and pins, not resurrect a private source loader. The sprint reviewed at the milestone level before finishing, which matches a surface touching several readers.

This sprint created the data contract before the website consumed it. That cut let the agent focus on export shape, closed vocabularies, and stale-field rejection. It passed cleanly, giving the site one shape to read.

This sprint followed the export contract and kept the Rails work scoped to rendering that shape. The fresh agent did not need to decide language semantics; it had to remove assumptions about retired grouping and header names. The green boundary tied the website gate to regenerated data.

This sprint aligned manuals, prompts, and reference prose after engine and website consumers had moved. Its repeated start indicates broad prose reach rather than a new code contract. The boundary was consistency: prompts still needed no-commit instructions while dropping live retired-language concepts.

This sprint cleared stale tests before final acceptance. It had an execution failure and an unsuccessful troubleshoot attempt before passing, which locates the late risk in fixture conversion and smoke proof rather than in the core runtime. The scope was still right-sized because it touched tests and fixtures, not new language features.

This sprint was the proof pass rather than a feature slab. It checked the rewritten corpus, a real build run, name invariance, regenerated data, website integration, record surfaces, and deleted-vocabulary boundaries. The sprint itself was green, but the run later needed merge-resolution repair, showing that final local acceptance and integration were separate boundaries.