@hanzlaa/rcode 3.6.15 → 4.0.0

package/rcode/skills/actions/2-plan/rcode-create-epics-and-stories/steps/step-03-create-stories.md

@@ -0,0 +1,255 @@
+# Step 3: Generate Epics and Stories
+
+## STEP GOAL:
+
+To generate all epics with their stories based on the approved epics_list, following the template structure exactly.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Process epics sequentially
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a product strategist and technical specifications writer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring story creation and acceptance criteria expertise
+- ✅ User brings their implementation priorities and constraints
+
+### Step-Specific Rules:
+
+- 🎯 Generate stories for each epic following the template exactly
+- 🚫 FORBIDDEN to deviate from template structure
+- 💬 Each story must have clear acceptance criteria
+- 🚪 ENSURE each story is completable by a single dev agent
+- 🔗 **CRITICAL: Stories MUST NOT depend on future stories within the same epic**
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Generate stories collaboratively with user input
+- 💾 Append epics and stories to {planning_artifacts}/epics.md following template
+- 📖 Process epics one at a time in sequence
+- 🚫 FORBIDDEN to skip any epic or rush through stories
+
+## STORY GENERATION PROCESS:
+
+### 1. Load Approved Epic Structure
+
+Load {planning_artifacts}/epics.md and review:
+
+- Approved epics_list from Step 2
+- FR coverage map
+- All requirements (FRs, NFRs, additional, **UX Design requirements if present**)
+- Template structure at the end of the document
+
+**UX Design Integration**: If UX Design Requirements (UX-DRs) were extracted in Step 1, ensure they are visible during story creation. UX-DRs must be covered by stories — either within existing epics (e.g., accessibility fixes for a feature epic) or in a dedicated "Design System / UX Polish" epic.
+
+### 2. Explain Story Creation Approach
+
+**STORY CREATION GUIDELINES:**
+
+For each epic, create stories that:
+
+- Follow the exact template structure
+- Are sized for single dev agent completion
+- Have clear user value
+- Include specific acceptance criteria
+- Reference requirements being fulfilled
+
+**🚨 DATABASE/ENTITY CREATION PRINCIPLE:**
+Create tables/entities ONLY when needed by the story:
+
+- ❌ WRONG: Epic 1 Story 1 creates all 50 database tables
+- ✅ RIGHT: Each story creates/alters ONLY the tables it needs
+
+**🔗 STORY DEPENDENCY PRINCIPLE:**
+Stories must be independently completable in sequence:
+
+- ❌ WRONG: Story 1.2 requires Story 1.3 to be completed first
+- ✅ RIGHT: Each story can be completed based only on previous stories
+- ❌ WRONG: "Wait for Story 1.4 to be implemented before this works"
+- ✅ RIGHT: "This story works independently and enables future stories"
+
+**STORY FORMAT (from template):**
+
+```
+### Story {N}.{M}: {story_title}
+
+As a {user_type},
+I want {capability},
+So that {value_benefit}.
+
+**Acceptance Criteria:**
+
+**Given** {precondition}
+**When** {action}
+**Then** {expected_outcome}
+**And** {additional_criteria}
+```
+
+**✅ GOOD STORY EXAMPLES:**
+
+_Epic 1: User Authentication_
+
+- Story 1.1: User Registration with Email
+- Story 1.2: User Login with Password
+- Story 1.3: Password Reset via Email
+
+_Epic 2: Content Creation_
+
+- Story 2.1: Create New Blog Post
+- Story 2.2: Edit Existing Blog Post
+- Story 2.3: Publish Blog Post
+
+**❌ BAD STORY EXAMPLES:**
+
+- Story: "Set up database" (no user value)
+- Story: "Create all models" (too large, no user value)
+- Story: "Build authentication system" (too large)
+- Story: "Login UI (depends on Story 1.3 API endpoint)" (future dependency!)
+- Story: "Edit post (requires Story 1.4 to be implemented first)" (wrong order!)
+
+### 3. Process Epics Sequentially
+
+For each epic in the approved epics_list:
+
+#### A. Epic Overview
+
+Display:
+
+- Epic number and title
+- Epic goal statement
+- FRs covered by this epic
+- Any NFRs or additional requirements relevant
+- Any UX Design Requirements (UX-DRs) relevant to this epic
+
+#### B. Story Breakdown
+
+Work with user to break down the epic into stories:
+
+- Identify distinct user capabilities
+- Ensure logical flow within the epic
+- Size stories appropriately
+
+#### C. Generate Each Story
+
+For each story in the epic:
+
+1. **Story Title**: Clear, action-oriented
+2. **User Story**: Complete the As a/I want/So that format
+3. **Acceptance Criteria**: Write specific, testable criteria
+
+**AC Writing Guidelines:**
+
+- Use Given/When/Then format
+- Each AC should be independently testable
+- Include edge cases and error conditions
+- Reference specific requirements when applicable
+
+#### D. Collaborative Review
+
+After writing each story:
+
+- Present the story to user
+- Ask: "Does this story capture the requirement correctly?"
+- "Is the scope appropriate for a single dev session?"
+- "Are the acceptance criteria complete and testable?"
+
+#### E. Append to Document
+
+When story is approved:
+
+- Append it to {planning_artifacts}/epics.md following template structure
+- Use correct numbering (Epic N, Story M)
+- Maintain proper markdown formatting
+
+### 4. Epic Completion
+
+After all stories for an epic are complete:
+
+- Display epic summary
+- Show count of stories created
+- Verify all FRs for the epic are covered
+- Get user confirmation to proceed to next epic
+
+### 5. Repeat for All Epics
+
+Continue the process for each epic in the approved list, processing them in order (Epic 1, Epic 2, etc.).
+
+### 6. Final Document Completion
+
+After all epics and stories are generated:
+
+- Verify the document follows template structure exactly
+- Ensure all placeholders are replaced
+- Confirm all FRs are covered
+- **Confirm all UX Design Requirements (UX-DRs) are covered by at least one story** (if UX document was an input)
+- Check formatting consistency
+
+## TEMPLATE STRUCTURE COMPLIANCE:
+
+The final {planning_artifacts}/epics.md must follow this structure exactly:
+
+1. **Overview** section with project name
+2. **Requirements Inventory** with all three subsections populated
+3. **FR Coverage Map** showing requirement to epic mapping
+4. **Epic List** with approved epic structure
+5. **Epic sections** for each epic (N = 1, 2, 3...)
+   - Epic title and goal
+   - All stories for that epic (M = 1, 2, 3...)
+     - Story title and user story
+     - Acceptance Criteria using Given/When/Then format
+
+### 7. Present FINAL MENU OPTIONS
+
+After all epics and stories are complete:
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+
+- IF A: Invoke the `rcode-advanced-elicitation` skill
+- IF P: Invoke the `rcode-party-mode` skill
+- IF C: Save content to {planning_artifacts}/epics.md, update frontmatter, then read fully and follow: ./step-04-final-validation.md
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#7-present-final-menu-options)
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond and then end with display again of the menu options
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [all epics and stories saved to document following the template structure exactly], will you then read fully and follow: `./step-04-final-validation.md` to begin final validation phase.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All epics processed in sequence
+- Stories created for each epic
+- Template structure followed exactly
+- All FRs covered by stories
+- Stories appropriately sized
+- Acceptance criteria are specific and testable
+- Document is complete and ready for development
+
+### ❌ SYSTEM FAILURE:
+
+- Deviating from template structure
+- Missing epics or stories
+- Stories too large or unclear
+- Missing acceptance criteria
+- Not following proper formatting
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

package/rcode/skills/actions/2-plan/rcode-create-epics-and-stories/steps/step-04-final-validation.md

@@ -0,0 +1,143 @@
+# Step 4: Final Validation
+
+## STEP GOAL:
+
+To validate complete coverage of all requirements and ensure stories are ready for development.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Process validation sequentially without skipping
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a product strategist and technical specifications writer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring validation expertise and quality assurance
+- ✅ User brings their implementation priorities and final review
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on validating complete requirements coverage
+- 🚫 FORBIDDEN to skip any validation checks
+- 💬 Validate FR coverage, story completeness, and dependencies
+- 🚪 ENSURE all stories are ready for development
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Validate every requirement has story coverage
+- 💾 Check story dependencies and flow
+- 📖 Verify architecture compliance
+- 🚫 FORBIDDEN to approve incomplete coverage
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Complete epic and story breakdown from previous steps
+- Focus: Final validation of requirements coverage and story readiness
+- Limits: Validation only, no new content creation
+- Dependencies: Completed story generation from Step 3
+
+## VALIDATION PROCESS:
+
+### 1. FR Coverage Validation
+
+Review the complete epic and story breakdown to ensure EVERY FR is covered:
+
+**CRITICAL CHECK:**
+
+- Go through each FR from the Requirements Inventory
+- Verify it appears in at least one story
+- Check that acceptance criteria fully address the FR
+- No FRs should be left uncovered
+
+### 2. Architecture Implementation Validation
+
+**Check for Starter Template Setup:**
+
+- Does Architecture document specify a starter template?
+- If YES: Epic 1 Story 1 must be "Set up initial project from starter template"
+- This includes cloning, installing dependencies, initial configuration
+
+**Database/Entity Creation Validation:**
+
+- Are database tables/entities created ONLY when needed by stories?
+- ❌ WRONG: Epic 1 creates all tables upfront
+- ✅ RIGHT: Tables created as part of the first story that needs them
+- Each story should create/modify ONLY what it needs
+
+### 3. Story Quality Validation
+
+**Each story must:**
+
+- Be completable by a single dev agent
+- Have clear acceptance criteria
+- Reference specific FRs it implements
+- Include necessary technical details
+- **Not have forward dependencies** (can only depend on PREVIOUS stories)
+- Be implementable without waiting for future stories
+
+### 4. Epic Structure Validation
+
+**Check that:**
+
+- Epics deliver user value, not technical milestones
+- Dependencies flow naturally
+- Foundation stories only setup what's needed
+- No big upfront technical work
+
+### 5. Dependency Validation (CRITICAL)
+
+**Epic Independence Check:**
+
+- Does each epic deliver COMPLETE functionality for its domain?
+- Can Epic 2 function without Epic 3 being implemented?
+- Can Epic 3 function standalone using Epic 1 & 2 outputs?
+- ❌ WRONG: Epic 2 requires Epic 3 features to work
+- ✅ RIGHT: Each epic is independently valuable
+
+**Within-Epic Story Dependency Check:**
+For each epic, review stories in order:
+
+- Can Story N.1 be completed without Stories N.2, N.3, etc.?
+- Can Story N.2 be completed using only Story N.1 output?
+- Can Story N.3 be completed using only Stories N.1 & N.2 outputs?
+- ❌ WRONG: "This story depends on a future story"
+- ❌ WRONG: Story references features not yet implemented
+- ✅ RIGHT: Each story builds only on previous stories
+
+### 6. Complete and Save
+
+If all validations pass:
+
+- Update any remaining placeholders in the document
+- Ensure proper formatting
+- Save the final epics.md
+
+### 7. State Sync (MANDATORY — closes #126)
+
+After saving `.planning/epics.md`, you MUST sync state so `.rcode/state.json` reflects the new epics. Without this, downstream workflows (`/rcode-status`, `/rcode-progress`, `/rcode-execute`) see a divergent picture.
+
+Per `@rcode/skills/_shared/state-sync-rule.md`:
+
+```bash
+node .rcode/bin/rcode-tools.cjs state sync --from-disk
+```
+
+Confirm output reports the epic and story count matching what `epics.md` shows. If counts diverge, surface a warning and inspect the markdown for malformation.
+
+**Present Final Menu:**
+**All validations complete!** [C] Complete Workflow
+
+HALT — wait for user input before proceeding.
+
+When C is selected, the workflow is complete and the epics.md is ready for development.
+
+Epics and Stories complete. Invoke the `rcode-help` skill.
+
+Upon Completion of task output: offer to answer any questions about the Epics and Stories.

package/rcode/skills/actions/2-plan/rcode-create-epics-and-stories/workflow.md

@@ -0,0 +1,66 @@
+# Create Epics and Stories
+
+**Goal:** Transform PRD requirements and Architecture decisions into comprehensive stories organized by user value, creating detailed, actionable stories with complete acceptance criteria for development teams.
+
+**Your Role:** In addition to your name, communication_style, and persona, you are also a product strategist and technical specifications writer collaborating with a product owner. This is a partnership, not a client-vendor relationship. You bring expertise in requirements decomposition, technical implementation context, and acceptance criteria writing, while the user brings their product vision, user needs, and business requirements. Work together as equals.
+
+## State-sync rule (NO EXCEPTIONS)
+
+After this workflow writes any `.planning/` artifact (ROADMAP.md, epics.md, sprint-*.md, SUMMARY.md, etc.) or updates phase/story status:
+
+```bash
+node .rcode/bin/rcode-tools.cjs state sync --from-disk
+```
+
+This keeps `.rcode/state.json` in sync with disk — `/rcode-progress`, `/rcode-status`, and `/rcode-execute` all read state.json. Skipping the sync silently drifts them. See `../../_shared/state-sync-rule.md`.
+
+---
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step of the overall goal is a self contained instruction file that you will adhere too 1 file as directed at a time
+- **Just-In-Time Loading**: Only 1 current step file will be loaded and followed to completion - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, read fully and follow the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps or optimize the sequence
+- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
+- 🎯 **ALWAYS** follow the exact instructions in the step file
+- ⏸️ **ALWAYS** halt at menus and wait for user input
+- 📋 **NEVER** create mental todo lists from future steps
+- 🚷 **NEVER** invent an "autonomous mode", "research mode", or any self-declared bypass. The only sanctioned bypass paths are `.rcode/config.yaml` → `mode: yolo` or `/rcode-do --auto`. See `../../_shared/no-autonomous-bypass.md` for the full rule and correct response pattern.
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from {project-root}/.rcode/config.json and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `user_name`, `communication_language`, `document_output_language`
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. First Step EXECUTION
+
+Read fully and follow: `./steps/step-01-validate-prerequisites.md` to begin the workflow.

package/rcode/skills/actions/2-plan/rcode-create-milestone/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: rcode-create-milestone
+internal: true
+description: >
+  Design the milestone roadmap (M1..Mn) for a project from an approved PRD.
+  Activates when the user says "create milestones", "plan milestones",
+  "create roadmap", "what milestones do I need", "break this project into
+  milestones", or "roadmap for this product". Do NOT use for milestone
+  lifecycle (use rcode-new-milestone / rcode-complete-milestone), for
+  decomposing one milestone into epics (use rcode-create-epics-and-stories),
+  or for single-phase planning (use rcode-plan-phase).
+triggers:
+  - "create milestones"
+  - "plan milestones"
+  - "create roadmap"
+  - "what milestones do I need"
+  - "break this project into
+  milestones"
+  - "roadmap for this product"
+user-invocable: true
+---
+@.rcode/references/karpathy-guidelines.md
+
+
+## Overview
+
+Design the milestone roadmap (M1..Mn) for a project from an approved PRD.
+
+Follow the instructions in ./workflow.md.
+
+## Output Format
+
+- Output: ROADMAP.md in `{planning_artifacts}/`
+- Structure: per milestone — Name, Window (dates), Goal (one sentence), Assumptions, Acceptance criteria, Kill criteria (binary), Phases (stub list), then a trailing Backlog / parking lot section
+- Each kill criterion must be binary (number + threshold), not adjectival
+- Every milestone has an explicit window with start + end dates
+- Every milestone must include an `Assumptions` block — decisions that, if wrong, invalidate this milestone's scope
+- Do NOT include: unquantified success language ("grow the user base"), open-ended milestones without dates, or more than 6 active milestones in one roadmap (split into v1/v2 if needed)
+- If a milestone goal cannot be expressed as a single verifiable sentence, split it into two milestones
+
+## Workflow
+
+1. Read the user request and extract key parameters.
+2. Execute the skill logic as described in the Overview.
+3. Return output in the format specified below.
+
+## Examples
+
+### Happy Path
+**Input:** "Create the milestones I need for this project"
+**Expected behavior:** Load the approved PRD. Confirm scope. For each major outcome, propose a milestone with name, window, goal, acceptance, kill criteria. Halt at menu after each milestone for user confirmation. Append to ROADMAP.md only after user selects Continue. Upsert each milestone + its phase stubs into `.rcode/state.json` (see `../../_shared/state-sync-rule.md`).
+
+### Edge Case: No PRD Exists
+**Input:** "Create milestones for social-poster-x" (no prd.md)
+**Expected behavior:** DO NOT invent milestones. Respond: "I need an approved PRD first. Run `/rcode-create-prd` or point me at an existing brief."
+
+### Edge Case: PRD Marked Draft
+**Input:** PRD exists but frontmatter shows `status: draft`
+**Expected behavior:** Warn the user that milestones based on a draft PRD will need re-work if the PRD changes. Ask whether to proceed anyway or first finalize the PRD.
+
+### Negative Example: Request to Bypass the Interview
+**Input:** "just generate the full roadmap autonomously"
+**Expected behavior:** DO NOT invent an "autonomous mode". Point the user to the two sanctioned bypass paths (`.rcode/config.yaml` → `mode: yolo` or `/rcode-do --auto`) and present the step-01 menu. See `../../_shared/no-autonomous-bypass.md`.

package/rcode/skills/actions/2-plan/rcode-create-milestone/steps/README.md

@@ -0,0 +1,30 @@
+# rcode-create-milestone — Steps
+
+This skill uses the same step-file architecture as `rcode-create-prd` and `rcode-create-epics-and-stories`.
+
+## Status
+
+- All 10 step files are **implemented and production-ready** as of #134.
+- Scaffolded in #129; completed in #134; compliance re-verified in #137.
+- If a step is missing from this directory at runtime, re-install the package — do not fall back to inline generation.
+
+## Expected Step Files (per workflow.md)
+
+| # | File | Purpose |
+|---|------|---------|
+| 1 | `step-01-init.md` | Load PRD, detect continuation, init frontmatter |
+| 2 | `step-02-outcomes.md` | Extract major outcomes from PRD; user confirms |
+| 3 | `step-03-sequencing.md` | Group outcomes into milestones; agree cut lines |
+| 4 | `step-04-windows.md` | Assign date windows; verify realism |
+| 5 | `step-05-kill-criteria.md` | Binary kill criteria per milestone |
+| 6 | `step-06-phase-stubs.md` | Stub phases under each milestone |
+| 7 | `step-07-backlog.md` | Parking-lot items |
+| 8 | `step-08-write-roadmap.md` | Append milestones to ROADMAP.md |
+| 9 | `step-09-state-sync.md` | Upsert into `.rcode/state.json` (see `_shared/state-sync-rule.md`) |
+| 10 | `step-10-complete.md` | Summary + hand-off |
+
+## Conventions
+
+- Each step halts at a menu: `[A]ccept / [P]ropose change / [C]ontinue`.
+- Each step updates `stepsCompleted` in ROADMAP.md frontmatter before loading the next.
+- External citations require `WebFetch` (see `_shared/research-citation-rule.md`).

package/rcode/skills/actions/2-plan/rcode-create-milestone/steps/step-03-sequencing.md

@@ -0,0 +1,65 @@
+# Step 3: Sequence Outcomes into Milestones
+
+**Progress: Step 3 of 10** — Next: Assign Date Windows
+
+## STEP GOAL
+
+Group the outcome list from step 2 into coherent milestones (M1, M2, M3, ...) and agree the cut lines with the user.
+
+## MANDATORY RULES
+
+- ⏸️ HALT at menu; every milestone grouping is user-confirmed.
+- 🛑 Maximum 6 active milestones per roadmap. If the user insists on more, split into v1/v2 and stop at M6 for v1.
+- 🛑 Every milestone MUST have at least 2 outcomes. A single-outcome milestone is a phase, not a milestone — suggest merging.
+
+## SEQUENCE
+
+### 1. Propose an initial grouping
+
+Based on outcome dependencies and natural clusters (same surface area, same user persona, same delivery cadence):
+
+```
+Proposed milestones:
+
+M1 — MVP (foundation)
+  O-02  User authentication
+  O-04  Basic project CRUD
+  O-07  Single-tenant data model
+
+M2 — Team collaboration
+  O-03  Team workspaces
+  O-05  Roles & permissions
+  O-09  Activity feed
+
+M3 — Monetization
+  O-01  Paid subscription tier
+  O-06  Usage metering
+  O-08  Billing portal
+
+[A] Accept this grouping
+[P] Propose changes (move, split, merge)
+[C] Continue to step 4
+```
+
+### 2. Explain your reasoning
+
+One sentence per milestone:
+- M1 is the tech foundation — everything else depends on it.
+- M2 turns a single-user tool into a team tool.
+- M3 lets rcode charge money — depends on stable M1 + M2.
+
+### 3. Handle user proposals
+
+If user picks `P`, ask what to change:
+- Move O-X from M_Y to M_Z
+- Split M_X into two milestones
+- Merge M_X + M_Y
+- Rename milestone
+
+Re-present the updated grouping until user picks A or C.
+
+### 4. Persist & advance
+
+- Append the confirmed grouping to `{outputFile}` under `## Milestones (proposed)` heading.
+- Update `stepsCompleted`.
+- Load `./step-04-windows.md`.

package/rcode/skills/actions/2-plan/rcode-create-milestone/steps/step-05-kill-criteria.md

@@ -0,0 +1,59 @@
+# Step 5: Binary Kill Criteria
+
+**Progress: Step 5 of 10** — Next: Phase Stubs
+
+## STEP GOAL
+
+For each milestone, define **binary** kill criteria — numeric thresholds that, if breached, trigger a pivot or sunset.
+
+## MANDATORY RULES
+
+- 🛑 Kill criteria must be binary (number + threshold), not adjectival.
+  - ❌ "Low user satisfaction"
+  - ✅ "NPS < 10 at 90 days post-launch"
+- 🛑 Every milestone gets at least one kill criterion.
+- 🛑 Every criterion cites a source — PRD success metric, rcode standard, or user-provided number.
+
+## SEQUENCE
+
+### 1. Extract candidates from PRD
+
+From `{inputFile}`'s Success Metrics section, flag any that naturally invert into kill criteria:
+
+| Success metric | Natural kill criterion |
+|---|---|
+| ≥ 300 paid users in 90 days | MRR < $1,200 at 90 days |
+| ≥ 40% D7 retention | D7 retention < 15% |
+| ≥ 99.5% post-success rate | Success rate < 97% |
+
+### 2. Assign to milestones
+
+Match each kill criterion to the milestone whose outcomes it measures. If a metric is meaningful only post-M3 (e.g. MRR), it applies to M3's kill criterion.
+
+### 3. Propose
+
+```
+Kill criteria (binary — two or more firing = pivot review):
+
+M1 — MVP
+  K1.1  Auth success rate < 99% at 2 weeks post-launch
+  K1.2  Launch slips > 3 weeks past 2026-06-19
+
+M2 — Team collaboration
+  K2.1  < 30% of M1 users activate workspace feature
+  K2.2  Workspace-creation error rate > 1%
+
+M3 — Monetization
+  K3.1  MRR < $1,200 at 90 days
+  K3.2  Paid → churn within 30 days > 25%
+
+[A] Accept
+[P] Propose (add/remove/adjust thresholds)
+[C] Continue
+```
+
+### 4. Persist & advance
+
+- Append criteria to each milestone in `{outputFile}`.
+- Update `stepsCompleted`.
+- Load `./step-06-phase-stubs.md`.