Gantry's Gated Demo Edition

This was the smallest viable slice of the demo edition: add the off-by-default feature and prove that the ordinary build did not gain network or signature-verifier machinery. A fresh agent could hold it because it had no runtime policy to decide and no lifecycle hook to place. Its gate went red after review and was repaired at the dependency boundary. That made the paid-build cleanliness check the useful boundary for the rest of the run.

This sprint carried an edition-neutral binary concern: reserve one passive personalization surface without turning it into licensing behavior. It was still compact enough for a memoryless worker because the brief asked only for embedding and proof of uniqueness, not parsing or enforcement. Its gate failed once and repaired, which fits a task whose risk was in optimized binary output rather than application control flow. The sprint boundary kept that risk away from the demo feature itself.

The reader completed the identity foundation by giving later work a typed answer instead of raw executable scanning. Its brief made clear what it must not do: no server call, no unlimited fallback, and no paid-edition behavior. Unlike the two earlier identity slices, it did not need a repair pass after the gate. That made it a contained parser task at the end of the foundation milestone.

This sprint was the offline trust base for everything that followed. It had a clear input and output: read a cache file, verify the signed payload, and report whether the demo should be treated as unlimited. Because it did not need command dispatch or network calls, the worker could focus on malformed cache files, tampering, expiration, and default demo state. The run facts show no repair pass here, so the boundary held cleanly.

The transport sprint was asked to speak the server contract without owning policy. That made the unit small enough for a fresh worker: normalize responses for check, used, and unlock calls, honor the base URL, and leave the meaning of those outcomes to later code. Its gate went red and was repaired, locating the difficulty in response classification and failure preservation. The later policy code could then depend on typed outcomes instead of HTTP details.

This was the policy sprint, intentionally before lifecycle wiring. It combined identity, cached unlimited state, and HTTP outcomes into startup and completion decisions that could be tested with injected parts. The gate went red and repaired, then review forced a re-plan of the remaining milestone work. That boundary event is important: once the pure decision surface existed, the run adjusted the following integration work around the actual allowed result it produced.

This sprint moved from pure decisions into real build ownership, which made it the broadest runtime integration cut. It had to run the gate before agent work, carry the allowed result until completion, and leave management or already-complete paths alone. The record shows a red gate, a fix, a review note, and another execute pass before it settled. The brief's corrected boundary was that completion reports from the identity inside the allowed gate result, not from a separately preserved stamp.

The unlock sprint was a command-level capstone on top of the token cache and HTTP client. Its job was narrow: parse the demo-only verb, redeem a code, verify the returned token before trusting it, and write the cache only on success. The gate went red and was repaired, putting the remaining stress at the user-facing command boundary. Because the verifier already existed, the worker did not have to reopen the token format while adding dispatch.

This sprint was a producer-side handoff rather than another runtime change. It asked one worker to extend the existing local release builder additively: paid artifacts keep their path, demo artifacts are built with the demo feature, and the manifest includes only shipped assets. Its gate failed once and repaired, locating the risk in catalog and manifest exactness. The runtime gate was already present, so this unit could focus on packaging shape.

The last sprint was a composition check over work that was already built. Its brief asked for the local-server flow, refusal cases, unlock behavior, and paid-edition boundary to be asserted together. It did not need a fix pass, which suggests the earlier separation left enough stable surface for end-to-end coverage to bind. As a closing unit, it was about proving the pieces still interacted through the intended contracts.