Quiet Semantic Gates
Verified Gate Breaks
Gantry now proves a clean merge red before treating it as semantic.
1 milestones 4 tasks 9 agents
2 plan 4 execute 5 review
142k peak context
121k median execute
49m 56s total 6m 39s per task
19m 58s execute 14m 51s review
30 edits 315 commands
codex harness
This run tightened the engine around an awkward failure mode: a resumed run could inherit recorded process leftovers, a gate could keep running after its launcher died, and a clean final merge could be declared semantic from a single contaminated red. The decomposition kept those concerns separate while still treating them as one engine behavior, then closed the loop with docs and plan bookkeeping.
How this walkthrough is structured
Feature
What did the run build and ship?
The current tree still has the quiet entry sweep, child-held gate lock, verified semantic merge verdicts, focused coverage, and runtime documentation in place.
Build
How did Gantry structure the work?
The run stayed green while a single milestone carried the coupled gate story through entry cleanup, lock lifetime, semantic verification, and durable documentation.
Milestone 1
Verified Break Handling
4 tasks 11 agents 41m 43s wall time 142k peak context
The milestone left a connected engine path rather than scattered fixes. Run entry calls the process roster sweep before continuing, gate execution passes the lock into the spawned command, and final integration verifies a marker-free red before semantic handling. The docs and archived plan still describe those rules, so the behavior is visible in both code and operator reference.
This milestone was asked to carry the whole engine-side change as one slab because its pieces share the same safety boundary: a gate verdict is meaningful only when the worktree is quiet and the gate is serialized. The brief constrained the work to the existing roster, gate lock, and semantic resolver designs, which kept the fresh agents from rebuilding adjacent subsystems. Its child sprints all passed their boundaries without recorded repair or replan pressure. The shape of the run says the risky part was coupling, not a single failing child.
Quiet Entry Sweep
2 agents 9m 14s wall time 121k peak context
Run entry now invokes a quiet-worktree sweep against the orchestration directory before the worktree setup proceeds. The helper marks already-gone groups as settled, records operator-visible history only when it actually terminates leftovers, and returns cleanup failures as entry stops. Focused root tests still exercise the journal evidence for recorded leftovers.
This sprint carried the resume-entry contract by itself: before a run resets or starts fresh work, it must settle recorded process groups from the durable roster. That was a tractable unit because it did not need to change gate locking or merge classification, only the entry point and the cleanup signal. The gates stayed green, so the boundary held at the first place later sprints would depend on.
Held Gate Lock
2 agents 6m 39s wall time 78k peak context
The gate lock guard now has an explicit inheritance path for a command and a separate close path for the parent after that inheritance. The gate runner uses it around the spawned gate command, so a dead engine no longer releases the repository lock while the gate family is still alive. The platform helper for descriptor inheritance remains in the system module, and the lock comments document the intended lifetime.
This sprint isolated the abnormal lifetime of the gate lock from ordinary successful gate execution. Its brief asked only for the spawned gate and descendants to keep the repository lock alive after an engine death, while leaving normal critical sections untouched. That made the work small enough for a fresh agent even though it reached into low-level process and file-descriptor behavior. The run facts show a clean handoff through review and gate.
Verified Semantic Breaks
2 agents 13m 7s wall time 142k peak context
Final integration now routes a clean gate red through verification before semantic resolution. A green verification records that the first red did not reproduce and continues, while a second red carries the gate tail and integration span into the semantic repair or stop path. The finish tests still cover both verdicts without pinning authored stop prose.
This was the verdict sprint, sequenced after the entry sweep and child-held lock were available. The brief gave it a narrow rule: a clean integration red must be swept and run again before semantic repair is allowed. It also had to pass mechanical evidence to stop material when the red reproduced. The sprint completed without a recorded red gate, so the new classification path was proven by focused scenarios rather than by pipeline repair.
Runtime Docs Archive
2 agents 3m 33s wall time 67k peak context
The runtime documentation now states that run entry sweeps recorded leftovers, gate commands keep the per-repository lock through their own process family, and semantic merge breaks require a reproduced red. The execution lifecycle guide also describes resume cleanup before work proceeds. The original plan lives in the archive and the plan index points there instead of presenting it as pending.
The final sprint was deliberately documentary and low risk. It came after the engine behavior was present, so its job was to make the new runtime rules findable and retire the plan from the live queue. The run facts show the same clean boundary as the code sprints, with no review-driven replan. That kept the closeout from becoming another behavior change.