> ## Documentation Index
> Fetch the complete documentation index at: https://docs.scoutqa.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Issues

> Track and triage quality issues discovered during Scout explorations.

Issues are quality problems that Scout discovers while exploring your application. From accessibility gaps to security concerns, Scout automatically detects, categorizes, and reports issues so your team can prioritize fixes.

## Issue categories

Scout classifies issues into five categories:

| Category          | Description                                                       | Example                                                              |
| ----------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------- |
| **Accessibility** | Barriers that prevent users with disabilities from using your app | Missing form labels, low color contrast, keyboard navigation issues  |
| **Security**      | Potential vulnerabilities or unsafe practices                     | Exposed credentials, insecure form handling, authentication bypasses |
| **Performance**   | Slow or resource-intensive behaviors                              | Long page load times, unoptimized images, memory leaks               |
| **Usability**     | Confusing or broken user experiences                              | Dead links, unclear error messages, inconsistent form validation     |
| **Other**         | Issues that don't fit other categories                            | Unexpected behavior, edge case failures                              |

## Severity levels

Each issue is assigned a severity to help you prioritize:

<CardGroup cols={2}>
  <Card title="Critical" icon="circle-exclamation" color="#ef4444">
    Severe problems that block core functionality or pose significant security risks. Address immediately.
  </Card>

  <Card title="High" icon="triangle-exclamation" color="#f97316">
    Important issues affecting user experience or application stability. Plan to fix soon.
  </Card>

  <Card title="Medium" icon="circle-minus" color="#eab308">
    Notable problems that should be addressed but aren't urgent. Add to your backlog.
  </Card>

  <Card title="Low" icon="circle" color="#22c55e">
    Minor issues or suggestions for improvement. Fix when convenient.
  </Card>
</CardGroup>

## Issue statuses

Track resolution progress with three statuses:

* **Open** — Issue needs attention. This is the default status when Scout discovers a problem.
* **Resolved** — Issue has been fixed. Mark issues resolved after deploying a fix.
* **Dismissed** — Issue is intentionally ignored. Use for false positives or accepted risks.

## Viewing issues

### Project issues list

<img src="https://mintcdn.com/scoutqa/ax3DXfgq5WjWC9Od/images/issues-list.png?fit=max&auto=format&n=ax3DXfgq5WjWC9Od&q=85&s=ce03bd5e856dba6e49039c45daa5dbe0" alt="Issues list view" width="4104" height="2330" data-path="images/issues-list.png" />

Access all issues across executions from the **Issues** page in your project. From here you can:

* **Search** by title to find specific issues
* **Filter** by status (Open, Resolved, Dismissed)
* **Filter** by severity (Critical, High, Medium, Low)
* **Filter** by category (Accessibility, Security, etc.)
* **Sort** by when issues were discovered

### Issue details

Click any issue to see the full details:

<AccordionGroup>
  <Accordion title="Summary">
    A brief description of what Scout found and why it's a problem.
  </Accordion>

  <Accordion title="Impact">
    Bullet points explaining how this issue affects users or your application.
  </Accordion>

  <Accordion title="Reproduction steps">
    The sequence of actions Scout took to discover the issue. This helps you reproduce and verify the problem.
  </Accordion>

  <Accordion title="How to fix">
    Guidance on resolving the issue, tailored to your specific context.
  </Accordion>
</AccordionGroup>

## Managing issues

### Update severity

If Scout's initial severity assessment doesn't match your priorities, you can adjust it. Click the severity dropdown on any issue to change it.

### Resolve issues

After fixing an issue:

1. Open the issue details
2. Click **Resolve**
3. The issue moves to Resolved status

<Tip>
  Run a new exploration after deploying fixes to verify issues are truly resolved. Scout will create new issues if problems persist.
</Tip>

### Dismiss issues

For false positives or accepted risks:

1. Open the issue details
2. Click **Dismiss**
3. Optionally add a reason for dismissing

Dismissed issues won't clutter your open issues list but remain in your history for reference.

### Fix with coding agents

<Note>
  **New in v0.11.0:** Go from bug discovery to bug fix in one click.
</Note>

When Scout finds a bug, you can send it directly to your preferred coding agent for fixing:

1. Open the issue details
2. Click **Fix with Agent**
3. Choose your agent — **Cursor**, **Codex**, or **Windsurf**
4. The agent launches with the bug context (summary, reproduction steps, suggested fix) pre-loaded

This creates a seamless loop: Scout finds bugs → coding agent fixes them → Scout verifies the fix.

### Verify bugs by re-running related flows

You can verify whether a bug is reproducible by re-running only the specific flow that triggered it.

**From the web UI:**

1. Open the issue details
2. Click **Verify Bug**
3. Scout re-runs only the specific flow that triggered the issue

**From the CLI:**

```bash theme={null}
# List issues from a previous execution
scoutqa list-issues --execution-id <execution-id>

# Verify a specific issue
scoutqa issue-verify --issue-id <issue-id>
```

<Tip>
  Use CLI verification in your CI/CD pipeline to automatically confirm bug fixes before merging.
</Tip>

This targeted approach is faster than running a full exploration and helps you quickly confirm:

* Whether the bug is consistently reproducible
* Whether your fix resolved the issue
* Whether the bug was a one-time occurrence

## Best practices

<AccordionGroup>
  <Accordion title="Triage regularly">
    Review new issues after each exploration. Quick triage keeps your issue list actionable and prevents important problems from getting lost.
  </Accordion>

  <Accordion title="Start with Critical and High">
    Focus on the most severe issues first. These typically have the biggest impact on users and may indicate broader problems.
  </Accordion>

  <Accordion title="Use filters effectively">
    Filter by category when working on specific areas. For example, filter to Security issues before a release or Accessibility issues during an audit.
  </Accordion>

  <Accordion title="Document dismissals">
    When dismissing issues, add a reason. This helps teammates understand why an issue was ignored and prevents re-discovery confusion.
  </Accordion>

  <Accordion title="Track trends over time">
    Notice patterns in your issues. Repeated accessibility problems might indicate a need for developer training. Recurring security issues might suggest architecture improvements.
  </Accordion>
</AccordionGroup>

## Issue lifecycle

```mermaid theme={null}
graph LR
    A[Scout discovers issue] --> B[Open]
    B --> C{Action}
    C -->|Fix deployed| D[Resolved]
    C -->|False positive| E[Dismissed]
    C -->|Needs work| B
```

Issues start as **Open** when discovered. Your team reviews and either **Resolves** them after fixing or **Dismisses** them if they're not actionable. Resolved and dismissed issues stay in your history for tracking and auditing.