jumpstart-mode 1.0.4 → 1.0.6

package/.github/agents/jumpstart-analyst.agent.md

@@ -1,10 +1,10 @@
 ---
 name: "Jump Start: Analyst"
 description: "Phase 1 -- Create personas, map journeys, define value proposition and MVP scope"
-tools: ['search', 'fetch', 'read', 'editFiles', 'createFile', 'askQuestions', 'manageTodoList']
+tools: ['search', 'web', 'read', 'edit', 'vscode/askQuestions', 'todo']
 handoffs:
   - label: "Proceed to Phase 2: Planning"
-    agent: jumpstart-pm
+    agent: Jump Start: PM
     prompt: "The Product Brief at specs/product-brief.md has been approved. Begin Phase 2 planning."
     send: false
 ---

package/.github/agents/jumpstart-architect.agent.md

@@ -1,10 +1,10 @@
 ---
 name: "Jump Start: Architect"
 description: "Phase 3 -- Select tech stack, design components, model data, specify APIs, create implementation plan"
-tools: ['search', 'fetch', 'read', 'editFiles', 'createFile', 'askQuestions', 'manageTodoList', 'githubRepo']
+tools: ['search', 'web', 'read', 'edit', 'vscode/askQuestions', 'todo']
 handoffs:
   - label: "Proceed to Phase 4: Build"
-    agent: jumpstart-developer
+    agent: Jump Start: Developer
     prompt: "The Architecture Document and Implementation Plan have been approved. Begin Phase 4 implementation."
     send: false
 ---

package/.github/agents/jumpstart-challenger.agent.md

@@ -1,10 +1,10 @@
 ---
 name: "Jump Start: Challenger"
 description: "Phase 0 -- Interrogate assumptions, find root causes, reframe the problem before any building begins"
-tools: ['search', 'fetch', 'read', 'editFiles', 'createFile', 'askQuestions', 'manageTodoList']
+tools: ['search', 'web', 'read', 'edit', 'vscode/askQuestions', 'todo']
 handoffs:
   - label: "Proceed to Phase 1: Analysis"
-    agent: jumpstart-analyst
+    agent: Jump Start: Analyst
     prompt: "The Challenger Brief at specs/challenger-brief.md has been approved. Begin Phase 1 analysis."
     send: false
 ---

package/.github/agents/jumpstart-developer.agent.md

@@ -1,7 +1,7 @@
 ---
 name: "Jump Start: Developer"
 description: "Phase 4 -- Execute the implementation plan task by task, writing tested code"
-tools: ['editFiles', 'runInTerminal', 'search', 'fetch', 'read', 'createFile', 'askQuestions', 'manageTodoList', 'getErrors', 'runTests', 'getChangedFiles', 'usages']
+tools: ['edit', 'execute', 'search', 'web', 'read', 'vscode/askQuestions', 'todo', 'agent']
 ---
 
 # The Developer -- Phase 4: Implementing

package/.github/agents/jumpstart-pm.agent.md

@@ -1,10 +1,10 @@
 ---
 name: "Jump Start: PM"
 description: "Phase 2 -- Write epics, user stories with acceptance criteria, NFRs, and milestones"
-tools: ['search', 'fetch', 'read', 'editFiles', 'createFile', 'askQuestions', 'manageTodoList']
+tools: ['search', 'web', 'read', 'edit', 'vscode/askQuestions', 'todo']
 handoffs:
   - label: "Proceed to Phase 3: Architecture"
-    agent: jumpstart-architect
+    agent: Jump Start: Architect
     prompt: "The PRD at specs/prd.md has been approved. Begin Phase 3 solutioning."
     send: false
 ---

package/.github/prompts/jumpstart-review.prompt.md

@@ -1,6 +1,6 @@
 ---
 description: "Validate current Jump Start artifacts against their templates and gate criteria"
-mode: agent
+agent: agent
 ---
 
 # Jump Start Artifact Review

package/.github/prompts/jumpstart-status.prompt.md

@@ -1,6 +1,6 @@
 ---
 description: "Show the current state of the Jump Start workflow"
-mode: agent
+agent: agent
 ---
 
 # Jump Start Status Check

package/.jumpstart/agents/pm.md

@@ -136,7 +136,8 @@ Track progress through the 9-step Planning Protocol.
 - [ ] Step 6: Dependencies and Risk Register
 - [ ] Step 7: Success Metrics
 - [ ] Step 8: Implementation Milestones
-- [ ] Step 9: Compile and Present the PRD
+- [ ] Step 9: Task Breakdown
+- [ ] Step 10: Compile and Present the PRD
 ```
 
 ---
@@ -317,7 +318,52 @@ For each milestone, list:
 - **Stories Included**: List of story IDs
 - **Depends On**: Previous milestones, if any
 
-### Step 9: Compile and Present the PRD
+### Step 9: Task Breakdown
+
+Decompose each user story into actionable development tasks for the Developer agent (Phase 4). This bridges requirements and implementation.
+
+**Task Format:** `[Task ID] [P?] [Story] Description`
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., E1-S1, E2-S3)
+
+**Phases to define:**
+
+1. **Setup (Phase 1):** Project initialization and basic structure
+   - Create project structure
+   - Initialize dependencies
+   - Configure linting/formatting
+   - Setup environment configuration
+
+2. **Foundational (Phase 2):** Core infrastructure that MUST be complete before ANY user story
+   - Database schema and migrations
+   - Authentication/authorization framework
+   - API routing and middleware
+   - Base models/entities
+   - Error handling and logging
+   - **Checkpoint marker** for foundation readiness
+
+3. **User Story Phases (Phase 3+):** One phase per story, organized by priority
+   - Goal and independent test description
+   - Test tasks (if tests requested) with [P] parallel markers
+   - Implementation tasks: models → services → endpoints → validation → logging
+   - **Checkpoint marker** for story completion
+
+4. **Polish (Phase N):** Cross-cutting concerns
+   - Documentation
+   - Refactoring
+   - Performance optimization
+   - Security hardening
+
+**Guidelines for task breakdown:**
+- Each task should be completable in a single development session
+- Mark tasks that can run in parallel with [P]
+- Include exact file paths in task descriptions
+- Define clear dependencies between tasks
+- Each user story phase should be independently implementable and testable
+
+**Capture insights as you work:** Document decisions about task granularity—when to split vs. combine tasks. Note dependencies discovered during decomposition that weren't obvious from stories alone.
+
+### Step 10: Compile and Present the PRD
 
 Assemble all sections into the PRD template (see `.jumpstart/templates/prd.md`). Present the complete document to the human for review.
 
@@ -366,5 +412,6 @@ Phase 2 is complete when:
 - [ ] Acceptance criteria are specific and testable (no vague qualifiers)
 - [ ] Non-functional requirements have measurable thresholds
 - [ ] At least one implementation milestone is defined
+- [ ] Task breakdown includes Setup, Foundational, and at least one user story phase
 - [ ] Dependencies and risks have identified mitigations
 - [ ] Success metrics map to Phase 0 validation criteria

package/.jumpstart/config.yaml

@@ -28,9 +28,9 @@ agents:
     persona_file: "agents/challenger.md"
     capture_insights: true              # Capture decision rationale and alternatives considered
     elicitation_depth: standard         # quick | standard | deep
-    #   quick:    3 assumption checks, 3 Whys, minimal stakeholder mapping
-    #   standard: 5-7 assumption checks, 5 Whys, full stakeholder map
-    #   deep:     10+ assumption checks, 5 Whys with branching, stakeholder
+    #   quick:    3 assumption checks, linear root cause analysis (approx 3 layers), minimal stakeholder mapping
+    #   standard: 5-7 assumption checks, recursive root cause analysis (drill until root found, usually ~5 layers), full stakeholder map
+    #   deep:     10+ assumption checks, multi-branch root cause analysis (Ishikawa/Fishbone style), stakeholder
     #             interviews simulation, competitive problem framing
     max_assumptions: 10                 # Cap on surfaced assumptions
     require_reframe: true               # Force at least one problem reframe
@@ -88,7 +88,7 @@ agents:
 # Integration Settings
 # ---------------------------------------------------------------------------
 integrations:
-  ai_assistant: "copilot"              # copilot | claude-code | cursor | gemini | windsurf
+  ai_assistant: "copilot"              # copilot | claude-code | cursor | gemini | windsurf | codex
   git_branch_per_phase: false           # Create a branch for each phase
   branch_naming: "jumpstart/phase-{n}-{name}"  # Branch name template
 

package/.jumpstart/templates/challenger-brief.md

@@ -36,18 +36,25 @@
 
 **Starting point:** [The core problem extracted from the original statement]
 
-| Level | Question | Answer |
-|-------|----------|--------|
-| Why 1 | Why does this problem exist? | [Human's answer] |
-| Why 2 | Why does [answer to Why 1] happen? | [Human's answer] |
-| Why 3 | Why does [answer to Why 2] happen? | [Human's answer] |
-| Why 4 | Why does [answer to Why 3] happen? | [Human's answer] |
-| Why 5 | Why does [answer to Why 4] happen? | [Human's answer] |
-
-**Root cause identified:** [Summary of the deepest cause reached]
-
-**Alternative threads noted (if any):**
-- [Branch point and alternative direction not pursued]
+> **Method:** Ask "Why?" until the root cause is revealed. This may take fewer or more than 5 iterations. Ensure the logic holds by checking backwards: "Root Cause > therefore > ... > Problem."
+
+**Analysis Chain:**
+
+1. **Why?** [Answer 1]
+2. **Why?** [Answer 2]
+3. **Why?** [Answer 3]
+4. **Why?** [Answer 4]
+5. **Why?** [Answer 5 - add or remove steps as needed to reach root cause]
+
+**Logic Check (Working Backwards):**
+> [Root Cause] **therefore** [Answer N-1] ... **therefore** [Original Problem].
+> *Does this chain of causality make logical sense without logical leaps?*
+
+**Root Cause Identified:**
+> [Summary of the deepest cause reached]
+
+**Alternative branches (if any):**
+- [Branch point] -> [Alternative root cause]
 
 ---
 

package/.jumpstart/templates/prd.md

@@ -180,6 +180,162 @@ _Alternative checklist format (if configured):_
 
 ---
 
+## Task Breakdown
+
+> **Purpose:** Decompose user stories into actionable development tasks for the Developer agent (Phase 4). This section bridges requirements and implementation.
+
+**Format:** `[Task ID] [P?] [Story] Description`
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., E1-S1, E2-S3)
+
+**Path Conventions:** Adjust paths based on project structure:
+- Single project: `src/`, `tests/`
+- Web app: `backend/src/`, `frontend/src/`
+- Mobile: `api/src/`, `mobile/src/`
+
+---
+
+### Phase 1: Setup (Shared Infrastructure)
+
+**Purpose:** Project initialization and basic structure
+
+- [ ] T001 Create project structure per implementation plan
+- [ ] T002 Initialize [language] project with [framework] dependencies
+- [ ] T003 [P] Configure linting and formatting tools
+- [ ] T004 [P] Setup environment configuration management
+
+---
+
+### Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose:** Core infrastructure that MUST be complete before ANY user story implementation
+
+**⚠️ CRITICAL:** No user story work can begin until this phase is complete
+
+- [ ] T005 Setup database schema and migrations framework
+- [ ] T006 [P] Implement authentication/authorization framework
+- [ ] T007 [P] Setup API routing and middleware structure
+- [ ] T008 Create base models/entities that all stories depend on
+- [ ] T009 Configure error handling and logging infrastructure
+
+**Checkpoint:** ☐ Foundation ready - user story implementation can now begin
+
+---
+
+### Phase 3: Story E1-S1 - [Story Title] (Priority: Must Have)
+
+**Goal:** [Brief description of what this story delivers]
+**Independent Test:** [How to verify this story works on its own]
+
+#### Tests for E1-S1 (Include if tests requested)
+
+> **NOTE:** Write tests FIRST, ensure they FAIL before implementation
+
+- [ ] T010 [P] [E1-S1] Contract test for [endpoint] in `tests/contract/test_[name].[ext]`
+- [ ] T011 [P] [E1-S1] Integration test for [user journey] in `tests/integration/test_[name].[ext]`
+
+#### Implementation for E1-S1
+
+- [ ] T012 [P] [E1-S1] Create [Entity] model in `src/models/[entity].[ext]`
+- [ ] T013 [E1-S1] Implement [Service] in `src/services/[service].[ext]` (depends on T012)
+- [ ] T014 [E1-S1] Implement [endpoint/feature] in `src/[location]/[file].[ext]`
+- [ ] T015 [E1-S1] Add validation and error handling
+- [ ] T016 [E1-S1] Add logging for story operations
+
+**Checkpoint:** ☐ Story E1-S1 fully functional and independently testable
+
+---
+
+### Phase 4: Story E1-S2 - [Story Title] (Priority: Must Have)
+
+**Goal:** [Brief description]
+**Independent Test:** [How to verify this story works on its own]
+
+#### Tests for E1-S2 (Include if tests requested)
+
+- [ ] T017 [P] [E1-S2] Contract test for [endpoint] in `tests/contract/test_[name].[ext]`
+- [ ] T018 [P] [E1-S2] Integration test in `tests/integration/test_[name].[ext]`
+
+#### Implementation for E1-S2
+
+- [ ] T019 [P] [E1-S2] Create [Entity] model in `src/models/[entity].[ext]`
+- [ ] T020 [E1-S2] Implement [Service] in `src/services/[service].[ext]`
+- [ ] T021 [E1-S2] Implement [endpoint/feature] in `src/[location]/[file].[ext]`
+- [ ] T022 [E1-S2] Integrate with E1-S1 components (if needed)
+
+**Checkpoint:** ☐ Stories E1-S1 AND E1-S2 both work independently
+
+---
+
+<!-- TEMPLATE NOTE: Repeat Phase blocks for each user story -->
+<!-- Organize by priority: Must Have → Should Have → Could Have -->
+<!-- Each story should be independently implementable and testable -->
+
+---
+
+### Phase N: Polish & Cross-Cutting Concerns
+
+**Purpose:** Improvements that affect multiple user stories
+
+- [ ] TXXX [P] Documentation updates in `docs/`
+- [ ] TXXX Code cleanup and refactoring
+- [ ] TXXX Performance optimization across all stories
+- [ ] TXXX [P] Additional unit tests (if requested) in `tests/unit/`
+- [ ] TXXX Security hardening
+
+---
+
+### Dependencies & Execution Order
+
+#### Phase Dependencies
+
+```
+Setup (Phase 1)
+    ↓
+Foundational (Phase 2) ← BLOCKS all user stories
+    ↓
+User Stories (Phase 3+) → Can proceed in parallel or sequentially by priority
+    ↓
+Polish (Phase N)
+```
+
+#### Within Each User Story
+
+1. Tests (if included) MUST be written and FAIL before implementation
+2. Models before services
+3. Services before endpoints
+4. Core implementation before integration
+5. Story complete before moving to next priority
+
+#### Parallel Opportunities
+
+- All Setup tasks marked [P] can run in parallel
+- All Foundational tasks marked [P] can run in parallel
+- Once Foundational completes, all user stories can start in parallel
+- Models within a story marked [P] can run in parallel
+- Tests within a story marked [P] can run in parallel
+
+---
+
+### Implementation Strategy
+
+#### MVP First (Highest Priority Stories Only)
+
+1. Complete Phase 1: Setup
+2. Complete Phase 2: Foundational (CRITICAL - blocks all stories)
+3. Complete highest priority user story (e.g., E1-S1)
+4. **STOP and VALIDATE:** Test story independently
+5. Deploy/demo if ready
+
+#### Incremental Delivery
+
+1. Setup + Foundational → Foundation ready
+2. Add Story 1 → Test independently → Deploy/Demo (MVP!)
+3. Add Story 2 → Test independently → Deploy/Demo
+4. Each story adds value without breaking previous stories
+
+---
+
 ## Glossary
 
 | Term | Definition |
@@ -209,6 +365,7 @@ See the insights document for complete decision rationale, alternatives consider
 - [ ] Acceptance criteria are specific and testable (no vague qualifiers)
 - [ ] Non-functional requirements have measurable thresholds
 - [ ] At least one implementation milestone is defined
+- [ ] Task breakdown includes Setup, Foundational, and at least one user story phase
 - [ ] Dependencies have identified mitigations
 - [ ] Risks have identified mitigations
 - [ ] Success metrics map to Phase 0 validation criteria

package/AGENTS.md

@@ -1,28 +1,96 @@
 # Jump Start Framework -- Agent Instructions
 
-This repository uses the Jump Start spec-driven agentic coding framework. When performing tasks in this repository, follow these rules.
+> **System Notice:** This repository is managed by the Jump Start spec-driven framework. All AI agents operating in this context must adhere strictly to the protocols defined below.
 
-## Workflow
+## Workflow Overview
 
-Five sequential phases, each with a dedicated agent persona in `.jumpstart/agents/`:
+The development lifecycle follows five strict, sequential phases. No phase may begin until the previous phase's artifact is **explicitly approved** by the human operator.
 
-| Phase | Agent | Command | Output |
-|-------|-------|---------|--------|
-| 0 | Challenger | Select "Jump Start: Challenger" agent | `specs/challenger-brief.md` |
-| 1 | Analyst | Select "Jump Start: Analyst" agent | `specs/product-brief.md` |
-| 2 | PM | Select "Jump Start: PM" agent | `specs/prd.md` |
-| 3 | Architect | Select "Jump Start: Architect" agent | `specs/architecture.md`, `specs/implementation-plan.md`, `specs/decisions/*.md` |
-| 4 | Developer | Select "Jump Start: Developer" agent | `src/`, `tests/`, `README.md` |
+```mermaid
+flowchart TB
+    P0[Phase 0: Challenge] -->|Brief| P1[Phase 1: Analyze]
+    P1 -->|Product Brief| P2[Phase 2: Plan]
+    P2 -->|PRD| P3[Phase 3: Architect]
+    P3 -->|Specs| P4[Phase 4: Build]
+    
+    C(Challenger) -.-> P0
+    A(Analyst) -.-> P1
+    PM(Product Manager) -.-> P2
+    Arch(Architect) -.-> P3
+    Dev(Developer) -.-> P4
 
-## Rules
+    style P0 fill:#1976d2,stroke:#333,stroke-width:2px,color:#fff
+    style P4 fill:#43a047,stroke:#333,stroke-width:2px,color:#fff
+```
 
-1. **Sequential enforcement.** Do not start a phase unless all preceding artifacts exist and are approved.
-2. **Agent fidelity.** When operating as a specific agent, load and follow `.jumpstart/agents/<agent>.md` exactly.
-3. **Human gates.** Never auto-approve phase transitions. Always present the artifact and ask for explicit approval.
-4. **Templates.** Use `.jumpstart/templates/` for all artifact structures.
-5. **Config.** Read `.jumpstart/config.yaml` at the start of every phase.
-6. **Artifact locations.** Specs go in `specs/`. ADRs in `specs/decisions/`. Code in `src/`. Tests in `tests/`.
+## Agent Directory
 
-## Checking Approval
+| Phase | Agent Persona | Activation Command | Primary Responsibility | Output Artifact |
+| --- | --- | --- | --- | --- |
+| **0** | **The Challenger** | `/jumpstart.challenge` | Interrogates the problem, finds root causes, reframes assumptions. | `specs/challenger-brief.md` |
+| **1** | **The Analyst** | `/jumpstart.analyze` | Defines personas, user journeys, and MVP scope. | `specs/product-brief.md` |
+| **2** | **The PM** | `/jumpstart.plan` | Writes user stories, acceptance criteria, and NFRs. | `specs/prd.md` |
+| **3** | **The Architect** | `/jumpstart.architect` | Selects tech stack, models data, designs APIs, plans tasks. | `specs/architecture.md`<br>
 
-An artifact is approved when its Phase Gate Approval section has all checkboxes checked and "Approved by" is not "Pending".
+<br>`specs/implementation-plan.md` |
+| **4** | **The Developer** | `/jumpstart.build` | Writes code and tests according to the plan. | `src/`, `tests/`, `README.md` |
+
+---
+
+## Operational Protocols
+
+All agents must follow these directives without exception.
+
+### 1. The Context Protocol
+
+* **Read Before Write:** Before generating any content, you must read `.jumpstart/config.yaml` and the specific agent instruction file in `.jumpstart/agents/`.
+* **Upstream Traceability:** You must read the *approved* artifacts from previous phases.
+* *Analyst* reads *Challenger Brief*.
+* *Architect* reads *PRD*, *Product Brief*, and *Challenger Brief*.
+* Do not hallucinate requirements that contradict upstream documents.
+
+
+
+### 2. The Execution Protocol
+
+* **Stay in Lane:**
+* The **Challenger** never suggests solutions or technologies.
+* The **Analyst** never writes code or defines database schemas.
+* The **Developer** never changes the architecture without flagging a deviation.
+
+
+* **Use Templates:** All outputs must be generated using the markdown templates located in `.jumpstart/templates/`. Do not invent new document formats.
+* **Living Insights:** Simultaneously maintain your phase's `insights.md` file to log your reasoning, trade-offs, and discarded alternatives.
+
+### 3. The Gate Protocol
+
+* **No Auto-Approval:** You cannot mark a phase as complete. You must present the final artifact to the human and ask: *"Does this meet your expectations?"*
+* **Checkboxes Matter:** An artifact is only considered "Approved" when:
+1. The `Phase Gate Approval` section at the bottom of the file is filled.
+2. All checkboxes in that section are marked `[x]`.
+3. The "Approved by" field is not "Pending".
+
+
+
+### 4. The Artifact Protocol
+
+* **Specs Location:** All documentation goes into `specs/`.
+* **Decisions:** Significant technical choices must be recorded in `specs/decisions/` as ADRs.
+* **Source Code:** Application code goes into `src/`.
+* **Tests:** Test code goes into `tests/`.
+
+---
+
+## Tool Usage (VS Code Copilot)
+
+If running within VS Code Copilot, agents have access to native UI tools:
+
+* **`ask_questions`:** Use this to present multiple-choice decisions to the user (e.g., selecting a tech stack or prioritizing a feature).
+* **`manage_todo_list`:** Use this to display a dynamic progress bar for your phase's protocol (e.g., "Step 3 of 8: User Journey Mapping").
+
+---
+
+## Troubleshooting
+
+* **Missing Context:** If an upstream artifact is missing (e.g., running `/jumpstart.plan` before Phase 1 is done), **stop** and instruct the user to complete the missing phase first.
+* **Ambiguity:** If a requirement is unclear, ask the user for clarification using the `ask_questions` tool rather than guessing.

package/README.md

@@ -1,22 +1,48 @@
-# Jump Start
+# ⚡ Jump Start
 
-A spec-driven agentic coding framework that transforms a raw idea into production-ready code through five sequential phases. Each phase is owned by a specialized AI agent. Every artifact lives in your repository, version-controlled and accessible.
+![Version](https://img.shields.io/npm/v/jumpstart-mode?style=flat-square)
+![License](https://img.shields.io/npm/l/jumpstart-mode?style=flat-square)
+![Node](https://img.shields.io/node/v/jumpstart-mode?style=flat-square)
+
+**A spec-driven agentic coding framework that transforms a raw idea into production-ready code through five sequential, AI-governed phases.**
+
+Every artifact lives in your repository, version-controlled, diffable, and transparent.
 
 ---
 
-## How It Works
+## Table of Contents
+- [How It Works](#how-it-works)
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Example Workflow](#example-workflow)
+- [Commands](#commands)
+- [Configuration](#configuration)
+- [Project Structure](#project-structure)
+- [Living Insights](#living-insights)
+- [VS Code Chat Features](#vs-code-chat-features)
+- [Troubleshooting](#troubleshooting)
 
-Jump Start runs five phases in a strict sequence. Each phase produces Markdown artifacts that become the input for the next phase. A human gate sits between every phase transition.
+---
 
-```
-Phase 0         Phase 1        Phase 2       Phase 3          Phase 4
-Challenge  -->  Analyze   -->  Plan     -->  Architect   -->  Build
-(Challenger)    (Analyst)      (PM)          (Architect)      (Developer)
-     |               |             |              |                |
-     v               v             v              v                v
-challenger-     product-       prd.md       architecture.md   src/
-brief.md        brief.md                    impl-plan.md      tests/
-                                            decisions/*.md    README.md
+## How It Works
+
+Jump Start runs five phases in a strict sequence. Each phase is owned by a specialized AI agent and produces Markdown artifacts that serve as the input for the next phase. A human gate sits between every transition to ensure quality.
+
+```mermaid
+flowchart TB
+    P0[Phase 0: Challenge] -->|Brief| P1[Phase 1: Analyze]
+    P1 -->|Product Brief| P2[Phase 2: Plan]
+    P2 -->|PRD| P3[Phase 3: Architect]
+    P3 -->|Specs| P4[Phase 4: Build]
+    
+    C(Challenger) -.-> P0
+    A(Analyst) -.-> P1
+    PM(Product Manager) -.-> P2
+    Arch(Architect) -.-> P3
+    Dev(Developer) -.-> P4
+
+    style P0 fill:#1976d2,stroke:#333,stroke-width:2px,color:#fff
+    style P4 fill:#43a047,stroke:#333,stroke-width:2px,color:#fff
 ```
 
 **Phase 0 -- Problem Discovery.** The Challenger agent interrogates your idea, surfaces hidden assumptions, drills to root causes, and produces a validated problem statement.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jumpstart-mode",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Spec-driven agentic coding framework that transforms ideas into production code through AI-powered sequential phases",
   "keywords": [
     "jumpstart",