Questions and answers

Causari cannot tell you that. It counts something narrower: the lines introduced by commits that carry machine-readable AI authorship metadata (a Co-Authored-By trailer naming an agent, a bot author, an AI-* trailer, a git-ai note), and how many of those lines git blame still attributes to them at HEAD. Code from inline completions or from untagged commits counts as human. Run re audit in any repository; the output states what was counted and what was not. Rules: causari.dev/method.

re audit                    # the repository you are in
re audit --json             # "coverage": what was counted, what was not

A line survives if git blame -w -M -C at HEAD still attributes it to the AI-tagged commit that introduced it. The survival ratio is surviving lines divided by introduced lines, summed over all such commits, so it is line-weighted; method v2 also reports a capped ratio and the median per commit. A rewritten line is a death even when the meaning is unchanged; a surviving line may be dead code. It is a count from git history, not a judgement about quality. Definition: causari.dev/method#survival.

Install the binary and run re audit inside a repository, or name a public one (re audit owner/repo clones it to a temporary directory and removes it afterwards). It reads git only: no account, no upload. --json prints the exact bytes behind every number; --summary writes Markdown for CI; --save appends a snapshot so you can compare a repository with itself over time. Full clones only: a shallow clone is refused because its history is truncated. Install options: github.com/croviatrust/causari#install.

curl -fsSL https://causari.dev/install.sh | sh
re audit                    # this repository
re audit vercel/next.js     # any public repository
re audit --json             # the exact bytes

No. re audit is one static binary of about 5 MB that reads the git repository in front of it. Nothing is uploaded; there is no telemetry, no account and no paid tier. Auditing a public repository by name clones it over plain git into a temporary directory. The installer checks the archive against the SHA256SUMS.txt published with each release and refuses to install on a mismatch; every archive carries a signed SLSA provenance attestation. Details: github.com/croviatrust/causari#install.

curl -fsSL https://causari.dev/install.sh | sh    # Linux, macOS
irm https://causari.dev/install.ps1 | iex           # Windows
brew install croviatrust/tap/causari                # Homebrew

Those that leave machine-readable metadata in git: Co-Authored-By trailers naming Claude, Copilot, aider, Codex, ChatGPT or OpenHands (Devin, Jules, Gemini and Cursor only with a bot identity or vendor domain); bot author identities such as noreply@anthropic.com, devin-ai, openhands, cursoragent, google-labs-jules; AI-* and Assisted-by: trailers; git-ai notes under refs/notes/ai. An agent that commits without any of these is UNKNOWN and never counted. The full rule table, signal by signal: causari.dev/method#counted.

No. Inline completions (Copilot, Cursor Tab, Windsurf, Continue, Zed AI, JetBrains AI) leave no trace in git: a person accepts the suggestion and commits it under their own name, so re audit counts those lines as human. "No git signal" means no metadata, not no AI. Agents that commit with a trailer or a bot identity (Claude Code, aider, Codex CLI, the Copilot coding agent, Devin, Jules) are visible. What stays invisible: causari.dev/method#cannot-see.

No. Causari counts; it does not grade. A deleted line may be a removed feature or a rewritten prototype; a surviving line may be dead code. There is no rank, no colour and no score, and a ratio from fewer than five AI-tagged commits is flagged as a small sample. For scale: Survival Report #1 found 61.3 % of lines from AI-tagged commits still at HEAD across 10 repositories, 95 % interval over that sample 53.0 % to 64.9 %. Source: causari.dev/reports/survival/2026/01/.

re audit --seal signs the exact audit JSON, bound to the audited commit and the method version, with the repository's Ed25519 issuer key as a crovia.seal.v1 receipt (audit.seal.json). re seal verify audit.seal.json checks it with the file alone; causari.dev/verify does the same in the browser without a network request. A valid seal proves that this key signed these numbers for this commit and that nothing changed since. It does not prove the numbers are true: rerun re audit on the commit and compare the bytes.

re audit --seal                  # writes audit.seal.json
re seal verify audit.seal.json   # 0 valid · 1 invalid · 2 unreadable

A weekly, numbered, citable page of counts for open-source repositories: alphabetical, unranked, with a DOI and the audit JSON behind every row. Report #1 (2026-09-20) measured 10 repositories: 462,838 of 754,476 lines from 12,349 AI-tagged commits still at HEAD, 61.3 %, 95 % bootstrap interval over the sample 53.0 % to 64.9 %. Repositories are added by pull request to .github/survival-repos.txt, not drawn at random. To opt out, add one line to .github/survival-optout.txt; the next run drops the row and never re-adds it. Archive: causari.dev/reports/survival/.

# .github/survival-optout.txt — one owner/repo per line, no questions asked
owner/repo

Yes. Causari is written in Rust and published under Apache-2.0 at github.com/croviatrust/causari; contributions are signed off under the DCO. "Causari" is a trademark of Crovia Trust and the licence grants no trademark rights (see NOTICE). Survival Report data is CC-BY-4.0. Every release archive and its SHA256SUMS.txt carry a signed SLSA build-provenance attestation that gh attestation verify checks against the repository.

One step. The GitHub Action croviatrust/causari@v1 downloads the prebuilt Linux binary, runs re audit --summary, writes the count to the job summary and keeps one sticky comment per pull request. fetch-depth: 0 matters: the audit reads every commit and refuses shallow clones. No cloud, no account, no verdict: a count with its coverage statement. A live example: causari-audit-demo/pull/1.

# .github/workflows/causari.yml
on: pull_request
permissions: { contents: read, pull-requests: write }
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }
      - uses: croviatrust/causari@v1

git blame says which commit last touched each line. Causari runs it, then adds what blame does not do: it decides which commits carry AI authorship metadata by a public rule table, sums introduced against surviving lines per commit, applies a per-commit cap and a sample floor, and writes a coverage block into every result. It can then sign the result for offline verification. You could script the same; the point is that everyone runs one method and gets the same bytes. Other ways to count: causari.dev/compare.

Rerun re audit owner/repo --json and compare the bytes with the published row; every report row links its JSON. If they differ, or a commit was misclassified, open an issue with the JSON at github.com/croviatrust/causari/issues. Corrections are made in public and recorded in the data history. The known ways a number can mislead (bulk commits, formatting, small samples, age) are written down first, at causari.dev/method#misleads.

diff <(re audit owner/repo --json) repos/owner__repo.json

You do not need it: the audit works on any git history. The ledger is the optional second half. re init creates a local, gitignored .causari/; re hook claude-code or re proxy then record each agent action as it happens (prompt, model, files read and written), and re why src/file.ts:42 names the event and the prompt behind a line. Everything stays on your machine. Treat .causari/ as sensitive: the proxy stores prompts verbatim. What each agent gives you today: the README table.

re init                     # .causari/, added to .gitignore
re hook claude-code         # every prompt and edit, exactly
re why src/auth.ts:42       # which event introduced this line

Crovia Trust is the maker of Causari and of the family it belongs to: TACET (verifiable silence proofs), PNX (proof of non-exfiltration) and the Crovia Seal receipt format, all at croviatrust.com.

For your own repository, yes: re audit --badge writes causari-badge.svg with the count for your README, and re audit --card writes a self-contained survival card. Both are one colour and carry no verdict. We issue no badge about repositories we do not own. If your repository is in the Survival Report, the report lists it with its counts and the exact command to reproduce them: causari.dev/reports/survival/.

re audit --badge            # causari-badge.svg
re audit --card             # causari-survival.svg