agentic-workflow-kit · aryeko · Jun 30, 2026 · Jun 30, 2026 · Jun 30, 2026 · Jun 30, 2026
diff --git a/MILESTONES.md b/MILESTONES.md
@@ -138,7 +138,7 @@ before any design or implementation:
 - Why now: These are the highest-leverage seams in the org. Planning produces execution
   plans, and Learning consumes run records.
 - Primary owner: `jig`
-- Participating repos: `jig`, `technical-design`, future Planning layer, future Learning
+- Participating repos: `jig`, `technical-design`, `design-to-plan`, future Learning
   loop, `.github`
 - Owned seam or artifact:
   - Execution-plan shape — high-level props (v0)
@@ -187,7 +187,7 @@ before any design or implementation:
 - Why now: Planning needs a stable design input shape as much as it needs Jig's output plan
   shape.
 - Primary owner: `technical-design`
-- Participating repos: `technical-design`, future Planning layer, `.github`
+- Participating repos: `technical-design`, `design-to-plan`, `.github`
 - Owned seam or artifact: Technical-design document format
 - Entry criteria:
   - The current `technical-design` skills, methodology profile, and evals are green.
@@ -206,7 +206,7 @@ before any design or implementation:
   - Any needed skill/template updates
 - Repo planning handoff:
   - `technical-design` derives a local docs/skills plan.
-  - Future Planning work consumes the contract, not the internal DDD profile mechanics.
+  - `design-to-plan` consumes the contract, not the internal DDD profile mechanics.
 - Risks / kill assumptions:
   - Fails if the handoff is too DDD-specific for future methodology profiles.
   - Fails if required planning facts are implied by prose instead of named fields or
@@ -225,8 +225,7 @@ before any design or implementation:
 - Why now: Planning and technical design both need durable "what and why" references before
   work decomposes into implementation plans.
 - Primary owner: `define-product`
-- Participating repos: `define-product`, `technical-design`, future Planning layer,
-  `.github`
+- Participating repos: `define-product`, `technical-design`, `design-to-plan`, `.github`
 - Owned seam or artifact: PRD / acceptance-criteria-ID format
 - Entry criteria:
   - M0 is adopted.
@@ -259,13 +258,13 @@ before any design or implementation:
 
 ### M4: Planning Layer Seed
 
-- State: current
+- State: done
 - Outcome: Enable an approved technical design to become a Jig-ready execution plan without
   re-deciding product or design scope.
 - Why now: Once Jig's plan shape is drafted and the design handoff is pinned, Planning can be designed
   against contracts rather than against another repo's internals.
-- Primary owner: future Planning layer
-- Participating repos: future Planning layer, `jig`, `technical-design`, `define-product`,
+- Primary owner: `design-to-plan`
+- Participating repos: `design-to-plan`, `jig`, `technical-design`, `define-product`,
   `.github`
 - Owned seam or artifact: None new. Planning consumes Product and Technical Design contracts
   and produces Jig execution plans.
@@ -277,40 +276,42 @@ before any design or implementation:
 - Exit criteria:
   - Planning product docs define its role, non-goals, and supported input/output contracts.
   - Planning design docs describe how designs become execution plans.
-  - The output fixture validates against Jig's execution-plan schema.
+  - The output fixture is checked against Jig's v0 execution-plan contract shape.
   - The layer refuses to invent product scope or implementation package structure not present
     in its inputs.
 - Artifacts:
   - Planning-layer product docs
   - Planning-layer design docs
   - Design-to-plan example fixture
 - Repo planning handoff:
-  - The Planning layer derives its own repo plan from M4.
+  - The `design-to-plan` layer derives its own repo plan from M4.
   - `jig` owns only plan validation feedback, not Planning's decomposition method.
   - `technical-design` owns only design input contract feedback, not execution sequencing.
 - Risks / kill assumptions:
   - Fails if Planning reopens product/design decisions instead of translating them.
   - Fails if plan output proves shape but not dependency closure.
   - Fails if producer/consumer relationships are implicit.
 - Evidence when landed:
-  - Planning-layer PR or repo creation merged with checks green.
-  - A sample plan is traceable from PRD IDs through technical-design IDs to Jig plan fields.
+  - `design-to-plan` PR #1 merged with the docs-only Planning-layer seed and `check` green.
+  - `.github` PR #12 merged with roadmap, milestone, and profile updates and `check` green.
+  - The sample plan fixture is traceable from PRD IDs through technical-design IDs to Jig v0 plan
+    properties.
 
 ### M5: Jig Local MVP Slice
 
-- State: proposed
+- State: current
 - Outcome: Enable an operator to run one minimal valid execution plan under policy and
   receive durable, inspectable run records.
 - Why now: After the contracts exist, a narrow vertical slice can prove the execution model
   without locking the whole product surface too early.
 - Primary owner: `jig`
-- Participating repos: `jig`, future Planning layer, `.github`
+- Participating repos: `jig`, `design-to-plan`, `.github`
 - Owned seam or artifact:
   - Local runner behavior behind the execution-plan and run-record contracts
   - Policy and approval behavior for the first supported local mode
 - Entry criteria:
   - M1 is done.
-  - M4 has produced or committed to a valid sample execution plan shape.
+  - M4 has produced a sample execution plan shape fixture.
   - Jig design has named the first local execution host and the minimum policy posture.
 - Exit criteria:
   - Jig can validate and preview one minimal execution plan.
@@ -326,8 +327,8 @@ before any design or implementation:
   - Tests and verification docs
 - Repo planning handoff:
   - `jig` derives implementation stories from its design docs.
-  - Planning provides only the sample plan fixture shape unless M4 is ready for broader
-    integration.
+  - `design-to-plan` provides only the sample plan fixture shape until broader integration is
+    planned.
 - Risks / kill assumptions:
   - Fails if the MVP bypasses the runner/worker authority boundary for convenience.
   - Fails if records are useful only for debugging and not for Learning consumers.
@@ -345,7 +346,7 @@ before any design or implementation:
   soon as Jig's record contract and sample records exist.
 - Primary owner: future Learning loop
 - Participating repos: future Learning loop, `jig`, `technical-design`, `define-product`,
-  future Planning layer, `.github`
+  `design-to-plan`, `.github`
 - Owned seam or artifact: None new. Learning consumes Jig observability / event records.
 - Entry criteria:
   - M1 event-record shape v0 is drafted and agreed.

diff --git a/ROADMAP.md b/ROADMAP.md
@@ -19,19 +19,19 @@ uses to derive its local plan.
 
 ```text
 PRODUCT ---------> DESIGN ----------> PLANNING --------> DELIVERY --------> LEARNING
-define / PRD       technical-design   design -> plan     jig (run)          feedback loop
-[seeded]           [built]            [planned]          [early]            [planned]
+define / PRD       technical-design   design-to-plan     jig (run)          feedback loop
+[seeded]           [built]            [seeded]           [early]            [planned]
 ```
 
-Each stage produces a **durable, structured artifact** that is the next stage's input. Three
-stages already exist as repos (`define-product`, `technical-design`, `jig`); two are planned
-(Planning, Learning). `.github` is org infrastructure, not a lifecycle stage. Of the existing
-repos, `define-product` is seeded, `technical-design` is built, and `jig` is early.
+Each stage produces a **durable, structured artifact** that is the next stage's input. Four stages
+already exist as lifecycle repos (`define-product`, `technical-design`, `design-to-plan`, `jig`);
+one is planned (Learning). `.github` is org infrastructure, not a lifecycle stage. Of the existing
+repos, `define-product` is seeded, `technical-design` is built, `design-to-plan` is seeded, and
+`jig` is early.
 
-> The org `profile/README.md` shows a **four-stage** suite spine that folds Planning under the
-> delivery handoff (`plan -> jig (run)`). This roadmap breaks Planning out as its **own layer**
-> because it is a separate planned repo with its own product/design/implementation arc. Same
-> lifecycle, different altitude — no contradiction.
+> Planning is its own layer because it has a separate repo and product/design/implementation arc. It
+> still owns no upstream seam: it consumes Product and Technical Design contracts and produces to
+> Jig's execution-plan contract shape.
 
 ---
 
@@ -42,15 +42,15 @@ coupled only by a small set of **shared contracts (seams)**. Pin down each seam'
 and every layer can be designed in parallel against the contract, not against another layer's
 internals. The currently pinned seams are owned by existing layer repos.
 
-| Seam (shared artifact)                                    | Owner              | Consumers                      | Status                                                                          |
-| --------------------------------------------------------- | ------------------ | ------------------------------ | ------------------------------------------------------------------------------- |
-| **Execution-plan schema** — Jig's one hard input boundary | `jig`              | Planning layer produces to it  | v0 shape: `jig/docs/design/execution-plan-contract-v0.md`                       |
-| **Observability / event records** — durable run output    | `jig`              | Learning loop consumes         | v0 shape: `jig/docs/design/observability-records-contract-v0.md`                |
-| **Technical-design document format**                      | `technical-design` | Planning layer consumes        | v0 handoff: `technical-design/docs/design/technical-design-handoff-contract.md` |
-| **PRD / ID'd acceptance-criteria format**                 | `define-product`   | Design + Planning cite the IDs | v0 contract: `define-product/docs/product/prd-contract.md`                      |
+| Seam (shared artifact)                                            | Owner              | Consumers                      | Status                                                                          |
+| ----------------------------------------------------------------- | ------------------ | ------------------------------ | ------------------------------------------------------------------------------- |
+| **Execution-plan contract shape** — Jig's one hard input boundary | `jig`              | Planning layer produces to it  | v0 shape: `jig/docs/design/execution-plan-contract-v0.md`                       |
+| **Observability / event records** — durable run output            | `jig`              | Learning loop consumes         | v0 shape: `jig/docs/design/observability-records-contract-v0.md`                |
+| **Technical-design document format**                              | `technical-design` | Planning layer consumes        | v0 handoff: `technical-design/docs/design/technical-design-handoff-contract.md` |
+| **PRD / ID'd acceptance-criteria format**                         | `define-product`   | Design + Planning cite the IDs | v0 contract: `define-product/docs/product/prd-contract.md`                      |
 
 **Sequencing rule of thumb:** the highest-leverage early work is authoring Jig's two seams
-(execution-plan schema, observability records), because two downstream layers wait on their
+(execution-plan contract shape, observability records), because two downstream layers wait on their
 _shape_ — not their implementation. Define the contracts first; build behind them in
 parallel. The current sequence is tracked in [`MILESTONES.md`](./MILESTONES.md).
 
@@ -89,8 +89,8 @@ parallel. The current sequence is tracked in [`MILESTONES.md`](./MILESTONES.md).
 
 - **Role:** run an approved execution plan under policy into reviewed, landed work — or a
   deliberate, inspectable stop.
-- **Owns the seams:** the **execution-plan schema** and the **observability / event records**.
-  These are the highest-leverage seams in the org; author them early and version them
+- **Owns the seams:** the **execution-plan contract shape** and the **observability / event
+  records**. These are the highest-leverage seams in the org; author them early and version them
   deliberately.
 - **Depends on:** a valid execution plan (its one hard input boundary). Upstream layers are
   optional strong defaults, not prerequisites.
@@ -123,20 +123,26 @@ parallel. The current sequence is tracked in [`MILESTONES.md`](./MILESTONES.md).
   legacy `docs/product/supporting-products/define-product.md`; v0.7 skill
   `agentic-workflow-kit:define-product`.
 
-### Planning layer — design -> plan `[planned]`
+### design-to-plan — Planning layer `[seeded]`
 
-- **Role:** decompose a technical design into a Jig-ready execution plan in the expected schema.
-- **Owns the seam:** none new — it **produces to** Jig's execution-plan schema and **consumes**
-  the Product PRD / acceptance-criteria-ID contract plus the technical-design document format.
+- **Role:** decompose a technical design into a Jig-ready execution plan in the expected contract
+  shape.
+- **Owns the seam:** none new — it **produces to** Jig's execution-plan contract shape and
+  **consumes** the Product PRD / acceptance-criteria-ID contract plus the technical-design document
+  format.
 - **Depends on (contract, not internals):** `define-product`'s PRD / acceptance-criteria-ID
-  contract, Jig's execution-plan schema, and technical-design's document format. Those owners
-  already exist; once the three seam shapes are pinned, Planning can be designed against contracts
-  rather than upstream internals.
-- **Next step (when picked up):** define product -> design -> implement, against the three seam
-  contracts above.
-- **References:** legacy `docs/product/supporting-products/design-to-plan.md`; legacy
-  `docs/implementation-authoring/delivery-pipeline/` and `docs/implementation-authoring/authoring-standard/`;
-  v0.7 skill `agentic-workflow-kit:plan-delivery-track` (and `workflow-init`).
+  contract, Jig's execution-plan contract shape, and technical-design's document format.
+- **Next step:** keep future Planning implementation work derived from its own product and design
+  docs. Do not freeze Jig's field-level schema from Planning.
+- **References:** its own
+  [`docs/product/design-to-plan.md`](https://github.com/agentic-workflow-kit/design-to-plan/blob/main/docs/product/design-to-plan.md),
+  [`docs/design/design-to-plan-contract.md`](https://github.com/agentic-workflow-kit/design-to-plan/blob/main/docs/design/design-to-plan-contract.md),
+  and
+  [`docs/design/examples/minimal-design-to-plan.md`](https://github.com/agentic-workflow-kit/design-to-plan/blob/main/docs/design/examples/minimal-design-to-plan.md);
+  legacy `docs/product/supporting-products/design-to-plan.md`; legacy
+  `docs/implementation-authoring/delivery-pipeline/` and
+  `docs/implementation-authoring/authoring-standard/`; v0.7 skill
+  `agentic-workflow-kit:plan-delivery-track` (and `workflow-init`).
 
 ### Learning loop — feedback `[planned]`
 
@@ -155,13 +161,14 @@ parallel. The current sequence is tracked in [`MILESTONES.md`](./MILESTONES.md).
 
 ## What can start in parallel now
 
-1. **`jig` design** — author `docs/design/`, leading with the two seams (execution-plan schema,
-   observability records). Highest leverage: unblocks Planning and Learning by shape.
+1. **`jig` design** — author `docs/design/`, leading with the two seams (execution-plan contract
+   shape, observability records). Highest leverage: unblocks Planning and Learning by shape.
 2. **`technical-design` hardening** — fully independent.
 3. **`define-product`** — product contract is seeded; future design and implementation can derive
    from its own product docs without blocking M4.
-4. **Planning layer** — designable once the Product PRD / acceptance-criteria-ID contract, Jig's
-   execution-plan schema, and technical-design's document format are pinned (all owners exist).
+4. **`design-to-plan`** — seeded against the Product PRD / acceptance-criteria-ID contract, Jig's
+   execution-plan contract shape, and technical-design's document format. Future implementation work
+   derives from its own product and design docs.
 5. **Learning loop** — designable in parallel once Jig's records seam is pinned.
 
 The only true ordering constraint is _contract-shape_, not _implementation_: Planning needs the

diff --git a/profile/README.md b/profile/README.md
@@ -27,14 +27,14 @@ repo can stay focused without inventing its own vocabulary.
 | [`define-product`](https://github.com/agentic-workflow-kit/define-product)     | Product layer: PRD authoring and stable, ID'd acceptance criteria upstream of design.                                                                             | Seeded; M3 contract bootstrap             |
 | [`technical-design`](https://github.com/agentic-workflow-kit/technical-design) | Design layer: frame, author, review-loop, enforce, and orchestrate technical designs.                                                                             | Built; planning handoff contract pinned   |
 | [`jig`](https://github.com/agentic-workflow-kit/jig)                           | Delivery / execution engine: runs an approved plan under policy into reviewed, landed work, or a deliberate stop. The tool you run (`@agentic-workflow-kit/jig`). | Early; product and contract design seeded |
-| Planning layer                                                                 | Decompose design into the execution plan Jig runs.                                                                                                                | Planned                                   |
+| [`design-to-plan`](https://github.com/agentic-workflow-kit/design-to-plan)     | Planning layer: decompose approved designs into the execution-plan shape Jig runs.                                                                                | Seeded; M4 contract bootstrap             |
 | Learning loop                                                                  | Capture run outcomes and feed them back into future work.                                                                                                         | Planned                                   |
 
 ## Lifecycle
 
 ```text
 PRODUCT ---------> DESIGN ----------> PLANNING --------> DELIVERY --------> LEARNING
-define / PRD       technical-design   design -> plan     jig (run)          feedback loop
+define / PRD       technical-design   design-to-plan     jig (run)          feedback loop
 ```
 
 The repos are meant to compose without becoming tightly coupled. Each should have a crisp purpose,
@@ -54,11 +54,12 @@ The shared vocabulary is intentionally small:
 
 ## Current Focus
 
-The current org focus is M4: seeding the Planning layer so approved technical designs can become
-Jig-ready execution plans without re-deciding product or design scope. M3 seeded `define-product`
-with the PRD and acceptance-criteria contract that Technical Design and Planning cite.
+The current org focus is M5: proving a narrow Jig local MVP slice now that Product, Technical
+Design, and Planning contract shapes are seeded. M4 seeded `design-to-plan` so approved technical
+designs can become Jig-ready execution plans without re-deciding product or design scope.
 
 Start with [`define-product`](https://github.com/agentic-workflow-kit/define-product) for product
 intent and acceptance-criteria IDs, [`technical-design`](https://github.com/agentic-workflow-kit/technical-design)
-for design-stage skills, or [`jig`](https://github.com/agentic-workflow-kit/jig) for the execution
+for design-stage skills, [`design-to-plan`](https://github.com/agentic-workflow-kit/design-to-plan)
+for Planning-layer docs, or [`jig`](https://github.com/agentic-workflow-kit/jig) for the execution
 engine.