README.md

---
license: mit
language:
  - en
pretty_name: "Greencheck Mutation Case Study"
authors:
  - Simin Yuan
tags:
  - mutation-testing
  - validation
  - ci
  - software-testing
  - reproducibility
size_categories:
  - n<1K
---

# greencheck — mutation testing for validators, with a measured case study

**Author:** Simin Yuan (袁思敏) — Independent Researcher
**Contact:** yleven120@gmail.com
**Code:** https://github.com/simin-yuan/greencheck

**Author's public record**
- *Volume or Coupling? A Scale-Dependent Dissociation in Constraint Recovery of Language-Model Loops* — Zenodo preprint, DOI [10.5281/zenodo.21200851](https://doi.org/10.5281/zenodo.21200851)
- *Can One Agent Restore Another? Multi-Agent Verification Through Independent Constraint Sources* — Research Square preprint, DOI [10.21203/rs.3.rs-10651733/v1](https://doi.org/10.21203/rs.3.rs-10651733/v1)
- GitHub: https://github.com/simin-yuan


## What this is

Your validator passes inputs it should reject. **greencheck** finds them: it mutates a target
one line at a time, re-runs the gate, and reports every edit the gate did not react to.
Zero dependencies, Python 3.9+, `pip install greencheck`.

This dataset carries the **measured case study** and the **telemetry** behind the tool:

| Path | What |
|---|---|
| `case_study/` | `run_case_study.py` + `results/` + `third_party/` (third-party gates put under test) |
| `data/gate_daily.jsonl` | day-by-day gate outcomes |
| `data/gate_summary.json` | aggregate results |
| `data/ledger_metric_samples.jsonl` | ledger metric samples |
| `data/PROVENANCE.md` | where every number came from |
| `docs/METHOD.md` | the measurement method |
| `greencheck/`, `tools/`, `tests/` | the tool itself |

---

*Original repository README follows.*

# greencheck

[![tests](https://github.com/simin-yuan/greencheck/actions/workflows/tests.yml/badge.svg)](https://github.com/simin-yuan/greencheck/actions/workflows/tests.yml)
[![PyPI](https://img.shields.io/pypi/v/greencheck.svg)](https://pypi.org/project/greencheck/)
[![licence: MIT](https://img.shields.io/badge/licence-MIT-blue.svg)](LICENSE)
[![dependencies: none](https://img.shields.io/badge/dependencies-none-brightgreen.svg)](#)

### Your validator passes inputs it should reject. This finds them.

```console
$ pip install greencheck
```

Zero dependencies, Python 3.9+, nothing to configure.

Then, from a checkout of this repository (both halves run against files that
ship with it, so a reader can reproduce every line below):

```console
$ python -m greencheck.cli mutate --gate "python examples/mutate-demo/gate.py {target}/config.json" --target examples/mutate-demo/input
```

```
baseline rc: 0  PASS (baseline is clean, mutating)
mutants    : 12
----------------------------------------------------------------------
      caught  drop-file:config.json
      caught  empty-file:config.json
      caught  drop-line:config.json:4:"replicas": 3,
      caught  blank-value:config.json:2:"service":
      caught  blank-value:config.json:3:"region":
   * ESCAPED  blank-value:config.json:4:"replicas":
      caught  blank-value:config.json:5:"owner":
----------------------------------------------------------------------
caught 11 / 12

mutants the gate let through (1):
  *  blank-value:config.json:4:"replicas":
```

The escaped mutant turns `"replicas": 3` into `"replicas": 0` — a service that
never starts. The gate checks that every key is present and every value is
non-empty. Zero is neither missing nor empty, so it says yes.

**Every structural property the gate tests for still holds.** That is exactly
why this class of gap survives review: it is invisible to anything that only
looks at shape. → [the runnable example](examples/mutate-demo/)

## It also audits metrics

Point it at a metric you already collect — a self-score, a recall rate, a health
probe — and it tells you whether the number varies with the thing it is named
after, or only with something adjacent: input existence, wall-clock freshness, a
single boolean.

```console
$ python -m greencheck.cli audit data/ledger_metric_samples.jsonl --field identity.identity_score
```

The same question, asked of numbers instead of gates: *has this ever been
observed to take a different value on input that differs?* If it has not, it is
not a measurement. It is a decoration that updates on a schedule.

---

## The one rule

> **A number is not a measurement until it has been observed to take different
> values on inputs that are known to differ.**

A metric that reads `1.0` forever is not telling you things are perfect. It is
not telling you anything. A dashboard that is green because it has never been
asked a question it could fail is a specific kind of silence — and this tool
exists to make that silence audible.

Point it at a metric you already collect: a self-score, a recall rate, a guard,
a health probe. It tells you whether the number varies with the thing it is
named after, or only with something adjacent — input existence, wall-clock
freshness, a single boolean.

---

## 30 seconds

```console
$ python -m greencheck.cli demo

[ok  ] content_length          (2 samples)
[FAIL] content_presence_score  (2 samples)
       - IDENTITY: 0/1 probe pairs separated within the claimed dimension
         'content'. The instrument responds to something other than what it
         claims to measure.
[FAIL] always_one (control)    (2 samples)
```

The middle line is the point. `content_presence_score` **does** separate one of
the probe pairs — `1.0` for text, `0.0` for empty. A naive check ("did any two
outputs differ?") passes it. But the pair it separates differs in *existence*,
not in *content*, and `content` is what the instrument is named after. A
discriminability test that is not dimension-scoped is itself a decoration.

Audit a real ledger (this one ships in `data/`):

```console
$ python -m greencheck.cli audit data/ledger_metric_samples.jsonl --field identity.identity_score

[FAIL] identity.identity_score  (84 samples)
       - CONSTANT: 84/84 samples report the identical value 1.0.
         Zero variance over the observed window.
       stats: n_samples=84, distinct_values=1
```

Check whether an assertion has ever fired. This reads the per-day aggregate
log in `data/` — the same file the case study table is computed from, so the
figure is yours to re-add:

```console
$ python -m greencheck.cli gate data/gate_daily.jsonl --fire-event block_issued

[FAIL] data/gate_daily.jsonl — 13 full days with zero firings  (27097 samples)
       - DEAD_GATE: 27,097 events recorded across 13 days, of which 25,594 were
         the guard reporting itself healthy, and the denial path fired 0 times.
         The assertion has never been observed to fire. Its existence is
         documented; its behaviour is not.
       stats: total_events=27097, health_events=25594, firings=0, silent_days_before_first_fire=13

[ok  ] data/gate_daily.jsonl — full window (16 days)  (33228 samples)
       - PASS: The path fired 5 times, the first on 2026-09-19. That first
         firing came from a positive control written specifically to exercise
         the path, not from ordinary traffic.
       stats: total_events=33228, health_events=31642, firings=5
```

Both rows are the same guard. The code did not change between them; what
changed is that somebody finally built it an input it was known to have to
reject. Full window: 5 firings out of 33,228 events. Without that positive
control, all 33,228 would have read as health.

Zero dependencies. Python 3.9+. Nothing to install beyond the repo.

---

## What it catches

| verdict | signature | how you notice |
|---|---|---|
| `CONSTANT` | Zero variance over the whole window | 84/84 samples report the same value |
| `IDENTITY` | Separates inputs by existence, not by the claimed dimension | Empty vs non-empty moves it; good vs contradictory content does not |
| `BARE_ZERO` | `n = 0` and `n > 0, 0 hits` produce the same output | 63 of 84 "recall" samples examined nothing and reported `0.0` |
| `LIVENESS_BIT` | All variance traces to one boolean | A composite score whose two values are exactly a freshness flag |
| `DEAD_GATE` | A guard exists, logs health, has never fired | 25,594 healthy events, 0 firings, 13 full days |
| `NO_DATA` | Nothing matched | Reported instead of `PASS`, on purpose |

**`NO_DATA` is the failure mode of the audit tool itself.** An empty input
returning `PASS` is precisely the class of bug this repository exists to catch,
so the tool refuses to commit it. And `IDENTITY` is not "the values differ
somewhere" — discrimination is scoped to the dimension the instrument *claims*
to measure, which is a strictly harder bar and the one that actually matters.

None of these is hypothetical. Each was found on a real instrument, in
production, in the case study below.

---

## The case study

`data/` holds two anonymised datasets from a continuously-running autonomous
agent over roughly two months. Everything in this repo is reproducible from
them:

```bash
python case_study/run_case_study.py
```

| instrument | n | verdict |
|---|---:|---|
| `self_assessment.identity_score` | 84 | **CONSTANT** |
| `self_assessment.memory_recall.recall_rate` | 84 | **CONSTANT; BARE_ZERO** |
| `self_assessment.reflection_score` | 84 | **LIVENESS_BIT** |
| `self_assessment.overall (composite)` | 84 | **LIVENESS_BIT** |
| `guard denial path — 13 full days with zero firings` | 27,097 | **DEAD_GATE** |
| `guard denial path — full window` | 33,228 | **PASS** |

Six instruments. Five flagged. Full write-up:
[`case_study/results/CASE_STUDY.md`](case_study/results/CASE_STUDY.md).

The last two rows are **the same guard**. It reads `DEAD_GATE` for the thirteen
days before anyone constructed an input it was *known* to have to block, and
`PASS` afterwards. Nothing about the guard changed at that moment. What changed
is that somebody finally asked it to prove itself.

Every number above can be recomputed from the two files in `data/`. The headline
is 27,097 and not a larger figure, because the larger one counted events with a
timestamp earlier than the first firing — which needs event-level data, and only
aggregates are published. A reader could not have checked it. Summing the
zero-firing rows of [`data/gate_daily.jsonl`](data/gate_daily.jsonl) gives
exactly 27,097, and that is the number used everywhere in this repository.

That is the whole thesis. A control is not validated by its presence in the
code, nor by its green light. It is validated by having been observed to fire.

### The same loop, on a validator nobody here wrote

[`case_study/third_party/`](case_study/third_party/) points it at third-party
artifacts instead: a real `package.json` from a public project, checked by
SchemaStore's official schema. 168 mutants, 36 caught, 132 let through — and
then the part that decides anything: `npm` refuses two of the escapes and
accepts a third. The count is not the finding. The triage is.

---

## Skills

The CLI audits a ledger **after** the fact. `greencheck/skills/` is for **before** —
agent-readable instructions that keep the broken instrument from being built at
all.

```console
$ python -m greencheck.cli skills
greencheck skills — 5 available

  bare-zero                  Use when a metric, counter, rate or score reports zero...
  dead-check                 Use when writing or reviewing a monitoring rule...
  dimension-scope            Use when testing whether an instrument measures what its name claims...
  measurement-or-decoration  Use when a system reports a score, confidence, health value about itself...
  positive-control           Use when writing a guard, assertion, test, alert or validation rule...

Read one in full:   python -m greencheck.cli skills <name>
```

Plain `SKILL.md` files with YAML frontmatter — the format used by Claude Code,
Codex, OpenClaw and most agent harnesses. Copy one where your harness looks for
skills, or let your agent read it directly:

```console
$ python -m greencheck.cli skills positive-control   # prints the whole file
```

| skill | use when |
|---|---|
| [`measurement-or-decoration`](greencheck/skills/measurement-or-decoration/SKILL.md) | the system reports a score about itself. The root rule; the others are special cases. |
| [`positive-control`](greencheck/skills/positive-control/SKILL.md) | writing a guard, assertion or alert that is supposed to reject bad input |
| [`dead-check`](greencheck/skills/dead-check/SKILL.md) | writing a monitor. Covers rules that can never fire, and rules with inverted polarity. |
| [`dimension-scope`](greencheck/skills/dimension-scope/SKILL.md) | testing whether an instrument measures the dimension its name claims |
| [`bare-zero`](greencheck/skills/bare-zero/SKILL.md) | a metric reports `0` |

## Install / use

No dependencies. Python 3.9+.

From a checkout of this repository:

```console
$ python -m unittest discover -s tests      # 46 tests, stdlib only
$ python -m greencheck.cli demo
```

Audit your own ledger:

```bash
python -m greencheck.cli audit my_ledger.jsonl \
    --field identity.identity_score \
    --count memory_recall.sampled \
    --fresh reflection.fresh
```

Or drive it as a library:

```python
from greencheck import ProbePair, discriminate

discriminate(my_metric, [
    ProbePair("rich vs degenerate", rich_text, "aaaa", dimension="content"),
    ProbePair("present vs absent", "hello", "", dimension="content"),
], subject="my_metric", claimed_dimensions=["content"])
```

---

## Where the evidence comes from

The underlying logs are from production and contain filesystem paths, host
identifiers and operator-specific strings. **They are not published.** What is
published is aggregated:

- `data/ledger_metric_samples.jsonl` — 84 samples, field names neutralised; no
  value, timestamp or count altered
- `data/gate_summary.json`, `data/gate_daily.jsonl` — per-day counts only

`tools/anonymise.py` produces them and **fails the run** if any forbidden pattern
survives. The leak gate has its own positive control (`--self-test`), because a
checker that has never been observed to fire is not a checker — and that rule
applies to this repository before it applies to yours. `tools/leakscan.py`
re-verifies the entire tree independently. Rules and provenance:
[`data/PROVENANCE.md`](data/PROVENANCE.md).

---

## Standing on

This did not start from nothing, and it would be dishonest to imply otherwise:

- **Dimension-scoped discriminability and falsification-first verification** —
  adapted from [obra/superpowers](https://github.com/obra/superpowers) (MIT).
- **`n = 1` case-study discipline** — report a single system honestly instead of
  inflating it into a general claim.

The strongest contribution in the other direction: if you have a metric that
passes `greencheck` and still lies to you, that is a bug here, and the issue is
welcome.

---

## Limits

- **This tests instruments, not systems.** A `PASS` means the instrument
  separates inputs within its claimed dimension. It does not mean the thing
  measured is good, or that the dimension is the right one to measure.
- **`n = 1` system.** One agent, roughly two months. The signatures recur across
  its instruments, but cross-system replication is open. Treat the taxonomy as a
  starting set, not a closed one.
- **The tool only sees what you record.** A metric that is never written down
  cannot be audited. Absence of records is itself a finding — a different one.
- **A positive control is part of the procedure, not an optional extra.** A
  guard's firing count is meaningless until someone has shown it fires when it
  should. See [`docs/METHOD.md`](docs/METHOD.md).
- **The instruments were written by the system being measured.** That is the
  condition under study, not a flaw in the study.
- **The judging standard is not set by the thing being judged.** The verdicts in
  the case study are proposed by this tool's author and should be read as a
  draft. Disagreeing with one of them is the useful move.

## Falsifiers

1. If any instrument in the case study is shown to separate inputs within the
   dimension it claims to measure, the corresponding finding is false.
2. If the guard is shown to have fired before `2026-09-19T14:52:23Z` on an input
   that should have been blocked, the `DEAD_GATE` finding is false.
3. If anonymisation changed any *value* (as opposed to a field name), every
   number in the case study is void. `tools/anonymise.py` is the only transform
   applied; its leak check is mandatory.

## Citation

See [`CITATION.cff`](CITATION.cff).

## License

MIT — see [`LICENSE`](LICENSE).

**Simon**, 2026.