Causari

∵ causari

AI-written code has no author. It has causes. Causari records them. How many lines from AI-tagged commits are still alive in your repo? One command, any git repo, no setup. A count, not a grade.

re audit counts lines introduced by commits whose git metadata matched an AI-detection rule, and how many of those lines git blame still attributes to those commits at HEAD. That count is survival: a count, not a grade. AI-tagged means the metadata matched. It does not prove a model wrote the line. UNKNOWN (no such metadata) is not human.

Causari also keeps a local ledger of what an agent runtime declared (prompt, model, files) and exposes it over MCP (re mcp). A Seal authenticates that a key signed these bytes for this commit and method. It does not authenticate that the numbers, or the attribution, are true.

Method and limits: causari.dev/method. The same limits, for an agent, in one file: causari.dev/llms.txt (full specification and schemas: causari.dev/llms-full.txt; agent discovery card: causari.dev/.well-known/agent.json).

curl -fsSL https://causari.dev/install.sh | sh

re audit

causari.dev · Weekly Survival Report · Method · Manifesto · Roadmap · Releases

Causari by Crovia Trust: the causari / re binary, the causari package on npm, PyPI and crates.io, the MCP server io.github.croviatrust/causari . Not related to causari.ai, the GitHub organisation causari or the npm scope @causari (a causal knowledge graph by another team).

---

re audit vercel/next.js     # any public repo, cloned to a temp dir and removed after

$ re audit

∵ causari · AI code survival ─────────────────────────────────────────────────── 216 commits analyzed (git metadata only, no setup required)

AI-tagged (metadata matched): 14 commits, 6267 introduced, 5185 survived survival 82.7% line-weighted · 82.7% capped · median 92.8% Of the lines introduced by metadata-matched commits, this percentage is the share git blame -w -M -C still attributes to those commits. It is not the share of the repository and it is not a quality score. Metadata matched does not prove who wrote each line. UNKNOWN and untagged are commits with no such signal; they are not a finding that a human wrote them. Age-matched gap: +2.9 percentage points (AI-tagged 85.6% minus untagged 82.7% in the matched age windows). Positive means the metadata-matched lines have the higher line-weighted survival in those windows, over 1 matched age window holding 75% of the AI-tagged lines. Lines outside those windows are not in this gap. Probable AI-assisted: none detected By agent (metadata matched only) agent commits introduced survived line-wt capped median cursor 14 6267 5185 82.7% 82.7% 92.8%

Baseline: untagged lines of the same repository untagged: 202 commits, 95759 introduced, 76085 survived · 79.5% line-weighted · 92.1% median line age AI-tagged untagged 0-30 d 85.6% (13 commits) 82.7% (142 commits) 30-90 d — 75.8% (23 commits) (below floor on one side) 90-180 d 73.9% (1 commit) 62.6% (37 commits) (below floor on one side) Age-matched gap: +2.9 percentage points (AI-tagged 85.6% minus untagged 82.7% in the matched age windows). Positive means the metadata-matched lines have the higher line-weighted survival in those windows, over 1 matched age window holding 75% of the AI-tagged lines. Lines outside those windows are not in this gap.

Confidence notes · JSON field verified = metadata matched (trailers, bot author, …), not authorship proved · PROBABLE = weak heuristic; may include human-assisted commits · UNKNOWN commits are excluded from headline numbers; they form the untagged baseline (human, inline-completed and untagged-agent code alike) · Only lines from AI-tagged commits are measured; inline completions (Copilot, Cursor Tab, …) leave no git trace and are invisible here · A measurement, not a grade: method v4 at https://causari.dev/method

Reading and export · The age-matched gap above is the comparison. An agent row marked below floor is not comparable. Meeting the floor is not a reliability guarantee. · Export: re audit --json, --summary, --seal, --badge, --card re report reads the local ledger. It does not export this audit.

The percentage is how many lines git blame still attributes to commits this method tagged. It is not code quality, developer productivity, total AI usage, proof a model wrote the line, security, correctness, or a causal effect of AI. An agent row under 5 commits is marked below floor; 5 commits is the comparability floor, not a reliability guarantee.

A git-ai note counts only when it names a non-empty tool (method v4). A schema-only note, a human-only note, and an empty tool do not. Method v3 counted any git-ai note. Survival Reports #1 and #2 stay method v2. Reports #3 and #4, and any audit from the 0.3.0 release, stay method v3. Report #4 is 10.5281/zenodo.23196011. Reports #5 and #6 stay method v4, measured with causari 0.4.1 (commit d4c4949, 2026-10-08). The published binary 0.5.0 (2026-10-21) is method v6, the method this source computes: surviving reads the same paths as introduced, so a binary blob (a PDF, an image) adds lines to neither count and a symlink adds one line to both; coverage.binary_files says how many blobs were left out. No binary shipped method v5. Published reports are not recomputed.

Fifteen minutes

curl -fsSL https://causari.dev/install.sh | sh

cd /path/to/a/git/repo re audit

Read three lines of the output. AI-tagged (metadata matched) is the cohort whose commit metadata matched a rule. Baseline is every other commit: untagged, not "human". The survival percentage is the line-weighted persistence of the tagged cohort. It does not prove who typed the code. The rules and the limits are at causari.dev/method.

The ledger is a second path, local and gitignored, used only if you record:

git history → re audit → survival counts

hooks or proxy → .causari/ → re why / trace / lens

A seal signs the audit bytes. It does not connect the two paths.

Everyone argues about how much code AI writes. Nobody can check the numbers. re audit reads plain git history — Co-Authored-By trailers, bot authors, agent markers — finds the commits whose metadata matched, and asks git blame how many of their lines are still at HEAD. Metadata matched is not proof a model wrote the line. No model, no estimate, no survey. --json stores the counts, repository.head, repository.root_commits, the method, the blame and numstat flags (coverage.blame_flags, coverage.numstat_flags), coverage.ignore_revs_sha256 and coverage.notes_oid (the target OID of refs/notes/ai when present). It does not store the note payloads of refs/notes/ai: that ref is not part of the commit object, and changing it changes coverage.notes_oid and can change the counts while the commit SHA stays the same. A repository that has moved has a different commit.

• --json the exact bytes behind any published row (the published rows themselves: causari.dev/reports/survival, also as a dataset at CroviaResearch/causari-survival)
• --summary Markdown for CI; --badge / --card one-colour SVGs
• --diff compare two audit JSONs or .seal.json bundles along one axis (repository_diff, method_diff, indeterminate_method_diff, metadata_diff, or identical_inputs), refusing multi-axis diffs and unrelated repositories
• --save append a snapshot to track your own trend

Compared with what: since method v3 every audit puts the repository's own untagged lines next to the AI-tagged ones, by line age, and states the age-matched gap: AI-tagged survival minus untagged survival inside the matched age windows of the same repository, not a comparison of identical timestamps. It also names the oldest line still at HEAD and how many commits predate it: a repository that was cleared or rewritten shows there, and its ratio is read accordingly.

What it cannot see: code from inline completions (Copilot, Cursor Tab, Windsurf, …) leaves no git trace, so it is in the untagged baseline. Untagged is not a finding that a human wrote it. Commits without a trailer are UNKNOWN. An agent that needs the same limits in one file should read causari.dev/llms.txt. A formatter pass or a moved function counts as a death under method v1. One bulk commit can dominate a line-weighted ratio; ratios under 5 AI-tagged commits are flagged. All of this is written out at causari.dev/method, with how to contest a number. The questions people ask, answered with the command and the limit: causari.dev/faq; how this differs from git blame, vendor dashboards and churn reports: causari.dev/compare.

The weekly Survival Report runs re audit on up to 100 open-source repositories: a hand-picked list plus the most-starred public repositories (at least 100 stars) where GitHub commit search finds at least five commits carrying the same AI authorship metadata, selected every week, the day before the report, by scripts/survival_discover.py under a rule stated on the method page; rows stay alphabetical, and one line in .github/survival-optout.txt removes a repository.

In CI: a count on every pull request

# .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 } # the audit reads every commit; shallow clones are wrong
• uses: croviatrust/causari@v1

The Action downloads the prebuilt Linux binary (a few seconds), runs re audit --summary, writes it to the job summary and posts one sticky comment per PR. No cloud, no account. A live example.

The ledger: from "which commit" to "which prompt"

The audit works on any history. If you also want to know *why* a line exists — the prompt, the model, the files the agent read — Causari records agent actions as they happen into a local, append-o