Runs and Patterns

This sprint took the lowest vocabulary layer: the enum shape, the run engine, the on-disk pin, and map argument names. It was an appropriate first cut because later agents needed stable type names and file names before building any pattern language on top. The facts show a green boundary, so the rename and compatibility reader were contained at this layer.

This sprint narrowed the work-unit migration to the ledger record and renderer vocabulary. It inherited the run and pattern names from the prior sprint, which made the task noun a local contract rather than another global sweep. Its gate went red and then passed after repair, locating the difficulty in keeping old sprint-keyed records resumable while the new task surface took over.

This sprint cleaned up the remaining places where job meant run, plus the configuration scope names that would confuse later pattern work. The brief gave the agent concrete public surfaces: MCP tools, window-title progress, override announcements, and config precedence renderers. It stayed green, suggesting the earlier vocabulary contracts were enough for this cross-surface sweep.

This was a focused display rename rather than a behavior sprint. The agent was asked to finish the stage-log view, modal, overlay, and snapshot flag names while preserving the old flag as an alias. It passed green because the scope was a single view family with a clear legacy boundary.

This sprint crossed the Rust, Python, and Rails boundary, so the brief correctly treated a green unit suite as insufficient. It renamed the corpus pipeline, web model, serving data, and analysis scripts together while keeping public redirects. The first gate went red and needed repair, showing that the hard part was the end-to-end replay contract rather than the isolated rename.

This sprint closed the terminology milestone by sweeping prose and removing stale gantry-era integration text. It was intentionally late, after behavior and compatibility had settled, so the docs could describe facts rather than pending intent. Review produced a note and the sprint was retried, which fits a prose boundary where accuracy and consistency mattered more than code mechanics.

This sprint replaced a compile-time prompt table with a walkable bundled tree. The brief made totality and reproducible build verification the agent's main contract, so later materialization could rely on an enumerable source. It stayed green, which matches a contained change to config discovery rather than to operator policy.

This sprint carried the policy-heavy part of defaults: pristine files refresh, edited files survive, legacy layouts migrate, and inert overrides are reported. The gate ran more than once even though it ended green, which points to the matrix of on-disk states as the risk. The unit was still small enough because it consumed the previous tree-walk contract.

This sprint added the deliberate reset path only after materialization knew what it owned. The task was mostly contract expression: name the verb, require confirmation or force, reset managed files, remove legacy debris, and document the model. It passed green, so the reset work did not reopen the materialization matrix.

This sprint fixed the goal-check prerequisite by changing where script checks execute and how immutability is enforced. The brief was bounded to verification semantics, not goal polarity or loop behavior, which kept it independent of the coming goal pattern. It stayed green through root tests and the heavier goal checks.

This sprint removed fragile control flow based on an agent's final text before any interpreter rules depended on those outcomes. The brief named the outcome files and review verdicts that later pattern conditions would read. It passed green, giving the language work a concrete communication substrate.

This sprint defined the pattern file format, loader, discovery tiers, and load-time validation. It was scoped to grammar and resolution rather than execution, which gave the following interpreter sprint a closed input shape. The gate ran more than once but stayed green after validation, fitting a foundation layer where edge cases are mostly malformed input.

This sprint attached pattern content and resume policy to run identity. Its brief asked for unconditional pins, declared done predicates, and dirty-worktree retention flags while preserving legacy resumes. It passed green, but later notes show that some real dispatch paths did not yet fold pattern identity as intended.

This was the central execution sprint for the flat language. The agent had to implement step dispatch, control flow, git operations, declared structure, progress descriptors, and the display write-side in one core. A replan followed the sprint, and the gate ran more than once, showing that interpreter mechanics touched enough downstream contracts to alter the remaining plan.

This sprint expressed ralph as a loaded pattern while leaving the compiled route in place for later deletion. The first attempt stopped and the sprint restarted, which matches a conversion that had to preserve abort, red-streak, sentinel, and resume behavior while changing the engine underneath. Keeping deletion out of scope made the retry bounded.

This sprint gave the interpreter the fan-out machinery that map would need: roster classification, per-task done predicates, repair, systemic rules, and checkpoint review. It triggered a replan, which fits a step kind that exposed write-side and resume assumptions to the rest of the milestone. The cut was still bounded because production map wiring waited for the next sprint.

This sprint made map the acid test for the flat interpreter by running real map behavior through the pattern route. It had to reconcile pool width, checkpoint rules, salvage, and partial behavior from the fan-out engine. The run facts show an extra gate pass and a replan, so map exposed the difference between journaling a declaration and executing the production semantics.

This sprint connected pattern files to the materialized default system from the previous milestone. Its contract was not to invent another registry, but to make built-ins refresh, reset, override, and document like prompts. It stayed green, showing that the config prerequisite held for pattern distribution.

This sprint was the first no-fallback deletion step. It routed ralph and persisted-label resumes through the pattern path, removed the compiled loop, and reconciled the suite around file-based done state. A recovery during replan and repeated review notes show that deletion was where earlier identity and behavior gaps became visible.

This sprint repeated the deletion move for map after the ralph removal clarified the pattern-only route. The brief demanded production wiring first, then removal of the old map driver and its unused fan-out engine, with constants relocated instead of stranded. A replan ran at the boundary, reflecting that the deleted route had been carrying behavior the pattern path had to prove.

This sprint accepted the milestone by resolving ralph abort and partial-merge behavior after the driver deletion. Its brief asked the agent to decide from the spec and removed behavior, then make the pattern route consistent without reopening map. It passed green, giving the milestone a recorded acceptance point despite the plan-impact notes that followed.

This sprint repaired the write-side shape needed before nested patterns could be trusted. The brief was narrow: preserve enclosing positions when loops or fan-outs journal task paths, while keeping flat built-ins unchanged. It passed green, making nesting a recorded path problem rather than a display guess.

This sprint made sub-pattern execution real instead of declarative. It had to resolve another pattern, re-point orchestration state, substitute parameters, scope counters, extend paths, and propagate termination back to the parent. The facts show a clean boundary, which suggests the previous path-composition sprint gave it the right substrate.

This sprint returned to identity because the earlier pinning work had left a dead fold on real runs. The brief asked for a reachable pattern-into-identity guard and a coherent pin story across divergent built-in shapes. It passed green, although the milestone note later records that converted recursive built-ins still exposed a gap.

This sprint extracted the shared execute, gate, repair, review, and commit loop into a parameterized sub-pattern. It gave a fresh agent one local job: express the common gated unit and expose knobs for prompt namespace, mode, relaxed baseline, and recovery defaults. The gate ran more than once and a replan followed, which is expected when a shared unit replaces duplicated driver behavior.

This sprint converted the default build itself into a pattern that can be invoked as a whole sub-pattern. The brief was careful about re-enumeration invariants, empty-campaign outcomes, and recovery caps because other patterns would soon call build recursively. An extra gate pass and a replan show that the hard boundary was preserving milestone behavior while making it data-driven.

This sprint converted the goal loop after build could be called as a sub-pattern. The agent had to keep frozen goal checks and amber-baseline semantics while moving cycle planning into an agent step and cycle execution into the build pattern. The gate ran more than once, but no recovery was recorded, so the boundary held through verification.

This sprint moved design and redesign through the same pattern system. The brief also fixed a known clean-slate defect by making that pass read test content through an agent step rather than filename equality. Extra gate work appeared, but the unit stayed contained because the shared gated task set already carried the common pipeline.

This sprint added a command that reads the pattern registry and reports what pattern a plan would use. It was intentionally placed after the registry and recursive built-ins existed, so it could inspect the real selection surface. The facts show a green boundary with no repair recorded.

This sprint completed the recursive conversion by deleting residual privileged drivers and accepting patterns as the only route. The brief also required recursive built-ins to ship through materialization and for old run modes to keep behavior through existing suites. It passed green, but the milestone note preserved the remaining identity and journal caveats for the projection work.

This sprint founded the read model by replaying a run directory from disk alone. The brief made it handle pattern journal paths, leaf roster events, pins, partial-merge capability, and legacy fallbacks in one cold entry point. The gate ran more than once, which fits a model that correlates several historical artifacts.

This sprint added the live side of the same model. The agent had to deliver pattern structure and progress events as they happened, then fold them into the same shape cold mode would later produce. It passed green, so live delivery did not require changing the frozen run journal.

This sprint moved the existing cold status command onto the projection model. Its scope was intentionally adapter-shaped: keep the neutral summary interface stable while deleting heuristics that guessed run shape from pins and rosters. It stayed green, suggesting the cold projection contract was strong enough for a user-facing migration.

This sprint moved MCP onto the projected task vocabulary. It renamed sprint listing to task listing, kept the old name as an alias, and replaced milestone-shaped log selectors with task paths. It passed green, helped by the cold model already exposing the hierarchy MCP needed.

This sprint brought the projection into the interactive display. The brief asked for arbitrary-depth sidebar rendering, user-authored pattern labels, and partial-merge enablement from the model rather than from a driver table. A replan ran at the boundary, indicating the display found assumptions that the remaining projection work had to respect.

This sprint tried to make headless output another projection consumer. The gate went red and was repaired, locating the difficulty in prose rendering rather than in the model itself. The final milestone note says the headless path still capped depth and reconstructed some tree shape from run events, so this row is an honest partial boundary.

This sprint carried the projection events over the attach wire without replacing existing frames. The brief asked for additive structure declarations, task paths, and progress descriptors, plus golden-frame updates. It stayed green, making the remote consumer story a bounded serialization task.

This acceptance sprint checked that one pattern could render through TUI, headless, cold status, and MCP, then deleted dead structure metadata. It also had to preserve frozen journal wire keys and old replay behavior. The sprint finished green, while the milestone note still names write-side limits that acceptance could not solve from the read side.