[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

# Security & privacy

Verity is built to review your code without keeping it. Here is exactly what leaves your machine, who sees it, what is stored, what stays on your disk, and how each of those is protected.

The short version

The files under review go to the Verity service and its model provider for the time a review takes. The service does not write file contents, diffs or tool output to its database. It keeps metadata and the text that the model writes: findings (which can quote your code), scores, decisions and the Standard version. It keeps your prompt for 30 days. Files shaped like secrets never leave your machine.

This page is a summary. The complete list comes from an audit of the hooks and the CLI with a network trace: every destination, when Verity contacts it, and what it sends. It is in the plugin README, [What Verity sends, and where](https://github.com/codacy/verity/blob/main/plugins/verity/README.md#what-verity-sends-and-where). If this page and the README differ, the README is the reference.

## What leaves your machine

| Mode | Sent to the Verity service | Sent elsewhere |
| --- | --- | --- |
| **Not set up** (no `.verity/` directory) | Nothing. | Nothing, except an npm install of the CLI when the plugin finds none. |
| **Set up, not signed in** | Nothing. A local Trivy scan runs, with no AI review. | Downloads of Trivy, its database and Lean, and the package names that the malicious-package check sends to OSV.dev. |
| **Signed in** | What a review needs, listed below. | The same as above. The service sends the review to its model provider. |

For a signed-in project, the Verity service receives, over TLS:

- **At each prompt:** the first 4,000 characters of your prompt. The service sends it to OpenAI to classify the task.
- **At a stop turn:** the full content of the files the agent wrote (up to 40 files, 50 KB each, 190 KB in total), diffs against the last review, files the agent read (up to 10 files, 24 KB in total), up to 10 recent prompts, the agent's last reply, the first 80 characters of up to 10 shell commands, Trivy findings, spec documents such as `CLAUDE.md`, your 3 newest Claude Code plans, and lines from other files that use the changed code.
- **At a commit and a push:** every staged or pushed file (up to 120 files, 96 KB each, 570 KB in total), the diff, commit messages, Trivy findings, excerpts from the code that calls the change, and the line numbers that the change wrote. The reviewing model can ask the CLI to read other tracked files and to run `git log`, `blame`, `show` and `diff`, at most 16,000 characters for each answer.

Two things that can carry more than you expect

A shell command can hold a secret that you typed inline, and its first 80 characters go with a stop-turn review. Claude Code plans in `~/.claude/plans/` are shared by every project on your machine, so a plan sent with a review can belong to another project.

To know which code the agent wrote, Verity reads your Claude Code session record **on your machine**. Tool output and the text inside Edit tool calls did not appear in the audit of what is sent.

**The model provider.** The reviewer is OpenAI by default, and each model request sets `store: false`. If OpenAI fails with an error other than an unreadable reply, the service sends the same review prompt, which includes code and your prompt, to Google (Gemini). A project cannot turn that fallback off. A Standard can also select Google with `ai_provider: gemini`. The [Privacy Notice](https://verity.md/privacy) names every provider.

## Files shaped like secrets

**Files shaped like secrets never leave your machine.** Only their paths do. This holds at a stop turn, at a commit and at a push. The list:

- `.env` and `.envrc` files;
- keys and keystores, such as `.pem`, `.key`, `.p8`, `.p12` and `id_rsa`;
- any file named `credentials`, `secret` or `secrets`, whatever its extension, such as `credentials.json`, `secrets.yaml` and `secrets.ts`;
- `.npmrc` and similar tool credentials;
- Terraform `.tfvars` and `.tfstate`, service-account JSON and `kubeconfig`;
- files under `.ssh/`, `.aws/`, `.gnupg/`, `.docker/` and `.kube/`.

The plugin README has the [complete list](https://github.com/codacy/verity/blob/main/plugins/verity/README.md#what-verity-sends-and-where). Then:

- **Trivy scans every one of these files on your machine.** A staged secret that Trivy recognizes can still block the commit.
- **A source file named like a secret is withheld too**, for example `secrets.ts` or `credentials.py`. The AI review does not read it, but Trivy scans it.
- **The agent review's tools refuse these paths.** At a commit and a push, the reviewing model can ask the CLI for more files. It cannot get a file shaped like a secret, also not through `git diff`.
- **Formal verification never sends one.** `/verity-prove` and the formal check at push never pick or send a file shaped like a secret, even one that you name.

## The local scan

Static analysis runs on your machine: Trivy 0.74, through `@codacy/analysis-cli` 0.29.0. It runs offline, with no telemetry and no update checks. Verity sets `TRIVY_DISABLE_TELEMETRY`, `TRIVY_OFFLINE_SCAN` and `CODACY_DISABLE_UPDATE_CHECK`. Offline, Trivy resolves a `pom.xml` only from the file and the local Maven cache, so **for a Maven project it can miss some dependency findings**.

**One thing from your project leaves: the malicious-package check.** To find known malicious packages (the `MAL-` advisories that OpenSSF publishes on OSV.dev), the CLI sends the ecosystem, name and version of each package in a changed manifest or lockfile to `api.osv.dev`. OSV.dev is a vulnerability database that Google runs. The request goes from your computer, signed in or not, and it includes the names of private packages. It sends no code, no file paths, no registry URLs and no account. No setting turns it off. The [Privacy Notice](https://verity.md/privacy) names OSV.dev.

The scan also downloads the Trivy binary (once per machine) and Trivy's vulnerability database (when it is out of date). These downloads carry no project data.

## Project rules: the repository profile

Project rules are optional. When the service has no Standard for the project, or you choose to create a new one, `verity init` offers to send a profile of the repository, so the service can write rules for it. `verity standard generate` does the same later. Nothing is sent without your yes, and `verity init --yes` alone sends nothing. Verity first writes the profile to `.verity/repo-profile.json`, so you can read the exact file. It holds:

- Languages with file counts, frameworks, build system and test framework.
- Dependency names, as the manifests declare them.
- Folder names, three levels deep, with file counts. No file names.
- The subjects of up to 500 recent commits, the paths each one changed, and whether it reads like a fix.
- The project's agent and contributor docs — such as `CLAUDE.md`, `AGENTS.md` and those of sub-projects — without their code blocks. `README.md` is read only when there is no agent doc at the root.

It never holds source code, diffs, author names or e-mail addresses. Commit subjects and docs are free text, so Verity removes secrets, e-mail addresses and credentials in URLs before it writes the file. That removal is best effort, which is why you can read the file first. The service passes the profile to the model provider in one call, with storage off, and does not store it. It keeps a hash and counts.

## What is stored

The service does not write diffs, file contents, tool output or the whole conversation to its database. It holds them in memory for the review and sends them to the model provider. This persists:

| What | Kept |
| --- | --- |
| Findings: title, description and suggested fix. The model writes them, and they can quote your code. | No automatic deletion |
| Your prompt, up to 4,000 characters | Cleared after 30 days |
| Task labels and summaries. A summary can be the first 500 characters of your prompt. | No automatic deletion |
| Scores, the verdict, the coverage ledger, file paths, session ids, file hashes and the Standard version | No automatic deletion |
| The dispositions you record (disputes, waives, feedback) and knowledge nodes, up to 8 KB each | No automatic deletion |
| Telemetry, if you opted in: metric points | Deleted after 14 days |
| Telemetry: spans | Deleted after 30 days |
| Telemetry: raw batches as received | Deleted after 7 days |
| Telemetry: daily totals | No automatic deletion |

The README has the [full table](https://github.com/codacy/verity/blob/main/plugins/verity/README.md#what-is-stored-and-for-how-long), including account data. When the service is unreachable, the offline record on your machine keeps paths and counts only.

## Who can read it

- **Repository access is verified against GitHub.** Storing or reading a repository's data requires a write or admin grant that Verity confirmed with GitHub — not merely possession of a token. Grants carry a verification date and go stale; losing access to a repository drops the grant at your next login.
- **Isolation.** A token resolves to exactly the projects you hold a grant on; row-level security keeps projects from seeing each other's data.
- **Service tokens are narrow.** A CI credential can review and record runs for its one repository. It cannot list your repositories, and it cannot list or revoke anyone's logins — a leaked one cannot enumerate its minter's access.
- **Read links stay read-only.** A shareable run link is a scoped, time-limited credential and is never accepted as a way to write — feedback and waives require an authenticated writer, so a link you shared cannot be used to silence findings.

## Authentication and tokens

You sign in once through GitHub's device flow ([Authentication](https://verity.md/docs/authentication)). The security properties:

- **Your GitHub token is used once and discarded.** It proves your repository access and reads your verified email, then it is gone — never written to our database, never written to your disk, and dropped by the browser the moment the web sign-in exchanges it. Storing it would turn Verity into a credential-theft target for push access to your repositories.
- **The Verity token is stored only as a SHA-256 hash** server-side. The raw value is shown once and is not retrievable.
- **Nothing secret is written into your repository.** Your credential lives at `~/.verity/credentials`, created with `0600` permissions at the moment of writing. Telemetry writes a switch, not a secret; the token is resolved at runtime.
- **A login is a session, not a key.** 90 days in the terminal, 30 in the browser, enumerable per machine, and any one of them revocable immediately with `verity sessions revoke` or `verity logout --others`.
- **The browser keeps only the Verity session**, for 30 days, in its own storage; the open repository's data lives for the tab.

A repository cannot redirect your credential

The hooks resolve the service URL from repo-controlled files, so a repository you merely cloned could name any backend and would receive your token on the next run. Verity pins a credential to the service that issued it, the way a cookie is pinned to its origin, and *refuses* to send it anywhere else rather than quietly stripping the header and posting your code there anyway. Local analysis still runs. The login flow itself never reads a URL from the repository: a GitHub token is never sent to a host a repository chose.

## The gate cannot be blinded in one move

Every way to stop the gate looking at something is designed to be verified, not obeyed:

- An edit to `.verityignore` suspends every ignore rule for the turn that made it, and the edit itself is always reviewed.
- An `exclude_paths` change in the Standard does not apply to the session that wrote it.
- A housekeeping declaration voids the instant anything is authored, and is budgeted.
- A waive is bound to the file's exact bytes, needs a reason, and lands in the ledger.
- A security finding needs two reasoned rounds to be disputed by an agent — or one human waive.

Details in [Findings & verdicts](https://verity.md/docs/findings).

## Telemetry

Opt-in, and metrics and traces only: token counts, estimated cost, model, timing, tool, skill and MCP server names, the repository owner, name and URL, and the session id. The exporter flags for prompt text, tool details and tool content are written *off* explicitly, and no logs exporter is configured. Claude Code also sends your email and account ids, and the service removes them on receipt. The setting is for the whole machine, but only Verity projects send: anywhere else, Claude Code exports nothing. The service deletes metric points after 14 days and spans after 30 days, and keeps daily totals. See [Token telemetry & cost](https://verity.md/docs/cost).

## What Verity keeps on your machine

| Path | What it holds |
| --- | --- |
| `~/.verity/credentials` | Your login token. Mode `0600`. The single on-disk secret store. |
| `~/.verity/sessions/` | Per-session working memory. Mode `0700`, outside every work tree, deleted when the session closes. |
| `.verity/.snapshot/` | Byte copies of the files each review looked at — including any secret the gate just flagged. Gitignored by setup; never commit it. |
| `.verity/.logs/` | Local diagnostic logs of what Verity did and said. Tokens are scrubbed before anything reaches disk. `VERITY_DEBUG=0` turns them off; `verity reset --all` deletes them. |
| `.verity/standard.yaml`, `.verity/memory/` | This machine's copy of the Standard and of the knowledge base. The service holds both. Git ignores them in a new project. |
| `.verity/.memory-trash/`, `.verity/dreams/` | The text and reason of each node you deleted with `verity memory delete`, and the record of each `verity memory dream --apply`. They stay on this machine. |

## Audit trail

Every analysis is recorded as an append-only, timestamped run — model used, decision, findings, coverage, and the Standard version in effect. Every disposition — a dispute, a waive, a housekeeping declaration, a piece of feedback — is recorded with its reason and who made it. Nothing is overwritten, so the history is a complete, reviewable record of what was checked and why a verdict was reached. Verity is built by **Codacy**, whose platform teams already rely on for code quality and security at scale.

Reducing what is shared further

Skip the repository profile: it is then never sent, and the service writes no project rules. Do not sign in, and the hooks run only the local scan: no review content leaves your machine. The malicious-package check still sends package names and versions to OSV.dev. One exception: a machine that still has an anonymous token from an older CLI sends review content. Run `verity login` to replace that token. If the service is unreachable, Verity falls back to local analysis and never blocks your agent on a network call.

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

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