driftproof 0.10.2 → 0.11.1

package/README.md

@@ -1,12 +1,13 @@
 <!-- SPDX-License-Identifier: Apache-2.0 -->
 # Driftproof
 
-**Your skill passed. On which model? On what date?**
+**Is the gap your skill makes real, or noise? Did it hold on the last model release?**
 
-A SKILL.md teaches an AI coding agent how you like things done. When a new model
-ships, the same file can stop helping, or start hurting. Driftproof re-runs the
-skill's tests on the new model and hands you a dated, hash-verified receipt
-saying whether it still helps.
+A SKILL.md teaches an AI coding agent how you like things done. A skill's own
+tests passing is one answer. Driftproof asks two more: whether the scores with
+the skill and without it separate beyond their spread, and whether that held
+when the model changed. Each answer is a dated, hash-verified receipt, and when
+there were too few draws to tell, the receipt says so.
 
 [![driftproof](https://img.shields.io/endpoint?url=https://driftproofhq.com/badges/commit-message-conventions.json)](https://driftproofhq.com)
 &nbsp;— live badge for the bundled `commit-message-conventions` example, generated from its own receipt.
@@ -295,7 +296,7 @@ A receipt is the unit of evidence — one JSON document conforming to
 
 ```jsonc
 {
-  "schema_version": "0.6",
+  "schema_version": "0.7",
   "skill":  { "name": "commit-message-conventions", "version": "0.2.0",
               "content_hash": "…sha256 over SKILL.md + bundled files…" },
   "suite":  { "format": "agentskills.io/evals", "suite_hash": "…", "case_count": 10 },
@@ -304,7 +305,7 @@ A receipt is the unit of evidence — one JSON document conforming to
     "model_release_date": "2025-10-01",
     "provider": "anthropic",
     "surface": "claude-cli",
-    "runner_version": "0.10.2",
+    "runner_version": "0.11.1",
     "date_utc": "2026-07-27T…Z",
     "registry": "registered",
     "transcripts": "hashes-only",
@@ -383,7 +384,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: driftproofhq/driftproof@v0.10.2
+      - uses: driftproofhq/driftproof@v0.11.1
         with:
           skill-dir: skills/my-skill
           models: claude-haiku-4-5

package/bin/driftproof

@@ -13,7 +13,7 @@ const { buildDriftReport, revisionPairProblem } = require('../lib/diff');
 const { surfaceForModel, isSubscriptionSurface, resolveModel, evalUser } = require('../lib/provider');
 const { estimateRunCostUSD, BudgetTracker } = require('../lib/cost');
 const { registryStatus, assertRegistered, REGISTRY_PATH } = require('../lib/models');
-const { verdictFromReceipt, badgeEndpoint, githubOutputLines } = require('../lib/verdict');
+const { verdictFromReceipt, badgeEndpoint, githubOutputLines, drawsLine, UNDERPOWERED_LINE } = require('../lib/verdict');
 const decision = require('../lib/decision');
 const { scaffoldInit } = require('../lib/init');
 
@@ -75,7 +75,7 @@ function loadRc(skillDir) {
 
 // Flags that never take a value, so `--trusted-skill <skill-dir>` keeps the dir
 // positional instead of swallowing it as the flag's value.
-const BOOLEAN_FLAGS = new Set(['trusted-skill']);
+const BOOLEAN_FLAGS = new Set(['trusted-skill', 'svg']);
 
 // ── THE INPUT CONTRACT (spec 026 AC-9, F5) ────────────────────────────────────
 // A COPY of action/lib.sh's RE_* rules, in the shape spec 028's fixture holds
@@ -177,7 +177,7 @@ USAGE
                         [--keep-transcripts] [--out DIR] [--trusted-skill]
   ${PROJECT_NAME} diff <receiptA.json> <receiptB.json> [--out FILE] [--mode release|revision]
   ${PROJECT_NAME} validate <receipt.json>
-  ${PROJECT_NAME} badge <receipt.json|receipts-dir> [--models a,b] [--out FILE] [--github-output]
+  ${PROJECT_NAME} badge <receipt.json|receipts-dir> [--models a,b] [--out FILE] [--github-output] [--svg [--href URL]]
   ${PROJECT_NAME} decide <receipts-dir> --models a,b [--github-output] [--badge FILE]
                         [--summary FILE] [--enforce] [--fail-on-regression true|false]
   ${PROJECT_NAME} import <results.json> --from agent-skills-eval|skillgrade [--out DIR]
@@ -515,17 +515,35 @@ function cmdBadge(positional, flags) {
   if (fs.existsSync(p) && fs.statSync(p).isDirectory()) return cmdBadgeSet(p, flags);
   const receipt = JSON.parse(fs.readFileSync(p, 'utf8'));
   refuseUnverified(receipt, p, 'badge');
+  if (flags.svg) {
+    // SPEC 036. The drawn badge: state, model, date, lift and uncertainty, with the
+    // machine token in its data attributes. After the same hash check as the JSON.
+    const svg = require('../lib/badge-svg').badgeSvg(receipt, { href: typeof flags.href === 'string' ? flags.href : null });
+    if (flags.out) {
+      const out = path.resolve(flags.out);
+      fs.mkdirSync(path.dirname(out), { recursive: true });
+      fs.writeFileSync(out, svg);
+      console.log(`badge written to ${flags.out}  (${verdictFromReceipt(receipt).verdict}, svg)`);
+    } else process.stdout.write(svg);
+    return;
+  }
   if (flags['github-output']) { console.log(githubOutputLines(receipt)); return; }
   const badge = badgeEndpoint(receipt);
   const json = JSON.stringify(badge, null, 2);
+  const v = verdictFromReceipt(receipt);
+  // SPEC 035 AC-3. An UNDERPOWERED receipt says so in words and says what it would
+  // have needed. Beside JSON on stdout the two lines go to stderr, so a caller that
+  // redirects the badge still gets a file that parses.
+  const power = v.verdict === 'UNDERPOWERED' ? [`${UNDERPOWERED_LINE}.`, drawsLine(v.drawsNeeded)] : [];
   if (flags.out) {
     const out = path.resolve(flags.out);
     fs.mkdirSync(path.dirname(out), { recursive: true });
     fs.writeFileSync(out, json + '\n');
-    const v = verdictFromReceipt(receipt);
     console.log(`badge written to ${flags.out}  (${v.verdict}: ${badge.message}, ${badge.color})`);
+    for (const line of power) console.log(line);
   } else {
     console.log(json);
+    for (const line of power) console.error(line);
   }
 }
 

package/config.js

@@ -9,7 +9,7 @@ const PROJECT_NAME = 'driftproof';
 // Bumped whenever the runner's behaviour or receipt-generation semantics change
 // in a way that could affect results. Recorded into every receipt as
 // run.runner_version so a receipt is reproducible against a known engine.
-const RUNNER_VERSION = '0.10.2';
+const RUNNER_VERSION = '0.11.1';
 
 // The eval format we CONSUME (we deliberately do not invent our own).
 const SUITE_FORMAT = 'agentskills.io/evals';
@@ -38,7 +38,7 @@ const SUITE_FORMAT = 'agentskills.io/evals';
 //        results.aggregates.band_rule, and bands that are null where the formula
 //        cannot form. NOT additive for the validator: a v0.5 receipt restamped 0.6
 //        is refused. v0.5 is frozen as receipt.v0.5.schema.json.
-const RECEIPT_SCHEMA_VERSION = '0.6';
+const RECEIPT_SCHEMA_VERSION = '0.7';
 
 // Input bounds on the skill loader and the post-checks (spec 026 AC-13, audit
 // A3/A7). lib/skill.js loaded every bundled file with no count, depth, byte,
@@ -104,6 +104,13 @@ const DEFAULT_JUDGE_SAMPLES = 5;
 // spec/RECEIPT.md § "Drift verdict rule" and the report methodology.
 const EFFECT_FLOOR = 0.05;
 
+// How many standard errors of the difference between two means a case's resolution
+// adds to its two spreads (spec 035 R-2). A case the band rule does not separate is
+// UNDERPOWERED when its spreads plus this many standard errors reach the floor: at
+// those spreads and draws, a true shift of the floor's size could have gone unseparated.
+// Named, so a later decision moves it by one line and one amendment.
+const POWER_Z = 2;
+
 // ── generation sampling (receipt spec v0.5) ─────────────────────────────────
 //
 // Report #006 measured across-draw spread at sd 0.186 and 0.183 while the
@@ -157,7 +164,7 @@ const REPORT_005_JUDGE_MODEL = 'claude-haiku-4-5';
 module.exports = {
   PROJECT_NAME, RUNNER_VERSION, SUITE_FORMAT, RECEIPT_SCHEMA_VERSION, DEFAULT_JUDGE_SAMPLES,
   SKILL_MAX_FILES, SKILL_MAX_BYTES, SKILL_MAX_DEPTH, SUITE_MAX_CASES, CASE_MAX_CHARS, CHECK_MAX_PATTERN,
-  EFFECT_FLOOR, DEV_MAX_USD, DEV_MAX_CALLS, REPORT_MAX_USD, TRIGGER_MAX_USD,
+  EFFECT_FLOOR, POWER_Z, DEV_MAX_USD, DEV_MAX_CALLS, REPORT_MAX_USD, TRIGGER_MAX_USD,
   GENERATION_SAMPLES_MIN, GENERATION_SAMPLES_MAX, GENERATION_SD_THRESHOLD, GENERATION_STABILITY_EPS,
   REPORT_002_CLAUDE_MODEL, REPORT_002_GPT_MODEL, REPORT_002_JUDGE_MODEL,
   REPORT_003_NEW_MODEL, REPORT_003_OLD_MODEL, REPORT_003_JUDGE_MODEL,

package/lib/badge-svg.js

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+'use strict';
+
+// The badge, drawn (spec 036).
+//
+// The shields endpoint JSON (lib/verdict.js badgeEndpoint) carries a label, a message
+// and a colour, which is all a shields badge can hold. This draws the badge itself, so
+// it can show what a reader needs at a glance: the state, the model, the date, the lift
+// and its uncertainty. Four segments, left to right:
+//
+//   driftproof | <state label> | <model> · <date> | lift <+0.000> <± 0.000 | no ±>
+//
+// The fourth segment carries the lift ONLY for a state that measured one. UNDERPOWERED and
+// NOT_MEASURED carry the draws taken against the draws needed instead (A-036-2):
+//
+//   driftproof | not enough draws | <model> · <date> | 3 draws of 87 needed
+//
+// THE WORDS ARE HUMAN; THE TOKENS ARE DATA. What a reader sees is a label (passing, not
+// enough draws); the machine token the Action and the differ publish sits on the root
+// element as data-verdict, with the receipt hash beside it, and never in the text.
+//
+// UNDERPOWERED IS DRAWN AS THE HONEST STATE, not as a failure: a calm indigo no other
+// state uses, an open hatch over it, a dashed edge around it, and the words "not enough
+// draws". Every state's text is white on a fill it clears 4.5:1 against, hatch included.
+//
+// Text widths are fixed with textLength, so a text's rendered box is the width this file
+// allots it whatever font the viewer has, and it cannot spill out of its segment.
+
+const { receiptVerdict, shortModel, receiptDrawsTaken } = require('./verdict');
+
+const INK = '#ffffff';
+const BRAND = '#24292f';
+const DETAIL = '#4b5563';
+const EFFECT = '#374151';
+const STATE = {
+  PASSED: { fill: '#1a7f37' },
+  REGRESSED: { fill: '#b42318' },
+  UNDERPOWERED: { fill: '#3538cd', hatch: '#444ce7', edge: '#a4bcfd' },
+  NO_EFFECT: { fill: '#57606a' },
+  NOT_MEASURED: { fill: '#656d76' },
+};
+const LABELS = {
+  PASSED: 'passing',
+  REGRESSED: 'regressed',
+  UNDERPOWERED: 'not enough draws',
+  NO_EFFECT: 'no separation detected',
+  NOT_MEASURED: 'not measured',
+};
+
+const H = 20;
+const PAD = 7;
+const CHAR = 6.6;
+const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const textW = (s) => Math.round(String(s).length * CHAR * 10) / 10;
+
+// A LIFT FIGURE IS A MEASUREMENT, so only a state that measured one may print it
+// (spec 036 A-036-2). UNDERPOWERED says the receipt's draws cannot resolve a shift of the
+// effect floor, and NOT_MEASURED says the receipt carries no verdict at all. A lift beside
+// either is the badge answering, in its most legible segment, a question the state has just
+// said it cannot answer -- and a reader who takes one figure from a badge takes that one.
+// Those two states print what the reader can act on instead: the draws taken against the
+// draws that would have been needed.
+function effectText(receipt, v) {
+  const c = receipt.comparison || {};
+  if (v.verdict === 'UNDERPOWERED' || v.verdict === 'NOT_MEASURED') return drawsText(receipt, v);
+  const lift = typeof c.delta === 'number' ? `lift ${c.delta >= 0 ? '+' : '-'}${Math.abs(c.delta).toFixed(3)}` : 'no lift';
+  const unc = typeof c.delta_uncertainty === 'number' ? `± ${c.delta_uncertainty.toFixed(3)}`
+    : c.delta_uncertainty_unavailable === 'single_case' ? 'no ± (1 case)' : 'no ±';
+  return `${lift} ${unc}`;
+}
+
+// Draws taken against draws needed, in the badge's words. The needed count is
+// receiptDrawsNeeded's, the same figure drawsLine prints in a sentence, so the badge and
+// the page cannot say two different numbers. Where no count exists the badge says which
+// of the two reasons it is, rather than printing a bare figure or nothing at all.
+//
+// BOTH NUMBERS ARE ONE CASE'S (A-036-7). Where a case sets the draws needed, the draws taken
+// are that case's own, which receiptDrawsNeeded carries as `taken`. This read the smallest
+// over every readable case, so a receipt whose binding case drew 4 and whose other case drew
+// 2 badged "2 draws of 5 needed": a 2 from a case the 5 does not belong to. Where no case sets
+// the draws needed (NOT_MEASURED carries no verdict to compute one from) there is no binding
+// case, and the smallest over every readable case is the figure.
+function drawsText(receipt, v) {
+  const d = v.drawsNeeded;
+  const taken = d ? d.taken : receiptDrawsTaken(receipt);
+  if (taken === null || taken === undefined) return 'no draws recorded';
+  const draws = `${taken} ${taken === 1 ? 'draw' : 'draws'}`;
+  if (!d) return `${draws}, needed not computed`;
+  if (typeof d.value === 'number') return `${draws} of ${d.value} needed`;
+  return `${draws}, no count at these spreads`;
+}
+
+function badgeSvg(receipt, { href = null } = {}) {
+  const v = receiptVerdict(receipt);
+  const state = STATE[v.verdict];
+  const label = LABELS[v.verdict];
+  const model = shortModel((receipt.run || {}).model_id);
+  const date = String((receipt.run || {}).date_utc || '').slice(0, 10);
+  const segs = [
+    { seg: 'brand', text: 'driftproof', fill: BRAND },
+    { seg: 'state', text: label, fill: state.fill },
+    { seg: 'detail', text: `${model} · ${date}`, fill: DETAIL },
+    { seg: 'effect', text: effectText(receipt, v), fill: EFFECT },
+  ];
+  let x = 0;
+  for (const s of segs) { s.w = Math.round(textW(s.text) + 2 * PAD); s.x = x; x += s.w; }
+  const width = x;
+  const title = `driftproof: ${label} on ${model}, ${date}, ${effectText(receipt, v)}`;
+  const L = [];
+  L.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${H}" viewBox="0 0 ${width} ${H}" role="img" aria-label="${esc(title)}" data-verdict="${v.verdict}" data-receipt-hash="${esc(receipt.receipt_hash || '')}">`);
+  L.push(`<title>${esc(title)}</title>`);
+  if (state.hatch) {
+    L.push(`<defs><pattern id="hatch" width="6" height="6" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><line x1="0" y1="0" x2="0" y2="6" stroke="${state.hatch}" stroke-width="3"/></pattern></defs>`);
+  }
+  if (href) L.push(`<a href="${esc(href)}">`);
+  for (const s of segs) {
+    const isState = s.seg === 'state';
+    const edge = isState && state.edge ? ` stroke="${state.edge}" stroke-width="1" stroke-dasharray="3 2"` : '';
+    L.push(`<rect data-seg="${s.seg}" x="${s.x}" y="0" width="${s.w}" height="${H}" fill="${s.fill}"${edge}/>`);
+    if (isState && state.hatch) L.push(`<rect data-seg="state-hatch" x="${s.x}" y="0" width="${s.w}" height="${H}" fill="url(#hatch)" opacity="0.35"/>`);
+  }
+  for (const s of segs) {
+    L.push(`<text data-seg="${s.seg}" x="${s.x + PAD}" y="14" fill="${INK}" font-family="Verdana,DejaVu Sans,sans-serif" font-size="11" textLength="${textW(s.text)}" lengthAdjust="spacingAndGlyphs">${esc(s.text)}</text>`);
+  }
+  if (href) L.push('</a>');
+  L.push('</svg>');
+  return L.join('\n') + '\n';
+}
+
+module.exports = { badgeSvg, LABELS, STATE };

package/lib/decision.js

@@ -20,7 +20,7 @@
 const fs = require('fs');
 const path = require('path');
 const { EFFECT_FLOOR } = require('../config');
-const { shortModel, githubOutputEntry } = require('./verdict');
+const { shortModel, githubOutputEntry, receiptVerdict, drawsLine, UNDERPOWERED_LINE } = require('./verdict');
 
 // The six decision states (spec 030 AC-4).
 //
@@ -29,7 +29,12 @@ const { shortModel, githubOutputEntry } = require('./verdict');
 // that says so. `no detected effect` is false about such a model - the effect
 // was detected and it cleared the floor - and widening it to mean "not a
 // regression" would put a measured lift and a measured nothing in one cell.
-const STATES = ['regression', 'refused', 'inconclusive', 'not measured', 'no detected effect', 'helped'];
+//
+// `underpowered` is the seventh (spec 035): the receipt measured, and its own spreads
+// and draws could not resolve a shift of the effect floor. It sits after `not
+// measured`, which measured nothing, and before `no detected effect`, which measured
+// with a resolution below the floor.
+const STATES = ['regression', 'refused', 'inconclusive', 'not measured', 'underpowered', 'no detected effect', 'helped'];
 
 // WORST FIRST. This is the single definition of the ordering; AC-1's
 // enforcement and AC-3's badge both read it, so they cannot disagree about
@@ -38,7 +43,7 @@ const STATE_ORDER = STATES.slice();
 
 // States that must never render as success on any surface the action writes -
 // the badge, the summary row, or the check title (AC-4).
-const NEVER_SUCCESS = ['inconclusive', 'not measured'];
+const NEVER_SUCCESS = ['inconclusive', 'not measured', 'underpowered'];
 
 // States that fail the job. `refused` fails CLOSED (AC-2): a model that
 // produced no receipt is not a model that passed. `regression` fails subject to
@@ -86,11 +91,15 @@ function decisionState(receipt) {
   if (level !== 'TESTED' || kind !== 'model') return 'not measured';
   const cmp = receipt.comparison || {};
   if ((receipt.run && receipt.run.status === 'incomplete') || typeof cmp.delta !== 'number') return 'inconclusive';
-  if (cmp.delta <= -EFFECT_FLOOR) return 'regression';
-  if (cmp.delta >= EFFECT_FLOOR) return 'helped';
-  return 'no detected effect';
+  // Spec 035: the measured states are the receipt verdict's, read per case by the
+  // band rule (lib/verdict.js receiptVerdict), not the aggregate delta against the floor.
+  // receiptVerdict refuses on the same four conditions the two clauses above split
+  // between `not measured` and `inconclusive`, so it cannot answer NOT_MEASURED here.
+  return MEASURED_STATE[receiptVerdict(receipt).verdict];
 }
 
+const MEASURED_STATE = { REGRESSED: 'regression', PASSED: 'helped', UNDERPOWERED: 'underpowered', NO_EFFECT: 'no detected effect' };
+
 // The worst state in a set, by STATE_ORDER. An empty set has no decision, and
 // says so with null rather than defaulting to something benign.
 function worstState(states) {
@@ -182,6 +191,8 @@ function decideSet(dir, requestedCsv, { failOnRegression = true } = {}) {
       delta: receipt && receipt.comparison && typeof receipt.comparison.delta === 'number'
         ? receipt.comparison.delta : null,
       file: hit ? path.basename(hit.file) : (unreadable ? path.basename(unreadable.file) : null),
+      // Spec 035 AC-3: what an underpowered row would have needed, from the same reading.
+      drawsNeeded: state === 'underpowered' ? receiptVerdict(receipt).drawsNeeded : null,
       // The distinction is carried on the ROW, not left in a sentence, because
       // the enforcement message has to say which of the two happened (AC-2's
       // mutation class, absence-vs-unreadable).
@@ -246,6 +257,7 @@ const RENDER = {
   refused: { word: 'refused', color: 'red', marker: '\u274c' },
   inconclusive: { word: 'inconclusive', color: 'yellow', marker: '\u26a0\ufe0f' },
   'not measured': { word: 'not measured', color: 'lightgrey', marker: '\u26a0\ufe0f' },
+  underpowered: { word: 'not enough draws', color: 'blue', marker: '\u26a0\ufe0f' },
   'no detected effect': { word: 'no effect', color: 'lightgrey', marker: '\u2014' },
   helped: { word: 'passing', color: 'brightgreen', marker: '\u2705' },
 };
@@ -283,7 +295,7 @@ function badgeEndpointForSet(d, { label = 'driftproof' } = {}) {
 // `worst`, `regressed` and `missing` are new and carry what it could not say.
 const VERDICT_WORD = {
   regression: 'REGRESSED', refused: 'REFUSED', inconclusive: 'INCONCLUSIVE',
-  'not measured': 'NOT_MEASURED', 'no detected effect': 'NO_EFFECT', helped: 'PASSED',
+  'not measured': 'NOT_MEASURED', underpowered: 'UNDERPOWERED', 'no detected effect': 'NO_EFFECT', helped: 'PASSED',
 };
 
 function githubOutputLines(d) {
@@ -299,6 +311,10 @@ function githubOutputLines(d) {
     ['regressed_models', d.regressed.join(',')],
     ['missing_models', d.missing.join(',')],
     ['receipt_count', d.receiptCount],
+    // Spec 035 AC-3: the draws the worst row would have needed, when that row is
+    // underpowered; `none` when no draw count reaches the floor at its spreads, and
+    // empty otherwise.
+    ['draws_needed', worstRow && worstRow.drawsNeeded ? (worstRow.drawsNeeded.value === null ? 'none' : worstRow.drawsNeeded.value) : ''],
   ].map(([k, v]) => githubOutputEntry(k, v)).join('\n');
 }
 
@@ -324,7 +340,8 @@ function summaryMarkdown(d) {
     const r = RENDER[row.state];
     const delta = row.delta === null ? 'n/a' : (row.delta >= 0 ? '+' : '') + row.delta.toFixed(3);
     const note = row.reason ? ` <br><sub>${cell(row.reason)}</sub>` : '';
-    L.push(`| \`${cell(row.model)}\` | ${r.marker} ${row.state} | ${delta} | ${cell(row.file) || '\u2014'}${note} |`);
+    const power = row.state === 'underpowered' ? ` <br><sub>${cell(UNDERPOWERED_LINE)}. ${cell(drawsLine(row.drawsNeeded))}</sub>` : '';
+    L.push(`| \`${cell(row.model)}\` | ${r.marker} ${row.state}${power} | ${delta} | ${cell(row.file) || '\u2014'}${note} |`);
   }
   L.push('');
   L.push(`Decided over ${d.receiptCount} receipt(s) for ${d.requestedCount} requested model(s). `

package/lib/diff.js

@@ -5,6 +5,7 @@ const { bandVerdict, round, WITHIN_NOISE } = require('./stats');
 const { EFFECT_FLOOR } = require('../config');
 const { revisionHeadline } = require('./revision');
 const { baselineReproduces, REFUSAL_REASONS, bandOf } = require('./reuse');
+const { caseRule, armOf, drawsLine, UNDERPOWERED_LINE } = require('./verdict');
 
 // Practical-significance gate applied ON TOP of band separation. bandVerdict()
 // stays a pure geometry test (kept that way so its unit checks are unambiguous);
@@ -198,6 +199,15 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   // untested input does: no delta is asserted, and the reason travels with it.
   const measured = belowTested.length === 0 && !refusal && incompleteSides.length === 0 && !judgeProblem;
 
+  // THE UNDERPOWERED STATE RIDES BESIDE THE VERDICT VALUE (spec 035 R-6). The value
+  // is unchanged, because Reports 006 to 008 and spec 009's gate compare against it
+  // and a published record quotes the lines it produced. `power` says, for a case
+  // the rule did not separate, whether the two with_skill arms' own spreads and
+  // draws could have resolved a shift of the effect floor, by the rule lib/verdict.js
+  // applies to a single receipt.
+  const rawWith = (r) => new Map(r.results.cases.filter((c) => c.mode === 'with_skill').map((c) => [c.id, c]));
+  const aRaw = rawWith(a);
+  const bRaw = rawWith(b);
   const perCase = ids.map((id) => {
     const before = aB[id] || null;
     const after = bB[id] || null;
@@ -205,7 +215,13 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
     const verdict = refusal ? 'refused'
       : !measured ? 'not measured'
       : (before && after) ? verdictWithFloor(before, after, delta) : 'n/a';
-    return { id, before, after, delta, verdict };
+    let power = null;
+    if (measured && before && after && (verdict === WITHIN_NOISE || verdict === WITHIN_NOISE_FLOOR)) {
+      const ra = armOf(aRaw.get(id)); const rb = armOf(bRaw.get(id));
+      const rule = ra && rb ? caseRule(ra, rb) : null;
+      if (rule && rule.state === 'underpowered') power = { state: 'underpowered', drawsNeeded: rule.drawsNeeded, reason: rule.reason, ...(rule.spread !== undefined ? { spread: rule.spread } : {}) };
+    }
+    return { id, before, after, delta, verdict, power };
   });
   // Sort worst-first: regressions, then by delta.
   const order = { regression: 0, [WITHIN_NOISE]: 1, [WITHIN_NOISE_FLOOR]: 1, improvement: 2, 'n/a': 3, 'not measured': 3, refused: 3 };
@@ -391,6 +407,18 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
     // the rule, which is what the headline above says.
     L.push(`with_skill mean moved ${fmt(headlineDelta)} (${bandStr(aAgg)} → ${bandStr(bAgg)}; band = suite dispersion). Per-case band-overlap verdicts: ${regressions.length} regression(s), ${perCase.filter((r) => r.verdict === 'improvement').length} improvement(s), ${nWithin - nFloor} with no separation detected${nFloor ? `, ${nFloor} below the ${EFFECT_FLOOR} effect floor` : ''}.`);
     L.push('');
+    const underpowered = perCase.filter((r) => r.power);
+    if (underpowered.length) {
+      // One count, one sentence, one draws line: the worst case's (spec 035 AC-5).
+      const spread = underpowered.find((r) => r.power.reason === 'spread');
+      const most = underpowered.filter((r) => r.power.reason === 'draws').sort((x, y) => y.power.drawsNeeded - x.power.drawsNeeded)[0];
+      const worst = spread ? { value: null, reason: 'spread', case: spread.id, spread: spread.power.spread }
+        : most ? { value: most.power.drawsNeeded, reason: 'draws', case: most.id }
+          : { value: 2, reason: 'single_draw', case: underpowered[0].id };
+      const powerLine = `Underpowered: ${underpowered.length} of the cases with no separation under the rule. ${UNDERPOWERED_LINE}. ${drawsLine(worst)}`;
+      L.push(powerLine);
+      L.push('');
+    }
   }
 
   L.push(`## Per-case with_skill (band overlap → verdict)`);
@@ -399,7 +427,8 @@ function buildDriftReport(a, b, { labelA = 'A', labelB = 'B', mode = 'release' }
   L.push(`|---|---|---|---|---|`);
   for (const r of perCase) {
     const flag = r.verdict === 'regression' ? '🔻 regression' : r.verdict === 'improvement' ? '🔼 improvement' : r.verdict === WITHIN_NOISE_FLOOR ? 'below effect floor' : r.verdict === WITHIN_NOISE ? 'no separation detected' : r.verdict === 'not measured' ? 'not measured' : 'n/a';
-    L.push(`| \`${r.id}\` | ${r.before ? bandStr(r.before) : 'n/a'} | ${r.after ? bandStr(r.after) : 'n/a'} | ${fmt(r.delta)} | ${flag} |`);
+    const label = r.power ? `${flag}; ${UNDERPOWERED_LINE}` : flag;
+    L.push(`| \`${r.id}\` | ${r.before ? bandStr(r.before) : 'n/a'} | ${r.after ? bandStr(r.after) : 'n/a'} | ${fmt(r.delta)} | ${label} |`);
   }
   L.push('');
 

package/lib/hygiene.js

@@ -23,6 +23,8 @@
 // Patterns are written so a regex literal cannot match its own text: a
 // metacharacter or a character class follows each fixed prefix.
 
+const zlib = require('zlib');
+
 const dec = (b64) => JSON.parse(Buffer.from(b64, 'base64').toString('utf8'));
 
 // Build-box host + private IP, base64 so the plaintext never lands in a file.
@@ -54,7 +56,70 @@ function scanPath(rel) {
   return /(^|\/)\.env(\.|$)/.test(rel) ? [{ file: rel, kind: 'env-file' }] : [];
 }
 
+// A PNG'S TEXT-BEARING REGIONS (spec 038 A-038-5, the classification spec 027 already made for the
+// repository gate's confidentiality scan, applied here).
+//
+// THE THREAT MODEL IS ACCIDENTAL PLAINTEXT DISCLOSURE by a person or an agent writing the tree
+// (CONSTITUTION § Threat model). A PNG carries text in its tEXt, iTXt and zTXt chunks, and carries
+// pixels in IDAT, which is deflate output: nobody types into it, and a run of bytes that happens to
+// decode as an address there is a coincidence of compression, not a disclosure. Scanned as one
+// string, a 2 MB screenshot is two million chances of that coincidence, and it has fired twice on
+// this repository's own committed captures.
+//
+// So: every chunk but IDAT is scanned, chunk type names included, and IDAT is not. A name RENDERED
+// INTO a screenshot is pixels, which no byte scan sees either way - that is the gap this scan has
+// always had, and it is unchanged. Everything that is not a PNG is scanned whole, as before.
+//
+// FAIL CLOSED WHERE THE FILE STOPS BEING A PNG (spec 038 approval F-3). Bytes after IEND are no chunk
+// at all, and a chunk whose length runs past the end of the file is a truncated file: either way the
+// remainder, from where the walk lost the structure, is scanned whole, as every file was before this
+// classification. And a text chunk is read in the encoding it carries text in: a zTXt chunk's text
+// and a compressed iTXt chunk's text are inflated and scanned as well as their raw bytes. A chunk
+// that does not inflate is scanned raw, which it already was.
+const PNG_SIG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const INFLATE_CAP = 16 * 1024 * 1024;
+function inflated(data) {
+  try { return zlib.inflateSync(data, { maxOutputLength: INFLATE_CAP }).toString('latin1'); } catch (_e) { return null; }
+}
+function pngTextBearing(buf) {
+  const parts = [];
+  const rest = (from) => { parts.push(buf.slice(from).toString('latin1')); return parts.join('\n'); };
+  let off = 8;
+  while (off + 8 <= buf.length) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.slice(off + 4, off + 8).toString('latin1');
+    const start = off + 8;
+    const end = start + len;
+    if (end + 4 > buf.length) return rest(off);   // a truncated chunk: it and all after it, whole
+    const data = buf.slice(start, end);
+    if (type !== 'IDAT') parts.push(type, data.toString('latin1'));
+    if (type === 'zTXt') parts.push(zTXtText(data));
+    if (type === 'iTXt') parts.push(iTXtText(data));
+    off = end + 4;
+    if (type === 'IEND') return rest(off);         // bytes after IEND, whole
+  }
+  return rest(off);                                // fewer than a chunk header's bytes, no IEND
+}
+// keyword \0 method data
+function zTXtText(data) {
+  const z = data.indexOf(0);
+  return (z >= 0 && inflated(data.slice(z + 2))) || '';
+}
+// keyword \0 flag method language \0 translated keyword \0 text; the text is deflated when flag is 1
+function iTXtText(data) {
+  const z = data.indexOf(0);
+  if (z < 0 || data[z + 1] !== 1) return '';
+  const lang = data.indexOf(0, z + 3);
+  const tr = lang >= 0 ? data.indexOf(0, lang + 1) : -1;
+  return (tr >= 0 && inflated(data.slice(tr + 1))) || '';
+}
+
 function scanContent(rel, content) {
+  // A reader may hand this bytes rather than text. A PNG is then read as its text-bearing regions;
+  // anything else is decoded and scanned whole.
+  if (Buffer.isBuffer(content)) {
+    return scanContent(rel, content.slice(0, 8).equals(PNG_SIG) ? pngTextBearing(content) : content.toString('utf8'));
+  }
   const hits = [];
   for (const p of PATTERNS) {
     const m = content.match(p.re);
@@ -104,10 +169,10 @@ function scanFiles(files, read, readLink) {
     }
     let c;
     try { c = read(rel); } catch (_e) { continue; }
-    if (typeof c !== 'string') continue;
+    if (typeof c !== 'string' && !Buffer.isBuffer(c)) continue;
     hits.push(...scanContent(rel, c));
   }
   return hits;
 }
 
-module.exports = { PATTERNS, EMAIL_ALLOW, HOSTIP, scanPath, scanContent, scanFiles };
+module.exports = { PATTERNS, EMAIL_ALLOW, HOSTIP, PNG_SIG, pngTextBearing, scanPath, scanContent, scanFiles };

package/lib/receipt.js

@@ -25,7 +25,11 @@ const SCHEMA_FILES = {
   // the validator (it requires the receipt to say what answered it), so the
   // number has to keep resolving to the schema it meant.
   '0.5': 'receipt.v0.5.schema.json',
-  '0.6': 'receipt.schema.json',
+  // v0.6 moved the same way when v0.7 took the current pointer (spec 035): v0.7 adds a
+  // verdict token a reader derives (UNDERPOWERED), and a v0.6 receipt restamped 0.7
+  // is refused by the const, so the number keeps resolving to the schema it meant.
+  '0.6': 'receipt.v0.6.schema.json',
+  '0.7': 'receipt.schema.json',
 };
 
 // THE BAND RULE, stated on every receipt (results.aggregates.band_rule, spec