Plugin Seam Refactor

This sprint was asked to pull milestone attribution and design prompt details out of shared mutable context into a unit descriptor. That was a small enough slice for a fresh agent because it changed ownership of a few specific state values without changing the run model. The gate and review stayed green, so later work could treat the descriptor as available.

This sprint targeted the accidental reaches between loop and goal behavior, and between map and milestone roster behavior. The cut was narrow: make the shared dependency explicit before any registry existed. It completed without recorded recovery, which meant the later service surface could rely on named support rather than inherited private methods.

This was the one behavior-changing preparatory slice. It converted internal harness drift from an implicit Claude run into a named error, while leaving product defaults alone. The sprint started more than once but landed as a contained change, keeping the harness registry milestone from mixing refactor with fallback semantics.

This sprint moved goal snapshot names and map checkpoint behavior toward the driver areas that owned them. It was scoped as ownership relocation, not a registry change, so persisted layouts and resume behavior stayed fixed. The nested ledger shows it landed without a recovery note.

This sprint replaced parallel harness identity and metadata dispatch with a registry and a defaults block. It was the milestone's pressure point: the gate failed once and a fix ran before it settled. That boundary made sense because every later harness behavior needed a single resolved entry to ask.

This sprint moved blocker-investigation launch behavior behind a harness capability. Its gate recorded a note but no retry, which fits a migration of launch details where preserving each harness's invocation shape was the main risk. It kept normal non-interactive execution out of scope.

This sprint turned the registry rule into a testable extension path. The requested toy harness kept the scope concrete: prove a new entry exercises construction, config, display, shortcut, and launch behavior without adding core branches. The run facts show this slice stayed green.

This sprint documented the harness seam after the implementation pieces were already in place. It was intentionally thin: align public and contributor docs with the registry without promising dynamic loading or changing harness selection. The gate stayed green.

This sprint introduced the named service contract for shared run operations. It was a foundation slice, broad enough to cover events, agents, gates, ledgers, worktree helpers, recovery hooks, metadata, and partial-merge state while excluding unit-local driver data. The record shows no recovery at this boundary.

This sprint named the shared plan-to-sprints primitive and exposed it through the service surface. It was the central reusable unit: flat runs were the bare form, while milestone and design runs added unit context. A clean boundary here let later migrations reuse the same proof loop.

This sprint moved milestone and design flows onto the service surface and the gated unit primitive. That was the first real consumer test for unit context because it carried milestone attribution and design prompt variation. The sprint stayed green, which meant the primitive could support non-default unit state.

This sprint moved goal and loop behavior toward the service-based execution path. Its charge was bounded by the earlier goal-cycle support work, so the agent could focus on iteration support rather than general dispatch. The gate and review completed without recovery.

This sprint had to enforce the map contract and write the boundary down. It stopped on the first attempt and then went through replanning before landing, which marks the documentation and enforcement edge as the uncertain part of the milestone. The final attempt completed green.

This sprint established the first driver interfaces and shared contract shapes. A replan stage ran even though the sprint finished green, which suggests the reviewer adjusted the remaining path early. The slice was still suitable as a base because it did not yet claim to remove every dispatch branch.

This sprint moved job selection responsibility toward the registry layer. It completed green, but the later milestone note shows this kind of central selection was not enough by itself. The useful boundary was identifying the selected owner before run dispatch, while the incomplete part was still rebuilding built-in routes around it.

This was the hard run-dispatch slice. It needed a retry and multiple replans, and later review still found the central built-in route machinery too strong. The stress correctly located the main problem: forwarding through drivers is not the same as letting drivers own dispatch.

This sprint classified provisional service hooks after real driver calls exposed what they were. Its boundary was cleanup inside the service surface: keep shared operations shared, move private behavior back to owning modules, and carve narrow support traits where needed. It landed green.

This sprint moved cold read behavior behind registry entry points. It hit a red gate, ran a fix, then replanned, which fits a read-side migration where status, replay, roster, and artifact views all had to keep legacy shapes. The sprint landed, but later review still found the broader registry seam incomplete.

This sprint gave drivers a way to supply partial merge behavior for composed runs. It was sequenced after run and read surfaces because partial merge needs both durable identity and shared finalize mechanics. The run facts show it stayed green.

This sprint codified the extension rules and documented the registry model as it then stood. It finished green, but the milestone-level review still rejected the claim that the seam was complete. That made the docs and invariant useful evidence for what remained, rather than the final contract.

This sprint defined the payload used to select which driver should run. It was the new foundation after the prior milestone's central enum path proved insufficient. The slice landed cleanly, giving later work a place to hang run, read, and merge behavior.

This sprint routed selected drivers to execution through the new contract. It needed a retry, which matches the risk in replacing direct entry calls while keeping old runs resumable. The retry still completed within the same bounded slice.

This sprint completed the cold read path for driver-facing state and results. It was scoped to status, replay, roster, progress, and artifact lookup, so a fresh agent could check it against persisted run data rather than live execution. The sprint stayed green.

This sprint made the service boundary structural instead of merely conventional. It replanned once because hiding the backing context from production drivers required module movement, not a grep rule. That was the right local difficulty: Rust privacy had to enforce the contract.

This sprint moved partial merge out of core driver-specific branching. It could proceed after boundary visibility because the owning routine needed both shared mechanics and a clear extension surface. The run facts show it finished without recovery.

This sprint closed the remaining central routing leak and encoded the extension invariant. It replanned once, which aligns with the brief's warning that route-like machinery still mapped built-in labels back into dispatch. The final slice made that inventory testable.

This sprint wrote the reference after the code-side contract was complete. Its scope was documentation as a deliverable: explain identity, run dispatch, read-side behavior, services, compatibility, and partial merge without promising dynamic plugins. It landed green.