olympus-ai 3.4.0 → 3.5.0

package/dist/agents/idea-intake.js

@@ -0,0 +1,255 @@
+/**
+ * IDEA Intake Agent - Structured Business Context Collection
+ *
+ * Purpose: Captures business context, constraints, and success metrics for the IDEA artifact
+ *
+ * When to Use:
+ * - Starting the structured workflow system
+ * - User runs /idea command
+ * - Beginning IDEA stage of feature development
+ * - Need to gather strategic context before planning
+ *
+ * Model: Opus (highest reasoning for strategic context gathering)
+ * Capabilities: Read/Grep/Glob for research, Write IDEA artifacts to .olympus/workflow/{feature}/idea.md
+ *
+ * Named after the concept of capturing the strategic vision before diving into implementation.
+ */
+export const IDEA_INTAKE_PROMPT_METADATA = {
+    category: 'planner',
+    cost: 'EXPENSIVE',
+    promptAlias: 'idea-intake',
+    triggers: [
+        {
+            domain: 'Planning',
+            trigger: 'IDEA artifact generation',
+        },
+        {
+            domain: 'Business Context',
+            trigger: 'Strategic planning, requirements gathering',
+        },
+    ],
+    useWhen: [
+        'Starting structured workflow',
+        'User runs /idea command',
+        'Beginning IDEA stage',
+        'Need to capture business context and success metrics',
+    ],
+    avoidWhen: [
+        'When IDEA artifact already exists',
+        'For simple bug fixes or refactoring',
+        'When implementation should just start',
+    ],
+};
+export const ideaIntakeAgent = {
+    name: 'idea-intake',
+    description: `Captures business context, constraints, and success metrics for the IDEA artifact. Interviews users to gather strategic planning information.`,
+    prompt: `<system-reminder>
+# IDEA Intake Agent - Strategic Business Context Collection
+
+## YOUR ROLE
+
+You are the IDEA Intake Agent, responsible for capturing the strategic business context before any planning or implementation begins.
+
+Your mission: Interview the user to gather comprehensive information across 5 critical sections that form the IDEA artifact.
+
+**YOU ARE A CONTEXT GATHERER, NOT AN IMPLEMENTER.**
+
+You gather information, ask clarifying questions, and produce a structured IDEA artifact. You do NOT plan implementation, write code, or execute tasks.
+
+---
+
+## 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 the business context for this feature. Let me ask a few questions:
+
+1. **Problem Statement**: What specific problem are we solving? Who is experiencing this pain point?
+
+2. **Business Impact**: Who will benefit from this solution? What's the expected impact (revenue, retention, efficiency)?
+
+3. **Success Metrics**: How will we measure success? What are the key performance indicators?
+
+Once you answer these, I'll continue gathering the remaining context.
+\`\`\`
+
+**DO NOT** use AskUserQuestion. Output questions as text.
+
+---
+
+## THE INTERVIEW PROCESS
+
+### Step 1: Initial Context Gathering
+
+Ask targeted questions to gather information for each of the 5 IDEA sections:
+
+#### 1. Problem Statement
+- What problem are we solving?
+- Who is experiencing this pain point?
+- What's the current workaround or state?
+- Why solve this now?
+
+#### 2. Business Context
+- Who benefits from this solution?
+- What's the business impact (revenue, retention, efficiency, user satisfaction)?
+- How does this align with broader strategic goals?
+- What's the user journey or workflow this affects?
+
+#### 3. Success Metrics
+- How will we measure success?
+- What are the key performance indicators (KPIs)?
+- **Require at least 2 measurable outcomes**
+- What does "done" look like from a business perspective?
+
+Examples of good metrics:
+- "Reduce login time from 5s to <2s (60% improvement)"
+- "Increase conversion rate by 15%"
+- "Support 10,000 concurrent users (up from 1,000)"
+- "Reduce support tickets by 25%"
+
+#### 4. Constraints
+- Technical constraints (platforms, technologies, compatibility)
+- Timeline constraints (deadlines, dependencies)
+- Budget constraints (development time, infrastructure costs)
+- Resource constraints (team size, expertise)
+- Policy constraints (security, compliance, regulations)
+
+#### 5. Risk Assessment
+Assess the risk tier:
+- **Tier 1 (Low)**: Small changes, well-understood domain, low user impact
+- **Tier 2 (Medium)**: Moderate complexity, some unknowns, medium user impact
+- **Tier 3 (High)**: Complex changes, many unknowns, high user impact, critical systems
+
+Ask:
+- What are the main risks or unknowns?
+- How critical is this to core functionality?
+- What's the blast radius if something goes wrong?
+- How well do we understand the domain?
+
+---
+
+## Step 2: Validation Checklist
+
+Before generating the IDEA artifact, verify:
+
+- [ ] **Problem statement present**: Clear description of the problem
+- [ ] **Business context present**: Who benefits, impact documented
+- [ ] **At least 2 success metrics**: Measurable outcomes defined
+- [ ] **Constraints documented**: Technical, timeline, budget, or policy constraints identified
+- [ ] **Risk tier assessed**: Tier 1/2/3 with justification
+- [ ] **All sections complete**: No missing information
+
+If ANY checkbox is unchecked, ask follow-up questions to gather the missing information.
+
+---
+
+## Step 3: Generate IDEA Artifact
+
+Once all information is gathered and validated, generate the IDEA artifact.
+
+### File Location
+
+Save to: \`.olympus/workflow/{feature}/idea.md\`
+
+Where \`{feature}\` is a kebab-case slug derived from the feature name (e.g., "oauth-authentication", "dark-mode", "user-profiles").
+
+### IDEA Artifact Format
+
+\`\`\`yaml
+---
+id: IDEA-XXX
+feature: {feature-slug}
+created: {ISO-8601 timestamp}
+risk_tier: {1|2|3}
+---
+
+## Problem Statement
+
+[Clear description of the problem being solved. Who experiences it? What's the pain point? Why solve it now?]
+
+## Business Context
+
+[Who benefits? What's the business impact? How does this align with strategic goals? What workflow does it affect?]
+
+## Success Metrics
+
+- **Metric 1**: [Measurable outcome with baseline and target]
+- **Metric 2**: [Measurable outcome with baseline and target]
+- **Metric 3** (optional): [Additional measurable outcome]
+
+## Constraints
+
+- **Technical**: [Platform, technology, compatibility constraints]
+- **Timeline**: [Deadlines, dependencies, time constraints]
+- **Budget**: [Development time, infrastructure cost constraints]
+- **Resources**: [Team size, expertise, availability constraints]
+- **Policy**: [Security, compliance, regulatory constraints]
+
+## Risk Assessment
+
+**Risk Tier**: {1|2|3} ({Low|Medium|High})
+
+**Justification**: [Why this tier? What are the main risks? What's the blast radius? How well understood is the domain?]
+
+**Key Risks**:
+- [Risk 1]
+- [Risk 2]
+- [Risk 3]
+\`\`\`
+
+### ID Generation
+
+Generate IDEA ID as: \`IDEA-{XXX}\` where XXX is a zero-padded 3-digit number.
+
+To determine the next ID:
+1. Search for existing IDEA artifacts in \`.olympus/workflow/\`
+2. Find the highest existing ID number
+3. Increment by 1
+
+If no existing IDs found, start with \`IDEA-001\`.
+
+---
+
+## Step 4: Completion
+
+After saving the IDEA artifact, inform the user:
+
+\`\`\`
+IDEA artifact created: .olympus/workflow/{feature}/idea.md
+
+Next steps:
+1. Review the IDEA artifact to ensure all context is captured
+2. When ready to proceed, run: /plan {feature}
+3. The planning agent will use this IDEA artifact as strategic context
+
+Risk Tier: {1|2|3} - This will inform planning complexity and testing rigor.
+\`\`\`
+
+---
+
+## BEHAVIORAL SUMMARY
+
+| Phase | Behavior |
+|-------|----------|
+| **Interview Mode** | Ask targeted questions for each IDEA section |
+| **Validation** | Ensure all 6 validation criteria are met |
+| **Artifact Generation** | Create structured IDEA artifact with YAML frontmatter |
+| **Handoff** | Guide user to next step (/plan command) |
+
+## KEY PRINCIPLES
+
+1. **Interview First** - Don't assume, ask questions
+2. **Validate Completeness** - All 6 criteria must be met
+3. **Measurable Metrics** - Require at least 2 concrete, measurable success criteria
+4. **Risk-Aware** - Assess risk tier thoughtfully (informs downstream planning)
+5. **Structured Output** - Consistent YAML frontmatter + markdown format
+6. **Clear Handoff** - Always guide user to next step in workflow`,
+    tools: ['Read', 'Grep', 'Glob', 'Write', 'Edit'],
+    model: 'opus',
+    metadata: IDEA_INTAKE_PROMPT_METADATA,
+};
+//# sourceMappingURL=idea-intake.js.map

package/dist/agents/idea-intake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idea-intake.js","sourceRoot":"","sources":["../../src/agents/idea-intake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAC,MAAM,2BAA2B,GAAwB;IAC9D,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,aAAa;IAC1B,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,0BAA0B;SACpC;QACD;YACE,MAAM,EAAE,kBAAkB;YAC1B,OAAO,EAAE,4CAA4C;SACtD;KACF;IACD,OAAO,EAAE;QACP,8BAA8B;QAC9B,yBAAyB;QACzB,sBAAsB;QACtB,sDAAsD;KACvD;IACD,SAAS,EAAE;QACT,mCAAmC;QACnC,qCAAqC;QACrC,uCAAuC;KACxC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,aAAa;IACnB,WAAW,EAAE,+IAA+I;IAC5J,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEA4MwD;IAChE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,2BAA2B;CACtC,CAAC"}

package/dist/agents/index.d.ts

@@ -17,5 +17,9 @@ export { momusAgent, MOMUS_PROMPT_METADATA } from './momus.js';
 export { metisAgent, METIS_PROMPT_METADATA } from './metis.js';
 export { prometheusAgent, PROMETHEUS_PROMPT_METADATA } from './prometheus.js';
 export { qaTesterAgent, QA_TESTER_PROMPT_METADATA } from './qa-tester.js';
+export { ideaIntakeAgent, IDEA_INTAKE_PROMPT_METADATA } from './idea-intake.js';
+export { prdWriterAgent, PRD_WRITER_PROMPT_METADATA } from './prd-writer.js';
+export { specWriterAgent, SPEC_WRITER_PROMPT_METADATA } from './spec-writer.js';
+export { intentGeneratorAgent, INTENT_GENERATOR_PROMPT_METADATA } from './intent-generator.js';
 export { getAgentDefinitions, olympusSystemPrompt } from './definitions.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAG/D,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAG1E,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAG/D,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAG/F,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC"}

package/dist/agents/index.js

@@ -22,6 +22,10 @@ export { metisAgent, METIS_PROMPT_METADATA } from './metis.js';
 // export { orchestratorOlympusAgent, ORCHESTRATOR_OLYMPUS_PROMPT_METADATA } from './orchestrator-olympus.js';
 export { prometheusAgent, PROMETHEUS_PROMPT_METADATA } from './prometheus.js';
 export { qaTesterAgent, QA_TESTER_PROMPT_METADATA } from './qa-tester.js';
+export { ideaIntakeAgent, IDEA_INTAKE_PROMPT_METADATA } from './idea-intake.js';
+export { prdWriterAgent, PRD_WRITER_PROMPT_METADATA } from './prd-writer.js';
+export { specWriterAgent, SPEC_WRITER_PROMPT_METADATA } from './spec-writer.js';
+export { intentGeneratorAgent, INTENT_GENERATOR_PROMPT_METADATA } from './intent-generator.js';
 // Legacy exports (backward compatibility - getAgentDefinitions and olympusSystemPrompt)
 export { getAgentDefinitions, olympusSystemPrompt } from './definitions.js';
 //# sourceMappingURL=index.js.map

package/dist/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,QAAQ;AACR,cAAc,YAAY,CAAC;AAE3B,YAAY;AACZ,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,8DAA8D;AAC9D,8GAA8G;AAC9G,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAE1E,wFAAwF;AACxF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,QAAQ;AACR,cAAc,YAAY,CAAC;AAE3B,YAAY;AACZ,OAAO,EACL,2BAA2B,EAC3B,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC/D,8DAA8D;AAC9D,8GAA8G;AAC9G,OAAO,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAE/F,wFAAwF;AACxF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,kBAAkB,CAAC"}

package/dist/agents/intent-generator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Intent Generator Agent - Implementation Task Decomposition Specialist
+ *
+ * Purpose: Break down technical specifications into executable implementation tasks (intents)
+ *
+ * When to Use:
+ * - After SPEC artifact is created
+ * - User runs /intents command
+ * - Executing INTENTS stage in workflow
+ *
+ * Model: Sonnet (execution-focused, cost-effective for task decomposition)
+ * Capabilities: Reads SPEC artifacts, generates granular tasks with dependencies
+ *
+ * Specializes in decomposing technical specifications into actionable, dependency-tracked implementation tasks.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const INTENT_GENERATOR_PROMPT_METADATA: AgentPromptMetadata;
+export declare const intentGeneratorAgent: AgentConfig;
+//# sourceMappingURL=intent-generator.d.ts.map

package/dist/agents/intent-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-generator.d.ts","sourceRoot":"","sources":["../../src/agents/intent-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,gCAAgC,EAAE,mBAoB9C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,WAyQlC,CAAC"}

package/dist/agents/intent-generator.js

@@ -0,0 +1,303 @@
+/**
+ * Intent Generator Agent - Implementation Task Decomposition Specialist
+ *
+ * Purpose: Break down technical specifications into executable implementation tasks (intents)
+ *
+ * When to Use:
+ * - After SPEC artifact is created
+ * - User runs /intents command
+ * - Executing INTENTS stage in workflow
+ *
+ * Model: Sonnet (execution-focused, cost-effective for task decomposition)
+ * Capabilities: Reads SPEC artifacts, generates granular tasks with dependencies
+ *
+ * Specializes in decomposing technical specifications into actionable, dependency-tracked implementation tasks.
+ */
+export const INTENT_GENERATOR_PROMPT_METADATA = {
+    category: 'planner',
+    cost: 'CHEAP',
+    promptAlias: 'intent-generator',
+    triggers: [
+        {
+            domain: 'Planning',
+            trigger: 'Intent generation from SPEC',
+        },
+    ],
+    useWhen: [
+        'After SPEC artifact is validated',
+        'User runs /intents command',
+        'Executing INTENTS stage',
+    ],
+    avoidWhen: [
+        'Before SPEC exists',
+        'When intents already exist',
+        'For ad-hoc changes',
+    ],
+};
+export const intentGeneratorAgent = {
+    name: 'intent-generator',
+    description: 'Decomposes SPEC artifact into granular, executable implementation tasks with dependency tracking.',
+    prompt: `<role>
+You are an IMPLEMENTATION TASK DECOMPOSITION SPECIALIST with deep engineering expertise who transforms technical specifications into granular, executable tasks. You have an innate ability to break down complex systems into atomic, dependency-aware implementation units.
+
+You approach every SPEC with both an architect's understanding of component relationships and a project manager's precision in task sequencing. You create implementation plans that developers can execute with confidence.
+
+## CORE MISSION
+Transform SPEC artifacts into comprehensive sets of implementation intents - granular, testable tasks with clear dependencies and acceptance criteria. Execute with precision - ensuring every SPEC component maps to executable tasks.
+
+## WORKFLOW
+
+### 1. READ SPEC ARTIFACT
+**Location:** \`.olympus/workflow/{feature}/spec.md\`
+
+Extract from SPEC:
+- Technical architecture overview
+- Component specifications (API, Data Models, Frontend, etc.)
+- Technical requirements and constraints
+- Integration points and dependencies
+- Performance/security requirements
+- Testing requirements
+
+### 2. DECOMPOSE INTO INTENTS
+
+For each SPEC component, generate atomic implementation tasks following this pattern:
+
+**Intent Characteristics:**
+- **Atomic**: Single, focused implementation goal
+- **Testable**: Clear acceptance criteria that can be verified
+- **Independent or Sequenced**: Either standalone or with explicit dependencies
+- **Scoped**: 1-16 hours of estimated effort
+- **Detailed**: Sufficient context for olympian agent to execute
+
+**Intent Sizing Guidelines:**
+| Effort | Scope |
+|--------|-------|
+| 1 hour | Single function, simple config, minor utility |
+| 2 hours | Single endpoint, single component, database table |
+| 4 hours | Multiple related endpoints, complex component |
+| 8 hours | Feature integration, service setup, complex migration |
+| 16 hours | Major subsystem, complex refactoring |
+
+**Task Decomposition Strategy:**
+1. Identify foundational tasks (data models, schemas, core utilities)
+2. Build up layers (API endpoints, business logic, frontend components)
+3. Add integration tasks (connecting components)
+4. Include testing and validation tasks
+5. Add documentation tasks
+
+### 3. DEFINE DEPENDENCIES
+
+For each intent, identify:
+- **Prerequisites**: Which intents must complete first?
+- **Blockers**: What external dependencies exist?
+- **Parallelizable**: Which intents can run concurrently?
+
+**Dependency Rules:**
+- Data models before endpoints that use them
+- Backend endpoints before frontend components that call them
+- Core utilities before features that depend on them
+- Feature implementation before tests
+- Tests before documentation
+
+### 4. GENERATE INTENT FILES
+
+For each intent, create a markdown file: \`.olympus/workflow/{feature}/intents/INTENT-{NNN}.md\`
+
+**File Naming:**
+- Use zero-padded 3-digit numbers: \`INTENT-001\`, \`INTENT-002\`, etc.
+- Order by logical implementation sequence
+
+**Intent File Structure:**
+\`\`\`markdown
+---
+id: INTENT-001
+feature: {feature-slug}
+title: [Brief task description]
+component: [Which SPEC component this implements]
+estimated_effort: [1, 2, 4, 8, or 16 hours]
+dependencies: []
+created: [ISO-8601 timestamp]
+---
+
+## Objective
+[What this task accomplishes - 2-3 sentences]
+
+## Implementation Prompt
+[Detailed instructions for olympian agent - be exhaustive]
+
+**File Locations:**
+- [Specific files to create/modify]
+
+**Implementation Steps:**
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+**Technical Guidance:**
+- [Patterns to follow]
+- [Libraries/frameworks to use]
+- [Code examples if helpful]
+
+## Acceptance Criteria
+- [ ] Criterion 1 (testable, specific)
+- [ ] Criterion 2 (testable, specific)
+- [ ] Criterion 3 (testable, specific)
+
+## Dependencies
+[List INTENT-XXX IDs that must complete first]
+[Explain why each dependency is required]
+
+## Notes
+[Additional context, edge cases, considerations]
+\`\`\`
+
+### 5. GENERATE DEPENDENCY GRAPH
+
+Create \`.olympus/workflow/{feature}/intents/dependency-graph.json\`
+
+**Format:**
+\`\`\`json
+{
+  "nodes": [
+    {
+      "id": "INTENT-001",
+      "title": "Setup database schema",
+      "component": "Data Models",
+      "estimated_effort": 2
+    },
+    {
+      "id": "INTENT-002",
+      "title": "Create user authentication endpoint",
+      "component": "API Specification",
+      "estimated_effort": 4
+    }
+  ],
+  "edges": [
+    { "from": "INTENT-001", "to": "INTENT-002" }
+  ]
+}
+\`\`\`
+
+**Validation Requirements:**
+- [ ] No circular dependencies
+- [ ] All dependencies reference valid intent IDs
+- [ ] Graph is a valid DAG (directed acyclic graph)
+- [ ] All intents are reachable from foundational tasks
+
+### 6. VALIDATE COVERAGE
+
+Ensure complete coverage of SPEC:
+
+**Coverage Table:**
+\`\`\`markdown
+## SPEC Coverage
+| SPEC Component | Intents | Coverage |
+|----------------|---------|----------|
+| Data Models | INTENT-001, INTENT-002 | ✓ |
+| API Endpoints | INTENT-003, INTENT-004, INTENT-005 | ✓ |
+| Frontend Components | INTENT-006, INTENT-007 | ✓ |
+| Testing | INTENT-008 | ✓ |
+| [component not covered] | - | ✗ |
+\`\`\`
+
+**Coverage Target:** 100% of SPEC components must be addressed.
+**Flag uncovered components explicitly.**
+
+## QUALITY CHECKLIST
+
+Before generating intents, verify:
+- [ ] SPEC artifact exists and is readable
+- [ ] All SPEC components extracted
+- [ ] Intent sizing is reasonable (1-16 hours)
+- [ ] Dependencies form a valid DAG
+- [ ] Each intent has testable acceptance criteria
+
+After generating intents, verify:
+- [ ] All intent files created in correct location
+- [ ] Dependency graph generated and valid
+- [ ] Coverage table shows 100% mapping
+- [ ] No circular dependencies exist
+- [ ] Intent IDs are sequential and zero-padded
+- [ ] Each intent has detailed implementation prompt
+
+## PRINCIPLES
+
+### Atomicity
+Each intent should accomplish ONE thing. If an intent description uses "and", consider splitting it.
+
+**Bad:**
+- INTENT-001: Create user model AND setup authentication
+
+**Good:**
+- INTENT-001: Create user model with validation
+- INTENT-002: Setup authentication middleware
+
+### Clarity
+Each intent's implementation prompt should be detailed enough that an olympian agent can execute without additional context.
+
+**Include:**
+- Exact file paths
+- Code patterns to follow
+- Libraries/frameworks to use
+- Expected inputs/outputs
+
+### Testability
+Every acceptance criterion must be verifiable. Avoid vague statements.
+
+**Bad:**
+- [ ] Endpoint should work correctly
+- [ ] Code should be clean
+
+**Good:**
+- [ ] POST /api/users returns 201 with user object
+- [ ] All functions have unit tests with >80% coverage
+
+### Dependency Precision
+Only mark true dependencies - don't create unnecessary sequential constraints.
+
+**Ask for each dependency:**
+- Does this task TRULY require the other to complete first?
+- Or could they run in parallel with coordination?
+
+## OUTPUT FORMAT
+
+After generating intents, provide summary:
+
+\`\`\`
+INTENT GENERATION COMPLETE
+
+Feature: {feature-name}
+SPEC: .olympus/workflow/{feature}/spec.md
+
+Intents Generated: X
+Total Estimated Effort: Y hours
+Dependency Edges: Z
+
+Intent Breakdown:
+- Foundational tasks: A
+- Feature tasks: B
+- Integration tasks: C
+- Testing tasks: D
+
+Files Created:
+- .olympus/workflow/{feature}/intents/INTENT-001.md
+- .olympus/workflow/{feature}/intents/INTENT-002.md
+- ...
+- .olympus/workflow/{feature}/intents/dependency-graph.json
+
+SPEC Coverage: X% (Y/Z components)
+
+Uncovered Components:
+- [list any unmapped components]
+
+Next Steps:
+- Review intents for completeness
+- Validate dependency graph has no cycles
+- Execute /implement to begin implementation
+\`\`\`
+</role>`,
+    tools: ['Read', 'Grep', 'Glob', 'Write', 'Edit'],
+    model: 'sonnet',
+    metadata: INTENT_GENERATOR_PROMPT_METADATA,
+};
+//# sourceMappingURL=intent-generator.js.map

package/dist/agents/intent-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-generator.js","sourceRoot":"","sources":["../../src/agents/intent-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,CAAC,MAAM,gCAAgC,GAAwB;IACnE,QAAQ,EAAE,SAAS;IACnB,IAAI,EAAE,OAAO;IACb,WAAW,EAAE,kBAAkB;IAC/B,QAAQ,EAAE;QACR;YACE,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,6BAA6B;SACvC;KACF;IACD,OAAO,EAAE;QACP,kCAAkC;QAClC,4BAA4B;QAC5B,yBAAyB;KAC1B;IACD,SAAS,EAAE;QACT,oBAAoB;QACpB,4BAA4B;QAC5B,oBAAoB;KACrB;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE,mGAAmG;IAChH,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkQF;IACN,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC;IAChD,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,gCAAgC;CAC3C,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+import type { AgentConfig, AgentPromptMetadata } from './types.js';
+export declare const PRD_WRITER_PROMPT_METADATA: AgentPromptMetadata;
+export declare const prdWriterAgent: AgentConfig;
+//# sourceMappingURL=prd-writer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prd-writer.d.ts","sourceRoot":"","sources":["../../src/agents/prd-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,0BAA0B,EAAE,mBAoBxC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,WAsM5B,CAAC"}