# Sigrid Reviewer
Sigrid is the quality gate for Valdr task work.

Use Sigrid when an implementation needs a quality gate before it can move forward. Sigrid reviews the task, acceptance criteria, checklist state, comments, session context, and worktree evidence before publishing an approval or changes-requested decision.

Execution proves that work was attempted. Review determines whether it should move forward. Sigrid exists to challenge the implementation, not validate the effort.

Sigrid answers one question: "Is this work actually ready to verify?"

## What this page covers

- When Sigrid should review work
- Why execution is not the same as acceptance
- How Sigrid fits between execution and verification
- How to use Sigrid from the UI and CLI
- What Sigrid should not be asked to do
- How the Sigrid reviewer is assembled inside the pack

## When you're new to Valdr

Start with Sigrid when:

- A task is ready for review
- You need findings grounded in acceptance criteria
- You need a severity call that separates functional defects from nits
- You want the review decision stored in Valdr instead of left in chat
- You need approved work to pass through the verification gate

Think of Sigrid as the quality gatekeeper. It should fail closed when evidence is missing or the implementation does not satisfy the task.

Sigrid treats review as a gate, not a courtesy pass. The review is workflow state: a published decision that either lets the task advance or sends actionable feedback back toward execution.

## Use Sigrid when

| Need | Ask Sigrid to |
|------|---------------|
| Task review | Inspect a task implementation against the task description and acceptance criteria |
| Checklist validation | Confirm required checklist items are complete and supported by evidence |
| Finding classification | Classify defects as blocker, high, medium, or nit using reviewer rules |
| Review publication | Publish status, score, recommendation, findings, and follow-up questions |
| Verification gate | Move approved work forward only when the task is ready to verify |

Sigrid is review-focused. It can inspect code and session context, but it should not be the agent that implements the fix. When Sigrid requests changes, route that feedback back to the executor session or launch follow-up work.

## First five minutes with Sigrid

A first Sigrid session should feel like turning an agent's claim into a reviewable decision:

| You ask | Sigrid helps by |
|---------|-----------------|
| "Review task WEB-142." | Fetching the task and checking whether a reviewer assignment already exists |
| "Is this ready to verify?" | Comparing the implementation to acceptance criteria and checklist state |
| "How severe is this issue?" | Applying severity rules before publishing the finding |
| "What should the executor fix?" | Publishing changes requested and sending actionable feedback when session routing is available |

The core value is an evidence-backed gate. Sigrid should not approve work just because the executor says it is done. Execution is not acceptance.

## How to use Sigrid

{{% steps %}}

### Start with a task key

Open the task in the Valdr UI, or launch a reviewer session with handle `sigrid`. Give Sigrid the task key and any focus area that matters for the review.

From Claude Code or Codex CLI, use the [`valdr-reviewer`](/valdr/docs/skills/valdr-reviewer/) wrapper and name the handle:

```text
/valdr-reviewer
Review task WEB-142 with reviewer sigrid and focus on acceptance criteria and regression risk.
```

### Let Sigrid resolve review context

Sigrid should fetch the task, comments, plan context, checklist state, reviewer assignment, and execution session or worktree before reviewing.

### Inspect before deciding

Ask Sigrid to cite findings against behavior, acceptance criteria, tests, or risk. Functional issues should not be softened into nits.

### Publish the review

Sigrid should publish the review through the review workflow, not leave the decision only in chat. The review should include status, score, recommendation, findings, and any open questions.

### Route the outcome

If approved, Sigrid checks whether the task can move through verification. If changes are requested, Sigrid should make the feedback actionable for the executor path.

{{% /steps %}}

## Which workflow agent should I use?

| Need | Start with |
|------|------------|
| Turn a rough idea into a plan and tasks | **Freya** |
| Review a completed task implementation | **Sigrid** |
| Score how an agent session performed | **Tyr** |
| Coordinate reviewer assignment and sprint flow | **Skadi** |

Sigrid is the right agent when the task exists and implementation evidence is ready to inspect. Use Freya before execution, and use Tyr after or alongside review when you need session-quality scoring.

## Strong prompts

Use Sigrid for review requests tied to a task:

- "Review task `WEB-142` with reviewer `sigrid`."
- "Check whether `OPS-31` satisfies its acceptance criteria and publish the review."
- "Review this implementation with extra focus on permission changes and risky shell commands."
- "Classify the findings before publishing and do not approve if any functional issue remains."
- "If changes are requested, make the feedback actionable for the executor."

The best Sigrid prompts provide the task key and review focus. Avoid vague "looks good?" prompts; ask for an actual review decision.

## Typical workflow

1. Give Sigrid the task key.
2. Let Sigrid resolve task state, reviewer assignment, and execution context.
3. Ask Sigrid to evaluate acceptance criteria and checklist evidence.
4. Publish approval or changes requested.
5. Let the verification gate move approved work forward, or route changes back to execution.

Sigrid makes the implementation decision inspectable; the workflow follows the decision.

## How Sigrid is built (advanced)

The pack defines Sigrid with inlined review flow plus hot-loaded review standards:

| Capability | Role | Use |
|------------|------|-----|
| `valdr.reviewer.sigrid.system` | Core | Identity, gatekeeper mindset, verification gate, tool index, and anti-patterns |
| `valdr.reviewer.sigrid.workflow` | Workflow | Review preflight, route selection, worktree resolution, checklist validation, publication, and executor notification |
| `valdr.reviewer.sigrid.severity` | Constraints | Severity classification for blocker, high, medium, and nit findings |
| `valdr.reviewer.sigrid.scoring` | Constraints | Status, score, and recommendation alignment before publishing |

You do not need these capability keys to use Sigrid. They matter when you want to understand how Sigrid keeps review decisions aligned with evidence, severity, score, and verification state.

## What Sigrid should not do

Sigrid is not the executor and should not approve work without evidence. Do not use it to make code changes, skip checklist validation, or downgrade functional defects into style feedback.

| Instead of asking Sigrid to... | Ask Sigrid to... |
|--------------------------------|------------------|
| "Approve this quickly." | "Review this task against acceptance criteria and publish the correct decision." |
| "Call this bug a nit so it can pass." | "Classify the finding using severity rules and block if the issue is functional." |
| "Summarize the diff in chat." | "Publish a review decision with findings, score, recommendation, and follow-up questions." |

Need to know whether the agent run itself was reliable? Use [Tyr](../tyr/) after review to audit session quality.