Pattern Diagrams

This sprint was asked to remove ambiguous diagram endpoints by making every edge attach to declared node ports. That is a narrow model contract a fresh worker could validate without touching layout or rendering. It gave later geometry work a stable endpoint vocabulary, and the run facts show no recorded recovery around that handoff.

This sprint owned the translation from explicit coordinates to box-drawing text. It could stay local because layout was not responsible for glyph decisions, precedence, shadows, labels, or degradation reporting. The green boundary meant the following layout work could reason in rectangles and routes instead of terminal cells.

This sprint introduced the plug-in point between diagram data and placement. Its scope was deliberately about contracts: a layout receives a generic model, returns placements and size, and is selected by registry name. Because it did not own lane math yet, it could prove lookup and validation before any real graph arrangement leaned on it.

This sprint carried the first real layout engine, but only the node-placement half. The brief asked it to arrange ordered groups into readable lanes and propagate vertical constraints before edge routing was in scope. That made the hard geometry problem small enough to test through coordinates rather than large rendered fixtures.

This sprint completed the lane engine by adding orthogonal routes after placement was already proven. Its brief put channel assignment, return paths, inline labels, and forward-flow constraints behind the same placement contract. The absence of recorded repair is useful here: the split kept routing from also having to invent the node layout boundary.

This sprint closed the foundation by assembling model, registry, layout options, theme, rendering, and plain text output into a public surface. It was sequenced after layout and painter contracts existed, so the worker mostly had to expose and check the composition. The result gave later Gantry-specific rendering a stable noninteractive entry point.

This sprint set the Gantry-specific contract without filling every visual detail. It required callers to supply typed loaded pattern data and resolved sub-pattern closure, which kept raw parsing out of the diagram adapter. That made the adapter boundary explicit before later sprints added richer semantics.

This sprint made step-level diagrams truthful about executable control flow. The worker had a clear surface: consume the static contract and project step kinds, branches, rule outcomes, transfers, halts, and styling into nodes and edges. Because the detail-level design was not yet expanded, this cut could focus on whether ordinary flow lied.

This sprint widened the static vocabulary from single steps to larger structures. It owned loops, fan-outs, rule ladders, and sub-pattern interfaces, all after the basic flow spine existed. The cut made container behavior testable as projection rules rather than as a demand for a finished interactive surface.

This sprint separated the supported static views by meaning rather than by display hiding. It consumed the flow and container vocabulary and assigned different contracts to block, step, and full diagrams. That was a contained information-design task, bounded by model content instead of terminal rendering.

This sprint made the shipped registry itself the source of static correctness checks. Its brief explicitly rejected hardcoded rosters and oversized rendered fixtures, so the worker could assert graph truth over dynamic registry entries. The green boundary meant snapshot review could remain editorial instead of becoming the pass-fail authority.

This sprint turned the static renderer into a headless user surface. It had to wire pattern discovery, detail selection, ASCII output, and snapshot generation through the already-proven projection contract. The sprint closed the milestone without taking on interactive navigation or live state.

This sprint added cell ownership without changing plain text rendering. That was the right first interaction cut because hit testing and focus need ownership, while headless output must remain stable. The worker could prove ownership over nodes, edges, precedence, and clipping before a widget existed.

This sprint wrapped rendered diagrams in generic terminal state. It consumed ownership metadata and focused on scrolling, hit testing, keyboard navigation, pointer selection, and focus highlighting. Because it remained generic, no pattern-source or monitor logic had to fit in the same worker context.

This sprint carried source metadata from typed pattern loading into diagram elements. It was intentionally placed after the generic widget contract, because source identities are Gantry-specific and optional. The boundary was that missing spans had to stay harmless and ignored rendering had to remain identical.

This sprint integrated the interactive diagram with the live terminal monitor. It consumed both the widget contract and pattern source references, then handled pattern selection, detail cycling, active-surface routing, scroll, focus, and fallback when no current pattern existed. The scope was broad but bounded by connecting existing contracts rather than inventing the renderer.

This sprint completed the navigation loop from focused diagram element to source range. Its brief also kept text selection optional, so the worker did not have to make generic diagrams depend on that integration. The boundary was a clean no-op when source data was absent.

This sprint defined runtime facts as a sidecar keyed to stable diagram elements. It was the correct first overlay cut because visual styling and monitor integration needed a deterministic data contract before they could paint anything. The brief also forced missing or unmatched run data to become empty overlay state rather than error-shaped noise.

This sprint applied overlay facts to rendered pattern diagrams while preserving the base chart vocabulary. It owned completed and current steps, taken and untaken branches, live counters, verdicts, dispositions, and fallback behavior. The cut kept painting semantics separate from runtime fact discovery.

This sprint connected overlay-capable diagrams to the live run monitor. It consumed the overlay contract and visual vocabulary, then preserved selection, detail changes, scrolling, focus, and source navigation while overlay facts changed. The worker boundary was matching runtime data to the active pattern without inventing state for unrelated views.

This sprint tested the layout plug-in boundary by adding another generic layout behind the same contract. Its point was not to replace lane diagrams, but to prove that model, canvas, paint, widget, and pattern mapping did not have to change for another placement strategy. That made the extraction claim evidence-backed instead of aspirational.

This final sprint wrote down the reusable boundary after the second layout and overlay proof existed. Its brief explicitly forbade claiming extraction had happened, so the work was a record plus checks rather than packaging. That was a small closeout sprint with a clear evidence list.