[Introduction](https://verity.md/docs) [Quickstart](https://verity.md/docs/quickstart) [Authentication](https://verity.md/docs/authentication) [How it works](https://verity.md/docs/how-it-works) [Moments](https://verity.md/docs/moments) [Formal verification](https://verity.md/docs/formal) [Findings & verdicts](https://verity.md/docs/findings) [The Standard](https://verity.md/docs/standard) [Org Standards](https://verity.md/docs/org-standards) [Standards on the web](https://verity.md/docs/web-standards) [The terminal editor](https://verity.md/docs/terminal-editor) [Memory](https://verity.md/docs/memory) [Org knowledge](https://verity.md/docs/org-knowledge) [Token telemetry & cost](https://verity.md/docs/cost) [The dashboard](https://verity.md/docs/dashboard) [CLI & commands](https://verity.md/docs/cli) [Files & configuration](https://verity.md/docs/files) [Security & privacy](https://verity.md/docs/security) [Troubleshooting](https://verity.md/docs/troubleshooting)

Reference

# CLI & commands

Every verity command, the Claude Code skills it installs, and the environment it reads. Day to day you need three of them — the rest are here for tuning, automation and debugging.

## The three you will use

```
npm install -g @codacy/verity-cli   # install the CLI (the analyzer comes with it)
verity init                          # the whole setup, in the repo root: sign-in, hooks, your Standard
verity login                         # sign in again later: one GitHub login, every repo you can write to
# optional, inside Claude Code:
/verity-setup                        # check the project rules against the code, and add more
```

Upgrade with `npm install -g @codacy/verity-cli@latest`; server-side changes reach every installed CLI on deploy day without it. `verity --version` prints what you have.

## If you installed the Claude Code plugin

The plugin ships its own pinned copy of the CLI, and the CLI carries the analyzer. So **you do not install either separately** — Claude Code fetches them on install and again on every plugin update:

```
/plugin marketplace add codacy/verity
/plugin install verity@verity
/verity:init                         # in your project — asks in the session, then runs verity init
```

Every command on this page still works; it is the same binary. What changes is the wiring: the hooks and skills come from the plugin rather than `.claude/settings.json`, so `verity hooks install` is not something you need, and `verity init` detects the plugin and removes any duplicate hooks it finds (`--no-plugin` overrules that). Which review moments are gated still lives in the project, at `.verity/config.json` — set it with `verity config moments`.

Update with `claude plugin update verity@verity` in your shell, then `/reload-plugins` in any open session. There is no `/plugin update` slash command. Or turn on auto-update in `/plugin` → **Marketplaces** → `verity`. A global install and a plugin can coexist: the plugin's pinned copy is the one the hooks use.

Installed before 0.32.2?

The marketplace was named `codacy` up to 0.32.1, which collided with Codacy's skills marketplace. An install from the old name keeps running but never updates again — move it:

```
/plugin uninstall verity@codacy
/plugin marketplace add codacy/verity
/plugin install verity@verity
```

`verity doctor` reports this, and the collision, if either applies to your machine.

## Setup and maintenance

| Command | What it does |
| --- | --- |
| `verity init [--yes] [--standard use\|new] [--profile send\|skip] [--telemetry on\|off] [--moments <list>] [--no-plugin] [--no-adopt] [--force]` | The whole setup: prerequisites, skills, hooks, `.verity/`, the `CLAUDE.md` block, sign-in, telemetry — and your Standard: your team's, or a new one from the review packs, with project rules if you send the repository profile. Every other choice is printed as a default. Ends with `Changed: …` and `Ready`, or `Not finished` and exit code 1 when no usable Standard was set up. Migrates a legacy `.gate/` install. Safe to re-run (keeps your answers). `--yes` asks nothing: no sign-in unless you are signed in already, telemetry as it is, the team's Standard, no profile. `--standard`, `--profile` and `--telemetry` answer one question each. With `--standard new` and a `.verity/standard.yaml` here, init first sets the file aside (a copy goes to `.verity/standard.<time>.yaml`, CLI 0.35.2 and later). `--moments stop,pre-commit,pre-push` (or `none`) sets the moments. `--no-plugin` wires this project's own hooks although the plugin is installed. `--no-adopt` builds a new Standard even when the team has one. `--untrack-memory` and `--untrack-state` untrack committed Verity files. `--force` reinstalls the skills. `--intensity` is ignored with a warning, and `--no-setup` is ignored: both are kept only for old scripts. `verity setup` is an alias. |
| `verity doctor [--json]` | What is set up here and what is missing: prerequisites (including which copy of the analysis CLI Verity runs — a global copy it does not run is marked `not used`), your recorded answers, the hook wiring, telemetry and the Standard — plus a `next` list. Read-only. |
| `verity config moments [turn,commit,push \| none]` | Set when Verity reviews: any of `turn`, `commit` and `push`, or `none`. With no list, prints the current setting. The choice survives a re-run of `verity init` ([Moments](https://verity.md/docs/moments)). |
| `verity hooks install [--moments stop,pre-commit,pre-push] [--force]` | Wire the Claude Code hooks. `--moments` reconciles the hooks to exactly the set given. `verity config moments` also records your choice, so prefer it. Also `check` and `remove`. |
| `verity telemetry install \| check \| uninstall` | Turn cost & usage export on or off for every Claude Code session on this machine. It writes `~/.claude/settings.json`. Only Verity projects send. `check --json` for scripts. `headers` is what Claude Code calls at startup to fetch the authorization header — not for you. |
| `verity migrate` | Migrate a legacy GATE.md install (`.gate` → `.verity`, hooks, `CLAUDE.md`). `verity init` runs it automatically. |
| `verity uninstall [--dry-run] [--keep-verity-md] [--purge-global]` | Remove Verity from the project: skills, hooks, `.verity/`, `VERITY.md`. `--purge-global` also deletes `~/.verity/` and your saved logins. |
| `verity reset [--keep-task] [--all]` | Close the current task and clear transient state under `.verity/`; `--all` also purges the diagnostic logs. |

## Accounts and access

See [Authentication](https://verity.md/docs/authentication) for when to reach for each.

| Command | What it does |
| --- | --- |
| `verity login [--force]` | Log in through GitHub's device flow. Covers every repository you can write to, for 90 days. `--force` re-authenticates and refreshes your grants. |
| `verity logout [--others \| --all]` | Sign out this machine; `--others` every other machine (a lost laptop); `--all` everywhere. |
| `verity sessions list [--json]` | Your logins, one per machine and browser — device, last use, expiry. `sessions revoke <id>` ends one. |
| `verity token create --name <name> [--expires <days>]` | Mint a service token for CI, shown once — store it as `VERITY_TOKEN`. `token list` shows ids and metadata, never secrets; `token revoke <id>`. |
| `verity auth register \| verify \| discover` | The legacy per-project token flow. `register` is superseded by `login`; `verify` checks the current token; `discover` asks whether this repository is registered. |

## Reviewing

| Command | What it does |
| --- | --- |
| `verity analyze [--mode standard\|plan\|debug\|skip] [--skip-static] [--json]` | The review after a turn. Invoked by the Stop hook; run it by hand to review the current turn again, or force a mode. `--debounce`, `--max-files`, `--max-file-size`, `--max-total-size` and `--max-iterations` override the stop-turn budgets. |
| `verity guard --on commit,push` | The commit and push gates. Invoked by the `PreToolUse` hook on the agent's git commands; reviews the staged diff or the push range and blocks on a failing review. |
| `verity review --files <paths> [--changed <paths>] [--intent <text>] [--specs <paths>] [--json]` | An on-demand review of specific files. Advisory — it never blocks. `/verity-analyze` in Claude Code wraps it. |
| `verity status [--history] [--limit <n>] [--json]` | Who you are, the Standard version, the active moments, the last verdict and trend, any declared ignore, the `.verityignore` rules, and the findings still open. `--history` adds recent runs. |
| `verity run <run-id> [--json]` | One run's findings in full. |

## Formal verification

At push, on by default for a new project. What it does and which pushes qualify is in [Formal verification](https://verity.md/docs/formal).

| Command | What it does |
| --- | --- |
| `verity config formal push\|off` | Turn it on or off for this checkout. `VERITY_GIT_MOMENT_FORMAL=push\|off` overrides it for one command. |
| `verity lean status\|install\|remove` | The managed Lean 4 toolchain the models are checked with (≈800 MB download, 2.7 GB on disk). Once per machine. `verity init` starts the download in the background, and `status` shows its progress. |
| `verity prove candidates [paths] [--since <days>] [--limit <n>] [--rank deterministic\|luna]` | Rank the riskiest code from git history and shape signals. Deterministic signals always show; the ranker may re-order, never hide. |
| `verity prove auto [files] [--deadline <ms>] [--json]` | The push-time phase, run by hand on the commits ahead of upstream: select, model, check, replay. Records the phase like a push would; blocks nothing. |
| `verity prove generate <file#symbol> [--hint <text>]` | Have the service write a Lean model of one symbol, lint it, and check it here — up to three rounds. |
| `verity prove check \| replay` | Check the models under `.verity/proofs/`; replay a counterexample on the real code in a disposable container. |
| `verity prove waive <file> --reason "…"` | Dismiss a reproduced counterexample for the file's exact bytes. It returns when the file changes. |

## Answering a finding

What each of these means, and when to use which, is in [Findings & verdicts](https://verity.md/docs/findings).

| Command | What it does |
| --- | --- |
| `verity waive <pattern-id> --reason <text> [--file <path>]` | Record a human's accepted-risk decision on an open finding. The reason is mandatory; the waive is bound to the file's bytes and voids when they change. `--file` must be a path inside the repository. The record names your account, and your org's admins see every waive in the org's repositories. |
| `verity ignore [--turn \| --for <30m>] --reason <text> [--agent]` | Declare the next turn, or a window up to 60 minutes, as housekeeping with nothing to review. Voids the moment anything is authored. Three per session. `ignore clear` cancels it. |
| `verity feedback finding <run-id> <pattern-id> <action> [note] [--file <path>] [--line <n>]` | Per-finding feedback: `false_positive`, `acknowledged`, `useful`. Enough false-positive votes suppress the pattern at that site. |
| `verity feedback message <text>` | Anything else you want the Verity team to know. |

## The Standard

What each part of the Standard does is in [The Standard](https://verity.md/docs/standard).

| Command | What it does |
| --- | --- |
| `verity standard edit [--org [name]]` | The full-screen editor at a terminal with Node 22 or later: every rule, Block, Warn or Off, severity, your own rules, saved as one new version. `--org` opens your org's Standard. Elsewhere it opens the YAML in `$EDITOR`, or prints the rules. See [The terminal editor](https://verity.md/docs/terminal-editor). |
| `verity standard set <rule> block\|warn\|off\|default` | Set what one rule does, saved as a new version. Inside Claude Code the history names it as an agent's change. |
| `verity standard refine <rule> [--case <text>] [--near-miss <text>] [--only-in <glob>]` | Add to one rule for this repository: a case it must also find, a near miss that is fine here, or the paths it applies to. |
| `verity standard draft "<words>" \| --from-finding <run-id:index> [--json]` | Draft one rule from your words or from a finding. Verity writes the title, the rule, the evidence it needs and an example, and names the rules it overlaps. A draft is at most medium severity. `--json` writes the file that `try` and `add-rule` read. |
| `verity standard try --draft <file> \| --rule <id> [--last <n>] [--file <path>] [--json]` | Try a rule before you add it: on the lines that your last `n` commits added (5 by default), or on files you name. It never sends a removed line, a file shaped like a secret, a path in `.verityignore`, or a file renamed or copied from one of them. The reviewer reads the code in memory and stores nothing. |
| `verity standard add-rule --draft <file> [--action block\|warn\|off]` | Add the drafted rule to the repository Standard, at Warn unless you choose. |
| `verity standard suggest [--yes] [--keep <ids>]` | Rules Verity writes for this repository from a profile of it, to keep, edit or redraft before they are saved. Asks before it sends the profile; `--yes` sends it. `--keep` saves rules from the last list at Warn, as one new version, within a day. |
| `verity standard push [--file <path>] [--created-by <name>]` | Upload `.verity/standard.yaml`. The service assigns the next version. The file is checked on your machine first: a file that is not valid YAML, or that the service would refuse, is not sent, and the CLI says why. It must be a regular file inside the repository. When the service stores it as review packs, the CLI says so in one line. If the file has not changed since, it then writes the stored version into it. |
| `verity standard pull` | Write the team's latest Standard on the service into `.verity/standard.yaml`. It keeps a copy of your file as `.verity/standard.<time>.yaml` first. A session start does this for you when the team's version moved and your file has no local edits. |
| `verity standard get [--version <n>] [--resolved]` | Print the live Standard, or a specific version. `--resolved` shows it as a review reads it, with the packs in `extends` expanded. |
| `verity standard history` | Every version, with who created it and when. |
| `verity standard catalogue [pack] [--json]` | Every review pack, one line each. `✓` marks the packs your Standard extends. With a pack name, that pack's rules with their rule text. The same catalogue is at [verity.md/review-packs](https://verity.md/review-packs). |
| `verity standard generate [--yes] [--status]` | Project rules from a profile of this repository. Writes the profile to `.verity/repo-profile.json` and asks before it sends it. `--yes` sends it without asking. Works when the service has no Standard for the project, or when your file is the team's latest version. `--status` prints whether the service writes project rules here: `on`, `off`, `unsupported` or `unknown`. Sends nothing. |
| `verity standard synthesize [--force] [--push]` | Build a Standard from this codebase, no model required. `--force` replaces an existing Standard. `--intensity` is ignored with a warning, and `--config-only` does nothing: static analysis is Trivy only, so there is no analysis config to write. |
| `verity config push [--file <path>] \| get` | Upload or fetch `.codacy/codacy.config.json`. The gate does not use it: it runs Trivy only. |
| `verity config service-url` | Print the resolved service URL. The skills use it to call the service directly. |

## Knowledge and tasks

| Command | What it does |
| --- | --- |
| `verity reflect [--user-input <text>] [--kind <kind>] [--title <text>] [--file-globs <glob...>] [--confirmed] [--task-id <id>]` | Record a reflection as a knowledge node, or with no input run the extractor on the current task. `--user-input -` reads the text from stdin. Kinds: decision, gotcha (the default), pattern, security, quality, intent, domain, integration. The title is the first sentence of the first line, unless `--title` sets it. The scope is the files the text names, unless `--file-globs` sets it. `--confirmed` only when a person wrote the exact words. `--autonomous` is ignored. See [Memory](https://verity.md/docs/memory). |
| `verity memory edit <node-id> [--title <text>] [--file-globs <glob...>] [--status active\|archived\|superseded] [--body <text>] [--force]` | Change a knowledge node and upload it at once. `--body -` reads stdin. Each glob must match a file. It refuses when the service holds a newer, different copy, unless `--force`. With no option, it uploads the file as it is on disk. CLI 0.36.0 and later. |
| `verity memory delete <node-id> [--reason <text>]` | Archive a node on the service and remove its file here. The reason (1 to 500 characters, `-` reads stdin) stays on this machine, in `.verity/.memory-trash/` and `.verity/memory/log.md`. CLI 0.36.0 and later. |
| `verity memory restore <node-id>` | Undo a delete: make the node active on the service and put its file back. CLI 0.36.0 and later. |
| `verity memory ask <question...> [--limit <n>] [--json] [--full] [--all]` | Find the nodes that answer a question and quote them, with their ids. Runs on this machine with no model, and sends nothing. Also `recall`. CLI 0.36.0 and later. |
| `verity memory dream [--apply \| --revert <dream-id> \| --list] [--json]` | Print a plan that merges near-identical nodes, retires superseded ones and removes empty placeholders. `--apply` makes the changes and saves a report in `.verity/dreams/`. `--revert` undoes one. It never changes a node that a person confirmed. CLI 0.36.0 and later. |
| `verity memory pull [--force]` | Download this repository's knowledge graph into `.verity/memory/`. The session-start hook runs it. `--force` fetches every node. |
| `verity memory untrack \| track` | `untrack` stops committing `.verity/memory/` (the files stay on disk). `track` records that you commit it on purpose. |
| `verity memory seed [--force] [--dry-run]` | Seed `.verity/memory/` from what setup extracted: the codebase profile, README, `CLAUDE.md`. A seed node that was deleted or retired stays removed. |
| `verity task list [--status active\|closed\|merged]` | The gate's lines of work in this repository. |
| `verity task close [--id <id>]` | Close the current task; the next run starts a new one and the extractor runs. |
| `verity task rename <label> [--id <id>]` | Rename the current task. |
| `verity task merge <source> <target>` | Fold one task into another when the automatic boundary split real work in two. |

## Hook internals

Wired by `verity init`; you should not need to run them. Listed so `.claude/settings.json` reads without surprises.

| Command | What it does |
| --- | --- |
| `verity intent capture` | UserPromptSubmit — records your prompt as the goal and injects relevant knowledge. |
| `verity baseline capture` | SessionStart — photographs the working tree so pre-existing changes are never blamed on the agent. |
| `verity compact` | PostCompact — re-states open findings after Claude Code compacts the conversation. |
| `verity session end` | SessionEnd — closes the session and writes its digest. |

## Global options and environment

| Option / variable | Effect |
| --- | --- |
| `--token <token>` | Use this credential for one command. Takes precedence over everything. |
| `--service-url <url>` | Talk to this backend. Treated as explicit intent — never second-guessed by credential pinning. |
| `--verbose` | Log every HTTP request and response to stderr. |
| `VERITY_TOKEN` | The credential, for CI. Exempt from pinning because setting it was an explicit act. |
| `VERITY_SERVICE_URL` | The backend, when it is not the default or the one in `VERITY.md`. |
| `VERITY_DEVICE_LABEL` | The name a login appears under in `verity sessions list`. Defaults to the hostname. |
| `VERITY_AUTONOMOUS=1` | Mark a headless run, with no person at the keyboard. `verity reflect` no longer reads it: a reflection is always recorded without a confirm step. |
| `VERITY_DEBUG=0` | Stop writing the local diagnostic logs under `.verity/.logs/`. |
| `VERITY_TRACE_PHASES=1` | Print each phase of `verity analyze` and its duration to stderr — the fastest way to find which step owns a symptom. |

## Claude Code skills

`verity init` installs these into `.claude/skills/`. Type them in Claude Code:

| Skill | What it does |
| --- | --- |
| `/verity-setup` | Optional after `verity init`: read the codebase, check the project rules the service wrote against it, fix or remove the wrong ones, add what is missing, and seed the knowledge base. (With no Standard at all it synthesizes one; `--force` replaces the existing one.) |
| `/verity-analyze [paths \| --full \| --intent "…"]` | Review specific files, a directory, or a sample of the whole repository on demand, with no scoping and no iteration limit. |
| `/verity-status` | Project health, recent runs and pending items, without running a new analysis. |
| `/verity-memory` | List, show, walk, add, edit, archive, search and lint knowledge nodes. It uses `verity memory ask`, `edit`, `delete` and `dream`. |
| `/verity-learn` | The shorter tour of what the project has learned. |
| `/verity-reflect` | Draft one to three cited lessons from the task just finished and record them, with no confirm step. It tells you each node id, so you can edit or delete a wrong one. |
| `/verity-feedback` | Send feedback in your exact words, or mark a finding false-positive, acknowledged or useful. |
| `/verity-insights` | Quality metrics from accumulated runs, and suggestions for how the Standard should evolve. |
| `/verity-prove [worry]` | Formal verification on demand: rank candidates, confirm with you which function to model, write and check a Lean model, replay any counterexample on the real code. Never blocks. |
| `/verity-rule [what to check]` | Write a team rule: find the code it is about, draft the rule with the service, try it on real files, and add it at Warn after you say yes. The history names it as an agent's change. |

Prefer the guided path

[Install + `verity init`](https://verity.md/docs/quickstart) is the whole setup; `/verity-setup` checks and adds project-specific rules when you want them. The commands above are for tuning, automation, CI and debugging. What each file the CLI writes is for is in [Files & configuration](https://verity.md/docs/files).

[Previous The dashboard](https://verity.md/docs/dashboard) [Next Files & configuration](https://verity.md/docs/files)

Source: https://verity.md/docs/cli
