docs: record the third softening, which was authored dirty

The two instances already in "Checks that were kind once" were correct
when written and decayed. The third was wrong on its first commit, and it
arrived by a different route: the check and the tree's failure to pass it
land in the same change, so the softening writes itself.

Concretely — the Clippy step had never run (no component in the
toolchain), and the tree is not clippy-clean, so fixing the step and
turning it red are the same commit. The first draft paired the fix with
`continue-on-error: true` and a comment promising removal once the debt
was paid: an expiry date nobody set, in the shape #12's closing line had
already ruled out for rustfmt. Reverted on reading it.

Adds the distinction, a table separating decay from dirty authorship, and
an earlier tell than the mechanical test:

    If you are writing the softening in the same commit as the check,
    the thing you want is an issue, not a flag.

The mechanical test is unchanged and still correct; this only catches the
same failure sooner, at the keyboard rather than at review.

Refs #12, #13

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01McNbzUeq1KRBWs4G6X2YVj

docs/agents/PROTOCOL.md

@@ -167,7 +167,7 @@ neither its own branch nor `main`.
 
 ## Checks that were kind once
 
-Two rules that look unrelated and are the same failure.
+Three instances now, and they are the same failure.
 
 **A check may only soften against a condition it can test.**
 
@@ -189,6 +189,45 @@ a collaborator exists, so the "yet" was never needed.
 stays. That is why they survive review, and why the smell is worth naming:
 *leniency with an expiry date nobody set.*
 
+### The third instance was authored dirty, not decayed into
+
+The two above were **correct when written**. The third was not, and it is worth
+separating because it arrives by a different route and is caught at a different
+moment.
+
+CI's `Clippy` step turned out never to have run — the toolchain shipped without
+the component, so `cargo clippy -- -D warnings` died on *"not installed"* on
+every commit in the repo's history. Fixing that is two lines. But the tree is
+not clippy-clean: the build already emits ~13 rustc warnings that `-D warnings`
+promotes to errors. So the fix and the first red result arrive together, and the
+first draft paired the two-line fix with `continue-on-error: true` and a comment
+saying *delete this line once the debt is paid* — which is precisely an expiry
+date nobody set. It was reverted within the hour, on reading #12's own closing
+line ruling the same shape out for rustfmt.
+
+The difference that matters:
+
+| | first two | third |
+|---|---|---|
+| when it was wrong | became wrong later | wrong on the first commit |
+| what caused it | the world moved | the tree was already dirty |
+| what catches it | auditing old allowances | noticing the impulse at the keyboard |
+
+**This is the default way a check gets written when the tree is not clean yet.**
+Not a rare slip — the ordinary shape of the first draft. Whenever a real check
+goes in against a tree that does not yet pass it, the softening is *right there*,
+it looks like pragmatism, and it comes with a sincere comment promising removal.
+The mechanical test still catches it after the fact. The earlier tell is this:
+
+> **If you are writing the softening in the same commit as the check, the thing
+> you want is an issue, not a flag.**
+
+A red check that measures something is worth more than a green one that measures
+nothing, and it is worth strictly more than a green one that *used to* measure
+something. Land the check gating, let it be red, and scope the debt where it can
+be read, argued with and closed — #12 for rustfmt, #13 for clippy. An issue has
+the expiry date the flag never gets.
+
 `share put <file> --note "…" --for port` records the sender, the time, **the
 commit they were on**, and whether their tree was dirty. A capture with no
 provenance is not evidence, it is a picture.