First-Class Patterns

This sprint took the safest deletion work first: retired selector spellings, stale prompt override aliases, decorative condition language, and dead compatibility helpers. It was small enough for one worker because each removal had a loud failure or a surviving current spelling to prove.

This unit moved the pieces modern drivers still needed before the old home was deleted. The boundary was contract work, not removal: preserve replan, already-built checks, and screencast metadata through the modern context and journal path.

This was the broadest early deletion: remove flat sprint resume, pinless layout inference, and pattern-journal-less projection fallback. Because the previous sprint had isolated the live continuation contract, this worker could delete old read paths without also inventing their replacement.

This sprint removed design and redesign as privileged entry points for the intermediate migration state. The brief kept generic prompt and baseline primitives out of scope for deletion, which kept the worker from erasing machinery later pattern data would need.

After the design entry point disappeared, this unit cleaned the design branches that had leaked into shared execution. Its build boundary was the shared task-set contract: strip design-only namespace and mode clauses while keeping prompt, confirm, ledger, and child-pattern primitives alive.

This unit removed map force rebuild before completion semantics were converted. The brief made the temporary refilm gap explicit, so the worker's task was deletion plus documentation rather than replacing one parallel done tracker with another.

This final cleanup sprint removed automatic wall-clock and no-output guards while preserving effort, aborts, retries, harness selection, and sandboxing. The slice was narrow because it touched budget semantics without changing how stages themselves are chosen.

This sprint cleared test and gate-contract fallout from the retired flat sprint driver. It was a preparatory slice: move any still-important review re-gating behavior onto the surviving interpreted path and stop letting deleted coverage define the heavy gate.

This worker established the typed parameter contract the selector would bind later. The brief kept the vocabulary closed and asked only for declarations, defaults, descriptions, and validation, which gave the next worker a typed model instead of raw strings.

This sprint connected pattern names, pattern files, and surviving sugar flags to one bound invocation shape. The run record shows a clean pass, which fits a boundary focused on selection and validation before frozen execution took over.

This unit made a run's source material stable at start time. Its contract was to freeze the reachable pattern closure and bound file or directory inputs, so later execution and resume would stop observing edits in the operator's live source tree.

This sprint replaced driver-shaped pin data with one generic pattern pin and folded frozen content into identity. Review triggered a replan here, which matches the risk named by the brief: resume, nested build invocation, and default build identity all had to stop taking lazy source reads.

This closeout made the compatibility boundary explicit. Instead of accepting old driver payloads as resume inputs, the worker added loud rejection plus a deliberate repin path for generic-pinned runs that intentionally refreshes frozen state.

This sprint removed dead compatibility code left from the generic-driver transition. Review immediately replanned later work, showing that the cleanup boundary was not just deletion; it changed what the rest of the milestone was allowed to assume.

This unit repeated the runtime-guard removal inside the larger migration plan so later pattern execution would not inherit retired budget controls. It stayed green, leaving effort and explicit stop handling as the budget vocabulary for the shared world.

This was where the gate found a remaining legacy terminal status and sent the sprint back. The brief had asked for flat sprint resumes and pinless projection to disappear, but the failed gate showed skipped-as-found state still flowing through domain, history, projection, and ledger handling.

This sprint eliminated design and redesign as Rust-owned modes for the larger pattern migration. Its clean run gave later workers a cleared surface: if design returned, it had to return through pattern selection and data.

This unit removed map force rebuild in the pattern-runtime context and review adjusted the remaining plan afterward. The useful boundary was keeping map completion from depending on a second journal regime before uniform ledger completion landed.

This sprint made pattern selection the central binding path and consumed the typed parameter vocabulary. It stayed green, letting later frozen-state work assume that file, directory, and string bindings were already checked before execution.

This unit persisted the frozen invocation: pattern identity, closure, and bound inputs. It was sequenced after binding so it could focus on durable state rather than parsing the selector again.

This sprint folded completion into one ledger policy across patterns. The clean boundary was done-ness, not display: a worker could unify terminal recording before later projection work decided how to show it.

This worker gave patterns a way to declare what a run can do before consumers asked driver-specific questions. It stayed inside the model boundary, deriving capability facts from pattern shape and declarations.

This sprint opened prompt ids without opening the parameter vocabulary. It let patterns name string prompt ids through the existing tiers while keeping engine-selected prompts internal where the engine still chooses them.

This unit introduced a shared production world over deterministic services. Its job was to give later built-ins one target contract, so every following migration did not need to carry its own filesystem, git, gate, and prompt plumbing.

This sprint moved ralph onto the shared world and proved it end to end. The record includes investigation but no repair, which points to integration verification rather than a redesign of the shared contract.

This unit moved the default build campaign onto the same world contract. Review replanned later work afterward, which is expected at this boundary because build is the parent pattern other workflows call into.

This sprint migrated map fan-out onto the generic world with declared behavior. It was scoped to real map execution, so the worker could validate fan-out products and checkpoint behavior against the shared interpreter.

This worker moved goal execution onto the shared world and removed the need for a bespoke executor. Its boundary was the cycle loop: freeze a check, build a composed plan, and read the partial-merge signal through common state.

Once the major built-ins had shared-world routes, this sprint removed the old world constructors. The worker had a deletion boundary that depended on prior migrations being complete enough not to strand a driver.

This unit rejected old resume pins and removed the closed driver binding registry. The record shows an investigation pass and extra review, matching a risky compatibility boundary where silent upgrade would have been worse than a loud stop.

This sprint shifted read-side projection, merge, and display checks toward declared shape and levels. It was deliberately downstream of capabilities and ledger completion, because display can only be honest after the durable model is settled.

This unit brought design and redesign back after the special mode had been removed. The slice depended on generic prompts, typed inputs, and shared world execution, so design could return as data instead of as Rust branches.

This closeout applied version and documentation updates after the migration pass. It stayed green, indicating that the compatibility story could be recorded without reopening the implementation cuts.

This sprint normalized terminal success and failure before capability or world work depended on it. The slice was intentionally semantic: every later pattern needed one way to say a unit was done or failed.

This unit added the capability model for pattern runs. It was a clean model pass, and the run record shows no review stage for the leaf, which suggests the gate was enough to prove the narrow contract.

This sprint defined the generic production world contract that later pattern steps target. It was kept separate from build campaign details so the worker could focus on the interface and deterministic services.

This unit moved the gated task set onto the shared world. A planning stage followed the green gate, which shows the sprint adjusted remaining work after proving the reusable unit boundary.

This was the milestone's difficult cut. The gate went red and the run investigated before review, placing the stress at the handoff between build campaign data and downstream consumers rather than at basic pattern parsing.

This sprint closed the presentation layer around the declared campaign envelope. It depended on the prior red-gate fix, so its own scope was to make the already-declared data visible and coherent.

This unit moved loop execution directly onto the shared world. The record shows investigation and extra review but no red gate, which fits an integration boundary around a standing loop rather than a basic model failure.

This sprint defined the product map and spec artifacts for map execution. It was an input-output slice: write and validate the spec products before any fan-out worker scheduling depended on them.

This unit made fan-out execution predictable by expanding and dispatching declared work. It stayed green, suggesting the earlier spec-product boundary gave the worker a stable input shape.

This sprint ran map logic against the generic world interface. The boundary was adapter removal: keep map semantics, but stop treating map as a special execution island.

This sprint extracted goal validation for reuse, and the execute stage had to recover before the gate passed. That places the difficulty inside the check abstraction itself, where multiple flows needed one verdict contract.

This unit tracked goal cycle state across repeated passes and transitions. A planning stage followed the gate, which made sense because cycle state affects how later goal execution should be cut.

This sprint moved goal logic onto the generic world abstraction. It consumed reusable checks and cycle state, so the worker could focus on execution flow rather than defining goal verdict semantics again.

This closeout cleaned shared world state and wrapped the pass. Its green run indicates the prior map and goal cuts had left no major open interface issue for the final worker.

This sprint defined the projection contract for turning pattern shape into downstream views. It was the right first unit because display and partial merge needed a common read model before they could stop asking driver-specific questions.

This was the milestone's most scrutinized display cut. The run investigated and replanned after review, showing that rendering from declared shape exposed assumptions still embedded in presentation code.

This sprint derived partial merge behavior from the shape model. It was sequenced after display so the worker could reuse the same task tree rather than inventing another read-side structure.

This unit rejected updates against older pinned state. The sprint stayed green, but the milestone review still found broader compatibility synthesis in goal and loop, so stale-pin rejection was necessary but not sufficient.

This sprint finished the goal and loop compatibility cleanup before opening prompts. Its boundary was resume and selector identity: sugar and generic selection had to meet at generic pins, with old payloads rejected clearly.

This worker made verdict and state channels pattern-declared data. It was a language-model slice, so it validated declarations, references, bad values, degraded defaults, and compatibility spellings before production dispatch consumed them.

This sprint wired declared prompts and channels into production execution, and it hit both execute and gate trouble before passing. The stress sat at the exact boundary where a validated language feature became persisted products, stale-value cleanup, and workflow branching.

This sprint closed the remaining selector and resume cutoff. Its job was to make every surviving shape enter through generic selection and to reject retired driver-shaped state without attempting an upgrade.

This unit rebuilt design and redesign as ordinary bundled patterns. It consumed the generic selector, prompt, channel, and shared-world contracts, so the worker could express the workflow in data and prompt prose.

This closeout bumped the release story and exercised the acid tests named by the plan. The run record shows a green finish, so the final worker was able to verify the user-facing boundary without another repair loop.