---
digest: >
  v0.27.0 is the Ariad Builder lifecycle runtime release. It turns Builder Mode
  from context loading plus partial Ariad support into an end-to-end delivery
  environment with deterministic surfaces, method gates, story packages,
  validation acceptance, Debt Review, Coherence, Done, and conservative
  higher-autonomy cadence. The release intentionally stops short of durable debt
  ledger automation and project-local method preference overrides, which remain
  planned as the next governance layers.
---

# v0.27.0 — Ariad Builder Lifecycle Runtime

**Date:** 2026-06-14

## Highlights

- Adds the full Ariad Builder lifecycle from Pull through Done.
- Makes Ariad surfaces deterministic runtime artifacts with verbatim transport.
- Enforces hard gates for Plan approval, implementation permission, Navigator validation acceptance, Debt Review, Coherence, and Done.
- Adds complete story package materialization for implementable User/Technical Stories.
- Adds conservative cadence profiles: `stepwise`, `checkpoint`, `accelerated`, and explicit-limit `autonomous`.
- Adds a full sandbox reset fixture for repeatable dogfooding in `/Users/alissonvale/Code/sandbox-pet-store`.

## Where We Started

Builder Mode could load a journey and Ariad could exist as method data, but the delivery lifecycle was still partly conversational. The Driver could inspect, pull, or plan work, but the method did not yet govern the whole path from roadmap choice to story closure. Dogfooding exposed the danger: if a gate lived only in prose, the agent could summarize, skip, or reinterpret it.

DS4 set out to make Ariad operational as runtime behavior. The goal was not autonomy for its own sake. The goal was a Driver that can move with discipline while preserving the Navigator's decisions at the points where product judgment, validation, debt, history, and release boundaries matter.

## What Changed

Builder now supports the complete Ariad story lifecycle:

```text
Pull -> Prepare -> Expand -> Plan -> Approve -> Implement -> Validate -> Debt Review -> Coherence -> Done
```

Delivery Stories are no longer directly implementable. Pulling a Delivery Story prepares and expands it into implementable User/Technical Stories, materializes the relevant story package, and stops for the next story confirmation. Plan belongs only to implementable stories, creates `index.md`, `plan.md`, and `test-guide.md`, and blocks implementation until `approve-plan` records an explicit approval event.

Post-implementation gates are now deterministic. `validate-item` separates automated checks, E2E evidence, Navigator validation route, and explicit Navigator acceptance. `review-item` names debt findings and the Navigator debt decision before Coherence. `coherence-item` verifies process, project, and product alignment. `done-item` records history action, roadmap/story package update, and next Ariad movement.

Surfaces became method-level runtime artifacts. The Ariad surface transport contract says that marked surfaces are returned verbatim and interpretation comes only after the block. This closed the gap where a successful runtime transition could be summarized conversationally instead of shown as the deterministic evidence surface.

Cadence also became explicit. `stepwise` supports phase-by-phase dogfooding, `checkpoint` supports ordinary hard-gate flow, `accelerated` can continue through safe soft stops, and `autonomous` requires explicit Navigator limits. Higher-autonomy cadence changes stop frequency; it does not weaken Plan approval, validation acceptance, debt decisions, unsafe-operation boundaries, push/release policy, or Done/history boundaries.

## Conscious Exclusions

- No durable versioned debt ledger yet. DS5 continues with ledger and Refactor-loop work.
- No pay-now Refactor loop yet. Pay-now debt remains blocked before Coherence until that loop exists.
- No project-local `.ariad/config.yml` preference overrides yet. DS8 owns method preferences and effective policy resolution.
- No release automation or push-policy enforcement beyond the current runtime and process boundaries.
- No retroactive migration of every existing CV20 story artifact into Ariad's final story package shape.

## What We Learned

Dogfooding was not a side activity; it was the design method. The most important fixes came from places where the agent behaved plausibly but not methodologically: treating a Delivery Story as directly plannable, counting a validation route as validation acceptance, or summarizing a surface instead of transporting it. Each time, the fix was to move the rule from conversational habit into runtime state, method data, or deterministic surface protocol.

The cadence work also clarified a useful principle: autonomy is not permission to cross judgment. Ariad can move faster when evidence is present, but the Navigator's gates remain the structure that makes the speed safe.

## Next Horizon

The next natural layers are governance, not basic lifecycle. DS5 can make technical debt durable through a versioned ledger and Refactor loop. DS8 can make Navigator and project preferences first-class method configuration through canonical defaults, local overrides, and effective-policy inspection. After this release, the Builder Mode Evolution journey itself is ready to adopt Ariad prospectively and dogfood those next stories with the runtime it just produced.
