/review-refiner

name: review-refiner
description: "Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging. Produces a formal review-standards.md document that the review molecule will use as its process configuration. Use when the user says 'customize review', 'configure review', 'review preferences', 'review settings', 'change review process', or 'set up review'."

Review Refiner

What This Produces

• **Output**: `.lattice/standards/review-standards.md` (or custom path from `.lattice/config.yaml` → `paths.review_standards`)
• **Two modes**:
• **Overlay** (`mode: overlay`): A slim document containing only sections that differ from the defaults. The review molecule reads its embedded defaults first, then applies this document's sections on top. This is the expected common case.
• **Override** (`mode: override`): A comprehensive standalone document that fully replaces the molecule's embedded defaults. For teams with fundamentally different review processes.
• **Default mode**: Overlay -- produces only what the user wants to change
• **Config key**: `paths.review_standards` in `.lattice/config.yaml`
• **Consumed by**: The review molecule (NOT an atom -- this is the first molecule-level config)
• **Template**: Read `./assets/template.md` for the full document structure, default content, and interview guidance comments

Scope Clarification

This refiner configures the review *process* -- how the review molecule orchestrates atom output. It does NOT configure what atoms check for.

| Belongs here (process orchestration) | Belongs in atom refiners (quality standards) | |---------------------------------------|----------------------------------------------| | Which atoms load and when | What checks an atom runs | | Severity level definitions | What constitutes a violation | | Report format and grouping | Checklist items and anti-patterns | | Delta scope rules | Layer definitions, naming rules | | Insight capture preferences | Domain modeling rules | | Health log format | Security check thresholds | | Custom review dimensions | Atom-specific validation logic |

If a user asks about changing what an atom checks for, redirect them to the appropriate atom refiner (architecture-refiner, clean-code-refiner, ddd-refiner).

Before You Begin

Check for existing documents

Before starting the interview, check whether a custom document already exists:

1. Read `.lattice/config.yaml` — does `paths.review_standards` point to a file? 2. If yes, read that file. Ask the user:

• "You already have a review standards document. Would you like to **revise** it (update specific sections), **start fresh** (new interview), or **add to it** (add new sections)?"
• Revise: Load the existing document, walk through only the sections the user wants to change, and update in place.
• Start fresh: Proceed with the full interview flow below.
• Add to it: Skip to the sections the user wants to add (e.g., custom dimensions).

3. If no config or no existing document, proceed with the full interview flow.

Scan for context

Look for signals that inform the conversation:

• **Existing review history**: Check the review log (the path an `additional_instructions.review` line in `.lattice/config.yaml` names, else `.lattice/reviews/review-log.md`) — what atoms have been loading? What severity patterns exist? Are there recurring findings?
• **Existing learnings**: Check the learnings file (resolved per `learning-harvest` Config Resolution: `paths.operational_learnings`, else `.lattice/learnings/operational-learnings.md`) — what patterns have been captured? Is the file growing dense in any category?
• **Project structure**: What does the codebase look like? Are there directories that should be excluded or always-scanned?
• **Existing atom refiners**: Which atom refiners have been run? (Check `.lattice/config.yaml` for `paths.architecture`, `paths.clean_code`, `paths.ddd_principles`) This tells you which atoms the team cares about.

Share relevant findings with the user at the start: "I looked at your review history and noticed [patterns]. I'll use that as context for our conversation."

If the project is new with no review history, proceed with defaults as the starting point.

Choosing the Mode

The first decision in the conversation. Present the three options:

"How would you like to configure your review process?

1. **Customize specific sections** (overlay) — Keep the defaults and change only what differs for your project. This produces a slim document. Most teams choose this. 2. **Define everything from scratch** (override) — Walk through all sections and produce a comprehensive standalone document. 3. **Add project-specific sections only** (overlay with additions) — Keep all defaults as-is and add new sections for your team's specific rules (e.g., custom review dimensions).

The defaults cover a solid review workflow. Option 1 is recommended unless your review process needs to be fundamentally different."

Map the choice:

• Options 1 and 3 → `mode: overlay`
• Option 2 → `mode: override`

Facilitation Approach

Conversation style

• **One section at a time.** Do not dump all questions at once. Walk through the template sequentially.
• **Defaults-first.** For each section, briefly summarize the default, then ask if it matches. Do not read the entire default verbatim -- summarize the key points and ask.
• **Record decisions, not discussion.** The output document reads as a specification, not meeting notes. "We discussed X and decided Y" is wrong. "Y" is right.
• **Probe, don't interrogate.** Use the probing questions in the template guidance comments as follow-ups when the user's answer is ambiguous, not as a checklist.

For overlay mode

This should be fast. Many sections will be "keep as-is."

1. Present each section's default briefly (a 2-3 sentence summary,