workspace-architect 1.3.0

package/assets/prompts/az-cost-optimize.prompt.md

@@ -0,0 +1,305 @@
+---
+mode: 'agent'
+description: 'Analyze Azure resources used in the app (IaC files and/or resources in a target rg) and optimize costs - creating GitHub issues for identified optimizations.'
+---
+
+# Azure Cost Optimize
+
+This workflow analyzes Infrastructure-as-Code (IaC) files and Azure resources to generate cost optimization recommendations. It creates individual GitHub issues for each optimization opportunity plus one EPIC issue to coordinate implementation, enabling efficient tracking and execution of cost savings initiatives.
+
+## Prerequisites
+- Azure MCP server configured and authenticated
+- GitHub MCP server configured and authenticated  
+- Target GitHub repository identified
+- Azure resources deployed (IaC files optional but helpful)
+- Prefer Azure MCP tools (`azmcp-*`) over direct Azure CLI when available
+
+## Workflow Steps
+
+### Step 1: Get Azure Best Practices
+**Action**: Retrieve cost optimization best practices before analysis
+**Tools**: Azure MCP best practices tool
+**Process**:
+1. **Load Best Practices**:
+   - Execute `azmcp-bestpractices-get` to get some of the latest Azure optimization guidelines. This may not cover all scenarios but provides a foundation.
+   - Use these practices to inform subsequent analysis and recommendations as much as possible
+   - Reference best practices in optimization recommendations, either from the MCP tool output or general Azure documentation
+
+### Step 2: Discover Azure Infrastructure
+**Action**: Dynamically discover and analyze Azure resources and configurations
+**Tools**: Azure MCP tools + Azure CLI fallback + Local file system access
+**Process**:
+1. **Resource Discovery**:
+   - Execute `azmcp-subscription-list` to find available subscriptions
+   - Execute `azmcp-group-list --subscription <subscription-id>` to find resource groups
+   - Get a list of all resources in the relevant group(s):
+     - Use `az resource list --subscription <id> --resource-group <name>`
+   - For each resource type, use MCP tools first if possible, then CLI fallback:
+     - `azmcp-cosmos-account-list --subscription <id>` - Cosmos DB accounts
+     - `azmcp-storage-account-list --subscription <id>` - Storage accounts  
+     - `azmcp-monitor-workspace-list --subscription <id>` - Log Analytics workspaces
+     - `azmcp-keyvault-key-list` - Key Vaults
+     - `az webapp list` - Web Apps (fallback - no MCP tool available)
+     - `az appservice plan list` - App Service Plans (fallback)
+     - `az functionapp list` - Function Apps (fallback)
+     - `az sql server list` - SQL Servers (fallback)
+     - `az redis list` - Redis Cache (fallback)
+     - ... and so on for other resource types
+
+2. **IaC Detection**:
+   - Use `file_search` to scan for IaC files: "**/*.bicep", "**/*.tf", "**/main.json", "**/*template*.json"
+   - Parse resource definitions to understand intended configurations
+   - Compare against discovered resources to identify discrepancies
+   - Note presence of IaC files for implementation recommendations later on
+   - Do NOT use any other file from the repository, only IaC files. Using other files is NOT allowed as it is not a source of truth.
+   - If you do not find IaC files, then STOP and report no IaC files found to the user.
+
+3. **Configuration Analysis**:
+   - Extract current SKUs, tiers, and settings for each resource
+   - Identify resource relationships and dependencies
+   - Map resource utilization patterns where available
+
+### Step 3: Collect Usage Metrics & Validate Current Costs
+**Action**: Gather utilization data AND verify actual resource costs
+**Tools**: Azure MCP monitoring tools + Azure CLI
+**Process**:
+1. **Find Monitoring Sources**:
+   - Use `azmcp-monitor-workspace-list --subscription <id>` to find Log Analytics workspaces
+   - Use `azmcp-monitor-table-list --subscription <id> --workspace <name> --table-type "CustomLog"` to discover available data
+
+2. **Execute Usage Queries**:
+   - Use `azmcp-monitor-log-query` with these predefined queries:
+     - Query: "recent" for recent activity patterns
+     - Query: "errors" for error-level logs indicating issues
+   - For custom analysis, use KQL queries:
+   ```kql
+   // CPU utilization for App Services
+   AppServiceAppLogs
+   | where TimeGenerated > ago(7d)
+   | summarize avg(CpuTime) by Resource, bin(TimeGenerated, 1h)
+   
+   // Cosmos DB RU consumption  
+   AzureDiagnostics
+   | where ResourceProvider == "MICROSOFT.DOCUMENTDB"
+   | where TimeGenerated > ago(7d)
+   | summarize avg(RequestCharge) by Resource
+   
+   // Storage account access patterns
+   StorageBlobLogs
+   | where TimeGenerated > ago(7d)
+   | summarize RequestCount=count() by AccountName, bin(TimeGenerated, 1d)
+   ```
+
+3. **Calculate Baseline Metrics**:
+   - CPU/Memory utilization averages
+   - Database throughput patterns
+   - Storage access frequency
+   - Function execution rates
+
+4. **VALIDATE CURRENT COSTS**: 
+   - Using the SKU/tier configurations discovered in Step 2
+   - Look up current Azure pricing at https://azure.microsoft.com/pricing/ or use `az billing` commands
+   - Document: Resource → Current SKU → Estimated monthly cost
+   - Calculate realistic current monthly total before proceeding to recommendations
+
+### Step 4: Generate Cost Optimization Recommendations
+**Action**: Analyze resources to identify optimization opportunities
+**Tools**: Local analysis using collected data
+**Process**:
+1. **Apply Optimization Patterns** based on resource types found:
+   
+   **Compute Optimizations**:
+   - App Service Plans: Right-size based on CPU/memory usage
+   - Function Apps: Premium → Consumption plan for low usage
+   - Virtual Machines: Scale down oversized instances
+   
+   **Database Optimizations**:
+   - Cosmos DB: 
+     - Provisioned → Serverless for variable workloads
+     - Right-size RU/s based on actual usage
+   - SQL Database: Right-size service tiers based on DTU usage
+   
+   **Storage Optimizations**:
+   - Implement lifecycle policies (Hot → Cool → Archive)
+   - Consolidate redundant storage accounts
+   - Right-size storage tiers based on access patterns
+   
+   **Infrastructure Optimizations**:
+   - Remove unused/redundant resources
+   - Implement auto-scaling where beneficial
+   - Schedule non-production environments
+
+2. **Calculate Evidence-Based Savings**: 
+   - Current validated cost → Target cost = Savings
+   - Document pricing source for both current and target configurations
+
+3. **Calculate Priority Score** for each recommendation:
+   ```
+   Priority Score = (Value Score × Monthly Savings) / (Risk Score × Implementation Days)
+   
+   High Priority: Score > 20
+   Medium Priority: Score 5-20
+   Low Priority: Score < 5
+   ```
+
+4. **Validate Recommendations**:
+   - Ensure Azure CLI commands are accurate
+   - Verify estimated savings calculations
+   - Assess implementation risks and prerequisites
+   - Ensure all savings calculations have supporting evidence
+
+### Step 5: User Confirmation
+**Action**: Present summary and get approval before creating GitHub issues
+**Process**:
+1. **Display Optimization Summary**:
+   ```
+   🎯 Azure Cost Optimization Summary
+   
+   📊 Analysis Results:
+   • Total Resources Analyzed: X
+   • Current Monthly Cost: $X 
+   • Potential Monthly Savings: $Y 
+   • Optimization Opportunities: Z
+   • High Priority Items: N
+   
+   🏆 Recommendations:
+   1. [Resource]: [Current SKU] → [Target SKU] = $X/month savings - [Risk Level] | [Implementation Effort]
+   2. [Resource]: [Current Config] → [Target Config] = $Y/month savings - [Risk Level] | [Implementation Effort]
+   3. [Resource]: [Current Config] → [Target Config] = $Z/month savings - [Risk Level] | [Implementation Effort]
+   ... and so on
+   
+   💡 This will create:
+   • Y individual GitHub issues (one per optimization)
+   • 1 EPIC issue to coordinate implementation
+   
+   ❓ Proceed with creating GitHub issues? (y/n)
+   ```
+
+2. **Wait for User Confirmation**: Only proceed if user confirms
+
+### Step 6: Create Individual Optimization Issues
+**Action**: Create separate GitHub issues for each optimization opportunity. Label them with "cost-optimization" (green color), "azure" (blue color).
+**MCP Tools Required**: `create_issue` for each recommendation
+**Process**:
+1. **Create Individual Issues** using this template:
+
+   **Title Format**: `[COST-OPT] [Resource Type] - [Brief Description] - $X/month savings`
+   
+   **Body Template**:
+   ```markdown
+   ## 💰 Cost Optimization: [Brief Title]
+   
+   **Monthly Savings**: $X | **Risk Level**: [Low/Medium/High] | **Implementation Effort**: X days
+   
+   ### 📋 Description
+   [Clear explanation of the optimization and why it's needed]
+   
+   ### 🔧 Implementation
+   
+   **IaC Files Detected**: [Yes/No - based on file_search results]
+   
+   ```bash
+   # If IaC files found: Show IaC modifications + deployment
+   # File: infrastructure/bicep/modules/app-service.bicep
+   # Change: sku.name: 'S3' → 'B2'
+   az deployment group create --resource-group [rg] --template-file infrastructure/bicep/main.bicep
+   
+   # If no IaC files: Direct Azure CLI commands + warning
+   # ⚠️ No IaC files found. If they exist elsewhere, modify those instead.
+   az appservice plan update --name [plan] --sku B2
+   ```
+   
+   ### 📊 Evidence
+   - Current Configuration: [details]
+   - Usage Pattern: [evidence from monitoring data]
+   - Cost Impact: $X/month → $Y/month
+   - Best Practice Alignment: [reference to Azure best practices if applicable]
+   
+   ### ✅ Validation Steps
+   - [ ] Test in non-production environment
+   - [ ] Verify no performance degradation
+   - [ ] Confirm cost reduction in Azure Cost Management
+   - [ ] Update monitoring and alerts if needed
+   
+   ### ⚠️ Risks & Considerations
+   - [Risk 1 and mitigation]
+   - [Risk 2 and mitigation]
+   
+   **Priority Score**: X | **Value**: X/10 | **Risk**: X/10
+   ```
+
+### Step 7: Create EPIC Coordinating Issue
+**Action**: Create master issue to track all optimization work. Label it with "cost-optimization" (green color), "azure" (blue color), and "epic" (purple color).
+**MCP Tools Required**: `create_issue` for EPIC
+**Note about mermaid diagrams**: Ensure you verify mermaid syntax is correct and create the diagrams taking accessibility guidelines into account (styling, colors, etc.).
+**Process**:
+1. **Create EPIC Issue**:
+
+   **Title**: `[EPIC] Azure Cost Optimization Initiative - $X/month potential savings`
+   
+   **Body Template**:
+   ```markdown
+   # 🎯 Azure Cost Optimization EPIC
+   
+   **Total Potential Savings**: $X/month | **Implementation Timeline**: X weeks
+   
+   ## 📊 Executive Summary
+   - **Resources Analyzed**: X
+   - **Optimization Opportunities**: Y  
+   - **Total Monthly Savings Potential**: $X
+   - **High Priority Items**: N
+   
+   ## 🏗️ Current Architecture Overview
+   
+   ```mermaid
+   graph TB
+       subgraph "Resource Group: [name]"
+           [Generated architecture diagram showing current resources and costs]
+       end
+   ```
+   
+   ## 📋 Implementation Tracking
+   
+   ### 🚀 High Priority (Implement First)
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ### ⚡ Medium Priority 
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ### 🔄 Low Priority (Nice to Have)
+   - [ ] #[issue-number]: [Title] - $X/month savings
+   
+   ## 📈 Progress Tracking
+   - **Completed**: 0 of Y optimizations
+   - **Savings Realized**: $0 of $X/month
+   - **Implementation Status**: Not Started
+   
+   ## 🎯 Success Criteria
+   - [ ] All high-priority optimizations implemented
+   - [ ] >80% of estimated savings realized
+   - [ ] No performance degradation observed
+   - [ ] Cost monitoring dashboard updated
+   
+   ## 📝 Notes
+   - Review and update this EPIC as issues are completed
+   - Monitor actual vs. estimated savings
+   - Consider scheduling regular cost optimization reviews
+   ```
+
+## Error Handling
+- **Cost Validation**: If savings estimates lack supporting evidence or seem inconsistent with Azure pricing, re-verify configurations and pricing sources before proceeding
+- **Azure Authentication Failure**: Provide manual Azure CLI setup steps
+- **No Resources Found**: Create informational issue about Azure resource deployment
+- **GitHub Creation Failure**: Output formatted recommendations to console
+- **Insufficient Usage Data**: Note limitations and provide configuration-based recommendations only
+
+## Success Criteria
+- ✅ All cost estimates verified against actual resource configurations and Azure pricing
+- ✅ Individual issues created for each optimization (trackable and assignable)
+- ✅ EPIC issue provides comprehensive coordination and tracking
+- ✅ All recommendations include specific, executable Azure CLI commands
+- ✅ Priority scoring enables ROI-focused implementation
+- ✅ Architecture diagram accurately represents current state
+- ✅ User confirmation prevents unwanted issue creation

package/assets/prompts/azure-resource-health-diagnose.prompt.md

@@ -0,0 +1,290 @@
+---
+mode: 'agent'
+description: 'Analyze Azure resource health, diagnose issues from logs and telemetry, and create a remediation plan for identified problems.'
+---
+
+# Azure Resource Health & Issue Diagnosis
+
+This workflow analyzes a specific Azure resource to assess its health status, diagnose potential issues using logs and telemetry data, and develop a comprehensive remediation plan for any problems discovered.
+
+## Prerequisites
+- Azure MCP server configured and authenticated
+- Target Azure resource identified (name and optionally resource group/subscription)
+- Resource must be deployed and running to generate logs/telemetry
+- Prefer Azure MCP tools (`azmcp-*`) over direct Azure CLI when available
+
+## Workflow Steps
+
+### Step 1: Get Azure Best Practices
+**Action**: Retrieve diagnostic and troubleshooting best practices
+**Tools**: Azure MCP best practices tool
+**Process**:
+1. **Load Best Practices**:
+   - Execute Azure best practices tool to get diagnostic guidelines
+   - Focus on health monitoring, log analysis, and issue resolution patterns
+   - Use these practices to inform diagnostic approach and remediation recommendations
+
+### Step 2: Resource Discovery & Identification
+**Action**: Locate and identify the target Azure resource
+**Tools**: Azure MCP tools + Azure CLI fallback
+**Process**:
+1. **Resource Lookup**:
+   - If only resource name provided: Search across subscriptions using `azmcp-subscription-list`
+   - Use `az resource list --name <resource-name>` to find matching resources
+   - If multiple matches found, prompt user to specify subscription/resource group
+   - Gather detailed resource information:
+     - Resource type and current status
+     - Location, tags, and configuration
+     - Associated services and dependencies
+
+2. **Resource Type Detection**:
+   - Identify resource type to determine appropriate diagnostic approach:
+     - **Web Apps/Function Apps**: Application logs, performance metrics, dependency tracking
+     - **Virtual Machines**: System logs, performance counters, boot diagnostics
+     - **Cosmos DB**: Request metrics, throttling, partition statistics
+     - **Storage Accounts**: Access logs, performance metrics, availability
+     - **SQL Database**: Query performance, connection logs, resource utilization
+     - **Application Insights**: Application telemetry, exceptions, dependencies
+     - **Key Vault**: Access logs, certificate status, secret usage
+     - **Service Bus**: Message metrics, dead letter queues, throughput
+
+### Step 3: Health Status Assessment
+**Action**: Evaluate current resource health and availability
+**Tools**: Azure MCP monitoring tools + Azure CLI
+**Process**:
+1. **Basic Health Check**:
+   - Check resource provisioning state and operational status
+   - Verify service availability and responsiveness
+   - Review recent deployment or configuration changes
+   - Assess current resource utilization (CPU, memory, storage, etc.)
+
+2. **Service-Specific Health Indicators**:
+   - **Web Apps**: HTTP response codes, response times, uptime
+   - **Databases**: Connection success rate, query performance, deadlocks
+   - **Storage**: Availability percentage, request success rate, latency
+   - **VMs**: Boot diagnostics, guest OS metrics, network connectivity
+   - **Functions**: Execution success rate, duration, error frequency
+
+### Step 4: Log & Telemetry Analysis
+**Action**: Analyze logs and telemetry to identify issues and patterns
+**Tools**: Azure MCP monitoring tools for Log Analytics queries
+**Process**:
+1. **Find Monitoring Sources**:
+   - Use `azmcp-monitor-workspace-list` to identify Log Analytics workspaces
+   - Locate Application Insights instances associated with the resource
+   - Identify relevant log tables using `azmcp-monitor-table-list`
+
+2. **Execute Diagnostic Queries**:
+   Use `azmcp-monitor-log-query` with targeted KQL queries based on resource type:
+
+   **General Error Analysis**:
+   ```kql
+   // Recent errors and exceptions
+   union isfuzzy=true 
+       AzureDiagnostics,
+       AppServiceHTTPLogs,
+       AppServiceAppLogs,
+       AzureActivity
+   | where TimeGenerated > ago(24h)
+   | where Level == "Error" or ResultType != "Success"
+   | summarize ErrorCount=count() by Resource, ResultType, bin(TimeGenerated, 1h)
+   | order by TimeGenerated desc
+   ```
+
+   **Performance Analysis**:
+   ```kql
+   // Performance degradation patterns
+   Perf
+   | where TimeGenerated > ago(7d)
+   | where ObjectName == "Processor" and CounterName == "% Processor Time"
+   | summarize avg(CounterValue) by Computer, bin(TimeGenerated, 1h)
+   | where avg_CounterValue > 80
+   ```
+
+   **Application-Specific Queries**:
+   ```kql
+   // Application Insights - Failed requests
+   requests
+   | where timestamp > ago(24h)
+   | where success == false
+   | summarize FailureCount=count() by resultCode, bin(timestamp, 1h)
+   | order by timestamp desc
+   
+   // Database - Connection failures
+   AzureDiagnostics
+   | where ResourceProvider == "MICROSOFT.SQL"
+   | where Category == "SQLSecurityAuditEvents"
+   | where action_name_s == "CONNECTION_FAILED"
+   | summarize ConnectionFailures=count() by bin(TimeGenerated, 1h)
+   ```
+
+3. **Pattern Recognition**:
+   - Identify recurring error patterns or anomalies
+   - Correlate errors with deployment times or configuration changes
+   - Analyze performance trends and degradation patterns
+   - Look for dependency failures or external service issues
+
+### Step 5: Issue Classification & Root Cause Analysis
+**Action**: Categorize identified issues and determine root causes
+**Process**:
+1. **Issue Classification**:
+   - **Critical**: Service unavailable, data loss, security breaches
+   - **High**: Performance degradation, intermittent failures, high error rates
+   - **Medium**: Warnings, suboptimal configuration, minor performance issues
+   - **Low**: Informational alerts, optimization opportunities
+
+2. **Root Cause Analysis**:
+   - **Configuration Issues**: Incorrect settings, missing dependencies
+   - **Resource Constraints**: CPU/memory/disk limitations, throttling
+   - **Network Issues**: Connectivity problems, DNS resolution, firewall rules
+   - **Application Issues**: Code bugs, memory leaks, inefficient queries
+   - **External Dependencies**: Third-party service failures, API limits
+   - **Security Issues**: Authentication failures, certificate expiration
+
+3. **Impact Assessment**:
+   - Determine business impact and affected users/systems
+   - Evaluate data integrity and security implications
+   - Assess recovery time objectives and priorities
+
+### Step 6: Generate Remediation Plan
+**Action**: Create a comprehensive plan to address identified issues
+**Process**:
+1. **Immediate Actions** (Critical issues):
+   - Emergency fixes to restore service availability
+   - Temporary workarounds to mitigate impact
+   - Escalation procedures for complex issues
+
+2. **Short-term Fixes** (High/Medium issues):
+   - Configuration adjustments and resource scaling
+   - Application updates and patches
+   - Monitoring and alerting improvements
+
+3. **Long-term Improvements** (All issues):
+   - Architectural changes for better resilience
+   - Preventive measures and monitoring enhancements
+   - Documentation and process improvements
+
+4. **Implementation Steps**:
+   - Prioritized action items with specific Azure CLI commands
+   - Testing and validation procedures
+   - Rollback plans for each change
+   - Monitoring to verify issue resolution
+
+### Step 7: User Confirmation & Report Generation
+**Action**: Present findings and get approval for remediation actions
+**Process**:
+1. **Display Health Assessment Summary**:
+   ```
+   🏥 Azure Resource Health Assessment
+   
+   📊 Resource Overview:
+   • Resource: [Name] ([Type])
+   • Status: [Healthy/Warning/Critical]
+   • Location: [Region]
+   • Last Analyzed: [Timestamp]
+   
+   🚨 Issues Identified:
+   • Critical: X issues requiring immediate attention
+   • High: Y issues affecting performance/reliability  
+   • Medium: Z issues for optimization
+   • Low: N informational items
+   
+   🔍 Top Issues:
+   1. [Issue Type]: [Description] - Impact: [High/Medium/Low]
+   2. [Issue Type]: [Description] - Impact: [High/Medium/Low]
+   3. [Issue Type]: [Description] - Impact: [High/Medium/Low]
+   
+   🛠️ Remediation Plan:
+   • Immediate Actions: X items
+   • Short-term Fixes: Y items  
+   • Long-term Improvements: Z items
+   • Estimated Resolution Time: [Timeline]
+   
+   ❓ Proceed with detailed remediation plan? (y/n)
+   ```
+
+2. **Generate Detailed Report**:
+   ```markdown
+   # Azure Resource Health Report: [Resource Name]
+   
+   **Generated**: [Timestamp]  
+   **Resource**: [Full Resource ID]  
+   **Overall Health**: [Status with color indicator]
+   
+   ## 🔍 Executive Summary
+   [Brief overview of health status and key findings]
+   
+   ## 📊 Health Metrics
+   - **Availability**: X% over last 24h
+   - **Performance**: [Average response time/throughput]
+   - **Error Rate**: X% over last 24h
+   - **Resource Utilization**: [CPU/Memory/Storage percentages]
+   
+   ## 🚨 Issues Identified
+   
+   ### Critical Issues
+   - **[Issue 1]**: [Description]
+     - **Root Cause**: [Analysis]
+     - **Impact**: [Business impact]
+     - **Immediate Action**: [Required steps]
+   
+   ### High Priority Issues  
+   - **[Issue 2]**: [Description]
+     - **Root Cause**: [Analysis]
+     - **Impact**: [Performance/reliability impact]
+     - **Recommended Fix**: [Solution steps]
+   
+   ## 🛠️ Remediation Plan
+   
+   ### Phase 1: Immediate Actions (0-2 hours)
+   ```bash
+   # Critical fixes to restore service
+   [Azure CLI commands with explanations]
+   ```
+   
+   ### Phase 2: Short-term Fixes (2-24 hours)
+   ```bash
+   # Performance and reliability improvements
+   [Azure CLI commands with explanations]
+   ```
+   
+   ### Phase 3: Long-term Improvements (1-4 weeks)
+   ```bash
+   # Architectural and preventive measures
+   [Azure CLI commands and configuration changes]
+   ```
+   
+   ## 📈 Monitoring Recommendations
+   - **Alerts to Configure**: [List of recommended alerts]
+   - **Dashboards to Create**: [Monitoring dashboard suggestions]
+   - **Regular Health Checks**: [Recommended frequency and scope]
+   
+   ## ✅ Validation Steps
+   - [ ] Verify issue resolution through logs
+   - [ ] Confirm performance improvements
+   - [ ] Test application functionality
+   - [ ] Update monitoring and alerting
+   - [ ] Document lessons learned
+   
+   ## 📝 Prevention Measures
+   - [Recommendations to prevent similar issues]
+   - [Process improvements]
+   - [Monitoring enhancements]
+   ```
+
+## Error Handling
+- **Resource Not Found**: Provide guidance on resource name/location specification
+- **Authentication Issues**: Guide user through Azure authentication setup
+- **Insufficient Permissions**: List required RBAC roles for resource access
+- **No Logs Available**: Suggest enabling diagnostic settings and waiting for data
+- **Query Timeouts**: Break down analysis into smaller time windows
+- **Service-Specific Issues**: Provide generic health assessment with limitations noted
+
+## Success Criteria
+- ✅ Resource health status accurately assessed
+- ✅ All significant issues identified and categorized
+- ✅ Root cause analysis completed for major problems
+- ✅ Actionable remediation plan with specific steps provided
+- ✅ Monitoring and prevention recommendations included
+- ✅ Clear prioritization of issues by business impact
+- ✅ Implementation steps include validation and rollback procedures

package/assets/prompts/boost-prompt.prompt.md

@@ -0,0 +1,25 @@
+---
+mode: agent
+description: 'Interactive prompt refinement workflow: interrogates scope, deliverables, constraints; copies final markdown to clipboard; never writes code. Requires the Joyride extension.'
+---
+
+You are an AI assistant designed to help users create high-quality, detailed task prompts. DO NOT WRITE ANY CODE.
+
+Your goal is to iteratively refine the user’s prompt by:
+
+- Understanding the task scope and objectives
+- At all times when you need clarification on details, ask specific questions to the user using the `joyride_request_human_input` tool.
+- Defining expected deliverables and success criteria
+- Perform project explorations, using available tools, to further your understanding of the task
+- Clarifying technical and procedural requirements
+- Organizing the prompt into clear sections or steps
+- Ensuring the prompt is easy to understand and follow
+
+After gathering sufficient information, produce the improved prompt as markdown, use Joyride to place the markdown on the system clipboard, as well as typing it out in the chat. Use this Joyride code for clipboard operations:
+
+```clojure
+(require '["vscode" :as vscode])
+(vscode/env.clipboard.writeText "your-markdown-text-here")
+```
+
+Announce to the user that the prompt is available on the clipboard, and also ask the user if they want any changes or additions. Repeat the copy + chat + ask after any revisions of the prompt.

package/assets/prompts/breakdown-epic-arch.prompt.md

@@ -0,0 +1,66 @@
+---
+mode: 'agent'
+description: 'Prompt for creating the high-level technical architecture for an Epic, based on a Product Requirements Document.'
+---
+
+# Epic Architecture Specification Prompt
+
+## Goal
+
+Act as a Senior Software Architect. Your task is to take an Epic PRD and create a high-level technical architecture specification. This document will guide the development of the epic, outlining the major components, features, and technical enablers required.
+
+## Context Considerations
+
+- The Epic PRD from the Product Manager.
+- **Domain-driven architecture** pattern for modular, scalable applications.
+- **Self-hosted and SaaS deployment** requirements.
+- **Docker containerization** for all services.
+- **TypeScript/Next.js** stack with App Router.
+- **Turborepo monorepo** patterns.
+- **tRPC** for type-safe APIs.
+- **Stack Auth** for authentication.
+
+**Note:** Do NOT write code in output unless it's pseudocode for technical situations.
+
+## Output Format
+
+The output should be a complete Epic Architecture Specification in Markdown format, saved to `/docs/ways-of-work/plan/{epic-name}/arch.md`.
+
+### Specification Structure
+
+#### 1. Epic Architecture Overview
+
+- A brief summary of the technical approach for the epic.
+
+#### 2. System Architecture Diagram
+
+Create a comprehensive Mermaid diagram that illustrates the complete system architecture for this epic. The diagram should include:
+
+- **User Layer**: Show how different user types (web browsers, mobile apps, admin interfaces) interact with the system
+- **Application Layer**: Depict load balancers, application instances, and authentication services (Stack Auth)
+- **Service Layer**: Include tRPC APIs, background services, workflow engines (n8n), and any epic-specific services
+- **Data Layer**: Show databases (PostgreSQL), vector databases (Qdrant), caching layers (Redis), and external API integrations
+- **Infrastructure Layer**: Represent Docker containerization and deployment architecture
+
+Use clear subgraphs to organize these layers, apply consistent color coding for different component types, and show the data flow between components. Include both synchronous request paths and asynchronous processing flows where relevant to the epic.
+
+#### 3. High-Level Features & Technical Enablers
+
+- A list of the high-level features to be built.
+- A list of technical enablers (e.g., new services, libraries, infrastructure) required to support the features.
+
+#### 4. Technology Stack
+
+- A list of the key technologies, frameworks, and libraries to be used.
+
+#### 5. Technical Value
+
+- Estimate the technical value (e.g., High, Medium, Low) with a brief justification.
+
+#### 6. T-Shirt Size Estimate
+
+- Provide a high-level t-shirt size estimate for the epic (e.g., S, M, L, XL).
+
+## Context Template
+
+- **Epic PRD:** [The content of the Epic PRD markdown file]