One Owner Per Run, Attach From Anywhere

This sprint was asked to carry the cross-process primitive by itself. That was the right size for a fresh agent because it did not also have to change start, resume, or list behavior; it only had to define where the lock lives, how pid liveness is read, and how stale ownership is reclaimed. The brief explicitly tied it to the existing gate lock shape, giving the worker a proven pattern for flock use and subprocess tests. Its boundary held without a red gate.

This piece took the proven primitive and wired it into the one engine-starting path. The brief kept the decision narrow: a free or stale run becomes owned, while a live owner is handled at one named branch that could later change from refusal to attach. That made release behavior and detach reconciliation the sprint's hard parts without asking the worker to build the future transport. The gate stayed green, so the ownership boundary did not have to move.

This sprint was intentionally smaller and presentation-facing. It depended on the read-only ownership query but did not need to touch the acquisition path, so a memoryless agent could focus on registry state and command output. The brief's constraint was non-disturbance: list and status had to inspect the lock without taking it or mutating it. The run facts show this remained a clean boundary.

This sprint carried the transport contract before any socket server or client existed. The brief made that isolation important because the journal format was lossy while a live attacher needed the full event stream and command set. A fresh agent could concentrate on codec completeness, timestamp preservation, handshake messages, and a canonical endpoint resolver. Nothing else in run behavior changed at this boundary.

This was the sprint where the cut came under stress. The worker had to insert a publisher around a running engine, preserve the owner's local stream, fan out events, merge subscriber commands, and handle late joiners without gaps or duplicates. The first execute attempt failed, then the retry passed through the gates and review. That locates the transport's hard boundary on owner-side serving, not on the protocol definition.

This sprint could lean on both earlier transport pieces. Its job was to make a remote run look like the same engine interface the TUI and headless modes already drive, then flip the existing live-owner branch from refusal to attach. That was a contained change because the previous milestone had already centralized the owner decision. The run facts show no gate or review stress after that routing was added.

Once front-ends could attach, this sprint separated leaving a view from stopping a run. The brief made lifecycle the whole unit: attached abort and quit should close only the client, while owner termination should still wind down the engine and release ownership. That scope was test-heavy but conceptually narrow, because the data path already existed. It passed without forcing a re-plan.

The last sprint used the completed transport as a proof of generality. Instead of changing the engine, it had to make a separate gantry mcp process attach through the same client shape and document the protocol for a future front-end. That made the unit a consumer integration and documentation pass, with the hard transport semantics already settled. Its gate and review stayed green.