@dedesfr/prompter 0.6.4 → 0.6.6

package/src/commands/story-generator.ts

@@ -0,0 +1,118 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { PrompterConfig, PROMPTER_DIR, PROMPTER_MARKERS } from '../core/config.js';
+import { registry } from '../core/configurators/slash/index.js';
+
+interface StoryGeneratorOptions {
+    tools?: string[];
+    noInteractive?: boolean;
+}
+
+export class StoryGeneratorCommand {
+    async execute(options: StoryGeneratorOptions = {}): Promise<void> {
+        const projectPath = process.cwd();
+
+        // Check if initialized
+        if (!await PrompterConfig.prompterDirExists(projectPath)) {
+            console.log(chalk.red('\n❌ Prompter is not initialized in this project.\n'));
+            console.log(chalk.gray('   Run `prompter init` first.\n'));
+            process.exitCode = 1;
+            return;
+        }
+
+        console.log(chalk.blue('\n📝 Generating Story Generator workflow files...\n'));
+
+        // Detect currently configured tools
+        const configuredTools = await this.detectConfiguredTools(projectPath);
+        
+        if (configuredTools.length === 0) {
+            console.log(chalk.yellow('⚠️  No tools configured yet.\n'));
+            console.log(chalk.gray('   Run `prompter init` to configure AI tools first.\n'));
+            process.exitCode = 1;
+            return;
+        }
+
+        // Generate story-generator workflow files for all configured tools
+        let successCount = 0;
+        let failCount = 0;
+
+        for (const toolId of configuredTools) {
+            const configurator = registry.get(toolId);
+            if (configurator) {
+                try {
+                    // Generate only the story-generator workflow file
+                    const body = configurator['getBody']('story-generator');
+                    const relativePath = configurator['getRelativePath']('story-generator');
+                    const filePath = path.join(projectPath, relativePath);
+                    
+                    // Ensure directory exists
+                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                    
+                    // Check if file exists
+                    const fileExists = await this.fileExists(filePath);
+                    
+                    if (fileExists) {
+                        console.log(chalk.yellow('⚠️') + ` ${chalk.cyan(relativePath)} already exists, skipping`);
+                        continue;
+                    }
+                    
+                    // Get frontmatter if needed
+                    const frontmatter = configurator['getFrontmatter']('story-generator');
+                    const sections: string[] = [];
+                    if (frontmatter) {
+                        sections.push(frontmatter.trim());
+                    }
+                    sections.push(`${PROMPTER_MARKERS.start}\n${body}\n${PROMPTER_MARKERS.end}`);
+                    const content = sections.join('\n') + '\n';
+                    
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    console.log(chalk.green('✓') + ` Created ${chalk.cyan(relativePath)}`);
+                    successCount++;
+                } catch (error) {
+                    console.log(chalk.red('✗') + ` Failed to create files for ${toolId}: ${error}`);
+                    failCount++;
+                }
+            }
+        }
+
+        // Success message
+        console.log(chalk.green(`\n✅ Story Generator workflow files created successfully!\n`));
+        console.log(chalk.blue('Next steps:'));
+        console.log(chalk.gray('  1. Use /story-generator in your AI tool to generate user stories'));
+        console.log(chalk.gray('  2. Stories will be saved to prompter/<slug>/stories.md\n'));
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private async detectConfiguredTools(projectPath: string): Promise<string[]> {
+        const configuredTools: string[] = [];
+        const allConfigurators = registry.getAll();
+
+        for (const configurator of allConfigurators) {
+            const targets = configurator.getTargets();
+            let hasFiles = false;
+
+            for (const target of targets) {
+                const filePath = path.join(projectPath, target.path);
+                if (await this.fileExists(filePath)) {
+                    hasFiles = true;
+                    break;
+                }
+            }
+
+            if (hasFiles) {
+                configuredTools.push(configurator.toolId);
+            }
+        }
+
+        return configuredTools;
+    }
+}

package/src/core/config.ts

@@ -56,6 +56,12 @@ export const AVAILABLE_PROMPTS: PromptChoice[] = [
         description: 'Generate comprehensive epic documentation',
         sourceFile: 'epic-single.md'
     },
+    {
+        name: 'Epic Generator',
+        value: 'epic-generator',
+        description: 'Generate comprehensive EPICs from FSD and TDD documentation',
+        sourceFile: 'epic-generator.md'
+    },
     {
         name: 'ERD Generator',
         value: 'erd-generator',
@@ -104,6 +110,12 @@ export const AVAILABLE_PROMPTS: PromptChoice[] = [
         description: 'Generate detailed user story documentation',
         sourceFile: 'story-single.md'
     },
+    {
+        name: 'Story Generator',
+        value: 'story-generator',
+        description: 'Generate comprehensive user stories from EPICs and FSD',
+        sourceFile: 'story-generator.md'
+    },
     {
         name: 'TDD Generator',
         value: 'tdd-generator',

package/src/core/configurators/slash/antigravity.ts

@@ -7,7 +7,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.agent/workflows/prd-agent-generator.md',
     'product-brief': '.agent/workflows/product-brief.md',
     'epic-single': '.agent/workflows/epic-single.md',
+    'epic-generator': '.agent/workflows/epic-generator.md',
     'story-single': '.agent/workflows/story-single.md',
+    'story-generator': '.agent/workflows/story-generator.md',
     'qa-test-scenario': '.agent/workflows/qa-test-scenario.md',
     'skill-creator': '.agent/workflows/skill-creator.md',
     'ai-humanizer': '.agent/workflows/ai-humanizer.md',
@@ -26,7 +28,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/configurators/slash/base.ts

@@ -9,7 +9,7 @@ export interface SlashCommandTarget {
     kind: 'slash';
 }
 
-const ALL_COMMANDS: SlashCommandId[] = ['enhance', 'prd-generator', 'prd-agent-generator', 'product-brief', 'epic-single', 'story-single', 'qa-test-scenario', 'skill-creator', 'ai-humanizer', 'api-contract-generator', 'erd-generator', 'fsd-generator', 'tdd-generator', 'tdd-lite-generator', 'wireframe-generator', 'document-explainer'];
+const ALL_COMMANDS: SlashCommandId[] = ['enhance', 'prd-generator', 'prd-agent-generator', 'product-brief', 'epic-single', 'epic-generator', 'story-single', 'story-generator', 'qa-test-scenario', 'skill-creator', 'ai-humanizer', 'api-contract-generator', 'erd-generator', 'fsd-generator', 'tdd-generator', 'tdd-lite-generator', 'wireframe-generator', 'document-explainer'];
 
 export abstract class SlashCommandConfigurator {
     abstract readonly toolId: string;

package/src/core/configurators/slash/claude.ts

@@ -7,7 +7,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.claude/commands/prompter/prd-agent-generator.md',
     'product-brief': '.claude/commands/prompter/product-brief.md',
     'epic-single': '.claude/commands/prompter/epic-single.md',
+    'epic-generator': '.claude/commands/prompter/epic-generator.md',
     'story-single': '.claude/commands/prompter/story-single.md',
+    'story-generator': '.claude/commands/prompter/story-generator.md',
     'qa-test-scenario': '.claude/commands/prompter/qa-test-scenario.md',
     'skill-creator': '.claude/commands/prompter/skill-creator.md',
     'ai-humanizer': '.claude/commands/prompter/ai-humanizer.md',
@@ -26,7 +28,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/configurators/slash/codex.ts

@@ -7,7 +7,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.codex/prompts/prd-agent-generator.md',
     'product-brief': '.codex/prompts/product-brief.md',
     'epic-single': '.codex/prompts/epic-single.md',
+    'epic-generator': '.codex/prompts/epic-generator.md',
     'story-single': '.codex/prompts/story-single.md',
+    'story-generator': '.codex/prompts/story-generator.md',
     'qa-test-scenario': '.codex/prompts/qa-test-scenario.md',
     'skill-creator': '.codex/prompts/skill-creator.md',
     'ai-humanizer': '.codex/prompts/ai-humanizer.md',
@@ -26,7 +28,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/configurators/slash/github-copilot.ts

@@ -10,7 +10,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.github/prompts/prd-agent-generator.prompt.md',
     'product-brief': '.github/prompts/product-brief.prompt.md',
     'epic-single': '.github/prompts/epic-single.prompt.md',
+    'epic-generator': '.github/prompts/epic-generator.prompt.md',
     'story-single': '.github/prompts/story-single.prompt.md',
+    'story-generator': '.github/prompts/story-generator.prompt.md',
     'qa-test-scenario': '.github/prompts/qa-test-scenario.prompt.md',
     'skill-creator': '.github/prompts/skill-creator.prompt.md',
     'ai-humanizer': '.github/prompts/ai-humanizer.prompt.md',
@@ -29,7 +31,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/configurators/slash/kilocode.ts

@@ -7,7 +7,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.kilocode/workflows/prd-agent-generator.md',
     'product-brief': '.kilocode/workflows/product-brief.md',
     'epic-single': '.kilocode/workflows/epic-single.md',
+    'epic-generator': '.kilocode/workflows/epic-generator.md',
     'story-single': '.kilocode/workflows/story-single.md',
+    'story-generator': '.kilocode/workflows/story-generator.md',
     'qa-test-scenario': '.kilocode/workflows/qa-test-scenario.md',
     'skill-creator': '.kilocode/workflows/skill-creator.md',
     'ai-humanizer': '.kilocode/workflows/ai-humanizer.md',
@@ -26,7 +28,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/configurators/slash/opencode.ts

@@ -7,7 +7,9 @@ const FILE_PATHS: Record<SlashCommandId, string> = {
     'prd-agent-generator': '.opencode/command/prd-agent-generator.md',
     'product-brief': '.opencode/command/product-brief.md',
     'epic-single': '.opencode/command/epic-single.md',
+    'epic-generator': '.opencode/command/epic-generator.md',
     'story-single': '.opencode/command/story-single.md',
+    'story-generator': '.opencode/command/story-generator.md',
     'qa-test-scenario': '.opencode/command/qa-test-scenario.md',
     'skill-creator': '.opencode/command/skill-creator.md',
     'ai-humanizer': '.opencode/command/ai-humanizer.md',
@@ -26,7 +28,9 @@ const DESCRIPTIONS: Record<SlashCommandId, string> = {
     'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
     'product-brief': 'Generate an executive-level product brief (1-page summary)',
     'epic-single': 'Generate a single well-defined Jira Epic',
+    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
     'story-single': 'Generate a single Jira User Story from requirements',
+    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
     'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
     'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
     'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',

package/src/core/prompt-templates.ts

@@ -1443,6 +1443,352 @@ The story must:
 Return **ONLY the completed story in Markdown**, nothing else.
 `;
 
+export const EPIC_GENERATOR_TEMPLATE = `# EPIC Generation Prompt
+
+# Role & Expertise
+You are a Senior Product Owner and Business Analyst with 10+ years of experience in Agile software development. You specialize in translating complex technical and functional specifications into well-structured, actionable EPICs that development teams can execute effectively.
+
+# Context
+You will analyze project documentation to extract and generate comprehensive EPICs for agile project planning. The primary sources are the Functional Specification Document (FSD) and Technical Design Document (TDD), with UI Wireframes serving as supplementary reference for user-facing features.
+
+# Primary Objective
+Generate a complete set of EPICs that capture all major feature areas, business capabilities, and technical deliverables defined in the provided documentation. Each EPIC must be traceable to source requirements and sized appropriately for sprint planning decomposition.
+
+# Input Documents
+1. **FSD (Functional Specification Document)** - PRIMARY
+   - Business requirements and functional capabilities
+   - User workflows and business rules
+   - Acceptance criteria foundations
+
+2. **TDD (Technical Design Document)** - PRIMARY
+   - System architecture components
+   - Integration points and APIs
+   - Technical constraints and dependencies
+
+3. **UI Wireframes** - SUPPLEMENTARY
+   - User interface flows
+   - Screen-level functionality
+   - User interaction patterns
+
+# Process
+
+## Phase 1: Document Analysis
+1. Extract all functional requirements from FSD
+   - Identify business capabilities
+   - Map user journeys and workflows
+   - Note business rules and validations
+2. Extract technical components from TDD
+   - Identify system modules and services
+   - Map integration dependencies
+   - Note technical constraints
+3. Cross-reference UI Wireframes
+   - Link screens to functional requirements
+   - Identify user-facing features
+   - Note UI-specific requirements
+
+## Phase 2: EPIC Identification
+1. Group related requirements into logical feature areas
+2. Identify natural boundaries based on:
+   - Business domain separation
+   - Technical component boundaries
+   - User journey completeness
+   - Dependency chains
+3. Validate each EPIC can be independently deliverable
+
+## Phase 3: EPIC Definition
+For each identified EPIC, define:
+- Clear business value statement
+- Scope boundaries (in/out)
+- High-level acceptance criteria
+- Dependencies and prerequisites
+- Estimated complexity tier
+
+## Phase 4: Validation
+1. Verify complete coverage of all requirements
+2. Check for gaps between documents
+3. Identify any conflicting requirements
+4. Flag assumptions made
+
+# Output Format
+
+## Executive Summary
+- Total EPICs identified: [number]
+- Complexity distribution: [High/Medium/Low counts]
+- Key dependencies identified: [summary]
+- Coverage gaps or conflicts: [if any]
+
+## EPIC Catalog
+
+### EPIC-[XXX]: [EPIC Title]
+
+**Business Value Statement:**
+[2-3 sentences describing the business outcome and user benefit]
+
+**Description:**
+[Detailed description of what this EPIC delivers]
+
+**Source Traceability:**
+| Document | Reference | Section/Page |
+|----------|-----------|--------------|
+| FSD | [Requirement ID] | [Location] |
+| TDD | [Component/Section] | [Location] |
+| Wireframe | [Screen Name] | [If applicable] |
+
+**Scope Definition:**
+| In Scope | Out of Scope |
+|----------|--------------|
+| [Item 1] | [Item 1] |
+| [Item 2] | [Item 2] |
+
+**High-Level Acceptance Criteria:**
+- [ ] [Criterion 1]
+- [ ] [Criterion 2]
+- [ ] [Criterion 3]
+- [ ] [Criterion 4]
+
+**Dependencies:**
+- **Prerequisite EPICs:** [EPIC-XXX, EPIC-XXX] or None
+- **External Dependencies:** [Systems, teams, data]
+- **Technical Prerequisites:** [Infrastructure, APIs, etc.]
+
+**Complexity Assessment:**
+- **Size:** [S / M / L / XL]
+- **Technical Complexity:** [Low / Medium / High]
+- **Integration Complexity:** [Low / Medium / High]
+- **Estimated Story Count:** [Range]
+
+**Risks & Assumptions:**
+- **Assumptions:** [List key assumptions]
+- **Risks:** [List identified risks]
+
+---
+
+[Repeat for each EPIC]
+
+## Dependency Map
+
+[Visual or text representation of EPIC dependencies]
+EPIC-001 ──► EPIC-003
+EPIC-002 ──► EPIC-003
+EPIC-003 ──► EPIC-005
+
+## Traceability Matrix
+| Requirement ID | FSD Section | TDD Component | Wireframe | EPIC |
+|----------------|-------------|---------------|-----------|------|
+| [REQ-001] | [Section] | [Component] | [Screen] | [EPIC-XXX] |
+
+## Gaps & Recommendations
+1. **Identified Gaps:** [Requirements not fully covered]
+2. **Conflicts Found:** [Contradictions between documents]
+3. **Recommendations:** [Suggested clarifications needed]
+
+# Quality Standards
+- Every functional requirement must map to at least one EPIC
+- Each EPIC must have clear, measurable acceptance criteria
+- Dependencies must form a valid directed acyclic graph (no circular dependencies)
+- EPIC sizing should allow decomposition into 5-15 user stories
+- Business value must be articulated in user/business terms, not technical terms
+- All assumptions must be explicitly stated
+
+# Special Instructions
+- If FSD and TDD conflict, note the conflict and use FSD as the authority for functional scope
+- If wireframes show features not in FSD/TDD, flag as "Potential Scope Addition"
+- Group infrastructure/DevOps requirements into dedicated technical EPICs
+- Non-functional requirements (security, performance) should be integrated into relevant EPICs AND have a dedicated NFR EPIC if substantial
+- Use consistent naming convention: EPIC-[3-digit number]: [Verb] [Object] [Qualifier]
+
+# Verification Checklist
+After generating EPICs, verify:
+- [ ] 100% of FSD functional requirements are covered
+- [ ] All TDD components have corresponding EPICs
+- [ ] No orphaned wireframe screens
+- [ ] Dependency chain is logical and achievable
+- [ ] Each EPIC is independently valuable
+- [ ] Complexity assessments are consistent
+- [ ] Traceability is complete and accurate
+`;
+
+export const STORY_GENERATOR_TEMPLATE = `# Story Generation Prompt
+
+# Role & Expertise
+You are a Senior Business Analyst and Agile Product Owner with 10+ years of experience translating functional specifications into well-structured user stories. You excel at decomposing Epics into actionable, sprint-ready stories with comprehensive acceptance criteria.
+
+# Context
+You will receive two primary inputs:
+1. **Epics** (Primary Resource) - High-level feature descriptions defining the scope
+2. **FSD (Functional Specification Document)** (Secondary Resource) - Detailed functional requirements, business rules, and technical specifications
+
+Your task is to synthesize these inputs into complete, development-ready user stories.
+
+# Primary Objective
+Generate comprehensive user stories from provided Epics, enriched with details from the FSD, following industry-standard Agile practices.
+
+# Process
+1. **Epic Analysis**
+   - Identify the core business value and user need
+   - Determine story boundaries and natural decomposition points
+   - Map dependencies between potential stories
+
+2. **FSD Integration**
+   - Extract relevant functional requirements for each story
+   - Identify business rules that impact acceptance criteria
+   - Note technical constraints and integration points
+   - Pull UI/UX specifications where applicable
+
+3. **Story Construction**
+   - Write clear user story statements
+   - Define comprehensive acceptance criteria
+   - Add technical notes and dependencies
+   - Estimate relative complexity
+
+4. **Quality Verification**
+   - Ensure stories follow INVEST principles
+   - Verify traceability back to Epic and FSD
+   - Confirm acceptance criteria are testable
+
+# Input Specifications
+**Epic Format Expected:**
+- Epic ID/Name
+- Description/Goal
+- Business Value
+- Scope boundaries (in/out)
+
+**FSD Format Expected:**
+- Functional requirements
+- Business rules
+- User flows/workflows
+- Data requirements
+- Integration specifications
+- UI/UX requirements (if available)
+
+# Output Requirements
+
+For each Epic, generate stories in this exact format:
+
+---
+
+## Epic: [Epic Name/ID]
+
+### Story [Number]: [Concise Story Title]
+
+**User Story:**
+As a [specific user role],
+I want to [action/capability],
+So that [business value/outcome].
+
+**Description:**
+[2-3 sentences providing additional context, referencing FSD sections where applicable]
+
+**Acceptance Criteria:**
+\`\`\`gherkin
+GIVEN [precondition/context]
+WHEN [action/trigger]
+THEN [expected outcome]
+
+GIVEN [precondition/context]
+WHEN [alternative action]
+THEN [expected outcome]
+\`\`\`
+
+**Business Rules:**
+- BR-1: [Rule from FSD]
+- BR-2: [Rule from FSD]
+
+**Technical Notes:**
+- [Integration requirements]
+- [Data considerations]
+- [API/System dependencies]
+
+**FSD Reference:** [Section/Requirement IDs traced from FSD]
+
+**Dependencies:** [Other story IDs or external dependencies]
+
+**Story Points:** [Fibonacci estimate: 1, 2, 3, 5, 8, 13]
+
+**Priority:** [Must Have / Should Have / Could Have / Won't Have]
+
+---
+
+# Quality Standards
+- **INVEST Compliant:** Each story must be Independent, Negotiable, Valuable, Estimable, Small, Testable
+- **Acceptance Criteria:** Minimum 3 criteria per story, written in Gherkin format (Given/When/Then)
+- **Traceability:** Every story must reference source Epic and relevant FSD sections
+- **Granularity:** Stories should be completable within a single sprint (typically 1-8 story points)
+- **Completeness:** Include edge cases and error scenarios in acceptance criteria
+
+# Special Instructions
+1. **Decomposition Rules:**
+   - If an Epic contains multiple user roles, create separate stories per role
+   - If workflows have distinct phases, split into sequential stories
+   - CRUD operations should be separate stories unless trivially simple
+
+2. **Acceptance Criteria Guidelines:**
+   - Include happy path scenarios
+   - Include at least one error/edge case scenario
+   - Include validation rules from FSD
+   - Make criteria specific and measurable
+
+3. **When FSD Details Are Missing:**
+   - Flag with "[CLARIFICATION NEEDED]" tag
+   - Provide reasonable assumption with "[ASSUMPTION]" tag
+   - Continue with story generation
+
+4. **Output Organization:**
+   - Group stories by Epic
+   - Order stories by logical implementation sequence
+   - Highlight cross-Epic dependencies
+
+# Example Output
+
+## Epic: User Authentication
+
+### Story 1: User Login with Email
+
+**User Story:**
+As a registered user,
+I want to log in using my email and password,
+So that I can access my personalized dashboard securely.
+
+**Description:**
+Enable standard email/password authentication as specified in FSD Section 3.2. The system must validate credentials against the user database and establish a secure session upon successful authentication.
+
+**Acceptance Criteria:**
+\`\`\`gherkin
+GIVEN I am on the login page
+WHEN I enter valid email and password and click "Login"
+THEN I am redirected to my dashboard and see a welcome message
+
+GIVEN I am on the login page
+WHEN I enter invalid credentials and click "Login"
+THEN I see an error message "Invalid email or password" and remain on login page
+
+GIVEN I have failed login 5 times
+WHEN I attempt to login again
+THEN my account is temporarily locked for 15 minutes per BR-AUTH-03
+\`\`\`
+
+**Business Rules:**
+- BR-AUTH-01: Passwords must be minimum 8 characters
+- BR-AUTH-03: Account lockout after 5 failed attempts
+
+**Technical Notes:**
+- Integrate with OAuth 2.0 service (per FSD 3.2.4)
+- Session timeout: 30 minutes of inactivity
+- Password hashing: bcrypt with salt
+
+**FSD Reference:** Section 3.2, Requirements FR-AUTH-001 through FR-AUTH-008
+
+**Dependencies:** None (foundational story)
+
+**Story Points:** 5
+
+**Priority:** Must Have
+
+---
+
+Now process the provided Epic(s) and FSD to generate comprehensive user stories.
+`;
+
 export const API_CONTRACT_GENERATOR_TEMPLATE = `# API Contract Generator Prompt
 
 # Role & Expertise
@@ -2725,6 +3071,7 @@ export const PROMPT_TEMPLATES: Record<string, string> = {
    'ai-humanizer': AI_HUMANIZER_TEMPLATE,
    'api-contract-generator': API_CONTRACT_GENERATOR_TEMPLATE,
    'document-explainer': DOCUMENT_EXPLAINER_TEMPLATE,
+   'epic-generator': EPIC_GENERATOR_TEMPLATE,
    'epic-single': EPIC_SINGLE_TEMPLATE,
    'erd-generator': ERD_GENERATOR_TEMPLATE,
    'fsd-generator': FSD_GENERATOR_TEMPLATE,
@@ -2733,6 +3080,7 @@ export const PROMPT_TEMPLATES: Record<string, string> = {
    'product-brief': PRODUCT_BRIEF_TEMPLATE,
    'qa-test-scenario': QA_TEST_SCENARIO_TEMPLATE,
    'skill-creator': SKILL_CREATOR_TEMPLATE,
+   'story-generator': STORY_GENERATOR_TEMPLATE,
    'story-single': STORY_SINGLE_TEMPLATE,
    'tdd-generator': TDD_GENERATOR_TEMPLATE,
    'tdd-lite-generator': TDD_LITE_GENERATOR_TEMPLATE,