sdlc-framework 1.0.0

package/src/commands/help.md

@@ -0,0 +1,144 @@
+---
+name: sdlc:help
+description: "Show SDLC framework command reference"
+allowed-tools: [Read]
+---
+
+<objective>
+Display the complete SDLC framework command reference. Core loop, all commands, quick start, and engineering laws summary. Everything a developer needs to start using the framework.
+
+**When to use:** First time using the framework. Forgot a command. Need a refresher.
+
+**What it does:** Displays the full reference. No side effects. No state changes.
+</objective>
+
+<execution_context>
+@.sdlc/LAWS.md
+</execution_context>
+
+<context>
+No arguments. Read .sdlc/LAWS.md if it exists (for the engineering laws summary section).
+</context>
+
+<process>
+Display the following reference document:
+
+```
+╔══════════════════════════════════════════════════════════╗
+║                SDLC Framework Reference                  ║
+╚══════════════════════════════════════════════════════════╝
+
+THE CORE LOOP
+─────────────
+
+  SPEC ──→ IMPLEMENT ──→ VERIFY ──→ REVIEW ──→ CLOSE
+   │                                              │
+   └──────────────── next cycle ←─────────────────┘
+
+Every unit of work flows through this loop. No exceptions.
+The framework forces the next action at every step.
+
+
+COMMANDS — Core Loop
+────────────────────
+
+  /sdlc:spec      Define a unit of work. Produces a plan with acceptance criteria.
+  /sdlc:impl      Implement the plan. Spawns subagents to write code.
+  /sdlc:verify    Run tests and Playwright checks. Confirm acceptance criteria met.
+  /sdlc:review    Review code against engineering laws. Flag violations.
+  /sdlc:close     Archive the plan. Update STATE.md. Advance to next cycle.
+
+
+COMMANDS — Quick Entry
+──────────────────────
+
+  /sdlc:fast      THE DEFAULT. Describe work, framework routes + executes.
+                  Simple work runs inline. Complex work routes to /sdlc:spec.
+                  Bugs route to /sdlc:debug. Critical issues to /sdlc:hotfix.
+
+COMMANDS — Fix & Debug
+──────────────────────
+
+  /sdlc:fix       Fix review blockers systematically, then auto re-review.
+  /sdlc:debug     Structured debugging: reproduce → isolate → root-cause → fix → verify.
+  /sdlc:hotfix    Emergency fix. Minimal ceremony, maximum verification.
+
+
+COMMANDS — Session Management
+─────────────────────────────
+
+  /sdlc:pause     Save context for a break. Creates HANDOFF.md.
+  /sdlc:resume    Restore context. Determines ONE next action.
+  /sdlc:status    Show current loop position, progress, and forced next action.
+
+
+COMMANDS — Planning & Research
+──────────────────────────────
+
+  /sdlc:milestone Create or complete project milestones.
+  /sdlc:research  Deploy subagents for codebase or web research.
+  /sdlc:init      Initialize the framework in a project. Run once.
+  /sdlc:help      Show this reference.
+
+
+QUICK START (3 steps)
+─────────────────────
+
+  1. /sdlc:init           Set up the framework and define your first milestone.
+  2. /sdlc:spec           Define your first unit of work.
+  3. /sdlc:impl           Implement it. The framework handles the rest.
+
+  The framework tells you what to do next at every step.
+  If you are lost, run /sdlc:status.
+
+
+JUST TELL IT WHAT TO DO
+───────────────────────
+
+  /sdlc:fast is the default entry point. Describe your work:
+  Example: /sdlc:fast add a loading spinner to the submit button
+  Example: /sdlc:fast the login form crashes on empty password
+  Example: /sdlc:fast refactor the auth module to use dependency injection
+
+  Simple work runs inline. Complex work routes to /sdlc:spec automatically.
+
+
+FOR BUGS
+────────
+
+  Use /sdlc:debug — it follows a structured debugging flow.
+  Example: /sdlc:debug login form submits twice on slow connections
+
+
+ENGINEERING LAWS (summary)
+──────────────────────────
+
+  These laws are enforced during REVIEW. Violations block CLOSE.
+
+  DRY            Search before writing. Reuse existing patterns.
+  Named Types    No inline object shapes with 2+ properties.
+  Clean Arch     Presentation → Domain → Infrastructure. No leaking.
+  Explicit       No magic. Guard clauses over nesting.
+  Single Resp    One function, one job. One service, one domain.
+  Tested         Every behavior has a test. Changed behavior = updated test.
+  Edge Cases     Handle null, empty, concurrent, partial failure.
+  40-Line Max    Functions over 40 lines must be split.
+  3-Param Max    More than 3 parameters = use a named interface.
+  No Suppress    No lint/type suppression in production code.
+
+  Full laws: .sdlc/LAWS.md
+```
+
+If .sdlc/LAWS.md exists, read it and append any project-specific law customizations to the summary.
+</process>
+
+<success_criteria>
+- [ ] Core loop diagram displayed
+- [ ] All 15 commands listed with one-line descriptions
+- [ ] Commands grouped by purpose (core loop, shortcuts, session, planning)
+- [ ] Quick start guide shown (3 steps)
+- [ ] Small tasks shortcut mentioned (/sdlc:fast)
+- [ ] Bug shortcut mentioned (/sdlc:debug)
+- [ ] Engineering laws summary displayed
+- [ ] No state changes made
+</success_criteria>

package/src/commands/hotfix.md

@@ -0,0 +1,99 @@
+---
+name: sdlc:hotfix
+description: "Emergency fix with minimal ceremony, maximum verification"
+argument-hint: "<critical-issue>"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, mcp__plugin_playwright_playwright__browser_navigate, mcp__plugin_playwright_playwright__browser_snapshot, mcp__plugin_playwright_playwright__browser_click, mcp__plugin_playwright_playwright__browser_fill_form, mcp__plugin_playwright_playwright__browser_take_screenshot, mcp__plugin_playwright_playwright__browser_evaluate, mcp__plugin_playwright_playwright__browser_console_messages, mcp__plugin_playwright_playwright__browser_close, AskUserQuestion]
+---
+
+<objective>
+Emergency fix for critical issues. Minimal ceremony getting to the fix. Maximum verification after the fix. No corners cut on quality — only on planning overhead.
+
+**When to use:** Production is broken. A critical path is failing. Security vulnerability discovered. Something that cannot wait for a full SPEC cycle.
+
+**What it does:**
+1. Skip full spec — create a lightweight inline spec (3 lines).
+2. Fix the issue directly.
+3. Run FULL verification (tests + Playwright).
+4. Run FULL review (engineering laws compliance).
+5. Record as a hotfix with decimal phase numbering (2.1, 2.2, etc.).
+
+**What happens next:** /sdlc:verify to run the full verification suite.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/hotfix.md
+@.sdlc/STATE.md
+@.sdlc/LAWS.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Read .sdlc/STATE.md to get current milestone and phase.
+Read .sdlc/LAWS.md — hotfixes are NOT exempt from engineering laws.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/hotfix.md
+
+Step-by-step:
+
+1. **Pre-flight check**
+   - Verify .sdlc/ exists. If not, tell the user to run /sdlc:init first.
+   - Read .sdlc/STATE.md to get current phase number (e.g., phase 2).
+   - Assign hotfix number: current phase + decimal increment (2.1, 2.2, etc.).
+   - Update STATE.md: set loop_position to HOTFIX, record hotfix number.
+
+2. **Lightweight inline spec (3 lines)**
+   - Line 1: WHAT is broken. (From $ARGUMENTS.)
+   - Line 2: WHERE is the likely location. (Quick search with Grep.)
+   - Line 3: WHAT the fix should achieve. (Expected behavior.)
+   - Record this inline spec in STATE.md under the hotfix entry.
+
+3. **Fix the issue**
+   - Search for the affected code using Grep and Read.
+   - Apply the fix. Follow engineering laws:
+     - DRY: use existing patterns.
+     - Handle edge cases.
+     - Named types for complex objects.
+     - No lint suppression. No non-null assertions.
+     - Max 40 lines per function.
+   - Keep the change surface as small as possible. Fix the issue, nothing more.
+
+4. **Full verification**
+   - Run the entire test suite. Not just affected tests — ALL tests.
+   - For UI-related hotfixes:
+     - Use Playwright to navigate to affected pages.
+     - Verify the fix visually with screenshots.
+     - Check console for errors.
+     - Test the happy path AND edge cases.
+   - If tests fail: fix the test failures before proceeding. Do not skip.
+
+5. **Full review against engineering laws**
+   - Read .sdlc/LAWS.md.
+   - Check every changed line against every applicable law.
+   - Verify: no dead code introduced, no unused imports, no inline complex types.
+   - If any law is violated: fix it. Hotfixes are not exempt.
+
+6. **Record in STATE.md**
+   - Update .sdlc/STATE.md:
+     - Record hotfix number (decimal: 2.1, 2.2, etc.).
+     - Record: issue description, files changed, tests run, verification status.
+     - Set loop_position back to current phase position.
+   - Create .sdlc/hotfixes/HOTFIX-{number}-{timestamp}.md with full details.
+
+7. **Force next action**
+   - Output: "NEXT ACTION REQUIRED: /sdlc:verify — run full verification suite to confirm no regressions."
+</process>
+
+<success_criteria>
+- [ ] Inline spec created (3 lines: what, where, expected behavior)
+- [ ] Fix applied following engineering laws — no exceptions for hotfixes
+- [ ] Full test suite runs and passes
+- [ ] Playwright verification completed for UI-related hotfixes
+- [ ] Engineering laws review passed on all changed code
+- [ ] Hotfix recorded in STATE.md with decimal phase numbering
+- [ ] Hotfix detail file created in .sdlc/hotfixes/
+- [ ] Change surface is minimal — only the fix, nothing extra
+- [ ] Output ends with NEXT ACTION REQUIRED: /sdlc:verify
+</success_criteria>

package/src/commands/impl.md

@@ -0,0 +1,142 @@
+---
+name: sdlc:impl
+description: Execute spec via parallel sub-agent development
+argument-hint: "[spec-path]"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, Agent, TaskCreate, TaskUpdate, TaskGet, TaskList]
+---
+
+<objective>
+Execute an approved specification by spawning parallel sub-agents for independent tasks. Track progress through the task dependency graph until all tasks are complete.
+
+**When to use:** After /sdlc:spec produces an approved SPEC.md. This is the BUILD phase of the SDLC loop.
+
+**What it does:**
+1. Read the approved SPEC.md and extract the task dependency graph.
+2. Create tracked tasks for each item in the spec.
+3. Spawn sub-agents for wave 1 (independent tasks) in parallel.
+4. When wave 1 completes, spawn wave 2 (tasks that depended on wave 1), and so on.
+5. Each sub-agent receives: its specific task, relevant file context, engineering laws, and boundaries.
+6. Track task completion and update progress.
+
+**What happens next:** Framework directs you to /sdlc:verify to validate the implementation against acceptance criteria.
+
+**Critical rule:** Sub-agents do the work. This command orchestrates. Each sub-agent operates within strict boundaries defined by the spec.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/execute-impl.md
+@.sdlc/STATE.md
+@.sdlc/LAWS.md
+The SPEC.md path is read from STATE.md or provided via $ARGUMENTS.
+</execution_context>
+
+<context>
+$ARGUMENTS — optional path to SPEC.md. If not provided, read from .sdlc/STATE.md spec_path field.
+
+Read these files:
+- .sdlc/STATE.md — current plan and spec path.
+- The SPEC.md file — tasks, dependency graph, execution waves, boundaries, acceptance criteria.
+- .sdlc/LAWS.md — engineering constraints every sub-agent must follow.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/execute-impl.md
+
+Step-by-step:
+
+1. **Load spec and validate state**
+   - Read .sdlc/STATE.md. Confirm loop_position is SPEC_COMPLETE. If not, warn: "Spec not complete. Run /sdlc:spec first."
+   - Resolve spec path from $ARGUMENTS or STATE.md spec_path field.
+   - Read the SPEC.md file. Extract:
+     - Task list with IDs, descriptions, file targets, dependencies, complexity.
+     - Execution waves (groups of parallelizable tasks).
+     - Boundaries (in-scope, out-of-scope).
+     - Acceptance criteria (for sub-agent awareness).
+   - Read .sdlc/LAWS.md for engineering constraints.
+
+2. **Create tracked tasks**
+   - For each task in the spec, call TaskCreate with:
+     - Title: task description.
+     - Status: pending.
+     - Metadata: wave number, dependencies, file targets, complexity.
+   - Call TaskCreate for ALL tasks in a single batch.
+
+3. **Build sub-agent instruction template**
+   Each sub-agent receives these instructions:
+   ```
+   TASK: <task description>
+   FILES TO MODIFY: <list of files>
+   FILES TO READ FIRST: <list of context files>
+   ACCEPTANCE CRITERIA: <relevant ACs for this task>
+   BOUNDARIES: Do NOT modify files outside your task scope.
+   ENGINEERING LAWS: <laws from LAWS.md>
+
+   RULES:
+   - Read every file before editing it.
+   - Follow existing code patterns and conventions.
+   - Write tests for new logic.
+   - Handle edge cases explicitly.
+   - Do not guess — if something is unclear, err on the side of simplicity.
+   - Report what you created, modified, and tested.
+   ```
+
+4. **Execute wave 1 (independent tasks)**
+   - Identify all tasks with no dependencies (wave 1).
+   - Spawn one Agent per task with `run_in_background: true`.
+   - Spawn ALL wave 1 agents in a single message.
+   - Update each task status to "in_progress" via TaskUpdate.
+   - Wait for all wave 1 agents to complete.
+
+5. **Process wave results**
+   - When a wave completes, review each agent's output:
+     - Verify the agent completed its task.
+     - Check for reported errors or blockers.
+     - Update task status to "complete" or "failed" via TaskUpdate.
+   - If any task failed:
+     - Log the failure reason.
+     - Determine if dependent tasks can still proceed.
+     - If the failure blocks downstream tasks, report to the user and ask for guidance.
+
+6. **Execute subsequent waves**
+   - For each subsequent wave (wave 2, 3, ...):
+     - Confirm all dependency tasks are complete.
+     - Spawn agents for the wave's tasks in parallel.
+     - Process results as in step 5.
+   - Repeat until all waves are complete.
+
+7. **Integration check**
+   - After all waves complete, run a quick integration check:
+     - Run `npm run build` or equivalent to verify the project compiles.
+     - Run existing tests to verify no regressions.
+   - If build fails or tests break, identify the issue and fix it.
+
+8. **Record implementation results**
+   - Create .sdlc/impl/IMPL-<plan-id>.md with:
+     - Task completion summary (passed/failed/skipped per task).
+     - Files created and modified (full list).
+     - Build status.
+     - Test results.
+     - Issues encountered and resolutions.
+
+9. **Update STATE.md**
+   - Set `loop_position: IMPL_COMPLETE`
+   - Set `impl_path: .sdlc/impl/IMPL-<plan-id>.md`
+
+10. **Output confirmation**
+    - Print implementation summary: tasks completed, files modified, build status.
+    - End with NEXT ACTION REQUIRED.
+</process>
+
+<success_criteria>
+- [ ] SPEC.md read and task dependency graph extracted
+- [ ] All tasks created via TaskCreate with correct metadata
+- [ ] Wave 1 (independent) tasks spawned in parallel via Agent with run_in_background: true
+- [ ] Each sub-agent received: task description, file targets, engineering laws, boundaries
+- [ ] Subsequent waves executed in order, respecting dependencies
+- [ ] Failed tasks logged with reasons and user notified
+- [ ] Integration check passed (build compiles, existing tests pass)
+- [ ] IMPL-<plan-id>.md created with completion summary
+- [ ] STATE.md updated with loop_position: IMPL_COMPLETE
+- [ ] No files modified outside spec boundaries
+- [ ] Output ends with NEXT ACTION REQUIRED: /sdlc:verify
+</success_criteria>

package/src/commands/init.md

@@ -0,0 +1,93 @@
+---
+name: sdlc:init
+description: Initialize SDLC framework in a project
+argument-hint: "[project-name]"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, AskUserQuestion]
+---
+
+<objective>
+Initialize the SDLC framework for a project. Create the .sdlc/ directory with four core files: PROJECT.md, STATE.md, ROADMAP.md, and LAWS.md.
+
+**When to use:** First time setting up SDLC in a project. Run this once per repository.
+
+**What it does:**
+1. Scan the current directory to understand project structure (language, framework, existing config).
+2. Ask clarification questions about project goals, team conventions, and quality thresholds.
+3. Create .sdlc/ directory with populated templates.
+4. Set the loop position to SPEC (the first phase of the development cycle).
+
+**What happens next:** Framework directs you to /sdlc:spec to define your first unit of work.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/init-project.md
+@~/.claude/sdlc-framework/templates/PROJECT.md
+@~/.claude/sdlc-framework/templates/STATE.md
+@~/.claude/sdlc-framework/templates/ROADMAP.md
+@~/.claude/sdlc-framework/templates/LAWS.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Current directory contents (run ls to inspect).
+Check if .sdlc/ already exists — if it does, warn the user and ask whether to reinitialize or abort.
+Read any existing package.json, Cargo.toml, pyproject.toml, go.mod, or similar to detect project type.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/init-project.md
+
+Step-by-step:
+
+1. **Pre-flight check**
+   - Run `ls -la` to inspect the current directory.
+   - Check if `.sdlc/` already exists. If yes, ask the user: "SDLC is already initialized. Reinitialize (overwrites existing state) or abort?"
+   - Detect project type from manifest files (package.json, Cargo.toml, etc.).
+
+2. **Gather project context** (use AskUserQuestion)
+   - Ask for project name if not provided via $ARGUMENTS.
+   - Ask: "Describe the project in 1-2 sentences. What problem does it solve?"
+   - Ask: "What are your top 3 quality priorities? (e.g., test coverage, performance, security, accessibility)"
+   - Ask: "What is the first milestone you want to reach?"
+
+3. **Create .sdlc/ directory structure**
+   - `mkdir -p .sdlc`
+
+4. **Populate PROJECT.md**
+   - Write project name, description, detected tech stack, quality priorities.
+   - Include directory structure overview.
+
+5. **Populate STATE.md**
+   - Set `loop_position: SPEC`
+   - Set `current_phase: null` (no phase until roadmap is defined)
+   - Set `current_plan: null`
+   - Set `initialized_at: <timestamp>`
+
+6. **Populate ROADMAP.md**
+   - Create at least one milestone from the user's answer.
+   - Break the milestone into at least one phase.
+   - Each phase has a name, objective, and empty plans list.
+
+7. **Populate LAWS.md**
+   - Copy engineering laws template.
+   - Configure severity levels based on project type:
+     - Library projects: stricter on API design, naming, documentation.
+     - Application projects: stricter on error handling, security, input validation.
+     - CLI projects: stricter on argument validation, help text, exit codes.
+
+8. **Output confirmation**
+   - Print summary of created files.
+   - Print the first milestone and phase.
+   - End with NEXT ACTION REQUIRED.
+</process>
+
+<success_criteria>
+- [ ] .sdlc/ directory created with PROJECT.md, STATE.md, ROADMAP.md, LAWS.md
+- [ ] PROJECT.md populated with project name, description, tech stack, quality priorities
+- [ ] STATE.md initialized with loop_position set to SPEC
+- [ ] ROADMAP.md has at least one milestone with at least one phase
+- [ ] LAWS.md contains engineering laws with severity levels configured for the project type
+- [ ] No guessing — all project context gathered via clarification questions
+- [ ] Output ends with NEXT ACTION REQUIRED: /sdlc:spec
+</success_criteria>

package/src/commands/milestone.md

@@ -0,0 +1,136 @@
+---
+name: sdlc:milestone
+description: "Create or complete project milestones"
+argument-hint: "[create <name> | complete]"
+allowed-tools: [Read, Write, Bash, Glob, Grep, AskUserQuestion]
+---
+
+<objective>
+Manage project milestones. Create new milestones with scope definition. Complete milestones with verification, archival, and tagging.
+
+**When to use:**
+- Starting a new body of work: `/sdlc:milestone create <name>`
+- Finishing a milestone: `/sdlc:milestone complete`
+- Checking milestone status: `/sdlc:milestone` (no argument)
+
+**What it does:**
+- **No argument:** Show current milestone status, phases, and progress.
+- **create:** Ask clarification questions about scope, then create milestone with phases.
+- **complete:** Verify all phases done, archive, update ROADMAP.md, create git tag.
+
+**What happens next:**
+- After create: /sdlc:spec to define the first unit of work.
+- After complete: Completion summary displayed.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/milestone.md
+@.sdlc/STATE.md
+@.sdlc/ROADMAP.md
+</execution_context>
+
+<context>
+$ARGUMENTS — one of: empty, "create <name>", or "complete".
+
+Read .sdlc/STATE.md for current milestone.
+Read .sdlc/ROADMAP.md for milestone definitions and progress.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/milestone.md
+
+Step-by-step:
+
+### If no argument: SHOW STATUS
+
+1. Read .sdlc/ROADMAP.md.
+2. Read .sdlc/STATE.md for current milestone.
+3. Display:
+   ```
+   Current Milestone: {name}
+   Status: {in-progress | blocked}
+
+   Phases:
+   [x] Phase 1: {name} — completed
+   [x] Phase 2: {name} — completed
+   [ ] Phase 3: {name} — in progress (3/5 plans done)
+   [ ] Phase 4: {name} — not started
+
+   Progress: [████████████░░░░░░░░] 60%
+   ```
+4. Show the next required action based on current loop position.
+
+### If "create <name>": CREATE MILESTONE
+
+1. Parse the milestone name from $ARGUMENTS.
+2. Ask clarification questions via AskUserQuestion:
+   - "What is the objective of this milestone? (1-2 sentences)"
+   - "What are the key deliverables? (list 3-5)"
+   - "What does 'done' look like? (acceptance criteria)"
+   - "Estimated number of phases? (suggest based on deliverables)"
+3. Create the milestone in .sdlc/ROADMAP.md:
+   ```
+   ## Milestone: {name}
+   Objective: {from answer}
+   Status: in-progress
+
+   ### Phases
+   - Phase 1: {derived from deliverables}
+   - Phase 2: {derived from deliverables}
+   ...
+
+   ### Acceptance Criteria
+   - {from answer}
+   ```
+4. Update .sdlc/STATE.md:
+   - Set current_milestone to the new milestone name.
+   - Set current_phase to Phase 1.
+   - Set loop_position to SPEC.
+5. Output: "NEXT ACTION REQUIRED: /sdlc:spec — define the first unit of work for Phase 1."
+
+### If "complete": COMPLETE MILESTONE
+
+1. Read .sdlc/STATE.md and .sdlc/ROADMAP.md.
+2. Verify ALL phases in the current milestone are marked complete.
+   - If any phase is incomplete, output: "Cannot complete milestone. Phase {N}: {name} is not done. Complete it first." Then stop.
+3. Archive the milestone:
+   - Create .sdlc/archive/MILESTONE-{name}-{timestamp}.md with full milestone data.
+   - Mark the milestone as `completed` in ROADMAP.md with completion timestamp.
+4. Update ROADMAP.md:
+   - Set milestone status to `completed`.
+   - If there is a next milestone, note it.
+5. Create a git tag:
+   - Run `git tag -a milestone/{name} -m "Milestone completed: {name}"`.
+   - If git is not initialized or tag fails, warn but continue.
+6. Update STATE.md:
+   - Clear current_milestone if no next milestone.
+   - Or set current_milestone to the next milestone and loop_position to SPEC.
+7. Output completion summary:
+   ```
+   Milestone Complete: {name}
+
+   Phases completed: {N}
+   Plans executed: {N}
+   Hotfixes applied: {N}
+   Git tag: milestone/{name}
+
+   {If next milestone exists}
+   Next milestone: {name}
+   Run /sdlc:spec to begin.
+
+   {If no next milestone}
+   All milestones complete. Define new milestones with /sdlc:milestone create <name>.
+   ```
+</process>
+
+<success_criteria>
+- [ ] No argument: milestone status displayed with phase progress
+- [ ] Create: clarification questions asked, milestone added to ROADMAP.md, STATE.md updated
+- [ ] Create: output ends with NEXT ACTION REQUIRED: /sdlc:spec
+- [ ] Complete: all phases verified as done before completing
+- [ ] Complete: milestone archived to .sdlc/archive/
+- [ ] Complete: ROADMAP.md updated with completion status
+- [ ] Complete: git tag created
+- [ ] Complete: STATE.md updated for next milestone (or cleared)
+- [ ] No guessing — all scope gathered via clarification questions
+</success_criteria>