Bug ReportClearly report a bug with detailed repro steps["bug"]What version of Roo Code are you using? (e.g., v3.3.1)
- Anthropic
- AWS Bedrock
- Chutes AI
- DeepSeek
- Glama
- Google Gemini
- Google Vertex AI
- Groq
- Human Relay Provider
- LiteLLM
- LM Studio
- Mistral AI
- Ollama
- OpenAI
- OpenAI Compatible
- OpenRouter
- Requesty
- Unbound
- VS Code Language Model API
- xAI (Grok)
- Not Applicable / Other
Exact model name (e.g., Claude 3.7 Sonnet). Use N/A if irrelevant.
Help us see what you saw. Give clear, numbered steps:
1. Setup (OS, extension version, settings)
2. Exact actions (clicks, input, files, commands)
3. What happened after each step
Think like you're writing a recipe. Without this, we can't reproduce the issue.
Recap what went wrong in one or two lines.
Example: "Expected code to run, but got an empty response and no error."
Expected ___, but got ___.Paste API logs, terminal output, or errors here. Use triple backticks (```) for code formatting.shellDetailed Feature ProposalReport a specific problem that needs solving in Roo Code["proposal", "enhancement"]
**Be concrete and detailed.** Explain the problem from a user's perspective.
✅ **Good examples (specific, clear impact):**
- "When running large tasks, users wait 5+ minutes because tasks execute sequentially instead of in parallel, blocking productivity"
- "AI can only read one file per request, forcing users to make multiple requests for multi-file projects, increasing wait time from 30s to 5+ minutes"
- "Dark theme users can't see the submit button because it uses white text on light grey background"
❌ **Poor examples (vague, unclear impact):**
- "The UI looks weird" -> What specifically looks weird? On which screen? What's the impact?
- "System prompt is not good" -> What's wrong with it? What behaviour does it cause? What should it do instead?
- "Performance could be better" -> Where? How slow is it currently? What's the user impact?
**Your problem description should answer:**
- Who is affected? (all users, specific user types, etc.)
- When does this happen? (specific scenarios/steps)
- What's the current behaviour vs expected behaviour?
- What's the impact? (time wasted, errors caused, etc.)
Be specific about the problem, who it affects, and the impact. Avoid generic statements like "it's slow" or "it's confusing."Mockups, screenshots, links, user quotes, or other relevant information that supports your proposal.
**Important:** If you check "Yes" below, the technical sections become REQUIRED.
We need detailed technical analysis from contributors to ensure quality implementation.
**If you want to implement this feature, this section is REQUIRED.**
**Describe your solution in detail.** Explain not just what to build, but how it should work.
✅ **Good examples:**
- "Add parallel task execution: Allow up to 3 tasks to run simultaneously with a queue system for additional tasks. Show progress for each active task in the UI."
- "Enable multi-file AI processing: Modify the request handler to accept multiple files in a single request and process them together, reducing round trips."
- "Fix button contrast: Change submit button to use primary colour on dark theme (white text on blue background) instead of current grey."
❌ **Poor examples:**
- "Make it faster" -> How? What specific changes?
- "Improve the UI" -> Which part? What specific improvements?
- "Fix the prompt" -> What should the new prompt do differently?
**Your solution should explain:**
- What exactly will change?
- How will users interact with it?
- What will the new behaviour look like?
Describe the specific changes and how they will work. Include user interaction details if relevant.
**If you want to implement this feature, this section is REQUIRED.**
**This is crucial - don't skip it.** Define what "working" looks like with specific, testable criteria.
**Format suggestion:**
```
Given [context/situation]
When [user action]
Then [expected result]
And [additional expectations]
But [what should NOT happen]
```
**Example:**
```
Given I have 5 large tasks to run
When I start all of them
Then they execute in parallel (max 3 at once, can be configured)
And I see progress for each active task
And queued tasks show "waiting" status
But the UI doesn't freeze or become unresponsive
```
Define specific, testable criteria. What should users be able to do? What should happen? What should NOT happen?
Use the Given/When/Then format above or your own clear structure.
**If you want to implement this feature, this section is REQUIRED.**
Share technical insights that could help planning:
- Implementation approach or architecture changes
- Performance implications
- Compatibility concerns
- Systems that might be affected
- Potential blockers you can foresee
e.g., "Will need to refactor task manager", "Could impact memory usage on large files", "Requires a large portion of code to be rewritten"
**If you want to implement this feature, this section is REQUIRED.**
What could go wrong or what alternatives did you consider?
- Alternative approaches and why you chose this one
- Potential negative impacts (performance, UX, etc.)
- Breaking changes or migration concerns
- Edge cases that need careful handling
e.g., "Alternative: use library X but it is 500KB larger", "Risk: might slow older devices", "Breaking: changes API response format"
Template now focuses on problem reporting first, with solution contribution as optional
Only problem description and context are required for basic submission
Technical fields (solution, acceptance criteria, etc.) are only required if user wants to contribute
Users can submit after describing the problem without technical details
Implementation guidance moved to contributor section only