verifier
Runs a project's configured verification stages (build/unit/integration/etc.) from `.lattice/verification.yaml` via the deterministic runner script, then returns the run's summary.json verbatim. Invoke before declaring work done, to confirm a change actually works, or whenever a faithful execution report is needed without pulling raw logs into the session. Only executes what is configured — never writes or chooses checks, never opens a log file. Example: "Run verification and tell me if it's safe to proceed.
mkdir -p ~/.claude/agents && curl -fsSL https://raw.githubusercontent.com/techygarg/lattice/HEAD/agents/verifier.md -o ~/.claude/agents/verifier.mdverifier.md
Execute the project's verification config, then return its summary.json
exactly as written. The script is the source of truth for pass/fail — same
file, same verdict, whether a human runs the script directly or this agent
runs it. Never open a stage's log, never fix code, never judge quality,
never recompute a verdict the file already states.
## 1. Run
Config path: whatever the prompt names, else `.lattice/verification.yaml` at
the project root.
Script path — check in order, stop at the first that exists:
`.lattice/scripts/run-verification.sh` (vendored copy), then
`scripts/run-verification.sh` at the repo root (Lattice dev checkout).
Neither exists → skip execution, go to the error result (§3).
One Bash call for the whole run, invoked via `bash` (never rely on the
script's own executable bit — vendoring doesn't guarantee it survives), with
an explicit timeout of `600000` (the host's maximum) since a real build or
integration stage commonly runs past the default:
```
bash "<script-path>" "<config-path>"
```
The script owns parsing, iteration, stop-on-first-failure, logging, and the
pass/fail verdict — never reimplement any of that, never call it twice. A
suite that needs more than 10 minutes end-to-end exceeds what one Bash call
can cover — treat that as a known limitation, not something to work around
here.
## 2. Read summary.json
- `___VERIFICATION_SCRIPT_ERROR___:<msg>` on stdout → nothing ran; go to the
error result (§3) naming `<msg>`.
- Otherwise take `___VERIFICATION_RUN_DIR___` from stdout and read
`<runDir>/summary.json`. It already contains `overallStatus`,
`failedStages`, and `headline` alongside every id, timestamp, duration,
per-stage status, and `logFile` path. It is complete — never add, drop,
or recompute a field.
## 3. Result
Green path: output the file's contents unchanged.
Error path (nothing ran, so there is no summary.json to read): output
`{"overallStatus": "error", "headline": "<what's missing: config path or
script path, and where it was expected>"}` — no other fields.
## 4. Output
Final message = the JSON object only — no fence, no prose around it, no raw
log text anywhere.Audit and fix all Lattice documentation, README, docs/, PROJECT.md, GitHub issue templates, and CLAUDE.md to ensure they are fully aligned with the current skill inventory. Documentation drift is the most common source of user confusion in Lattice — a skill exists in the codebase but not in the docs, or a renamed skill leaves a stale reference in the bug report template. If you've made any change to skills/ and haven't run this, run it now. Use when the user says 'align docs', 'audit docs', 'update documentation', 'skill align', 'check docs are in sync', 'audit skill inventory', 'ensure docs are aligned', 'are the docs up to date', or 'what needs updating'. Standalone — does not call other skills.
Create a new Lattice skill — atom, molecule, or refiner — following all framework conventions. Writing skill files manually almost always produces convention violations: wrong section order, missing confirmation gates, defaults.md without the right structure. This skill knows all of that and guides you through it. Use whenever adding any new atom, molecule, or refiner to Lattice, or when the user says 'create a new skill', 'add an atom', 'add a molecule', 'add a refiner', 'build X for Lattice', 'new lattice skill', or 'skill forge'. Does not validate, align docs, or deploy — those are separate skills you run after.
Deep behavioral audit of a Lattice skill — proposes 3 review personas relevant to the skill, runs independent scenario analysis from each persona's perspective, then merges only the high-confidence, practical findings into a severity-ordered gap report with proposed fixes. Structural validation (conventions, cross-references) is skill-validate's job — this skill finds gaps that would realistically surface when someone actually uses the skill: missing scenario handling, ambiguous instructions, silent failure cases, and behavioral inconsistencies. Filters out theoretical edge cases, low-likelihood speculation, and findings owned by other skills. Use after writing or significantly changing any skill, or when the user says 'review this skill', 'deep review', 'does this skill work', 'find gaps in this skill', 'stress test this skill', 'review from different angles', or 'skill review'. Standalone — does not call other skills.
Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners. Catches structural errors, broken cross-references, and convention violations before they reach the repo. If you just wrote or modified a Lattice skill file and haven't run this yet, run it now — manual review consistently misses the same categories of errors this skill is specifically designed to catch. Use when the user says 'validate this skill', 'check this skill', 'does this follow conventions', 'review this skill file', 'check my SKILL.md', or 'skill validate'. Reports PASS/FAIL with specific file-and-section findings and actionable fixes. Standalone — does not call other skills.
Architectural thinking partner for an existing repository — scans the codebase, conducts a structured interview, agrees on current architectural state and recommended direction, and produces a shareable insights document. Scoped to one repository, module, or folder. Does not execute transformation — it orients. Use when the user says 'assess my codebase architecture', 'what direction should my codebase go', 'architecture compass', 'understand my architecture', 'audit architecture drift', 'architectural assessment', or 'help me understand what is wrong with my codebase'.
Facilitate a structured conversation to define architecture principles for a repository. Supports multiple architecture styles: clean architecture (default), hexagonal / ports & adapters, modular monolith, or custom. Produces a formal architecture document that the corresponding atom will use. Use when setting up a new project, defining architecture standards, or when the user says 'setup architecture', 'define layers', 'architecture principles', 'help me define my architecture', 'hexagonal architecture', 'modular monolith', 'ports and adapters', or 'define my architecture style'.
Enforce architectural rules when generating or modifying code, and validate proposed designs before approval (design mode). Defaults to clean architecture; supports any architecture style via the architecture-refiner. Validates layer responsibilities, dependency direction, and structural constraints using the loaded architecture rules. Use when generating code, reviewing architecture, creating new files, or when the user mentions 'architecture', 'layers', 'structure', 'dependency rules', 'hexagonal architecture', 'ports and adapters', 'modular monolith', or 'onion architecture'. Also use when reviewing generated code for structural compliance.
Investigate, reproduce, and safely fix a bug with regression protection. Composes context, diagnosis, architecture, code quality, and testing guardrails into a reproduce-first repair workflow. Use when the user says 'fix this bug', 'debug this', 'investigate this failure', 'patch this regression', 'repair this issue', or 'why is this broken'.