PayneSDD 0.6.0

Added

• DIGEST.md — the always-on digest: a ~2.4k-token compressed floor of the protocol (tiers + hard floor, every gate, the never-do list, the voice) for always-loaded / token-metered setups — ~29% of the full file's 8.1k tokens. Opens with the loading rule: on any Light/Full task, read the full AGENT.md BEFORE the contract. The digest is the floor; AGENT.md stays the single source of truth.
• Digest drift gate: DIGEST.md carries a sha256 pin of AGENT.md; scripts/payne-check.sh goes RED on any AGENT.md edit until the digest is re-reviewed and re-pinned (scripts/payne-digest-stamp.sh); a size band (8,000–10,500 chars) blocks both bloat and gutting.
• Measured token costs (README "Token cost — measured"): live behavioral tests — real claude -p runs, mechanical scoring — show the digest holds every gate the full file holds (no premature code on a hard-floor probe, consent before code, cheap trivial answers, persona intact) at roughly a quarter of the always-on cost. Committed run summary: benchmark/token-tests-0.6.0.md.

Changed

• Step 0: the tier is named in your FIRST line — even when missing inputs force you to ask before doing anything else.

PayneSDD 0.5.1

Added

• Failure → contract ratchet (Step 4 + Step 5): a failed gate — or an accepted adversarial finding — must ask whether it exposed a hole the contract never covered (a missed edge case, a missing negative AC). If yes, the clause plus the named check that proves it land FIRST, then the code fix. A ratcheted clause is still a change to a locked contract: a genuine behavior fork re-enters the 1.6 gate; an unambiguous closure is logged.
• Caller-drift check in the fork sweep (Step 1.5a): when the delivery surface / public API already exists, check the new shape against its CURRENT callers (cite the caller, file:line) instead of assuming they still match.
• Compact subagent reports (Step 5 + /payne-review): every protocol subagent (analyst, adversarial, quality reviewer) returns one line per finding/fork — source tie + claim + proposed fix, an explicit "none" when empty. The main thread's context is the budget they spend.
• Pre-committed battle-validation methodology (benchmark/README.md): three arms with a cheap-control headline, a committed results snapshot, and a mandatory "what this does NOT measure" section — fixed before any numbers exist.

PayneSDD 0.5.0

Born from a full protocol revision (7 audit lenses + 4 research tracks, every finding adversarially verified) — the enforcement machinery, the self-gate, and the docs got the honesty treatment the protocol preaches.

Fixed

• The enforced gate is honest and loop-safe. The Stop-hook now reads its stdin JSON and honors stop_hook_active; a stuck-red gate blocks up to PAYNE_MAX_BLOCKS times (default 3 — the Step 2 iteration budget), then releases the stop as UNVERIFIED with an explicit escalate message instead of looping (Claude Code force-ends after 8 consecutive blocks anyway — the old "literally cannot end" overclaim is gone). The hook path is quoted (a project path with a space used to fail open: exit 127 = no gate at all), the user command runs in a fresh shell via bash -c (the core's set -u/pipefail no longer cause false REDs), and the snippets ship a timeout (a timed-out hook silently doesn't block). Honest escalation is documented: disarm the marker on done, abandoned, or escalated with the red log attached.
• The self-gate checks the product, not just two hook files. scripts/payne-check.sh now verifies: shell syntax + shellcheck for hooks/ and scripts/, one version everywhere (badge = Latest = CHANGELOG = the new AGENT.md header stamp), every README link and CLAUDE.md import resolves, dogfood command copies match canon. Plus the first CI (.github/workflows/gate.yml) — the gate runs on every push and PR.
• Install docs actually install: a copy-the-hooks step, where slash commands / the payne-quality agent / ROLES.md go, a settings.example.json pointer, the "(git-ignored)" falsehood about .claude/settings.json corrected, and a security note — PAYNE_TEST_CMD is executed on every stop, review changes to it like code.

Changed

• Contract sweeps (Step 1): edge cases are found by a fixed sweep (boundary, adjacency, empty, encoding, ordering, precision, idempotency, concurrency), not inspiration; prohibitions are behavior — "must NEVER do X" gets a negative AC (WHEN … SHALL NOT), distinct from Non-goals.
• The adversarial pass audits the tests themselves (Step 5 + /payne-review): deleted/empty assertions, skips, loosened thresholds, mocks faking the unit under test — how green was reached is in scope. On Light, the self-review re-reads the actual diff/artifact — fake the independence you don't have.
• Consistency fixes across the protocol: the Light tier note names behavior/data-semantics forks as never-defaulted; 1.6 says code = Step 3+; ROLES' QA outputs a recommended verdict (the main thread adjudicates); the decision-log "closing verdict line" contradiction is removed; dev-mode SELF-NOTICED deduped; /payne-edit's "a typo may be Trivial" carve-out removed; payne-spec/payne-edit opt out of model auto-invocation; the SPEC template caught up with EARS ACs and executable references; AGENT.md carries a gate-checked version stamp; README/DEPLOYMENT.md document the zero-footprint variant, @-import install, and the /goal zero-install gate.

Every change ran the full cycle: skeptic-verified findings → per-item vetting judges + an aggregate anti-bloat arbiter (+12 lines always-loaded total) → 14/14 empirical hook tests, gate green under bash 5 and macOS bash 3.2, mutant checks go red as designed → independent payne-quality review: SHIP (after it caught an off-by-one in the new block counter — the reviewer earns its keep).

PayneSDD 0.4.7

A README overhaul — plainer where it was watery, deeper where it was thin. Docs only; no protocol rule changed.

The feedback was that the landing page over-explained the same idea several times, stayed shallow on what the protocol actually does, and didn't show the recent 0.4.x improvements.

Changed

• New plain-language "What you get" opening — what a programmer gains over coding through raw prompts / vibe-coding: the plan is agreed before code, "done" is proven by the machine (a red check blocks "finished"), and an independent second agent tries to break the result. Stated once, replacing several paragraphs that restated the same "the agent said so isn't proof" point.
• Deeper cycle table — each step now describes what it actually enforces today: EARS WHEN … SHALL … acceptance criteria, the criterion→check coverage matrix, the simplicity rule, the no-progress loop-stop, the independent adversarial pass. It points to AGENT.md for the full rules rather than duplicating them (no drift surface).
• Concrete worked example — the password-reset walkthrough now shows real criteria, coverage at the gate, and a source-tied finding, instead of terse one-liners.
• Trimmed the Status changelog from ~40 lines to recent highlights + a pointer to the changelog.

Net: 212 → 199 lines — leaner overall, richer where it counts.

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.6

A new Simplicity & Scope rule in execution (Step 3)

Added

• Step 3 now bars over-engineering a single implementation. The protocol already guarded scope (no features outside the contract) and duplication (the ratchet), but nothing stopped an agent from over-building one implementation: speculative abstraction, unrequested config/flexibility, handling for impossible states — "1000 lines where 100 would do," the most-cited LLM-coding-agent failure mode.

Worded to NOT cause the opposite problem (under-engineering): write the minimum that satisfies the contract, not the minimum possible. Contracted edge cases, error paths, and abstractions that earn their keep stay — and the Step-4 machine gate enforces them, so the rule can only trim gold-plating, never required behavior.

Plus a surgical-scope clause: don't silently refactor or reformat adjacent code you weren't asked to; surface foreign broken/dead code (propose it, like the duplication ratchet) instead of silently fixing or silently ignoring it.

Two of the four principles in that distillation (think-before-coding, goal-driven execution) were already covered — and enforced more strictly — by PayneSDD's Step 1.5/1.6 consent gate and Step 4 machine gate. The simplicity gap was the genuine find.

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.5

Two small refinements from a research pass on AI-agent loops and code reviewers — each a sharpening of an existing rule, no new ceremony.

Changed

• The iteration loop now stops when it's stuck, not only when it's out of tries (Step 2 + Step 6). The budget already capped auto-iterations by count; now NO-PROGRESS — two iterations that don't move the same failing check — is a distinct stop/escalate trigger alongside budget-exhausted. Step 6's ITERATE now requires "budget left and not a no-progress loop"; ESCALATE lists the no-progress trigger. Don't burn the last try repeating what just failed. (Source: OpenHands no-progress pathological-state detection.)
• The built-in quality reviewer (payne-quality) now loads what it checks. Its cross-reference lens (versions / step numbers / CHANGELOG / cycle table must line up) was blind to anything outside the diff; it is now told to load the whole change plus every cross-referenced file before judging — so it can actually catch the breakage that lens exists for.

Also

• Closed a long-deferred design tail: splitting AGENT.md into a thin always-loaded index + heavy on-demand protocol was rejected as a default. The token saving only matters for stateless / metered / always-on agents without prompt caching — a segment already served by the opt-in DEPLOYMENT.md slim-core guide. Making it the default would re-add a drift surface (just removed in 0.4.4) and setup complexity for the majority who get the full file cached for free.

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.4

A dehydration pass — an independent two-auditor anti-bloat review of the protocol found ~6–7% trimmable redundancy. ~20 lines removed from the always-loaded AGENT.md (553 → 533), zero rules changed, every rule preserved elsewhere.

Changed

• Install instructions + optional-add-ons catalog removed from AGENT.md — they were pure duplication of the README's own Install and Optional add-ons sections. AGENT.md now points there; it's the running protocol, not the setup guide.
• The "costly-to-reverse" rule was stated in full twice — kept the operational copy in Step 1.5a, reduced the What you never do entry to a prohibition + pointer.
• Tier-applicability restatements collapsed to pointers — the Step 4 header already says ALL TIERS; the Step 1.5c / 1.6 "Exception" tails just re-stated their own tier notes.
• CLAUDE.md's ROLES paraphrase collapsed to a pointer.

Deliberately kept (load-bearing reinforcement, not bloat): the What you never do digest, the ROLES gate restatements, the "if you need a paragraph…" aphorism, and the source-over-memory rule.

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.3

Three refinements distilled from a landscape scan of popular spec-driven tools

Changed

• Acceptance criteria get a structured, machine-mappable shape (Step 1). Each AC should use WHEN <condition> the system SHALL <observable behavior> (and IF <failure> THEN ... for error/edge paths) — a shape that maps 1:1 to a Step-4 check and that a vague "works correctly" criterion can't be cast into. (EARS notation — Kiro; SHALL + Given/When/Then — OpenSpec; requirement-quality checklists — Spec Kit.)
• Acceptance-criteria coverage is surfaced and enforced (Step 4). The gate must map EVERY acceptance criterion to the check that proves it and show that AC→check mapping at the gate; an AC with no check is an unverified gap, not a pass. Makes the long-standing "each AC → a check" rule mechanical instead of assumed. (Spec Kit /analyze coverage matrix.)
• The analyst hunts internal contradictions in the contract (Step 1.5a). Beyond enumerating decision forks, it flags clauses that conflict (one rule forbids what another requires; an AC no edge-case resolution satisfies) so they're fixed at contract time, not discovered in Step 5 after the code. (Kiro "Analyze Requirements" pass.)

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.2

Two refinements distilled from the JPoint 2026 talk «Build your own database in an hour with Claude Code» — both sharpenings of existing steps, keeping the always-loaded protocol minimal.

Changed

• Soft-gate is now a justified last resort, not a default (AGENT.md — Step 4). Before settling for a SOFT / by-eye gate on a runnable app/GUI, the agent must first make an honest attempt to close the loop automatically — drive the real artifact end-to-end (spawn the CLI/binary as a subprocess over stdin/stdout) so the agent, not a human validator, sees the result. Only genuinely undriveable interactive UI stays SOFT. Closes a permissive escape hatch.
• Source of truth prefers an executable reference (AGENT.md — Step 1). When a reference implementation or golden dataset exists, diff against it rather than docs/eyeballing, and build that comparison harness first, before the main code.

Full changelog: https://github.com/vlr-code/PayneSDD/blob/main/CHANGELOG.md

PayneSDD 0.4.1

Changed

• "Costly-to-reverse" rule broadened (AGENT.md — "WHAT YOU NEVER DO" + the Step 1.5a fork categories, kept in sync) — now also covers behavior / data-semantics forks (analytics event timing/payload, what & when to persist or send, which business-logic branch fires), not only technical/stack choices: when more than one reasonable reading exists, ASK — even on a small ambiguous follow-up.
• Step 6 "Open questions" guard (AGENT.md) — that section is only for decisions still OPEN (nothing built on them yet); a behavior-changing fork must be asked before coding (re-enter the Step 1.6 gate), never resolved in code and then logged there.
• README status — badge + Status section updated from "early · not battle-tested" to "actively used on real projects".

Born from a real session: an agent unilaterally chose analytics-event timing on an ambiguous instruction and filed the rejected alternative as an "open question" instead of asking first.