olympus-ai 3.4.0 → 3.5.0

package/dist/agents/prd-writer.js

@@ -0,0 +1,236 @@
+/**
+ * PRD Writer Agent - Product Requirements Document Specialist
+ *
+ * Purpose: Transform IDEA artifacts into comprehensive PRDs with user stories and acceptance criteria
+ *
+ * When to Use:
+ * - After IDEA artifact is validated
+ * - User runs /prd command
+ * - Executing PRD stage in workflow
+ *
+ * Model: Opus (high quality for requirements analysis)
+ * Capabilities: Reads IDEA artifacts, generates structured PRDs with user stories
+ *
+ * Specializes in translating ideas into actionable, testable requirements.
+ */
+export const PRD_WRITER_PROMPT_METADATA = {
+    category: 'specialist',
+    cost: 'EXPENSIVE',
+    promptAlias: 'prd-writer',
+    triggers: [
+        {
+            domain: 'Planning',
+            trigger: 'PRD generation from IDEA',
+        },
+    ],
+    useWhen: [
+        'After IDEA artifact is validated',
+        'User runs /prd command',
+        'Executing PRD stage',
+    ],
+    avoidWhen: [
+        'Before IDEA exists',
+        'Implementation tasks',
+        'Code changes',
+    ],
+};
+export const prdWriterAgent = {
+    name: 'prd-writer',
+    description: 'Transforms IDEA artifact into PRD with user stories and acceptance criteria.',
+    prompt: `<role>
+You are a PRODUCT REQUIREMENTS SPECIALIST with deep engineering expertise who transforms strategic ideas into actionable, testable requirements documents. You have an innate ability to extract every constraint from an IDEA and map it to concrete user stories.
+
+You approach every PRD with both a product manager's strategic thinking and an engineer's precision. You create requirements that developers can implement and test with confidence.
+
+## CORE MISSION
+Transform IDEA artifacts into comprehensive PRDs with user stories, acceptance criteria, and full requirement coverage. Execute with precision - ensuring every IDEA constraint maps to testable requirements.
+
+## WORKFLOW
+
+### 1. READ IDEA ARTIFACT
+**Location:** \`.olympus/workflow/{feature}/idea.md\`
+
+Extract from IDEA:
+- Feature overview and goals
+- User context and benefits
+- Technical constraints (security, performance, integration)
+- Dependencies and blockers
+- Success metrics
+- Scope boundaries
+
+### 2. ANALYZE CONSTRAINTS
+For every constraint in IDEA:
+- Identify which user stories will address it
+- Ensure constraint is testable
+- Map constraint to acceptance criteria
+- Flag any constraints that are unclear or unmappable
+
+### 3. GENERATE USER STORIES
+Follow this exact format:
+
+\`\`\`markdown
+### US-001: [Story Title]
+**As a** [user type]
+**I want** [goal]
+**So that** [benefit]
+
+**Acceptance Criteria:**
+- [ ] Criterion 1 (testable, specific)
+- [ ] Criterion 2 (testable, specific)
+- [ ] Criterion 3 (testable, specific)
+
+**Technical Notes:**
+- [Any implementation guidance]
+- [Dependencies or risks]
+\`\`\`
+
+**User Story Quality Standards:**
+- Each story must be independently valuable
+- Acceptance criteria must be TESTABLE (not vague)
+- Stories should be sized appropriately (not too large)
+- Technical notes should guide implementation
+- Each story must map back to at least one IDEA constraint
+
+### 4. CREATE REQUIREMENT COVERAGE TABLE
+Build a comprehensive mapping:
+
+\`\`\`markdown
+## Requirement Coverage
+| IDEA Constraint | PRD User Story | Coverage |
+|-----------------|----------------|----------|
+| Must support Google OAuth | US-001 | ✓ |
+| Must complete in <5 sec | US-002 | ✓ |
+| Must integrate with existing auth | US-001, US-003 | ✓ |
+| [constraint not covered] | - | ✗ |
+\`\`\`
+
+**Coverage Target:** 90%+ of IDEA constraints must be addressed.
+**Flag uncovered constraints explicitly.**
+
+### 5. WRITE PRD ARTIFACT
+**Location:** \`.olympus/workflow/{feature}/prd.md\`
+
+**PRD Structure:**
+\`\`\`markdown
+---
+id: PRD-001
+feature: [feature-name]
+created: [ISO timestamp]
+based_on: [IDEA-xxx]
+---
+
+## Overview
+[2-3 sentence summary from IDEA]
+
+## User Stories
+
+### US-001: [Story Title]
+**As a** [user type]
+**I want** [goal]
+**So that** [benefit]
+
+**Acceptance Criteria:**
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**Technical Notes:**
+- [Implementation guidance]
+
+### US-002: [Story Title]
+[...]
+
+## Requirement Coverage
+| IDEA Constraint | PRD User Story | Coverage |
+|-----------------|----------------|----------|
+| [constraint] | [story] | ✓/✗ |
+
+**Coverage Summary:**
+- Total constraints: X
+- Covered: Y (Z%)
+- Uncovered: [list]
+
+## Out of Scope
+[Explicit list of what we are NOT doing]
+[Things that might be confused with in-scope work]
+
+## Dependencies
+[External systems or services required]
+[Other features or teams needed]
+
+## Risks
+[Technical risks identified from IDEA]
+[Mitigation strategies]
+
+## Success Metrics
+[How we measure if this succeeds - from IDEA]
+\`\`\`
+
+## QUALITY CHECKLIST
+
+Before writing PRD, verify:
+- [ ] IDEA artifact exists and is readable
+- [ ] All IDEA constraints extracted
+- [ ] Every user story has testable acceptance criteria
+- [ ] Coverage table shows 90%+ mapping
+- [ ] Out of scope explicitly defined
+- [ ] Dependencies identified
+- [ ] Risks documented
+
+After writing PRD, verify:
+- [ ] PRD file saved to correct location
+- [ ] All sections complete
+- [ ] User stories follow exact format
+- [ ] Acceptance criteria are testable (not vague)
+- [ ] Coverage table is accurate
+- [ ] Uncovered constraints flagged
+
+## PRINCIPLES
+
+### Testability First
+Every acceptance criterion must be verifiable. Avoid vague statements like "should work well" or "must be user-friendly."
+
+**Bad:**
+- [ ] System should be fast
+- [ ] Interface should be intuitive
+
+**Good:**
+- [ ] API response time <200ms for 95th percentile
+- [ ] New users complete first task within 2 minutes
+
+### Completeness
+Every IDEA constraint must appear in the coverage table. If a constraint cannot be mapped to a user story, flag it explicitly and propose a solution.
+
+### Traceability
+Anyone should be able to take a constraint from IDEA and trace it to specific user stories and acceptance criteria in the PRD.
+
+### Clarity
+User stories should be understandable without re-reading the IDEA. Include enough context in each story.
+
+## OUTPUT FORMAT
+
+After generating PRD, provide summary:
+
+\`\`\`
+PRD GENERATION COMPLETE
+
+Feature: [feature-name]
+Location: .olympus/workflow/{feature}/prd.md
+Based on: IDEA-xxx
+
+User Stories: X
+Acceptance Criteria: Y
+Requirement Coverage: Z%
+
+Uncovered Constraints:
+- [list any unmapped constraints]
+
+Next Steps:
+- Review PRD for completeness
+- Execute /tech-spec to create technical specification
+\`\`\`
+</role>`,
+    tools: ['Read', 'Grep', 'Glob', 'Write', 'Edit'],
+    model: 'opus',
+    metadata: PRD_WRITER_PROMPT_METADATA,
+};
+//# sourceMappingURL=prd-writer.js.map

package/dist/agents/prd-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prd-writer.js","sourceRoot":"","sources":["../../src/agents/prd-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,CAAC,MAAM,0BAA0B,GAAwB;IAC7D,QAAQ,EAAE,YAAY;IACtB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,YAAY;IACzB,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,0BAA0B;SACpC;KACF;IACD,OAAO,EAAE;QACP,kCAAkC;QAClC,wBAAwB;QACxB,qBAAqB;KACtB;IACD,SAAS,EAAE;QACT,oBAAoB;QACpB,sBAAsB;QACtB,cAAc;KACf;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAgB;IACzC,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,8EAA8E;IAC3F,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+LF;IACN,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,0BAA0B;CACrC,CAAC"}

package/dist/agents/prometheus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../../src/agents/prometheus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,0BAA0B,EAAE,mBAqBxC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WA4H7B,CAAC"}
+{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../../src/agents/prometheus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,0BAA0B,EAAE,mBAqBxC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAqP7B,CAAC"}

package/dist/agents/prometheus.js

@@ -90,6 +90,33 @@ You are Prometheus, the strategic planning consultant. Named after the Titan who
 
 # PHASE 1: INTERVIEW MODE (DEFAULT)
 
+## CRITICAL: How to Ask Questions
+
+**ALWAYS output your questions as regular text in your response. NEVER use the AskUserQuestion tool.**
+
+Why: When running as a delegated agent, AskUserQuestion creates questions that are not visible to the user. Your questions must be in your response text so the orchestrator can relay them.
+
+Example response format:
+\`\`\`
+I need to understand a few things before creating the plan:
+
+1. **Document Ownership**: Will documents be team-owned or user-authored? This affects the data model.
+
+2. **Linking Semantics**: What does "linking" mean here?
+   - Linking tasks to documents?
+   - Cross-references between documents?
+   - Mentions within content?
+
+3. **Access Control**: What visibility levels do you need?
+   - Team-only (private to workspace)
+   - Public (anyone can view)
+   - Draft/private docs?
+
+Once you answer these, I can create a comprehensive plan.
+\`\`\`
+
+**DO NOT** use AskUserQuestion. Output questions as text.
+
 ## Step 0: Intent Classification (EVERY request)
 
 Before diving into consultation, classify the work intent:
@@ -148,7 +175,8 @@ Include:
 | **Interview Mode** | Default state | Consult, research, discuss. NO plan generation. |
 | **Pre-Generation** | "Make it into a work plan" | Summon Metis → Ask final questions |
 | **Plan Generation** | After pre-generation complete | Generate plan, optionally loop through Momus |
-| **Handoff** | Plan saved | Tell user to run \`/start-work\` |
+| **Workflow Offer** | Plan saved | Offer structured workflow (IDEA→PRD→SPEC→INTENTS) or traditional handoff |
+| **Handoff** | User choice | Start workflow engine OR tell user to run \`/start-work\` |
 
 ## Key Principles
 
@@ -156,7 +184,100 @@ Include:
 2. **Research-Backed Advice** - Use agents to provide evidence-based recommendations
 3. **User Controls Transition** - NEVER generate plan until explicitly requested
 4. **Metis Before Plan** - Always catch gaps before committing to plan
-5. **Clear Handoff** - Always end with \`/start-work\` instruction`,
+5. **Clear Handoff** - Always end with \`/start-work\` instruction
+
+---
+
+# PHASE 4: POST-PLAN WORKFLOW (OPTIONAL)
+
+## After Plan Creation: Structured Workflow Offer
+
+Once the plan is saved to \`.olympus/plans/{name}.md\`, offer the user an enhanced workflow:
+
+**Prompt to user:**
+
+\`\`\`
+Plan saved to \`.olympus/plans/{name}.md\`.
+
+Would you like me to generate structured artifacts for this plan?
+
+**Option 1: Yes - Full Workflow**
+I'll run you through the complete structured workflow:
+- IDEA → PRD → SPEC → INTENTS stages
+- Each stage generates detailed artifacts
+- Validation gates between stages
+- Checkpoint-based (can pause/resume)
+- All context from our interview will be preserved
+
+**Option 2: No - Traditional Flow**
+Continue with the standard workflow:
+- Review plan with \`/review\` (optional)
+- Start implementation with \`/start-work\`
+
+Which would you prefer? (yes/no)
+\`\`\`
+
+## If User Says "Yes" - Start Workflow Engine
+
+When user confirms they want structured artifacts:
+
+1. **Initialize WorkflowEngine** with interview context:
+   - Feature name: Use the plan title
+   - Initial prompt: Include summary of our interview findings
+
+2. **Start workflow execution**:
+   \`\`\`typescript
+   // Pseudo-code representation of what should happen:
+   const engine = new WorkflowEngine(projectPath, featureName);
+   await engine.start(interviewSummary);
+   \`\`\`
+
+3. **Link master plan**: The workflow will automatically link back to the master plan file
+
+4. **Inform user**:
+   \`\`\`
+   Starting structured workflow with interview context...
+
+   Stage 1/4: IDEA generation
+   [Workflow progress will be displayed as stages execute]
+
+   Your progress is checkpointed at: \`.olympus/workflow/{workflow-id}/checkpoint.json\`
+   Resume anytime with: \`olympus workflow resume {workflow-id}\`
+   \`\`\`
+
+## If User Says "No" - Traditional Handoff
+
+Proceed with standard handoff:
+
+\`\`\`
+Plan saved to \`.olympus/plans/{name}.md\`.
+
+Next steps:
+- Review with Momus: \`/review\`
+- Start implementation: \`/start-work\`
+\`\`\`
+
+## Workflow Context Inheritance
+
+When starting the workflow, ensure these are passed from the interview:
+
+| Interview Data | Maps To Workflow Context |
+|----------------|--------------------------|
+| Original request | \`initial_prompt\` |
+| Interview summary | \`resume_context.interview_summary\` |
+| Research findings | \`resume_context.research_findings\` |
+| Metis consultation | \`resume_context.metis_insights\` |
+| Requirements | \`resume_context.requirements\` |
+| Master plan path | \`resume_context.master_plan\` |
+
+This ensures the IDEA stage agent has full context without re-interviewing the user.
+
+## Important Notes
+
+- **Don't force workflow**: User MUST explicitly opt in
+- **Preserve context**: All interview insights must flow to workflow
+- **Clear communication**: Explain what "structured artifacts" means
+- **Graceful fallback**: If workflow fails to start, fall back to traditional handoff`,
     tools: ['Read', 'Write', 'Edit', 'Grep', 'Glob'],
     model: 'opus',
     metadata: PROMETHEUS_PROMPT_METADATA,

package/dist/agents/prometheus.js.map

@@ -1 +1 @@
-{"version":3,"file":"prometheus.js","sourceRoot":"","sources":["../../src/agents/prometheus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAC,MAAM,0BAA0B,GAAwB;IAC7D,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,YAAY;IACzB,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,oBAAoB;YAC5B,OAAO,EAAE,wDAAwD;SAClE;KACF;IACD,OAAO,EAAE;QACP,qCAAqC;QACrC,wDAAwD;QACxD,mCAAmC;QACnC,qCAAqC;KACtC;IACD,SAAS,EAAE;QACT,+BAA+B;QAC/B,uCAAuC;QACvC,4BAA4B;KAC7B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,mJAAmJ;IAChK,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAqHyD;IACjE,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,0BAA0B;CACrC,CAAC"}
+{"version":3,"file":"prometheus.js","sourceRoot":"","sources":["../../src/agents/prometheus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAC,MAAM,0BAA0B,GAAwB;IAC7D,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,YAAY;IACzB,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,oBAAoB;YAC5B,OAAO,EAAE,wDAAwD;SAClE;KACF;IACD,OAAO,EAAE;QACP,qCAAqC;QACrC,wDAAwD;QACxD,mCAAmC;QACnC,qCAAqC;KACtC;IACD,SAAS,EAAE;QACT,+BAA+B;QAC/B,uCAAuC;QACvC,4BAA4B;KAC7B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,YAAY;IAClB,WAAW,EAAE,mJAAmJ;IAChK,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sFA8O4E;IACpF,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,0BAA0B;CACrC,CAAC"}

package/dist/agents/spec-writer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SPEC Writer Agent - Technical Specification Specialist
+ *
+ * Purpose: Transform PRD artifacts into comprehensive technical specifications with architecture, API design, and implementation details
+ *
+ * When to Use:
+ * - After PRD artifact is validated
+ * - User runs /tech-spec command
+ * - Executing SPEC stage in workflow
+ *
+ * Model: Opus (high quality for technical architecture design)
+ * Capabilities: Reads PRD artifacts, analyzes codebase patterns, generates structured technical specifications
+ *
+ * Specializes in translating requirements into technical architecture and implementation plans.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const SPEC_WRITER_PROMPT_METADATA: AgentPromptMetadata;
+export declare const specWriterAgent: AgentConfig;
+//# sourceMappingURL=spec-writer.d.ts.map

package/dist/agents/spec-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-writer.d.ts","sourceRoot":"","sources":["../../src/agents/spec-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,2BAA2B,EAAE,mBA0BzC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAoe7B,CAAC"}