Feed Cards That Match the Run's Real Shape
A run classified for milestones but built as one flat sprint no longer announces a structure it never builds.
While a Gantry run works, it streams a feed of short cards describing what it is doing. Some runs are big enough to be split into milestones; many are not. The trouble was a run in between: Gantry's classifier decides a plan looks like a milestone build, but then the planner writes just one brief, so the run quietly collapses into a plain flat sprint build instead. The early cards had already gone out announcing a milestone decomposition — and because cards stream to an append-only journal, there is no way to reach back and correct them once the run turns out flat.
This job made the wording of those early cards honest about run shape. The cards emitted before Gantry knows whether it will build one slab or several are now phrased to read truthfully under either outcome, and an internal routing label that the classifier card used to expose is no longer put in front of the reader. Explicit milestone language is kept only for the moment a run is actually committed to building two or more milestones.
Build
The whole plan was a single sprint, and the run stayed green start to finish — the difficulty was a dense set of constraints on a display-only change, not a decomposition problem, so there was nothing to cut apart.
This build is a single-sprint job, and the interesting thing about the cut is that there was almost nothing to cut. The brief carries the entire plan: reword the two planning cards the milestone driver emits before the collapse-versus-multi decision is known, and stop the classifier card from leaking its raw verdict token. That fits one fresh agent's context because the whole task is one invariant applied in a few places — change only what the feed shows, and leave the parsed decision byte-for-byte identical.
What makes the change awkward is not size but ordering. The cards go out before the number of authored briefs is known, and they cannot be rewritten afterwards, so the fix cannot be to suppress milestone language once the run collapses. It has to be wording chosen at emit time that is already true whether the run ends flat or genuinely builds several milestones. The brief states that constraint explicitly and lists precisely what must not move: routing, the collapse dispatch, the on-disk milestone layout, and the classifier's returned verdict. Holding all of those still is what kept this a wording change rather than a behavioural one.
The run confirms the difficulty lived in the constraints, not the boundaries: the classifier ran, the plan step ran, the gate that builds and checks the tree passed, and then the one sprint executed, gated, and passed review without a repair or a re-plan. There was one observable detail worth noting — the run that built this fix was itself a run the classifier sent toward milestones and the planner then collapsed to a single brief. The job's own build is an instance of the case it was written to make honest.
Feature
Before, a collapsing run's opening cards promised a milestone structure that never appeared, with no way to retract them; now the pre-decision cards are worded to hold under either outcome and the classifier no longer surfaces its routing token.
Before this job, the feed lied by omission. A run headed for a single flat build still opened with cards announcing that it was structuring milestones and authoring milestone files, and the classification card showed the raw internal verdict — the word a later collapse would frequently contradict. Since the cards are append-only, a reader who saw the promise never saw it withdrawn.
The design answer is to move the honesty to emit time. The two decomposition cards were given count-neutral wording that describes what the step is doing without committing to how many pieces come out of it, and explicit milestone framing was reserved for the roster and route card that only appear once a run of two or more milestones is real. The classifier card was reframed to describe classifying the plan rather than to print the routing label the user should not be reasoning about.
At today's HEAD the pre-decision half of that design is still standing and better anchored than it was left: the two card strings now live as named constants in the milestone driver, carrying a comment that spells out the rule they exist to enforce — read truthfully under either outcome, and never surface the on-disk milestone directory the card once named. The collapse route card still describes a single coherent build with no milestone language. The classifier-card portion has drifted: the file that held it has been rewritten wholesale since, and the classification step no longer sits where this job left it, so that specific card wording can no longer be traced to this change. The card-honesty rule survives; part of the code it was first written into has been folded into later work.