Wds 3 Scenarios

Follow the instructions in ./workflow.md.

Scenario Quality Checklist

Used by: step-07-quality-review.md Source: Adapted from dream-up-rubric-phase-4-scenarios.md

---

Dimension 1: Completeness (7 sections)

For each scenario, verify all 7 components exist:

• [ ] Core Feature — Clear statement of what scenario covers, aligned to business goal
• [ ] Entry Point — Specific starting location with device, context, and discovery method
• [ ] Mental State — All three present: Trigger (what happened), Hope (what they want), Worry (what they fear)
• [ ] Success Goals — Both present: User success (tangible) + Business success (measurable)
• [ ] Shortest Path — Linear steps listed with name + purpose, no branches
• [ ] Scenario Name — Persona name in title, ID assigned (01, 02...)
• [ ] Trigger Map Connections — Persona named, driving forces listed, business goal referenced

Minimum: 6/7 present (Trigger Map Connections can be implicit if obvious from other sections)

---

Dimension 2: Quality Criteria (7 checks)

2.1 Persona Alignment

• Scenario serves a specific persona from Trigger Map (not generic "user")
• Mental state matches persona's psychological profile
• Entry point reflects persona's behavior patterns

2.2 Mental State Richness

• All three components (Trigger/Hope/Worry) are specific and visceral
• You can FEEL the user's emotional state
• Mental state informs design decisions

Bad: "User is interested in the product" Good: "Panicked — motorhome broke down, family vacation at risk, unfamiliar area"

2.3 Mutual Success Clarity

• Both successes are specific and measurable
• Business success is not just "revenue" or "engagement"
• User success is tangible (not "satisfied" or "happy")

Bad: Business: "Get more customers" / User: "Successfully use the site" Good: Business: "High-intent tourist call captured, info call avoided" / User: "Confirmed capability, got location, feels confident calling"

2.4 Sunshine Path Focus

• Path is completely linear (no "if" statements)
• Error states and edge cases deferred
• This is the absolute happiest path

2.5 Minimum Viable Steps

• Each step moves meaningfully toward success
• No unnecessary pages or detours
• Can you remove any step without breaking the flow?

2.6 Entry Point Realism

• Describes HOW user actually discovered this
• Includes device context
• Reflects real-world behavior

Bad: "User opens app" Good: "Tourist googles 'car repair Öland' on mobile at gas station, clicks top result"

2.7 Business Goal Connection

• Traces to specific business goal from Trigger Map
• Business value is explicit, not assumed
• User success drives business success (not competes)

Minimum: 5/7 fully met

---

Dimension 3: Common Mistakes (7 checks)

All 7 must be avoided — any single mistake requires correction.

3.1 Edge Cases in Sunshine Path

Check: Are there any "if" statements, error states, or branches? Fix: Remove all conditional logic. Document edge cases separately.

3.2 Feature-First Naming

Check: Does the scenario name describe a feature or a user goal? Fix: Rename to persona + purpose format.

• Bad: "Homepage and Services"
• Good: "Hasse's Emergency Search"

3.3 Missing Mental State

Check: Is mental state present with all three components? Fix: Add Trigger/Hope/Worry with specific, visceral descriptions.

3.4 Vague Page Descriptions

Check: Do pages have just names, or names + purpose? Fix: Add what user accomplishes at each step.

• Bad: "1. Homepage 2. Services 3. Contact"
• Good: "1. Homepage — confirms mechanic fixes motorhomes 2. Contact — gets phone + directions"

3.5 Generic Persona

Check: Does scenario use a Trigger Map persona with name? Fix: Replace "user" with specific persona name and driving forces.

3.6 Missing Business Value

Check: Is business success explicitly defined and measurable? Fix: Add specific business outcome connected to Trigger Map goal.

3.7 Bloated Descriptions

Check: Does any single component (Entry Point, Mental State, Success Goals) exceed 2 sentences? Fix: Trim to bullet-point essentials. Entry points: device + context + discovery. Mental state: one phrase per component. Success: one measurable statement each.

Minimum: 7/7 avoided (zero tolerance for mistakes)

---

Dimension 4: Best Practices (4 checks)

4.1 Persona in Scenario Name

Scenario title includes persona name (e.g., "Hasse's Emergency Search")

4.2 Highest-Value Persona First

Scenario 01 serves the Primary persona. Design scenarios for Primary first, then Secondary.

4.3 One Job Per Scenario

Each scenario accomplishes ONE clear job-to-be-done. No scope creep.

4.4 Driving Forces Explicitly Linked

Scenario states which specific wants/fears from Trigger Map it addresses, with checkmark format:

• ✅ Want: [specific force]
• ❌ Fear: [specific force]

Minimum: 2/4 followed

---

Scoring Summary Template

## Quality Review: [Scenario ID]

**Completeness:** [X]/7
**Quality:** [X]/7
**Mistakes Avoided:** [X]/7
**Best Practices:** [X]/4

**Status:** [Excellent / Good / Needs Work]
**Gaps:** [list or "None"]

---

Thresholds

If not meeting Minimum after corrections: Note gaps and consult user for guidance.

---

_Quality checklist for Step 07: Quality Review_

Scenario Outline Template

Used by: step-05-outline-scenario.md Purpose: Structure the answers from the 8-question scenario dialog into a complete scenario outline.

---

Template

# [NN]: [Persona Name]'s [Purpose]

**Project:** [project_name]
**Created:** [date]
**Method:** Whiteport Design Studio (WDS)

---

## Transaction (Q1)

**What this scenario covers:**
[The key transaction — stated as user purpose, not feature name]

---

## Business Goal (Q2)

**Goal:** [Which specific business goal this serves]
**Objective:** [Objective reference from Trigger Map]

---

## User & Situation (Q3)

**Persona:** [Name] ([Priority level: Primary/Secondary/Tertiary])
**Situation:** [Real-life context — who they are, where they are, what's happening]

---

## Driving Forces (Q4)

**Hope:** [What they're hoping to find or achieve — one sentence]

**Worry:** [What they're afraid of or want to avoid — one sentence]

> CONSTRAINT: One sentence per component. Phrases, not paragraphs.

---

## Device & Starting Point (Q5 + Q6)

**Device:** [Mobile / Desktop / Tablet]
**Entry:** [How they actually arrive] — max 2 sentences

---

## Best Outcome (Q7)

**User Success:**
[Tangible, measurable outcome the user achieves]

**Business Success:**
[Specific, measurable result the business gets]

---

## Shortest Path (Q8)

[Linear sunshine path — NO branches, NO "if" statements. Minimum viable steps.]

1. **[Page Name]** — [What user sees/does/achieves at this step]
2. **[Page Name]** — [What user sees/does/achieves at this step]
3. **[Page Name]** — [What user sees/does/achieves at this step] ✓

---

## Trigger Map Connections

**Persona:** [Name] ([Priority level])

**Driving Forces Addressed:**
- ✅ **Want:** [Specific positive driver from Trigger Map]
- ❌ **Fear:** [Specific negative driver from Trigger Map]

**Business Goal:** [Specific goal + objective from Trigger Map]

---

## Scenario Steps

Steps are outlined one at a time after scenario creation. The first step is processed automatically.

| Step | Folder | Purpose | Exit Action |
|------|--------|---------|-------------|
| [NN].1 | `[NN].1-[page-slug]/` | [Step purpose] | [Interaction that leads to next step] |
| [NN].2 | `[NN].2-[page-slug]/` | [Step purpose] | [Interaction that leads to next step] |
| [NN].3 | `[NN].3-[page-slug]/` | [Step purpose] | [Final — scenario success] ✓ |

**First step** ([NN].1) includes full entry context (Q3 + Q4 + Q5 + Q6).
**On-step interactions** (that don't leave the step) are documented as storyboard items within each page spec.

---

Quality Reminders

When filling this template, check:

Transaction — Is this a real user journey? Browsing content page-by-page counts. Comparing options counts. Any meaningful path through the site with intent.

Driving Forces — Can you FEEL the user's state? "Interested" is not enough. "Panicked because family vacation is at risk" is.

Best Outcome — "Get more customers" fails. "Reduce info calls by 40% by giving tourists the info they need online" passes.

Shortest Path — Count the steps. Can you remove any? Each step must justify its existence.

Trigger Map — Don't invent a user. Use the actual persona with their actual driving forces.

---

_Template for Step 05: Outline Scenario (8-Question Dialog)_

WDS Scenario Validation Standards

Reference document for Phase 3 validation steps.

---

What Makes a Valid Scenario

Minimum Requirements (must pass)

1. All 7 components present (name, feature, entry, mental state, success, path, TM connections) 2. Path is truly linear (zero branches) 3. Mental state is specific and visceral 4. Both success goals are measurable 5. Trigger Map connections are explicit

Quality Thresholds

• Completeness: 6/7 minimum
• Quality: 5/7 minimum
• Mistakes avoided: 6/6 (all must be avoided)
• Best practices: 2/4 minimum

---

WDS Navigation Conventions

Page Naming

• Use user-facing names (not technical: "Tjänster", not "services-page")
• Consistent naming across scenarios (same page = same name)
• Include page purpose in descriptions

Flow Rules

• Entry page must be reachable from the described discovery method
• Each step transitions naturally to the next
• Final step has clear success marker (✓)
• No dead ends, no impossible jumps

Shared Pages

• Pages appearing in 2+ scenarios must serve consistent purposes
• Shared pages should accommodate all relevant personas

---

SEO Integration

Phase 1 → Phase 3 Connection

• Every page should map to at least one keyword from the Phase 1 keyword map
• Page names should be compatible with planned URL slugs
• No keyword cannibalization (two pages competing for same keyword)

---

Validation Severity Levels

Step 1: Load Context & Detect Project State

STEP GOAL:

Read all prerequisite artifacts (Product Brief, Trigger Map) and detect whether this is a fresh start or resume, establishing the complete project context needed for scenario creation.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on loading context and detecting project state
• 🚫 FORBIDDEN to skip reading any prerequisite artifact
• 💬 Approach: Methodically gather all context before any creative work
• 📋 Present a clear context summary so the user can verify understanding

EXECUTION PROTOCOLS:

• 📖 Read all prerequisite files completely before summarizing
• 💾 Extract and note key elements from each artifact
• 🔍 Check for existing work to determine fresh start vs resume
• 🚫 FORBIDDEN to proceed without presenting context summary to user

CONTEXT BOUNDARIES:

• Available context: Project config, Product Brief, Trigger Map artifacts
• Focus: Loading and understanding all prerequisite data
• Limits: No scenario creation, no analysis — only context gathering
• Dependencies: Product Brief (Phase 1) and Trigger Map (Phase 2) must exist

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Read Configuration

Read {project-root}/_bmad/wds/config.yaml and extract:

• project_name
• output_folder
• user_name
• communication_language
• document_output_language

2. Read Product Brief

Read {output_folder}/A-Product-Brief/product-brief.md

Extract and note:

• Site/app type (marketing site, SaaS, booking system, portfolio, etc.)
• Business context and constraints
• Technical platform (WordPress, custom, etc.)
• Number of pages/views mentioned
• Any navigation structure described

3. Read Trigger Map

Read {output_folder}/B-Trigger-Map/trigger-map.md (the hub document)

Extract and note:

• Business Goals: Vision statement, all objectives with priority tiers (Primary/Secondary/Tertiary)
• Personas: For each persona:
• Name and role
• Priority level (Primary/Secondary/Tertiary)
• Top 3 positive drivers (wants)
• Top 3 negative drivers (fears)
• Role in flywheel

Also read persona documents if they exist:

• {output_folder}/B-Trigger-Map/02-*.md (Primary persona)
• {output_folder}/B-Trigger-Map/03-*.md (Secondary persona)
• {output_folder}/B-Trigger-Map/04-*.md (Tertiary persona, if exists)

4. Check for Existing Work

Check for resume situation:

• Does {output_folder}/C-UX-Scenarios/ exist?
• Are there any scenario files already?
• Is there in-progress work in the design log ({output_folder}/_progress/00-design-log.md)?

If existing work found:

"I see we have existing scenario work:
- [list what exists]

Should I:
1. Continue where we left off
2. Review and adjust existing scenarios
3. Start fresh"

Wait for user response before proceeding.

If starting fresh: Continue to next instruction.

5. Present Context Summary

Present to user:

"Here's what I'm working with:

**Project:** [project_name]
**Site Type:** [type from Product Brief]
**Business Goals:** [count] objectives across [tier count] tiers
**Personas:** [list names with priority levels]
**Primary Persona:** [name] — [top driving force]

Ready to analyze the scope."

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Scope Analysis?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [context summary presented and acknowledged], will you then load and read fully {nextStepFile} to execute and begin scope analysis.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All prerequisite artifacts read completely (Product Brief, Trigger Map, persona documents)
• Key elements extracted and noted from each artifact
• Existing work detected and handled appropriately
• Clear context summary presented to user
• User acknowledges understanding before proceeding
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Skipping any prerequisite artifact
• Not detecting existing work when it exists
• Proceeding without presenting context summary
• Generating scenarios or analysis during this step
• Not waiting for user acknowledgment before proceeding

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 2: Analyze Scope & Scale Strategy

STEP GOAL:

Determine site type, list all pages/views, assess scale, select approach mode, and present the analysis for user approval at this critical checkpoint.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on scope analysis, page inventory, and scale strategy
• 🚫 FORBIDDEN to proceed past the user checkpoint without explicit user approval
• 💬 Approach: Present structured analysis and wait for user confirmation
• 📋 This is a USER CHECKPOINT — do not auto-proceed

EXECUTION PROTOCOLS:

• 🔍 Classify site type based on Product Brief data
• 📋 Create complete page inventory from all sources
• 📊 Assess scale and recommend approach mode
• 🚫 FORBIDDEN to skip user checkpoint — must wait for explicit approval

CONTEXT BOUNDARIES:

• Available context: Product Brief data, Trigger Map data loaded in Step 1
• Focus: Site classification, page inventory, scale assessment
• Limits: No scenario creation, no strategic context building — only scope analysis
• Dependencies: Step 1 context must be loaded

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Site Type Detection

Based on Product Brief, classify the site:

Presentation Site (marketing, service catalog, company profile, portfolio):

• Scenario format: Screen Flow (page-to-page navigation)
• Coverage: Expose all pages
• Storyboarding: Minimal (only for complex interactions like booking forms)

Dynamic App (SaaS, booking system, social platform, productivity tool):

• Scenario format: Storyboard (document states within views)
• Coverage: Focus on core workflow first
• Screen flow: Only for multi-step processes (onboarding, checkout)

Mixed (presentation site with dynamic features):

• Use both formats as needed per scenario

2. List All Pages/Views

Create a complete list of every page or view from the Product Brief.

Format:

## Page Inventory

1. [Page Name] — [Brief purpose]
2. [Page Name] — [Brief purpose]
3. [Page Name] — [Brief purpose]
...

**Total: [N] pages/views**

Rules:

• Include every page mentioned in Product Brief
• Include pages implied by navigation structure
• Include pages implied by business goals (e.g., if goal mentions "booking" there's a booking page)
• Do NOT include generic shared elements (header, footer, navigation) — these are documented separately

3. Scale Assessment

Based on page count, determine strategy:

Small (< 20 pages):

• Strategy: Comprehensive coverage — document all pages across scenarios
• Mode recommendation: Dream or Suggest
• Every page must appear in exactly one scenario

Medium (20-50 pages):

• Strategy: Comprehensive coverage with natural groupings
• Mode recommendation: Suggest
• Group pages by navigation patterns, service types, or content categories

Large (100+ pages):

• Strategy: Selective ignorance — focus on most valuable workflow
• Mode recommendation: Dialog
• Deep work on business-critical flow (learning effect reveals patterns for rest)

4. Page Documentation Strategy

Determine how to handle similar pages:

Few pages + high variation → Document as separate pages

• Each page substantially different in structure, content, or purpose
• Example: 13 vehicle pages with different positioning

Many pages + low variation → Document as template with content variations

• Structurally identical pages with only content differences
• Example: 500 product pages with same layout, different product data

5. Present Analysis (USER CHECKPOINT)

Present to user and wait for approval:

## Scope Analysis

**Site Type:** [Presentation / Dynamic / Mixed]
**Total Pages:** [N]
**Scale:** [Small / Medium / Large]
**Recommended Mode:** [Dream / Suggest / Dialog]
**Scenario Format:** [Screen Flow / Storyboard / Mixed]

### Page Inventory
[numbered list from step 2]

### Page Strategy
- [X] pages documented individually (high variation)
- [Y] pages as templates (low variation groups: [list groups])

**Does this look right? Any pages missing or that should be grouped differently?**

WAIT for user response. Do not proceed until user confirms.

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Building Strategic Context?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [user has explicitly approved the scope analysis], will you then load and read fully {nextStepFile} to execute and begin building strategic context.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Site type correctly classified from Product Brief data
• Complete page inventory created with all pages accounted for
• Scale assessment matches page count
• Page documentation strategy determined
• Analysis presented clearly at user checkpoint
• User explicitly approves before proceeding
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Proceeding without user approval at checkpoint
• Missing pages from the inventory
• Incorrect site type classification
• Skipping scale assessment or mode recommendation
• Auto-proceeding past the user checkpoint

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 3: Build Strategic Context

STEP GOAL:

Extract strategic context from the Trigger Map — tracing paths from business goals through personas and driving forces to transactions — assign pages to each scenario chain, prioritize them, and verify complete coverage of all pages.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on building strategic context, assigning pages, and prioritizing
• 🚫 FORBIDDEN to create scenario outlines — only identify and plan scenarios
• 💬 Approach: Systematically trace paths from business goals to user actions
• 📋 Every page from the inventory must be assigned to exactly one scenario chain

EXECUTION PROTOCOLS:

• 🔗 Trace complete chains from Business Goal → Persona → Force → Transaction → Scenario
• 📋 Answer all 7 Decision Matrix questions for each scenario chain
• 📊 Assign pages ensuring no repetition and full coverage
• 🚫 FORBIDDEN to leave any page unassigned

CONTEXT BOUNDARIES:

• Available context: Product Brief, Trigger Map, approved page inventory from Step 2
• Focus: Strategic context extraction, page assignment, prioritization
• Limits: No scenario outlining, no file creation — only planning
• Dependencies: Approved scope analysis from Step 2

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Build Strategic Context Chains

What is a strategic context chain?

A strategic context chain traces the path from business strategy to user action:

Business Goal → Persona → Driving Force → Transaction → Scenario

Example:

BG01: Reduce info calls by 40%
  → Hasse (Primary - stressed tourist)
    → Fear: Being stranded with broken RV
      → Transaction: Confirm mechanic capability + get directions
        → 01: "Hasse's Emergency Search"

For each business goal from the Trigger Map:

1. Identify which persona(s) most directly drive this goal 2. Identify which driving forces (wants AND fears) connect to this goal 3. Determine the specific transaction/action that fulfills it 4. Name a candidate scenario using the persona's name

For each scenario chain, answer the Decision Matrix (all 7 required):

2. Assign Pages to Scenario Chains

For each scenario chain, list which pages from the inventory (Step 02) the user visits.

Rules:

• Each page appears in exactly ONE scenario chain (no repetition)
• If a page could fit multiple scenarios, assign it to the highest-priority one
• Shared elements (navigation, footer) are excluded from page assignment

3. Prioritize

Rank the scenario chains:

Priority 1 — Critical Path:

• Top business goal + primary persona + core product value
• These scenarios are created first and in most detail

Priority 2 — Supporting:

• Secondary persona scenarios, alternative entry paths
• Important but not the strategic core

Priority 3 — Edge Cases:

• Admin tasks, rare user segments, error recovery
• May be deferred to later phases

4. Coverage Check

After building all scenario chains, verify:

• [ ] Every page from inventory is assigned to exactly one scenario chain
• [ ] Primary persona has at least one Priority 1 scenario
• [ ] Top business goal is addressed by at least one scenario
• [ ] No page appears in multiple scenarios

If pages are unassigned: Create additional scenario chains or expand existing ones to cover them.

5. Present Scenario Chain List

Present the complete scenario chain list:

## Strategic Context Chains

### Priority 1
**Chain 01:** [Business Goal] → [Persona] → [Force] → [Transaction]
- Scenario: 01-[slug]
- Pages: [list]

### Priority 2
**Chain 02:** [Business Goal] → [Persona] → [Force] → [Transaction]
- Scenario: 02-[slug]
- Pages: [list]

### Coverage: [X/Y] pages assigned

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Scenario Suggestions?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [scenario chain list with full page coverage presented], will you then load and read fully {nextStepFile} to execute and begin scenario suggestions.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All business goals traced through complete strategic context chains
• All 7 Decision Matrix questions answered for each scenario chain
• Every page from inventory assigned to exactly one scenario chain
• Scenario chains prioritized with clear rationale
• Coverage check passes (all pages assigned, no duplicates)
• Complete scenario chain list presented to user
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Leaving pages unassigned
• Assigning pages to multiple scenario chains
• Skipping Decision Matrix questions
• Creating scenario outlines during this step
• Not verifying coverage before proceeding

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 4: Suggest Scenarios (USER CHECKPOINT)

STEP GOAL:

Present the complete scenario plan to the user for approval before creating any outlines, ensuring alignment on scenario count, page assignments, naming, and priorities.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on presenting the scenario plan and getting user approval
• 🚫 FORBIDDEN to proceed to outlining without explicit user approval
• 💬 Approach: Present clearly, handle feedback gracefully, re-present if needed
• 📋 This is a critical USER CHECKPOINT — do not auto-proceed under any circumstances

EXECUTION PROTOCOLS:

• 📋 Format scenario plan exactly as specified
• ✅ Include coverage check with all four verifications
• 🔄 Handle user feedback and re-present adjusted plan
• 🚫 FORBIDDEN to skip user approval checkpoint

CONTEXT BOUNDARIES:

• Available context: Strategic context from Step 3, page inventory, Trigger Map data
• Focus: Presenting and getting approval for the scenario plan
• Limits: No scenario outlining, no file creation — only planning approval
• Dependencies: Complete strategic context chains from Step 3

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Format the Scenario Plan

Present to user in this exact format:

## Scenario Plan for [Project Name]

### Site Analysis
- **Type:** [Presentation / Dynamic / Mixed]
- **Total Pages:** [N]
- **Format:** [Screen Flow / Storyboard / Mixed]
- **Scenarios:** [N] total

---

### Suggested Scenarios

**01: [Persona Name]'s [Purpose]** ⭐ Priority 1
- **Pages:** [comma-separated list]
- **Persona:** [Name] — [Primary driving force]
- **User Value:** [What user gets — be specific]
- **Business Value:** [What business gets — be measurable]
- **Format:** [Screen Flow / Storyboard]

**02: [Persona Name]'s [Purpose]** ⭐ Priority 1
- **Pages:** [comma-separated list]
- **Persona:** [Name] — [Primary driving force]
- **User Value:** [specific]
- **Business Value:** [measurable]
- **Format:** [Screen Flow / Storyboard]

[Continue for all scenarios...]

---

### Coverage Check
✅ All pages assigned: [Yes/No — if No, list unassigned pages]
✅ No page repetition: [Yes/No]
✅ Primary persona covered: [Yes/No]
✅ Top business goal addressed: [Yes/No]

2. Naming Rules

Scenario names MUST use persona names:

Good:

• "Hasse's Emergency Search"
• "Lars Checks Workshop Hours"
• "Åke Coordinates Fleet Service"

Bad:

• "Emergency Booking Flow"
• "Hours Lookup"
• "Service Scheduling"

Why: Keeps persona psychology front-of-mind throughout design.

3. Scenario ID Convention

• Format: 01, 02, 03, etc.
• Folder slug: 01-hasses-emergency-search (lowercase, hyphenated)
• File: 01-hasses-emergency-search.md

4. Wait for Approval

CHECKPOINT — Wait for user response.

User may:

• "Looks good, proceed" → Continue to menu options
• "Combine X and Y" → Adjust and re-present
• "Add a scenario for [purpose]" → Add scenario chain and re-present
• "Focus on just [one flow]" → Apply selective ignorance, re-present
• "Missing page [X]" → Add to inventory and assign

Do NOT proceed to Step 05 until user explicitly approves the scenario plan.

5. Record Approved Plan

After user approval, record:

• Final scenario count
• Final page assignments
• Any user adjustments and reasoning

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Outlining Scenarios?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [user has explicitly approved the scenario plan], will you then load and read fully {nextStepFile} to execute and begin scenario outlining.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Scenario plan formatted exactly as specified
• All scenarios use persona names in their titles
• Coverage check included and all four items verified
• User explicitly approves the plan before proceeding
• User feedback handled gracefully with re-presentation
• Approved plan recorded with any adjustments noted
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Proceeding without explicit user approval
• Using feature-first naming instead of persona names
• Missing coverage check
• Not handling user feedback (combining, adding, removing scenarios)
• Auto-proceeding past the user checkpoint

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 5: Outline Scenario (One at a Time)

STEP GOAL:

Define ONE scenario through 8 strategic questions in natural conversation order. Start with the primary transaction (highest priority), complete it fully, then loop for each remaining scenario. A transaction is any meaningful user journey — purchasing, booking, researching content page-by-page, comparing options, or any interaction where the user moves through the site with intent.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator — you ASK, the user DECIDES
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus on ONE transaction at a time, complete it fully before moving to the next
• 🚫 FORBIDDEN to skip any of the 8 strategic questions
• 💬 Approach: Ask one question at a time, let the answer shape the next question naturally
• 📋 Verify all quality gates before proceeding to the next scenario or step

EXECUTION PROTOCOLS:

• 📖 Load the scenario outline template before starting
• 💬 Walk through 8 questions as a dialog — one question at a time, building on each answer
• ✅ Run quality gates check before moving on
• 💾 Create output file in the correct folder structure
• 🔄 Loop back for each remaining scenario (next transaction, next target group)
• 🚫 FORBIDDEN to proceed if any quality gate fails

CONTEXT BOUNDARIES:

• Available context: Approved scenario plan from Step 4, strategic context, page inventory, Trigger Map
• Focus: Detailed outlining of one scenario at a time
• Limits: Only outline scenarios from the approved plan
• Dependencies: User-approved scenario plan from Step 4

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Determine Which Scenario

Process scenarios in priority order (Priority 1 first, then 2, then 3).

If this is your first time at this step, start with scenario 01. If returning from a loop, continue with the next unfinished scenario.

2. Load Template

Load the full template: {scenarioTemplate}

3. The 8-Question Scenario Dialog

Two modes — same 8 questions, different driver:

• Conversation mode (default): YOU ask, the USER answers. One question at a time. Each answer shapes the next question naturally.
• Suggest mode (when user asks you to suggest): YOU answer all 8 questions based on the Trigger Map, Product Brief, and strategic context. Present the complete scenario to the user for review and adjustment.

This IS the scenario — when all 8 are answered, the outline writes itself.

What counts as a transaction: Not just purchases or bookings. Clicking through a menu item by item to research site content is a transaction. Comparing options is a transaction. Any meaningful journey where the user moves through the site with intent.

Q1: "What transaction do we need to get really right?"

Start with the WHY. What is the most important thing a user needs to accomplish on this site?

• State as user purpose, not feature name
• Bad: "Homepage and service pages"
• Good: "Verify service availability before booking"

Q2: "If this transaction succeeds, which business goal does it add value to?"

Connect to the Trigger Map immediately. Which specific business goal and objective does this serve?

• Reference actual goals from the Trigger Map
• This grounds the scenario in business strategy, not just user needs

Q3: "Which user experiences this most, and in what real-life situation?"

Identify the persona AND their context. Not just "who" but "who, where, when."

• Use actual personas from the Trigger Map
• Bad: "A customer looking for information"
• Good: "Hasse, 55, motorhome tourist stranded in Byxelkrok with a broken vehicle during family vacation"

Q4: "What do they want and what do they fear going into this interaction?"

The driving forces — hope and worry. These must be visceral and specific.

• Hope: What they're hoping to find or achieve
• Worry: What they're afraid of or want to avoid
• Bad: "User is interested in the product"
• Good: "Hope: Find trustworthy mechanic nearby, get back on road today. Worry: Being stranded for days, getting ripped off by unknown mechanic"
• Length Rule: ONE sentence max per component. Phrases, not paragraphs.

Q5: "What device are they on?"

Mobile, desktop, or tablet. This shapes the entire design approach.

Q6: "What's the natural starting point — how do they actually arrive?"

How the user ACTUALLY gets to the site. Be specific about discovery method.

• Bad: "User opens the website"
• Good: "Googles 'car repair Öland' on mobile while parked at gas station, clicks top organic result"
• Length Rule: 1-2 sentences max. Device + context + discovery method.

Q7: "What does the best possible outcome look like — for both sides?"

Mutual success — user AND business. Both specific and measurable.

• User Success: Tangible outcome the user achieves
• Business Success: Measurable result for the business
• Bad: User: "Successfully use the site" / Business: "Get more customers"
• Good: User: "Confirmed mechanic fixes motorhomes, has location and hours, feels confident calling" / Business: "High-intent tourist call captured, positioned as emergency-capable, info call avoided"

Q8: "What's the shortest path through the site to get there?"

The linear sunshine path. Numbered steps, each with page name + what the user accomplishes.

Rules:

• Completely linear — ZERO "if" statements, ZERO branches
• Minimum viable steps — can you remove any step without breaking the flow?
• Each step moves meaningfully toward success

Format:

1. **[Page Name]** — [What user sees/does/achieves here]
2. **[Page Name]** — [What user sees/does/achieves here]
3. **[Page Name]** — [What user sees/does/achieves here] ✓

4. Name the Scenario

After the 8 questions, name the scenario using the persona:

• Name: Persona name + purpose (e.g., "Hasse's Emergency Search")
• ID: 01, 02, etc.
• Slug: 01-hasses-emergency-search

5. Quality Gates (Check Before Moving On)

Before proceeding, verify the scenario outline:

• [ ] All 8 questions answered with specific, concrete responses
• [ ] Mental state is visceral and specific (not generic "interested")
• [ ] Entry point is realistic with device + context + discovery method
• [ ] Path is truly linear (zero "if" statements)
• [ ] Both successes are specific and measurable (not vague)
• [ ] Scenario name includes persona name
• [ ] Trigger Map connection is explicit (persona + business goal)

If any gate fails: Fix before proceeding.

6. Create the Scenario File

1. Create folder: {output_folder}/C-UX-Scenarios/[NN-slug]/ 2. Create file: {output_folder}/C-UX-Scenarios/[NN-slug]/[NN-slug].md 3. Use the template from data/ to structure the content from the 8 answers

7. After Scenario Creation — Outline Scenario Steps

After the scenario file is saved (Q1-Q8 answered, quality gates passed), begin outlining scenario steps from the Q8 shortest path.

Automatic First Step

Process the first scenario step from Q8 automatically: 1. Name it using Q8's first step name 2. Create the page folder (see Page Folder Structure below) 3. Fill first-step metadata from Q3 (user situation), Q4 (mental state), Q5 (device), Q6 (entry point) 4. Present the result to the user

Then show the Scenario Step Menu.

Scenario Step Menu

After each scenario step is outlined, present:

Step [NN.X] "[step-name]" outlined!

1. Outline next scenario step — [next step name from Q8]
2. Start designing — enter the design loop from step 1

---
[N] Define the next scenario
[C] Continue to overview (when all scenarios are done)

Adaptive labels:

• Option 1 shows the name of the next step from Q8
• When all Q8 steps are outlined: Option 1 becomes unavailable — show "All [X] scenario steps outlined!"
• Option 2: "Start designing" when only 1 step is outlined. "Start designing pages" when 2+ steps are outlined.

Menu Handling Logic:

• IF 1 (Outline next): Ask the two questions for the next step (see Per-Step Dialog below), create the folder, then show this menu again.
• IF 2 (Start designing): Hand over to Phase 4 (UX Design) → Discuss activity. Phase 4 handles the creative dialog (D1, D2) and all design decisions. The design loop always starts from scenario step 1, regardless of how far the outline has progressed.
• IF N: Loop back to instruction 1 for the next scenario. The current scenario's remaining steps can be outlined later.
• IF C: Load, read entire file, then execute {nextStepFile} (only when all planned scenarios are complete).

EXECUTION RULES:

• ALWAYS halt and wait for user input after presenting menu
• User can chat or ask questions — always respond and then redisplay the menu
• The first step is processed automatically after scenario creation (no menu prompt first)

Per-Step Dialog

For each step after the first, refine Q8's outline into a concrete scenario step:

1. "What's the point of this step?"

What does the user need to accomplish here? This becomes the step purpose.

• e.g., "See a list of news articles" or "Find the phone number and opening hours"

2. "What does the user do to move forward?"

What interaction takes them to the next step? This defines the exit action.

• e.g., "Selects 'News' in the menu" → next step
• e.g., "Clicks 'Read more' on an article" → next step

Two types of interactions:

• Leaves the step → new scenario step (new page folder, next number)
• Stays on the step → storyboard item (documented within the page spec as an on-page interaction)

After answering, create the page folder and return to the Scenario Step Menu.

Page Folder Structure

Naming convention: {scenario-number}.{step-number}-{page-slug} (e.g., 1.1-start-page, 1.2-news-listing, 1.3-article-detail)

Each page folder contains:

{NN}.{step}-{page-slug}/
├── {NN}.{step}-{page-slug}.md
└── Sketches/

Page boilerplate:

# {NN}.{step}-{page-name}

## Page Metadata

| Property | Value |
|----------|-------|
| **Scenario** | {scenario-name} |
| **Page Number** | {NN}.{step} |
| **Platform** | {Device from Q5} |

## Overview

**Page Purpose:** {What the user needs to accomplish here}

**Entry Context:** {How the user arrived — previous page + interaction that brought them here}

**Exit Action:** {What the user does to move to the next step}

**On-Page Interactions:**
- {Any interactions that keep the user on this page — storyboard items}

The first step additionally includes:

• User Situation from Q3
• Mental State (hope + worry) from Q4
• Discovery Method from Q6

CRITICAL STEP COMPLETION NOTE

When [C] is selected, ALL scenarios from the approved plan must be outlined and pass quality gates. Then load and read fully {nextStepFile} to begin generating the overview.

When Start designing is selected, hand over to Phase 4 with the current scenario context. The design loop starts from scenario step 1. The user can return to Phase 3 later for remaining scenarios or steps.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All 8 questions answered for each scenario with specific, concrete responses
• All quality gates pass for every scenario
• Scenario outline file created in correct folder structure
• Scenarios processed in priority order (primary transaction first, then secondary, etc.)
• All scenarios from approved plan completed before proceeding
• Conversation mode: Dialog felt like a natural conversation, not a form to fill
• Suggest mode: All 8 answers grounded in actual Trigger Map/Brief data, presented for user review
• First scenario step processed automatically after scenario creation
• User presented with clear two-option flow after each step (outline next / start designing)
• "Start designing" always begins from scenario step 1

❌ SYSTEM FAILURE:

• Skipping any of the 8 strategic questions
• Conversation mode: Presenting all questions at once instead of one at a time
• Suggest mode: Not presenting answers for user review before proceeding
• Proceeding with failing quality gates
• Skipping scenarios from the approved plan
• Using generic mental states or vague success goals
• Creating branching paths instead of linear sunshine paths
• Not creating output files
• Not automatically processing the first scenario step after scenario creation
• Starting the design loop from a step other than step 1
• Presenting the old [N]/[O]/[D]/[C] menu instead of the simplified two-option flow

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 6: Generate Scenario Overview

STEP GOAL:

Create the 00-ux-scenarios.md index file that links all scenarios, includes a coverage matrix, and serves as the master reference for Phase 3 output.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on creating the overview index file with accurate links and data
• 🚫 FORBIDDEN to modify any scenario files during this step
• 💬 Approach: Compile and verify all data from completed scenarios
• 📋 All links must be verified as pointing to correct files

EXECUTION PROTOCOLS:

• 📋 Follow the exact document structure specified
• 🔗 Verify all file links point to correct folders and files
• ✅ Cross-check coverage matrix against actual scenario content
• 🚫 FORBIDDEN to create the file with broken links or missing scenarios

CONTEXT BOUNDARIES:

• Available context: All completed scenario outlines from Step 5
• Focus: Index file creation and link verification
• Limits: No scenario modifications, only index compilation
• Dependencies: All scenarios from Step 5 must be complete

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Create Overview File

Create {output_folder}/C-UX-Scenarios/00-ux-scenarios.md

2. Document Structure

Use the following structure:

# UX Scenarios: [Project Name]

> Scenario outlines connecting Trigger Map personas to concrete user journeys

**Created:** [Date]
**Author:** [user_name] with [Agent Name]
**Method:** Whiteport Design Studio (WDS)

---

## Scenario Summary

| ID | Scenario | Persona | Pages | Priority | Status |
|----|----------|---------|-------|----------|--------|
| 01 | [Name] | [Persona] | [count] | ⭐ P1 | ✅ Outlined |
| 02 | [Name] | [Persona] | [count] | ⭐ P1 | ✅ Outlined |
| 03 | [Name] | [Persona] | [count] | P2 | ✅ Outlined |

---

## Scenarios

### [01: Scenario Name](01-slug/01-slug.md)
**Persona:** [Name] — [Driving Force]
**Pages:** [comma-separated list]
**User Value:** [one line]
**Business Value:** [one line]

---

### [02: Scenario Name](02-slug/02-slug.md)
[Same format...]

---

## Page Coverage Matrix

| Page | Scenario | Purpose in Flow |
|------|----------|----------------|
| [Page 1] | 01 | [What user does here] |
| [Page 2] | 01 | [What user does here] |
| [Page 3] | 02 | [What user does here] |
| ... | ... | ... |

**Coverage:** [X/Y] pages assigned to scenarios

---

## Next Phase

These scenario outlines feed into **Phase 4: UX Design** where each page gets:
- Detailed page specifications
- Wireframe sketches
- Component definitions
- Interaction details

---

_Generated with Whiteport Design Studio framework_

3. Verify Links

• [ ] Each scenario link points to correct folder/file
• [ ] All scenarios from approved plan are listed
• [ ] Page coverage matrix is complete
• [ ] No pages missing from matrix

4. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Quality Review?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [overview file created with all links verified], will you then load and read fully {nextStepFile} to execute and begin quality review.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Overview file created at correct path
• All scenarios listed with accurate data
• All links verified and pointing to correct files
• Coverage matrix complete with all pages
• Document structure follows specification exactly
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Missing scenarios from the overview
• Broken file links
• Incomplete coverage matrix
• Incorrect data (wrong persona, wrong page counts)
• Not verifying links before completing

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 7: Quality Review

STEP GOAL:

Self-review all scenarios against the quality rubric across four dimensions (completeness, quality criteria, mistakes avoided, best practices), fix any failing items, and present a review summary.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on reviewing quality against the rubric — no new content creation
• 🚫 FORBIDDEN to skip any dimension of the quality review
• 💬 Approach: Be honest and thorough in self-review, fix gaps before proceeding
• 📋 Present clear summary with scores for each scenario

EXECUTION PROTOCOLS:

• 📖 Load the full quality checklist before starting review
• ✅ Score each scenario across all four dimensions
• 🔧 Fix any failing items before presenting summary
• 🚫 FORBIDDEN to proceed if minimum thresholds are not met

CONTEXT BOUNDARIES:

• Available context: All completed scenario outlines and overview file
• Focus: Quality verification and gap remediation
• Limits: Only fix quality issues, do not add new scenarios
• Dependencies: All scenarios and overview must be complete from Steps 5-6

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Load Checklist

Load the full checklist: {qualityChecklist}

2. Review Each Scenario

For each scenario, verify these four dimensions:

Dimension 1: Completeness (7 components)

• [ ] Core Feature defined (aligned to business goal)
• [ ] Entry Point realistic (device + context + discovery)
• [ ] Mental State with Trigger/Hope/Worry (all three specific)
• [ ] Success Goals mutual (business + user, both measurable)
• [ ] Shortest Path linear (numbered steps, zero branches)
• [ ] Scenario Name includes persona name + ID assigned
• [ ] Trigger Map Connections explicit (persona, forces, goal)

Score: [X]/7

Dimension 2: Quality Criteria (7 checks)

• [ ] Persona-specific (not generic "user")
• [ ] Mental state is visceral (not "interested" or "curious")
• [ ] Both successes are measurable (not "get more customers")
• [ ] Path has zero "if" statements
• [ ] Minimum viable steps (each step justifies existence)
• [ ] Entry point is realistic (not "user opens app")
• [ ] Business goal connection is explicit (not assumed)

Score: [X]/7

Dimension 3: Mistakes Avoided (6 checks)

• [ ] No edge cases in sunshine path
• [ ] Goal-first, not feature-first naming
• [ ] Mental state present (not just actions)
• [ ] Page descriptions include purpose (not just page name)
• [ ] Uses Trigger Map persona (not invented user)
• [ ] Business value explicitly defined

Score: [X]/6 avoided

Dimension 4: Best Practices (4 checks)

• [ ] Scenario named after persona
• [ ] Started with highest-value persona
• [ ] One job-to-be-done per scenario
• [ ] Driving forces explicitly linked

Score: [X]/4

3. Check Thresholds

Minimum (must meet to proceed):

• Completeness: 6/7
• Quality: 5/7
• Mistakes avoided: 6/6 (all must be avoided)
• Best practices: 2/4

Excellent:

• All scores maxed

4. Fix Failing Items

If any scenario fails: 1. Identify which scenario(s) fail which checks 2. Go back to the scenario file and fix the specific gaps 3. Re-verify after fixing

If still failing after corrections: Note remaining gaps and present to user for guidance.

5. Present Review Summary

## Quality Review Summary

**Scenarios Reviewed:** [N]

| Scenario | Complete | Quality | Mistakes | Practices | Status |
|----------|----------|---------|----------|-----------|--------|
| 01 | 7/7 | 7/7 | 6/6 | 4/4 | ✅ Excellent |
| 02 | 7/7 | 6/7 | 6/6 | 3/4 | ✅ Good |

**Overall:** [Excellent / Good / Needs Work]
**Gaps:** [list any, or "None"]

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Updating the Design Log?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 scenarios meet minimum quality thresholds], will you then load and read fully {nextStepFile} to execute and begin updating the design log.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All scenarios reviewed across all four dimensions
• Quality checklist loaded and applied thoroughly
• Failing items identified and fixed before proceeding
• Clear summary with scores presented to user
• All scenarios meet minimum quality thresholds
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Skipping any review dimension
• Not loading the quality checklist
• Proceeding with scenarios below minimum thresholds
• Not presenting the review summary
• Rubber-stamping without thorough checking

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 8: Update Design Log

STEP GOAL:

Document Phase 3 completion in the project design log, recording all artifacts created, key decisions made, and quality scores achieved.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus only on updating the design log with accurate Phase 3 data
• 🚫 FORBIDDEN to overwrite existing log entries — only append
• 💬 Approach: Be specific and factual in documentation
• 📋 List every artifact file created — no summarizing with "etc."

EXECUTION PROTOCOLS:

• 📖 Read the existing design log before making changes
• 📋 Append progress entry after the last existing entry
• ✅ Record key decisions if any were made during Phase 3
• 🚫 FORBIDDEN to use generic summaries — be specific

CONTEXT BOUNDARIES:

• Available context: All Phase 3 artifacts, quality review results, scenario data
• Focus: Design log documentation only
• Limits: No scenario modifications, only log updates
• Dependencies: Quality review must be complete from Step 7

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Read the Current Log

Read {output_folder}/_progress/00-design-log.md to understand existing entries and format.

2. Append Progress Entry

Add the following under the ## Progress section (after the last entry):

### [date] — Phase 3: UX Scenarios Complete

**Agent:** Saga (Scenario Outline)
**Scenarios:** [N] scenarios covering [N] pages
**Quality:** [Excellent / Good]

**Artifacts Created:**
- `C-UX-Scenarios/00-ux-scenarios.md` — Scenario index
- `C-UX-Scenarios/01-[slug]/01-[slug].md` — [Scenario name]
- [list ALL scenario files created]

**Summary:** [2-3 sentences: what scenarios were created, key design decisions made during the process, page coverage status]

**Next:** Phase 4 — UX Design

Rules:

• List every artifact file — do not summarize with "etc."
• Summary must mention specific decisions, not generic statements
• Use the actual date, not a placeholder

3. Record Key Decisions

Add rows to the ## Key Decisions table for any significant choices made during Phase 3:

| [date] | [decision] | Phase 3: Scenarios | Saga + [user_name] |

Examples of key decisions worth logging:

• Scenario count adjustments (user added/removed scenarios)
• Page assignment changes
• Priority reordering
• Scope decisions (selective ignorance applied)

If no significant decisions were made, skip this section.

4. Verify

• [ ] Progress entry appended (not overwriting existing entries)
• [ ] All artifact files listed
• [ ] Summary is specific, not generic
• [ ] Key decisions recorded (if any)

5. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Handover?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [design log updated with all required information], will you then load and read fully {nextStepFile} to execute and begin the handover process.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Existing log read before making changes
• Progress entry appended (not overwriting)
• All artifact files listed individually
• Summary is specific with concrete decisions mentioned
• Key decisions recorded where applicable
• Verification checklist passes
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Overwriting existing log entries
• Summarizing artifacts with "etc." instead of listing each
• Using generic summary statements
• Not reading existing log first
• Missing artifact files from the list

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Step 9: Handover

STEP GOAL:

Complete Phase 3 by presenting a final summary, guiding the user through design intent selection for each scenario, explaining what comes next in Phase 4, and updating the design log.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 UX Scenario Facilitator collaborating with the project owner
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring scenario thinking and user journey expertise, user brings their project knowledge, together we create concrete UX scenario outlines
• ✅ Maintain collaborative equal-partner tone throughout

Step-Specific Rules:

• 🎯 Focus on completion summary, design intent selection, and handover
• 🚫 FORBIDDEN to end without presenting design intent options for each scenario
• 💬 Approach: Celebrate completion while providing clear next steps
• 📋 Save design intent choices to scenario frontmatter

EXECUTION PROTOCOLS:

• 📋 Present comprehensive completion summary
• 🎯 Guide user through design intent selection per scenario
• 💾 Save design intent and status to scenario files
• 📖 Explain Phase 4 approaches clearly
• 🚫 FORBIDDEN to end workflow without proper completion

CONTEXT BOUNDARIES:

• Available context: All Phase 3 artifacts, quality scores, design log
• Focus: Phase completion and Phase 4 preparation
• Limits: No scenario modifications, only status updates
• Dependencies: Design log must be updated from Step 8

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Present Completion Summary

## Phase 3: UX Scenarios Complete ✓

**Project:** [project_name]
**Scenarios Created:** [N]

### Scenario List
| ID | Name | Persona | Pages | Priority |
|----|------|---------|-------|----------|
| 01 | [Name] | [Persona] | [N] | P1 |
| 02 | [Name] | [Persona] | [N] | P1 |
| ... | ... | ... | ... | ... |

### Coverage
- **Total pages:** [N]
- **Pages in scenarios:** [N]
- **Coverage:** [100% / X%]

### Quality
- **All scenarios pass quality review:** [Yes/No]
- **Overall quality:** [Excellent / Good]

### Files Created
- `C-UX-Scenarios/00-ux-scenarios.md` — Scenario index
- `C-UX-Scenarios/01-[slug]/01-[slug].md` — [Scenario name]
- `C-UX-Scenarios/02-[slug]/02-[slug].md` — [Scenario name]
[list all...]

2. Design Intent Selection

Before handing over to Phase 4, help the user choose a design approach for each scenario.

Present:

Your scenarios are ready for design. How would you like to approach each?

| # | Scenario | Approach |
|---|----------|----------|
| 01 | [Name] | [K] [C] [S] [D] [L] |
| 02 | [Name] | [K] [C] [S] [D] [L] |
| ... | ... | ... |

**Approaches:**
[K] Sketch — I will draw it myself, agent interprets later
[C] Discuss — Creative dialog for page design
[S] Suggest — Agent proposes step by step, I confirm each
[D] Dream Up — Agent creates the whole flow, I review the result
[L] Later — Decide when I start Phase 4

For each scenario, save the chosen approach as design_intent in the scenario output file:

• Add design_intent: [K|C|S|D|L] to the scenario frontmatter
• Add design_status: not-started to track progress

3. What Comes Next

Explain to user:

**Next Steps:**

**Phase 4: UX Design** takes each scenario outline and designs it using your chosen approach:
- **Sketch** scenarios wait for your drawings
- **Discuss** scenarios start with a creative dialog for each page
- **Suggest** scenarios let the agent propose step by step
- **Dream Up** scenarios let the agent create autonomously

You can always change approach in Phase 4.

Would you like to continue to Phase 4, or take a break?

4. Update Design Log (If Exists)

If tracking via design log:

• Mark Phase 3 as complete
• Log scenario count and quality scores
• Note any user adjustments made during the process

5. Present MENU OPTIONS

Display: "[M] Main Menu — Return to workflow start"

Menu Handling Logic:

• IF M: Load, read entire file, then execute {workflowFile}

EXECUTION RULES:

• ALWAYS halt and wait for user input after presenting menu
• ONLY complete workflow when user selects 'M' or indicates they want to stop
• 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 [M main menu option] is selected and [design intent captured for all scenarios], will the workflow end gracefully with Phase 3 complete and Phase 4 prepared.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Comprehensive completion summary presented
• Design intent selection offered for each scenario
• Design intent and status saved to scenario frontmatter
• Phase 4 approaches clearly explained
• Design log updated if applicable
• User informed of next steps
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Not presenting completion summary
• Skipping design intent selection
• Not saving design intent to scenario files
• Ending without explaining next steps
• Not updating design log when one exists

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validation Step 1: Scenario Coverage

STEP GOAL:

Verify that all strategic context chains from the Trigger Map are covered by at least one scenario, with Priority 1 chains having dedicated scenarios.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 Validation Specialist reviewing scenario quality, coverage, and consistency
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring validation expertise and quality standards knowledge, user brings project context, together we ensure scenario quality meets WDS standards
• ✅ Maintain thorough analytical tone throughout

Step-Specific Rules:

• 🎯 Focus only on strategic-context-to-scenario coverage verification
• 🚫 FORBIDDEN to modify any scenario files during validation
• 💬 Approach: Systematic cross-referencing of Trigger Map strategic context against scenarios
• 📋 Report findings with clear severity levels

EXECUTION PROTOCOLS:

• 📖 Load both Trigger Map and all scenario files
• 🔗 Cross-reference every strategic context chain against scenario coverage
• 📊 Report with severity levels (Critical/Warning/Pass)
• 🚫 FORBIDDEN to skip any chain during verification

CONTEXT BOUNDARIES:

• Available context: Trigger Map, all scenario outlines, scenario index
• Focus: Strategic context coverage verification only
• Limits: No scenario modifications, only verification and reporting
• Dependencies: All scenario files must exist from Phase 3 creation workflow

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Load Trigger Map Data

Read {output_folder}/B-Trigger-Map/trigger-map.md and extract all strategic context chains (Business Goal → Persona → Driving Force chains).

2. Load All Scenario Files

Read all scenario outlines from {output_folder}/C-UX-Scenarios/.

3. Cross-Reference

For each strategic context chain, verify:

• [ ] At least one scenario addresses this chain
• [ ] The scenario Trigger Map Connections section explicitly references the strategic context components
• [ ] Priority 1 chains have dedicated scenarios (not just secondary coverage)

4. Generate Report

## Coverage Report

| Chain | Persona | Driving Force | Scenario(s) | Status |
|-----|---------|---------------|-------------|--------|
| [Goal] | [Name] | [Force] | [Scenario ID] | ✅/⚠️/❌ |

**Coverage: [X]/[Total] chains covered ([X]%)
**Gaps: [list uncovered chains]]

Severity:

• ❌ Critical: Priority 1 chain with no scenario
• ⚠️ Warning: Priority 2-3 chain with no scenario
• ✅ Pass: Chain covered by at least one scenario

5. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Navigation Patterns validation?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [coverage report generated with all chains checked], will you then load and read fully {nextStepFile} to execute and begin navigation patterns validation.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All strategic context chains from Trigger Map identified and cross-referenced
• Every chain checked against scenario coverage
• Severity levels correctly assigned
• Coverage report generated with clear gaps identified
• Priority 1 chains verified for dedicated scenario coverage
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Missing any chain from the cross-reference
• Not loading all scenario files
• Incorrect severity assignment
• Not identifying coverage gaps
• Modifying scenario files during validation

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validation Step 2: Navigation Patterns

STEP GOAL:

Verify that all scenario shortest paths follow WDS navigation conventions, page naming is consistent across scenarios, and navigation flows are logical with no impossible jumps or dead ends.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 Validation Specialist reviewing scenario quality, coverage, and consistency
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring validation expertise and quality standards knowledge, user brings project context, together we ensure scenario quality meets WDS standards
• ✅ Maintain thorough analytical tone throughout

Step-Specific Rules:

• 🎯 Focus only on navigation pattern verification and page naming consistency
• 🚫 FORBIDDEN to modify any scenario files during validation
• 💬 Approach: Build a page registry and check for conflicts systematically
• 📋 Report navigation conflicts with specific details

EXECUTION PROTOCOLS:

• 📋 Check page naming consistency across all scenarios
• 🔗 Verify navigation flow rules for each scenario
• 📊 Build cross-scenario page registry
• 🚫 FORBIDDEN to skip any scenario during verification

CONTEXT BOUNDARIES:

• Available context: All scenario outlines with their shortest paths
• Focus: Navigation pattern verification and page naming consistency
• Limits: No scenario modifications, only verification and reporting
• Dependencies: All scenario files must exist

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Page Naming Consistency

For each scenario shortest path:

• [ ] Page names are consistent across scenarios (same page = same name everywhere)
• [ ] Page names are descriptive and user-facing (not technical identifiers)
• [ ] No duplicate page names with different meanings

2. Navigation Flow Rules

For each scenario:

• [ ] Path is truly linear — zero "if" statements, zero branches
• [ ] First step is a landing/entry page (not an internal page)
• [ ] Last step ends with a success state (marked with ✓)
• [ ] Each step transitions naturally to the next (no impossible jumps)
• [ ] No dead ends — every page has a clear next action

3. Cross-Scenario Page Registry

Build a page registry from all scenarios:

## Page Registry

| Page Name | Used In Scenarios | Role |
|-----------|-------------------|------|
| [Name] | 01, 03 | Landing |
| [Name] | 01, 02, 03 | Service Detail |

**Total unique pages:** [N]
**Shared pages:** [N] (appear in 2+ scenarios)

4. Navigation Conflicts

Check for conflicts:

• [ ] No scenario routes FROM the same page TO different pages without clear context
• [ ] Shared pages serve consistent purposes across scenarios
• [ ] Entry points are reachable from the described discovery method

5. Generate Report

## Navigation Pattern Report

**Scenarios checked:** [N]
**Unique pages:** [N]
**Shared pages:** [N]
**Conflicts found:** [N]

[List any issues with severity]

6. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Outline Completeness validation?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [navigation pattern report generated], will you then load and read fully {nextStepFile} to execute and begin outline completeness validation.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All scenario paths checked for navigation rules
• Page naming consistency verified across all scenarios
• Page registry built with shared page tracking
• Navigation conflicts identified and reported
• Report generated with all findings
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Skipping any scenario during navigation check
• Not building the page registry
• Missing navigation conflicts
• Not verifying page naming consistency
• Modifying scenario files during validation

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validation Step 3: Outline Completeness

STEP GOAL:

Verify every scenario outline has all 7 required components with sufficient quality, scoring each component and identifying specific gaps.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 Validation Specialist reviewing scenario quality, coverage, and consistency
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring validation expertise and quality standards knowledge, user brings project context, together we ensure scenario quality meets WDS standards
• ✅ Maintain thorough analytical tone throughout

Step-Specific Rules:

• 🎯 Focus only on validating the 7 required components of each scenario
• 🚫 FORBIDDEN to modify any scenario files during validation
• 💬 Approach: Check each component systematically with specific quality criteria
• 📋 Score each component and provide actionable gap descriptions

EXECUTION PROTOCOLS:

• 📋 Check all 7 components for each scenario
• ✅ Score each component with pass/warning/fail
• 📊 Generate completeness report with specific gaps
• 🚫 FORBIDDEN to skip any component or any scenario

CONTEXT BOUNDARIES:

• Available context: All scenario outlines
• Focus: Component completeness and quality verification
• Limits: No scenario modifications, only verification and reporting
• Dependencies: All scenario files must exist

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Validate Each Scenario

For each scenario, validate all 7 components:

Component 1: Scenario Name & ID

• [ ] Name includes persona name
• [ ] ID assigned (01, 02, etc.)
• [ ] Slug follows format: NN-descriptive-name

Component 2: Core Feature

• [ ] Stated as user purpose (not feature name)
• [ ] Aligned to a specific business goal from Trigger Map

Component 3: Entry Point

• [ ] Device specified (mobile/desktop/tablet)
• [ ] Context described (where user is, what they are doing)
• [ ] Discovery method specified (search, link, ad, bookmark, etc.)
• [ ] Realistic — not "user opens app"

Component 4: Mental State

• [ ] Trigger present and specific (what just happened)
• [ ] Hope present and specific (what they want)
• [ ] Worry present and specific (what they fear)
• [ ] All three are visceral, not generic

Component 5: Success Goals

• [ ] User success defined and measurable
• [ ] Business success defined and measurable
• [ ] Both are specific — not "get more customers"

Component 6: Shortest Path

• [ ] Linear — zero "if" statements
• [ ] Each step has page name + purpose
• [ ] Minimum viable steps (each justifies existence)
• [ ] Final step marked with ✓

Component 7: Trigger Map Connections

• [ ] Persona referenced (with priority level)
• [ ] Positive driving force(s) linked
• [ ] Negative driving force(s) linked
• [ ] Business goal referenced (with objective number)

2. Generate Report

## Outline Completeness Report

| Scenario | Name | Feature | Entry | Mental | Success | Path | TM Links | Score |
|----------|------|---------|-------|--------|---------|------|----------|-------|
| 01 | ✅ | ✅ | ✅ | ⚠️ | ✅ | ✅ | ✅ | 6.5/7 |

**All scenarios complete:** [Yes/No]
**Issues found:** [list specific gaps]

3. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to Cross-Scenario Consistency validation?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [completeness report generated for all scenarios], will you then load and read fully {nextStepFile} to execute and begin cross-scenario consistency validation.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• All 7 components checked for every scenario
• Each component scored with clear pass/warning/fail
• Specific gaps identified with actionable descriptions
• Completeness report generated with scores
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Skipping any component or any scenario
• Not providing specific gap descriptions
• Giving pass scores without thorough checking
• Modifying scenario files during validation
• Not generating the completeness report

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validation Step 4: Cross-Scenario Consistency

STEP GOAL:

Verify scenarios are consistent with each other — no contradictions, proper page sharing, balanced persona and business goal coverage, and no duplicate scenarios.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 Validation Specialist reviewing scenario quality, coverage, and consistency
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring validation expertise and quality standards knowledge, user brings project context, together we ensure scenario quality meets WDS standards
• ✅ Maintain thorough analytical tone throughout

Step-Specific Rules:

• 🎯 Focus only on cross-scenario consistency and balance verification
• 🚫 FORBIDDEN to modify any scenario files during validation
• 💬 Approach: Compare scenarios against each other systematically
• 📋 Check for contradictions, duplicates, and coverage imbalances

EXECUTION PROTOCOLS:

• 🔗 Check shared page consistency across scenarios
• 📊 Verify persona and business goal balance
• 🔍 Identify any duplicate or overlapping scenarios
• ✅ Validate scenario index accuracy
• 🚫 FORBIDDEN to skip any consistency check

CONTEXT BOUNDARIES:

• Available context: All scenario outlines, scenario index, Trigger Map
• Focus: Cross-scenario consistency and balance
• Limits: No scenario modifications, only verification and reporting
• Dependencies: All scenario files and index must exist

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Shared Page Consistency

For pages that appear in multiple scenarios:

• [ ] Same page name = same page purpose everywhere
• [ ] Page descriptions are compatible (not contradictory)
• [ ] If a page serves different personas, it should handle both needs

2. Persona Balance

• [ ] Priority 1 personas have the most scenarios
• [ ] No persona is over-represented relative to their priority
• [ ] Each primary persona has at least one dedicated scenario

3. Business Goal Coverage

• [ ] Each business goal is addressed by at least one scenario
• [ ] High-priority goals have more scenario coverage
• [ ] No business goal is orphaned (referenced but no scenario)

4. Scenario Overlap

Check for:

• [ ] No two scenarios are essentially duplicates (same path, different name)
• [ ] Overlapping scenarios have distinct user intents
• [ ] Shared pages are intentional, not accidental

5. Scenario Index Verification (00-ux-scenarios.md)

• [ ] Index lists all scenarios
• [ ] Priority assignments are consistent with Trigger Map priorities
• [ ] Coverage matrix is accurate
• [ ] Page count matches actual pages in scenarios

6. Generate Report

## Cross-Scenario Consistency Report

**Scenarios analyzed:** [N]
**Shared pages:** [N]
**Contradictions found:** [N]
**Duplicate concerns:** [N]

**Persona coverage:**
| Persona | Priority | Scenarios | Status |
|---------|----------|-----------|--------|
| [Name] | P1 | 01, 03 | ✅ |

**Business goal coverage:**
| Goal | Scenarios | Status |
|------|-----------|--------|
| [Goal] | 01, 02 | ✅ |

7. Present MENU OPTIONS

Display: "Are you ready to [C] Continue to SEO Keyword Alignment validation?"

Menu Handling Logic:

• IF C: Load, read entire file, then execute {nextStepFile}

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 [cross-scenario consistency report generated], will you then load and read fully {nextStepFile} to execute and begin SEO keyword alignment validation.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• Shared page consistency verified across all scenarios
• Persona balance checked against Trigger Map priorities
• Business goal coverage verified
• Scenario overlap and duplicates checked
• Scenario index accuracy verified
• Consistency report generated with all findings
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Skipping any consistency check
• Not verifying the scenario index accuracy
• Missing contradictions between scenarios
• Not checking persona or business goal balance
• Modifying scenario files during validation

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validation Step 5: SEO Keyword Alignment

STEP GOAL:

Verify that scenario pages align with the SEO keyword strategy defined in Phase 1, compile results from all 5 validation steps into a final report, and save the report to the output folder.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• 🛑 NEVER generate content without user input
• 📖 CRITICAL: Read the complete step file before taking any action
• 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
• 📋 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 Validation Specialist reviewing scenario quality, coverage, and consistency
• ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
• ✅ We engage in collaborative dialogue, not command-response
• ✅ You bring validation expertise and quality standards knowledge, user brings project context, together we ensure scenario quality meets WDS standards
• ✅ Maintain thorough analytical tone throughout

Step-Specific Rules:

• 🎯 Focus on SEO keyword alignment and final validation report compilation
• 🚫 FORBIDDEN to modify any scenario files during validation
• 💬 Approach: Check keyword mapping and compile all validation results
• 📋 If no SEO keyword map exists, note as gap and proceed to final report

EXECUTION PROTOCOLS:

• 📖 Load SEO keyword map from Phase 1 output
• 🔗 Map keywords to scenario pages
• 📊 Compile final validation report from all 5 steps
• 💾 Save report to output folder
• 🚫 FORBIDDEN to skip the final report compilation

CONTEXT BOUNDARIES:

• Available context: All scenario outlines, Phase 1 SEO data, results from validation steps 1-4
• Focus: SEO alignment and final report
• Limits: No scenario modifications, only verification and final reporting
• Dependencies: All previous validation steps must be complete

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Load SEO Keyword Map

Load the SEO keyword map from {output_folder}/A-Product-Brief/ (content language section or dedicated SEO strategy file).

If no SEO keyword map exists, note this as a gap and skip to the final report (instruction 5).

2. Page-Keyword Mapping

For each unique page across all scenarios:

• [ ] Page has at least one primary keyword assigned (from Phase 1 keyword map)
• [ ] Keywords match the page user intent (not forced)
• [ ] No two pages compete for the same primary keyword

3. Keyword Coverage

• [ ] All high-priority keywords from Phase 1 map to at least one scenario page
• [ ] Service keywords map to relevant service pages
• [ ] Location keywords map to location-relevant pages
• [ ] Problem keywords map to solution pages

4. URL Slug Alignment

If URL slugs were defined in the keyword map:

• [ ] Scenario page names align with planned URL slugs
• [ ] No naming conflicts between scenario names and SEO slugs

5. SEO Report

## SEO Keyword Alignment Report

**Pages with keywords:** [X]/[Total]
**Keyword conflicts:** [N]
**Unmapped keywords:** [list]

| Page | Primary Keyword | Secondary | Status |
|------|----------------|-----------|--------|
| [Name] | [keyword] | [keywords] | ✅/⚠️/❌ |

**Overall SEO readiness:** [Good / Needs Work / No keyword map]

6. Final Validation Report

Compile results from all 5 validation steps into a summary:

## Phase 3 Validation Report

**Project:** {project_name}
**Date:** [date]
**Scenarios validated:** [N]

### Results Summary
| Check | Status | Issues |
|-------|--------|--------|
| Scenario Coverage | ✅/⚠️/❌ | [summary] |
| Navigation Patterns | ✅/⚠️/❌ | [summary] |
| Outline Completeness | ✅/⚠️/❌ | [summary] |
| Cross-Scenario Consistency | ✅/⚠️/❌ | [summary] |
| SEO Keyword Alignment | ✅/⚠️/❌ | [summary] |

### Critical Issues (must fix)
[list or "None"]

### Warnings (should fix)
[list or "None"]

### Recommendations
[list or "All clear"]

Save report to {output_folder}/C-UX-Scenarios/validation-report.md

7. Present MENU OPTIONS

Display: "[M] Main Menu — Return to workflow start"

Menu Handling Logic:

• IF M: Load, read entire file, then execute {workflowFile}

EXECUTION RULES:

• ALWAYS halt and wait for user input after presenting menu
• ONLY complete workflow when user selects 'M' or indicates they want to stop
• 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 [M main menu option] is selected and [final validation report compiled and saved], will the validation workflow end gracefully with all results documented.

---

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

• SEO keyword map loaded (or gap noted if absent)
• Page-keyword mapping verified for all pages
• Keyword coverage checked against Phase 1 map
• SEO report generated
• Final validation report compiled from all 5 steps
• Report saved to output folder
• Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

• Not checking for SEO keyword map
• Skipping the final validation report compilation
• Not saving the report to output folder
• Missing results from any of the 5 validation steps
• Modifying scenario files during validation

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

Validate UX Scenarios

Goal: Systematically validate all scenario outlines against WDS quality standards and generate an actionable report.

Your Role: Validation specialist reviewing scenario quality, coverage, and consistency.

---

INITIALIZATION

Design Log

Read {output_folder}/_progress/00-design-log.md. Check Current and Backlog for context.

Configuration Loading

Load and read full config from {project-root}/_bmad/wds/config.yaml and resolve:

• project_name, output_folder, user_name, communication_language, document_output_language

Load Scenario Files

Load all scenario files from {output_folder}/C-UX-Scenarios/ and the scenario index 00-ux-scenarios.md.

Route to Validation

Load, read completely, and execute {validateWorkflow} (steps-v/step-01-scenario-coverage.md)

Auto-proceed through all validation steps. Present final report at the end.

---

AFTER COMPLETION

1. Update design log 2. Suggest next action 3. Return to activity menu

Phase 3: UX Scenarios

Goal: Transform the Trigger Map into concrete UX scenario outlines — linear sunshine paths that expose all pages for design scrutiny.

Your Role: UX Scenario Facilitator collaborating with the project owner — you ASK, the user DECIDES. You bring scenario thinking and user journey expertise. Work together as equals.

---

WORKFLOW ARCHITECTURE

This uses step-file architecture for disciplined execution:

Core Principles

• Micro-file Design: Each step is a self-contained instruction file
• Just-In-Time Loading: Only current step file is in memory
• Sequential Enforcement: Steps must be completed in order
• User Checkpoints: Steps 02 and 04 require user approval before proceeding
• Quality Validation: Step 07 validates all scenarios against rubric

Step Processing Rules

1. READ COMPLETELY: Always read entire step file before taking any action 2. FOLLOW SEQUENCE: Execute all sections in order, never deviate 3. LOAD NEXT: When directed, load, read entire file, then execute next step 4. CHECKPOINT: When a step says "wait for user", do NOT auto-proceed

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 follow the exact instructions in step file

Prerequisites

• Phase 1: Product Brief (required)
• Phase 2: Trigger Map (required)

---

Steps

---

INITIALIZATION

1. Configuration Loading

Load and read full config from {project-root}/_bmad/wds/config.yaml and resolve:

• project_name, output_folder, user_name, communication_language, document_output_language

2. Design Log

Read {output_folder}/_progress/00-design-log.md. Check Current and Backlog for context.

3. Mode Determination

Check invocation:

• "validate" / -v → Load and execute ./workflow-validate.md
• Default (create) → Continue to step 3

4. First Step

Load and execute ./steps-c/step-01-load-context.md to begin.

---

REFERENCE CONTENT

---

OUTPUT

• {output_folder}/C-UX-Scenarios/00-ux-scenarios.md — Scenario index with coverage matrix
• {output_folder}/C-UX-Scenarios/NN-[scenario-name]/NN-[scenario-name].md — Individual scenario outlines

---

AFTER COMPLETION

1. Update design log 2. Suggest next action or proceed to Phase 4: UX Design