v0.13.0 — install fix + verifier independence + gate depth (~43% MET)

v0.13.0 — install fix, verifier independence, gate depth, ADRs (~36% → ~43% strict)

Executed a full independent worklist of the cheapest, cleanest convertible standards items — each a real graded gap, each verified without gaming.

Fixed (correctness)

• Install completeness (critical): the README "Universal" install symlinked only 1 of 5 skills, so a by-the-book install could never reach DONE (the verify-gate needs mnm-verify). Now links all five.
• Verifier independence: mnm-verify's disallowed-tools was missing Task/Skill/NotebookEdit — the certifier could delegate around its own restriction. Fixed (IEEE 1012 technical independence).

Added

• Go/Cargo supply-chain gates (govulncheck / cargo audit) — Node/Python had them, Go/Cargo didn't (ISO 25010 §1.1/8.2).
• Declared task-criticality tier (T/L/M/H/C) on the terminal row, distinct from a gate's oracle_tier, so tier-vs-verification is auditable from the log (IEEE 1012 / spec B.4).
• docs/adr/ — 4 retroactive Architecture Decision Records (signed manifest, author≠verifier, poison scoping, six terminal states) (SWEBOK KA2).
• CHANGELOG.md (Keep-a-Changelog), CODE_OF_CONDUCT.md, PR template, docs/TEST-DESIGN.md, SECURITY threat-model, live README CI/release badges.

Changed (honesty)

• Corrected .claude-plugin/plugin.json version (0.5.0→0.12.0), the gates/INCENTIVES.md "not-yet-wired" staleness, and the gate-stack.md mutation overclaim (doc said differential+60/80% floor; shipped is whole-file flat 0.5). Doc-currency now points to CHANGELOG so it stops drifting.

Deliberately NOT done (with reason)

• Wiring check_manifest into run_gates: declined — it would break the dev loop (every script edit invalidates the signature) and contradicts the design (the signed manifest is the out-of-band root, already hard-enforced by CI). An in-band manifest check is both bypassable and dev-hostile.

Honest measurement

Independently re-measured 23.3% → 31.8% → 35.7% → ~43% strict MET (nearly 2× the baseline). Every cheap+light+achievable-medium item is now done. 80% remains a multi-week campaign (~55 more conversions, mostly genuine features), with a ~90% structural cap (~10-14 items need a second accountable party — IEEE 1012 independence, third-party audit, production telemetry). Reported as measured, never gamed.

Verification

• Unit suite + 18 eval scenarios green; both CI workflows green on HEAD; manifest re-signed each script change.

v0.12.0 — --help everywhere + more MET conversions (honest 35.7%)

v0.12.0 — standards-completeness pass continues (35.7% → climbing)

More PARTIAL/NOT-MET → MET conversions, each with a negative control, driven by two rounds of independent adversarial re-measurement that keep the number honest (they caught — and I fixed — a real commit-message overclaim and doc-drift in this batch itself).

• --help/-h on EVERY entry point (17 scripts) — shared lib.sh::_maybe_help + a python print(__doc__) handler; test_help.sh iterates the scripts dir (53 assertions) so a new script without --help fails by omission. Fixes the prior batch's "every entry point" overclaim by making it true; log_verdict.sh --help (the standard's cited proof-point) now works. (ISO/IEC 25010 Interaction Capability.)
• Requirement→artifact traceability gate + real coverage floor + STUCK-BUDGET end-to-end eval + mnm-loop wrapper tests (SWEBOK Requirements, ISO 29119).
• docs/TEST-DESIGN.md — decision-table / boundary-value / state-transition / property-based technique tables, each mapped to a real assertion (29119-4 test-design artifact).
• Community profile + doc currency: CODE_OF_CONDUCT.md, PULL_REQUEST_TEMPLATE.md, de-staled INCENTIVES.md (mutation/coverage/sast now marked shipped, not deferred), and the last stale docs (STATUS.md, CONTRIBUTING.md).

Honest measurement (Campbell / Goodhart)

Independently re-measured: 23.3% → 31.8% → 35.7% strict MET and climbing. 80% strict remains structurally unreachable — ~10-14 items are permanently capped for a solo/unfunded/unaudited repo (IEEE 1012 managerial + financial V&V independence, genuine PR peer review, production false-DONE telemetry, live-interactive hook-fire proof, third-party pentest, the in-band adversarial-panel-skip residual). Realistic near-term ceiling ≈ 55-70%. The number is moved by fixing substance and reported as measured, never gamed to a target — the re-measurement even caught this batch's own overclaim, which was then corrected in code rather than in the number.

Verification

• 621 unit tests + 18 eval scenarios, 0 failed; both CI workflows green; manifest re-signed each script change.

v0.11.0 — requirement traceability + real coverage floor

v0.11.0 — two more PARTIAL→MET conversions (requirement traceability + real coverage floor)

Continuing the standards-completeness pass on substance (each conversion carries a negative control; no metric-gaming):

• Requirement→artifact traceability gate (SWEBOK v4 Requirements / ISO/IEC/IEEE 29148). mnm-planner produced an acceptance_slice_map but nothing read it back — a criterion could go unimplemented and still reach DONE. New check_traceability.py, wired into run_gates, fails the run if any acceptance criterion maps to zero files or to a file that doesn't exist (no plan.json at T/L tiers → SKIPPED). 13 unit tests including missing-file, empty-mapping, no-slice-map, and malformed-JSON negative controls.
• Coverage is a real gate now (ISO/IEC/IEEE 29119 test-completeness). coverage.sh fails below MNM_COV_FLOOR (default 90%, currently ~98%); CI runs it hard (no || true) with a teeth negative control — an impossible 100% floor must fail.

Verification

• 559 unit tests, 0 failed, across 19 files · 17 self-eval scenarios · both CI workflows green
• This builds on v0.10.1 (all 5 re-grade gaps closed + the two verify-forgery bypasses fixed, independently revert-tested)

An independent re-measurement of the overall MET% (and an honest Campbell/Goodhart verdict on the 80% target) is in progress; the substance-level ceiling is reported transparently rather than the number being gamed to a target.

v0.10.1 — independent re-grade + verify-forgery bypasses fixed

v0.10.1 — independent re-grade of the closures + two verify-forgery bypasses fixed

An independent adversarial verifier re-ran revert-and-test on all five v0.10.0 fixes (scratch copy → baseline PASS → revert the fix → assertion goes red → substance check). All five confirmed real and teeth-backed — none cosmetic. It also found two undisclosed bypasses that made v0.10.0's "a DONE typed on broken code is refused" claim overstated. Both are now addressed, honestly:

Fixed

• MNM_DONE_DIR decoy redirect (silent — the dangerous one). The live re-execution accepted an agent-supplied directory, so pointing it at a clean decoy granted DONE on genuinely broken code. The override is removed: re-execution now runs in the project cwd, whose cwd-relative DoD/test anchors trip INTEGRITY-COMPROMISED on any redirect. Locked by evals/run.sh::verify-forgery-decoy-redirect.
• MNM_SKIP_REVERIFY self-bypass (test hatch) — now loud. It disables the re-execution (needed to isolate the log layer in unit tests) and can no longer be silent: a real DONE with it set prints WARNING … NOT independently re-checked to stderr, and it's named in SKILL.md's residual.

Corrected claim (honesty over closure)

The re-execution closes the dangerous decoy/broken-code case. It does not close, in-band: (a) a verify-row skip of the adversarial panel when the code genuinely passes the gates, or (b) an agent setting MNM_SKIP_REVERIFY. Both are the same fundamental in-band limit — a guard that closed them would either re-run the panel (violating the author≠verifier independence it exists to enforce) or trust an env the agent owns. The real roots stay the ed25519-signed manifest, the independent mnm-verify sub-agent, and CI re-running the gates in a clean environment — none controlled by the agent under test.

Verification

• 546 unit tests, 0 failed · 17 self-eval scenarios, 0 failed · both CI workflows green
• All five closures independently revert-tested; the two bypasses independently reproduced and re-tested after the fix

v0.10.0 — standards re-grade gap closure (5 live gaps closed)

⚠️ Correction — see v0.10.1. An independent adversarial re-grade confirmed all 5 fixes are real (revert→red→substance), but found the verify-forgery fix bypassable via MNM_DONE_DIR (redirect the re-execution at a clean decoy dir) and MNM_SKIP_REVERIFY. The claim below that "a DONE typed on broken code is refused" is therefore overstated for v0.10.0. v0.10.1 removes MNM_DONE_DIR (re-execution now runs in the project cwd, fail-closed on redirect via cwd-relative anchors), makes MNM_SKIP_REVERIFY loud, and corrects the claim to name what is not closed in-band.

---

v0.10.0 — standards re-grade gap closure

An independent, adversarial standards re-grade (ISO/IEC 25010, ISO/IEC/IEEE 29119/12207/1012, SWEBOK v4 — docs/evals/standards/) named five concrete, independently-reproduced live gaps where the harness's own DONE or its evidence could fail to mean what it says. All five are now closed on substance, each locked by a negative control that goes red without the fix.

Closed

1. Coverage measured the whole environment, not the project — --source=. scopes the coverage gate, so unrelated installed packages can no longer block a fully-tested repo.
2. Integrity anchor set excluded the enforcement layer — freeze_dod now anchors the hooks, every SKILL.md, and agents/*.md; tampering a hook trips INTEGRITY-COMPROMISED (negative control: tamper a hook → exit 4).
3. A caught cheat froze the whole repo — GAMING-DETECTED is now scoped to the cheating task_id (a cheat on task A no longer blocks task B's honest DONE); INTEGRITY-COMPROMISED stays repo-wide. Enforced identically in verdict_state.py, log_verdict.sh, and the self-contained .githooks/pre-commit, locked to agree.
4. False STUCK-OSCILLATING — the convergence detector is scoped to one task and counts distinct passing gate names (excluding the verify re-run), killing a double-count that flagged converging runs as thrashing.
5. Verify-forgery (the #1 gap) — a DONE now re-executes the deterministic gate stack at write time instead of trusting logged rows, so a DONE typed on broken code is refused when the real gates fail.

Honest residual (named, not gamed)

Verify-forgery's dangerous case — a false DONE on broken code — is closed. The residual: an agent whose code genuinely passes the gates can still type a verify row to skip the adversarial panel. Closing that fully is not an in-band property without violating the author≠verifier independence the harness exists to enforce; the real roots are the ed25519-signed manifest, the independent mnm-verify sub-agent, and CI/pre-commit re-running the gates in a clean environment.

Metric honesty (Campbell / Goodhart)

The re-grade's strict figure — 30 MET / 74 PARTIAL / 23 NOT-MET / 2 N/A = 23.3% strict across 129 items — is treated as a directional signal, not truth. The denominator mixes incommensurable standards, and several PARTIALs are one honest step from MET. 80% strict MET is not honestly reachable without N/A-gaming the denominator; this release moves the number by fixing substance, not by redefining the metric.

Verification

• 546 unit tests (incl. property-based + cross-task regression + a live-re-execution lock), 0 failed
• 16 self-eval scenarios (incl. verify-forgery-broken-code), 0 failed
• Both CI workflows green (unit suite + coverage; signed-manifest integrity + independence-guard lints)

v0.9.0 — 494 unit tests + 98% coverage + real gate classes

494 unit tests + ~98% python coverage for the harness's own 15 scripts (the audits' #1 test-adequacy gap). Coverage/SAST/supply-chain/shellcheck gate classes wired. Two real bugs the tests found (stop-loop INTEGRITY masking; mutate bytecode-cache flake) fixed. Cross-task laundering (verdict_state ignored task_id) fixed + task-scoped. macOS mktemp test-portability fixed.

v0.8.0 — independent verifier required for DONE

A DONE now requires a 'verify' gate emitted only by verify_confirm.sh (independent re-execution), not just the implementer's own logged gates. Closes the fabricated-implementer-gate-PASS path on the honest route.

v0.7.1 — ISO/IEEE gating audit + disallowed-tools fix

Extensive ISO/IEEE gating-completeness audit (docs/evals/iso-ieee-gating-audit/). Fixed: sibling skills used disallowedTools (camelCase, inert) -> disallowed-tools (kebab). Named the fabricated-gate-PASS DONE hole (later closed in v0.8).

v0.7.0 — mutation gate (source-of-truth boost)

Mutation-testing gate (mutate.py + mutation_gate.sh): if the agent's own tests don't kill mutants they're too weak to certify DONE -> STUCK. Wired toward the verify step. Fixes the SWE-bench self-authored-oracle false-done class.

v0.6.2 — standards eval + honest corrections

A standards-anchored evaluation (ISO/IEC 25010:2023, ISO/IEC/IEEE 29119/12207/1012/29148, SWEBOK v4 — docs/evals/standards/) graded the product honestly: not a complete, professionally-tested product — an unusually honest v0 with real strengths and real, named gaps. Its anti-rubber-stamp critic found concrete defects; all were verified by hand and fixed:

• Hash-chain honesty (the key correction). The verdict.log hash chain is tamper-EVIDENT (catches accidental corruption + any append outside log_verdict.sh → INTEGRITY-COMPROMISED) but NOT forgery-proof — it is an unkeyed SHA-256 over public scripts, so an adversary who reproduces the formula can forge a valid DONE (shown in ~15 lines). Earlier "DONE can't be forged" wording overstated it and is corrected. Real forgery-proofing needs an out-of-band trust root the agent can't reach — the deferred R13 signed manifest + external CI (a local HMAC key would be theater: a shell agent can read any key the harness can).
• pre-commit consistency (real bug): its inlined logic had drifted from verdict_state.py and wrongly blocked a legitimate red→green DONE. Now identical latest-iteration rule.
• All 6 terminal states now reachable: STUCK-OSCILLATING / STUCK-INCONCLUSIVE were defined but never emitted; run_gates now emits both (an all-skipped run is no longer a false green). Proven by new scenarios — self-eval suite 11 → 13 green.
• Re-freeze in the same repo (mode-444 lock) fixed; R1 sole-writer CI lint added (was claimed, didn't exist); CONTRIBUTING de-staled.

Still open, now clearly named: no unit tests / no coverage number for the harness's own 15 scripts (biggest test-adequacy gap); verifier independence is architectural, not mechanically enforced; DONE needs gate evidence but not a logged verifier-CONFIRMED row; forgery-proofing awaits R13.

Full assessment: docs/evals/standards/COMPLETENESS-VERDICT.md.