driftproof 0.11.2 → 0.11.3

package/README.md

@@ -13,16 +13,16 @@ there were too few draws to tell, the receipt says so.
  — live badge for the bundled `commit-message-conventions` example, generated from its own receipt.
 
 **[Quickstart](https://driftproofhq.com/#quickstart)** ·
-**[Latest report](https://driftproofhq.com/reports/010/)** ·
+**[Latest report](https://driftproofhq.com/reports/011/)** ·
 [driftproofhq.com](https://driftproofhq.com)
 
 Driftproof **consumes** the [`agentskills.io/evals`](https://agentskills.io) eval
 format; it does not invent its own.
 
-📊 **Ten published reports** (each re-derived from committed files, nothing
+📊 **Eleven published reports** (each re-derived from committed files, nothing
 hand-entered: Driftproof's receipts, or for Report #010 the upstream harness's own
 output), spanning seven published report types, the newest being instrument
-comparison. The nine that measure with Driftproof read its own arms by one
+comparison. The ten that measure with Driftproof read its own arms by one
 band-based, floor-gated verdict rule and differ in what moves underneath the
 skill — or, in the value report, in which axes are measured; or, in the instrument re-measurement, in the
 instrument itself; or, in the instrument comparison, in which instrument measures:
@@ -92,11 +92,21 @@ instrument itself; or, in the instrument comparison, in which instrument measure
   and 2 failed, both failures on one expectation the skill's ADR instructions do
   not state. No Driftproof measurement was taken and no Driftproof judge ran, and
   the report does not isolate what caused the variation.
+- **[Report #011](https://driftproofhq.com/reports/011/)** — *release drift*:
+  Claude Opus 5.5 on its release day, measured on Report #009's three skills and
+  cases, one case each, beside a fresh Claude Opus 5 arm on the same Claude Code
+  version. Read by the runner's own comparison of the with-skill arms, the three
+  skills read 1 with no separation detected and 2 with not enough draws to conclude
+  at the effect floor, which is not evidence that nothing changed. A second table
+  sets Report #009's own Claude Opus 5 receipts beside this run's; between them the
+  Claude Code version, its host build and the date all changed. Every draw was
+  judged with `claude-opus-5`, which departs from the judge policy, so its figures
+  are not comparable with Reports #001 to #008.
 
 ✍️ The launch essay, **[Three model releases later: what actually happens to agent
-skills](https://driftproofhq.com/writing/three-releases/)**, reads all ten reports
+skills](https://driftproofhq.com/writing/three-releases/)**, reads all eleven reports
 together: what moves underneath a skill, what the skill costs to run, and what a
-corrected instrument did to three published results. Revised 2026-09-22; every
+corrected instrument did to three published results. Revised 2026-09-23; every
 figure in it is gate-checked against the report page it cites.
 
 ## Why
@@ -229,6 +239,7 @@ npx driftproof badge receipt.json --out badges/my-skill.json
 # epistemics — no fabricated hashes, excluded from drift verdicts), and emit
 # the minimal stable summary other tools can consume. See docs/interop.md.
 npx driftproof import results.json --from agent-skills-eval   # or: skillgrade
+npx driftproof import evals/results/<timestamp>/ --from claude-plugin-eval   # or: skill-creator
 npx driftproof export receipt.json --to summary-json
 ```
 
@@ -312,7 +323,7 @@ A receipt is the unit of evidence — one JSON document conforming to
 
 ```jsonc
 {
-  "schema_version": "0.7",
+  "schema_version": "0.9",
   "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 },
@@ -321,7 +332,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.11.2",
+    "runner_version": "0.11.3",
     "date_utc": "2026-07-27T…Z",
     "registry": "registered",
     "transcripts": "hashes-only",
@@ -400,7 +411,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: driftproofhq/driftproof@v0.11.2
+      - uses: driftproofhq/driftproof@v0.11.3
         with:
           skill-dir: skills/my-skill
           models: claude-haiku-4-5
@@ -448,9 +459,15 @@ the skill hurt — but they **never render as success** on any of the three
 surfaces: not in the badge, not in the summary row, and not in the check title,
 which carries a `::warning` naming the state and the models it came from.
 
+A receipt set that does not say one thing is `REFUSED` as well. Two receipts for
+one requested model, or a receipt with two rows for one case and arm, fail the job
+naming the files or the case, because a decision that depends on which one was read
+is not a pass. Each invocation of the Action writes to its own directory and uploads
+its own artifact, so a job may run it more than once, one skill per step.
+
 Step outputs: `verdict`, `delta` (of the model the worst decision came from),
-`worst_state`, `regressed_models`, `missing_models` and `receipts_dir`. Each is
-described in [`action.yml`](action.yml).
+`worst_state`, `regressed_models`, `missing_models`, `receipts_dir` and
+`artifact_name`. Each is described in [`action.yml`](action.yml).
 
 For a free CI dry-run with **zero model calls**, set `DRIFTPROOF_STUB=1` in the job
 env — the runner returns canned receipts so the wiring can be tested without spend
@@ -495,7 +512,7 @@ site, so it reflects a real dated run, not a hand-set color.
 
 ## Reports
 
-Ten reports are published, spanning seven report types. A report page lives at a
+Eleven reports are published, spanning seven report types. A report page lives at a
 draft path — `docs/reports/NNN-draft/` — until the publish sequence renames it, and
 `scripts/build-public.sh` excludes every `*-draft/` path from the published tree
 (see the roll at the top of this README, and

package/bin/driftproof

@@ -8,7 +8,7 @@ const { PROJECT_NAME, RUNNER_VERSION, DEFAULT_JUDGE_SAMPLES, DEV_MAX_USD, DEV_MA
 const { loadSkill } = require('../lib/skill');
 const { runSkillOnModel, summarizeReceipt, projectCalls, answeredLine, band, uncertaintyStr } = require('../lib/run');
 const { SAMPLING } = require('../lib/sampling');
-const { validateReceipt, verifyReceiptHash } = require('../lib/receipt');
+const { validateReceipt, verifyReceiptHash, duplicateCaseRows, ambiguityLine } = require('../lib/receipt');
 const { buildDriftReport, revisionPairProblem } = require('../lib/diff');
 const { surfaceForModel, isSubscriptionSurface, resolveModel, evalUser } = require('../lib/provider');
 const { estimateRunCostUSD, BudgetTracker } = require('../lib/cost');
@@ -16,6 +16,8 @@ const { registryStatus, assertRegistered, REGISTRY_PATH } = require('../lib/mode
 const { verdictFromReceipt, badgeEndpoint, githubOutputLines, drawsLine, UNDERPOWERED_LINE } = require('../lib/verdict');
 const decision = require('../lib/decision');
 const { scaffoldInit } = require('../lib/init');
+const { planRegrade, regradeReceipt } = require('../lib/regrade');
+const { sha256 } = require('../lib/canonical');
 
 // Output dirs default to the USER's current directory, not the package dir, so a
 // global/npx install writes receipts/transcripts into the project being tested
@@ -59,6 +61,20 @@ function refuseUnverified(receipt, file, command) {
   process.exit(4);
 }
 
+// ── AN AMBIGUOUS RECEIPT IS NOT RENDERED (spec 050 AC-3) ─────────────────────
+// A receipt with two rows for one (id, mode) verifies and, before spec 050, validated:
+// the loader let two cases share an id, and the verdict kept whichever row came last.
+// The surfaces that render ONE receipt refuse it here, after the hash check, the way
+// they refuse a tampered one: nothing on stdout, no file, the pair on stderr, exit 2.
+// The set surfaces (decide, badge <dir>) do not come here: they decide the model
+// `refused`, which fails the job closed and keeps the row that says why.
+function refuseAmbiguous(receipt, file, command) {
+  const dups = duplicateCaseRows(receipt);
+  if (!dups.length) return;
+  console.error(`  ✗ REFUSED (${command}): ${path.basename(file)} is ambiguous: ${ambiguityLine(dups)}. A verdict over it would depend on which row was read; nothing rendered.`);
+  process.exit(2);
+}
+
 // Read an optional .driftproofrc (JSON) for per-project run defaults. Looked up
 // in the skill dir first (where `driftproof init` writes it), then the CWD. CLI
 // flags always win over the rc; the rc wins over built-in defaults.
@@ -75,7 +91,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', 'svg']);
+const BOOLEAN_FLAGS = new Set(['trusted-skill', 'svg', 'count-errored-runs', 'strict', 'no-harness-check']);
 
 // ── 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
@@ -176,11 +192,16 @@ USAGE
                         [--judge-model M] [--concurrency N] [--max-usd N]
                         [--keep-transcripts] [--out DIR] [--trusted-skill]
   ${PROJECT_NAME} diff <receiptA.json> <receiptB.json> [--out FILE] [--mode release|revision]
+  ${PROJECT_NAME} regrade <receipt.json> --skill <dir> --answers <file> --judge-model <id>
+                        [--samples N] [--max-calls N] [--max-usd N] [--out DIR] [--trusted-skill]
+  ${PROJECT_NAME} stale <receipt.json>... [--skill DIR] [--suite FILE] [--model ID] [--judge ID]
+                        [--harness-version V | --no-harness-check] [--strict] [--json [path]]
   ${PROJECT_NAME} validate <receipt.json>
   ${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]
+  ${PROJECT_NAME} import <file|dir> --from claude-plugin-eval|skill-creator [--count-errored-runs] [--out DIR]
   ${PROJECT_NAME} export <receipt.json> [--to summary-json] [--report-url URL] [--out FILE]
 
 ENV
@@ -228,12 +249,33 @@ NOTES
     epistemics: verification_level DECLARED (never TESTED), surface "external",
     source "imported/<tool>", and NO fabricated hashes. Imported receipts are
     excluded from drift verdicts (diff reports NOT MEASURED). See docs/interop.md.
+  - import --from claude-plugin-eval reads \`claude plugin eval\`'s aggregate-result.json
+    (or its --json output); --from skill-creator reads a benchmark.json (skill-creator's,
+    or skill-up's, with its result.json beside it). Given a directory, it finds the one
+    document and refuses none or several. Runs the source recorded an error for are kept
+    out of the band and listed (--count-errored-runs puts them back); anything the source
+    does not record is written as unknown and named in run.import.notices.
+  - stale compares what each receipt recorded (model, harness, skill, suite, judge,
+    template, each case's rubric) with what would run today, read from the flags,
+    then .driftproofrc; a value nobody gives is unknown, never current. It says per
+    arm whether the result stands, needs a rerun, or only a regrade, and prints the
+    command to run next. No model call, no network. Exit 0 current, 1 stale, 3
+    something unknown or a newer model, 2 an error; --strict turns 3 into 1.
+  - regrade grades a receipt's saved answers again with another judge (or the
+    same judge under a new template): what lib/reuse.js's triage calls
+    "regrade". --answers is {"answers": {"<generation_hash>": "<text>"}}; every
+    answer is checked against its hash before any call. The generation side of
+    the new receipt is the original's, draw for draw; --samples defaults to the
+    original's. The receipt records the re-judge (its archived arms, judged_at and
+    grader_revision); <receipt>.regrade.json beside it names the original receipt
+    and the answers file.
   - export --to summary-json emits the minimal stable interchange summary
     (driftproof/summary v1) other tools can consume without a receipt parser.`);
 }
 
 function slug(s) { return String(s).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''); }
-function dateStamp(iso) { return iso.slice(0, 10); }
+// An imported receipt whose source records no date carries date_utc null (receipt v0.9).
+function dateStamp(iso) { return iso ? iso.slice(0, 10) : 'undated'; }
 
 async function cmdRun(positional, flags) {
   const skillDir = positional[0];
@@ -279,7 +321,14 @@ async function cmdRun(positional, flags) {
   const outDir = flags.out ? path.resolve(flags.out) : RECEIPTS_DIR;
   fs.mkdirSync(outDir, { recursive: true });
 
-  const skill = loadSkill(skillDir);
+  let skill;
+  try { skill = loadSkill(skillDir); } catch (e) {
+    // Spec 050 AC-1: a suite whose case ids collide is refused before the projection and
+    // before any call, naming the suite file, like the empty suite below.
+    if (!e || e.code !== 'DUPLICATE_CASE_ID') throw e;
+    console.error(`  ✗ REFUSED: the suite at ${path.join(path.resolve(skillDir), 'evals', 'evals.json')}: ${e.message}. Nothing measured, no receipt written.`);
+    process.exit(2);
+  }
   const nCases = maxCases ? Math.min(maxCases, skill.suite.caseCount) : skill.suite.caseCount;
   // Spec 026 AC-5 (F2): a suite with no cases measures nothing, and a receipt
   // over nothing is a receipt about nothing. Refused here, before the
@@ -467,6 +516,118 @@ function cmdDiff(positional, flags) {
   }
 }
 
+// ── stale (spec 053) ────────────────────────────────────────────────────────
+// Whether each receipt's conclusion still stands under what would run today. Exit 0 current, 1 stale,
+// 3 nothing stale but something unknown or a newer model, 2 an unreadable or invalid receipt or a bad
+// flag; --strict turns 3 into 1. `--json` prints the driftproof.stale/1 document; `--json <path>`
+// writes it there, over an earlier stale document, and refuses (exit 2) a path that holds anything
+// else, so `stale --json receipts/*.json` cannot overwrite a receipt (A-053-1, approval F-1).
+function cmdStale(positional, flags) {
+  const { staleReport, renderText } = require('../lib/stale');
+  const VALUE = ['skill', 'suite', 'model', 'judge', 'harness-version'];
+  const BOOL = ['strict', 'no-harness-check'];
+  const bad = (msg) => { console.error(`  ✗ stale: ${msg}\n`); console.error(`  usage: ${PROJECT_NAME} stale <receipt.json>... [--skill DIR] [--suite FILE] [--model ID] [--judge ID] [--harness-version V | --no-harness-check] [--strict] [--json [path]]`); process.exitCode = 2; };
+  for (const k of Object.keys(flags)) if (![...VALUE, ...BOOL, 'json'].includes(k)) return bad(`unknown flag --${k}`);
+  for (const k of VALUE) if (flags[k] === true) return bad(`--${k} needs a value`);
+  if (flags['harness-version'] && flags['no-harness-check']) return bad('--harness-version and --no-harness-check together');
+  const files = [...positional];
+  let jsonOut = null;
+  if (typeof flags.json === 'string') {
+    if (fs.existsSync(flags.json)) {
+      let earlier = null; try { earlier = JSON.parse(fs.readFileSync(flags.json, 'utf8')); } catch { /* not a stale document */ }
+      if (!earlier || earlier.schema !== 'driftproof.stale/1') return bad(`--json ${flags.json} names an existing file that is not a stale document; nothing is written over it (put --json last with a new path, or give --json alone)`);
+    }
+    jsonOut = flags.json;
+  }
+  if (!files.length) return bad('no receipt given');
+  if (flags.skill) { try { loadSkill(flags.skill); } catch (e) { return bad(`--skill ${flags.skill}: ${e.message}`); } }
+  if (flags.suite) { try { JSON.parse(fs.readFileSync(flags.suite, 'utf8')); } catch (e) { return bad(`--suite ${flags.suite}: ${e.message}`); } }
+  const doc = staleReport(files, {
+    skill: flags.skill || null, suite: flags.suite || null, model: flags.model || null, judge: flags.judge || null,
+    harnessVersion: flags['harness-version'] || null, noHarnessCheck: !!flags['no-harness-check'], strict: !!flags.strict,
+    rc: loadRc(flags.skill || null),
+  });
+  if (flags.json) {
+    const text = JSON.stringify(doc, null, 2) + '\n';
+    if (jsonOut) { fs.writeFileSync(jsonOut, text); process.stdout.write(renderText(doc)); } else process.stdout.write(text);
+  } else process.stdout.write(renderText(doc));
+  process.exitCode = doc.exit_code;
+}
+
+// ── regrade (spec 044) ──────────────────────────────────────────────────────
+// The executor behind lib/reuse.js's `regrade` decision. Every input is checked
+// before the projection, and the projection before any call: the receipt's seal,
+// the skill and suite it was run on, and every answer against its hash (AC-4).
+async function cmdRegrade(positional, flags) {
+  const receiptPath = positional[0];
+  if (!receiptPath) { console.error('  ✗ regrade: a receipt path is required\n'); usage(); process.exit(2); }
+  for (const f of ['skill', 'answers', 'judge-model']) {
+    if (typeof flags[f] !== 'string' || !flags[f]) { console.error(`  ✗ REFUSED (regrade): --${f} is required; nothing run, no receipt written.`); process.exit(2); }
+  }
+  const checked = checkNumericInputs(flags, {});
+  const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+  const judgeModel = resolveModel(flags['judge-model']);
+  checkRegistered([receipt.run.model_id], () => judgeModel);
+  const origSamples = receipt.run && receipt.run.judge && receipt.run.judge.samples;
+  const samples = checked.samples !== undefined ? parseInt(checked.samples, 10) : origSamples;
+  if (!Number.isInteger(samples) || samples < 1) { console.error('  ✗ REFUSED (regrade): the receipt records no judge sample count; pass --samples.'); process.exit(2); }
+  const maxCalls = checked['max-calls'] !== undefined ? parseInt(checked['max-calls'], 10) : DEV_MAX_CALLS;
+  const maxUsd = checked['max-usd'] !== undefined ? parseFloat(checked['max-usd']) : DEV_MAX_USD;
+  const trusted = !!flags['trusted-skill'];
+  const outDir = flags.out ? path.resolve(flags.out) : RECEIPTS_DIR;
+  const skill = loadSkill(flags.skill);
+  const answersFile = path.resolve(flags.answers);
+  const answersBytes = fs.readFileSync(answersFile);
+  const answers = (JSON.parse(answersBytes.toString('utf8')) || {}).answers || {};
+
+  const plan = planRegrade({ receipt, skill, answers, judgeModel, samples });
+  console.log(`\n${PROJECT_NAME} regrade: ${path.basename(receiptPath)}`);
+  if (process.env.DRIFTPROOF_STUB === '1') console.log('  STUB RUN (DRIFTPROOF_STUB=1): nothing will answer the judge; the receipt will be UNVERIFIED and grade nothing');
+  console.log(`  model: ${receipt.run.model_id} (generations kept)   judge: ${receipt.run.judge.model_id} → ${judgeModel}   samples/answer: ${samples}`);
+  if (plan.problems.length) {
+    console.error(`\n  ✗ REFUSED (regrade): ${plan.problems.length} problem(s) with the inputs; nothing run, no receipt written.`);
+    for (const p of plan.problems.slice(0, 20)) console.error(`    - ${p}`);
+    process.exit(2);
+  }
+  console.log(`  answers to grade: ${plan.draws}   projected calls: ${plan.calls}   cap: ${maxCalls}`);
+  console.log(`  projected cost: ~$${plan.usd.toFixed(2)} (the runner's per-call judge estimate; budget $${maxUsd.toFixed(2)}, hard-stop $${(maxUsd * 1.25).toFixed(2)})`);
+  if (plan.calls > maxCalls) {
+    console.error(`\n  ✗ ABORT (cost guard): projected ${plan.calls} calls exceeds --max-calls ${maxCalls}.`);
+    process.exit(3);
+  }
+  if (plan.usd > maxUsd) {
+    console.error(`\n  ✗ ABORT (cost guard): projected cost ~$${plan.usd.toFixed(2)} exceeds --max-usd $${maxUsd.toFixed(2)}.`);
+    process.exit(3);
+  }
+  let result;
+  try {
+    result = await regradeReceipt({
+      receipt, skill, answers, judgeModel, samples,
+      opts: {
+        trusted, budget: new BudgetTracker(maxUsd),
+        onProgress: (p) => { if (p.phase === 'done') console.log(`  ${p.case} / ${p.mode}: ${p.outcome} (${p.score.toFixed(2)} ± ${(p.stddev || 0).toFixed(2)})`); },
+      },
+    });
+  } catch (e) {
+    if (e && e.code === 'SUBSTRATE_MISMATCH') { console.error(`\n  ✗ REFUSED (substrate mismatch): ${e.message}`); process.exit(5); }
+    if (e && e.code === 'BUDGET_HARDSTOP') { console.error(`\n  ✗ ABORT (budget hard-stop): ${e.message}`); process.exit(3); }
+    throw e;
+  }
+  const out = result.receipt;
+  const { valid, errors } = validateReceipt(out);
+  if (!valid) { console.error('  ✗ regraded receipt FAILED schema validation:', JSON.stringify(errors, null, 2)); process.exitCode = 1; }
+  if (!verifyReceiptHash(out)) { console.error('  ✗ receipt_hash does not verify'); process.exitCode = 1; }
+  fs.mkdirSync(outDir, { recursive: true });
+  const base = `${slug(out.skill.name)}-${slug(out.run.model_id)}-regrade-${slug(judgeModel)}-${dateStamp(out.run.date_utc)}`;
+  const jsonPath = path.join(outDir, `${base}.json`);
+  fs.writeFileSync(jsonPath, JSON.stringify(out, null, 2));
+  fs.writeFileSync(path.join(outDir, `${base}.summary.md`), summarizeReceipt(out));
+  const provenance = { ...result.provenance, answers: { file: path.basename(answersFile), sha256: sha256(answersBytes), graded: plan.draws } };
+  fs.writeFileSync(path.join(outDir, `${base}.regrade.json`), JSON.stringify(provenance, null, 2));
+  console.log(`  → ${path.relative(process.cwd(), jsonPath)}  (${result.calls} judge calls)`);
+  console.log(`  → verification_level ${out.verification_level}; provenance: ${base}.regrade.json\n`);
+}
+
 function cmdValidate(positional) {
   const p = positional[0];
   if (!p) { usage(); process.exit(2); }
@@ -515,6 +676,7 @@ 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');
+  refuseAmbiguous(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.
@@ -661,12 +823,27 @@ function cmdImport(positional, flags) {
   const p = positional[0];
   const from = flags.from;
   const { IMPORT_TOOLS, importResults } = require('../lib/importers');
+  const { ANTHROPIC_TOOLS, importAnthropic, ImportRefused } = require('../lib/importers-anthropic');
+  const tools = [...IMPORT_TOOLS, ...ANTHROPIC_TOOLS];
   if (!p || typeof from !== 'string') {
-    console.error(`usage: driftproof import <results.json> --from ${IMPORT_TOOLS.join('|')} [--out DIR]`);
+    console.error(`usage: driftproof import <results.json|dir> --from ${tools.join('|')} [--count-errored-runs] [--out DIR]`);
     process.exit(2);
   }
-  const data = JSON.parse(fs.readFileSync(p, 'utf8'));
-  const receipt = importResults(data, { from, importedAt: new Date().toISOString() });
+  let receipt;
+  let read = p;
+  if (ANTHROPIC_TOOLS.includes(from)) {
+    // Spec 049: a file or a directory; the clock is read once, into run.import.imported_at.
+    try {
+      ({ receipt, file: read } = importAnthropic(p, { from, importedAt: new Date().toISOString(), countErroredRuns: flags['count-errored-runs'] === true }));
+    } catch (e) {
+      if (!(e instanceof ImportRefused)) throw e;
+      console.error(`✗ import refused, nothing written: ${e.message}`);
+      process.exit(1);
+    }
+  } else {
+    const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+    receipt = importResults(data, { from, importedAt: new Date().toISOString() });
+  }
   const { valid, errors } = validateReceipt(receipt);
   if (!valid || !verifyReceiptHash(receipt)) {
     console.error('✗ converted receipt failed validation — nothing written:', JSON.stringify(errors, null, 2));
@@ -674,12 +851,18 @@ function cmdImport(positional, flags) {
   }
   const outDir = flags.out ? path.resolve(flags.out) : RECEIPTS_DIR;
   fs.mkdirSync(outDir, { recursive: true });
-  const base = `${slug(receipt.skill.name)}-${slug(receipt.run.model_id)}-imported-${slug(from)}-${dateStamp(receipt.run.date_utc)}`;
+  // Spec 049 (approval F-2): the two formats it adds produce several documents per skill, model and
+  // day (one per iteration or per results directory), so their receipt name carries the document's
+  // own hash and one import never overwrites another's receipt. The same document names the same file.
+  const doc = receipt.run.import && ANTHROPIC_TOOLS.includes(from) ? `-${receipt.run.import.source_sha256.slice(0, 12)}` : '';
+  const base = `${slug(receipt.skill.name)}-${slug(receipt.run.model_id)}-imported-${slug(from)}-${dateStamp(receipt.run.date_utc)}${doc}`;
   const jsonPath = path.join(outDir, `${base}.json`);
   fs.writeFileSync(jsonPath, JSON.stringify(receipt, null, 2));
+  if (read !== p) console.log(`read ${path.relative(process.cwd(), read)}`);
   console.log(`imported → ${path.relative(process.cwd(), jsonPath)}`);
   console.log(`  verification_level: DECLARED (source ${receipt.run.source}) — the source tool's declaration, converted faithfully;`);
   console.log(`  no generation hashes (never fabricated); excluded from drift verdicts unless re-run TESTED. See docs/interop.md.`);
+  for (const n of (receipt.run.import && receipt.run.import.notices) || []) console.log(`  notice: ${n}`);
 }
 
 // Emit the minimal stable interchange summary for one receipt (interop, Phase 7).
@@ -691,6 +874,7 @@ function cmdExport(positional, flags) {
   const { toSummaryJson } = require('../lib/export');
   const receipt = JSON.parse(fs.readFileSync(p, 'utf8'));
   refuseUnverified(receipt, p, 'export');
+  refuseAmbiguous(receipt, p, 'export');
   const summary = toSummaryJson(receipt, { reportUrl: typeof flags['report-url'] === 'string' ? flags['report-url'] : null });
   const json = JSON.stringify(summary, null, 2);
   if (flags.out) {
@@ -710,6 +894,8 @@ async function main() {
     case 'init': return cmdInit(positional);
     case 'run': return cmdRun(positional, flags);
     case 'diff': return cmdDiff(positional, flags);
+    case 'regrade': return cmdRegrade(positional, flags);
+    case 'stale': return cmdStale(positional, flags);
     case 'validate': return cmdValidate(positional);
     case 'badge': return cmdBadge(positional, flags);
     case 'decide': return cmdDecide(positional, flags);

package/config/models.json

@@ -10,8 +10,9 @@
   "models": [
     { "id": "claude-fable-5-1",            "family": "fable",  "provider": "anthropic", "released": "2026-09-01", "input_price": 10.0, "output_price": 50.0, "cache_read_price": 0.25, "tier": "frontier", "judge_eligible": false, "surface_verified": "claude-cli", "surface_verified_at": "2026-09-01" },
     { "id": "claude-fable-5",              "family": "fable",  "provider": "anthropic", "released": "2026-06-09", "input_price": 10.0, "output_price": 50.0, "tier": "frontier", "judge_eligible": false, "lifecycle": "legacy" },
-    { "id": "claude-opus-5",               "family": "opus",   "provider": "anthropic", "released": null,         "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
-    { "id": "claude-opus-4-8",             "family": "opus",   "provider": "anthropic", "released": null,         "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
+    { "id": "claude-opus-5-5",             "family": "opus",   "provider": "anthropic", "released": "2026-09-22", "input_price": 4.0,  "output_price": 20.0, "cache_read_price": 0.2, "tier": "frontier", "judge_eligible": false },
+    { "id": "claude-opus-5",               "family": "opus",   "provider": "anthropic", "released": "2026-07-24", "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
+    { "id": "claude-opus-4-8",             "family": "opus",   "provider": "anthropic", "released": "2026-05-28", "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
     { "id": "claude-opus-4-7",             "family": "opus",   "provider": "anthropic", "released": null,         "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
     { "id": "claude-opus-4-6",             "family": "opus",   "provider": "anthropic", "released": null,         "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },
     { "id": "claude-opus-4-5-20251101",    "family": "opus",   "provider": "anthropic", "released": "2025-11-01", "input_price": 5.0,  "output_price": 25.0, "tier": "frontier", "judge_eligible": false },

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.11.2';
+const RUNNER_VERSION = '0.11.3';
 
 // 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.7';
+const RECEIPT_SCHEMA_VERSION = '0.9';
 
 // 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,

package/lib/counts.js

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+'use strict';
+
+// Receipt counts (spec 043, receipt spec v0.8). Two counts describe how a receipt's data
+// came to be, and they are kept apart because they measure different things (Report 006:
+// generation spread ran 3 to 7 times judge spread on the same cases):
+//
+//   generations_per_arm           independent candidate generations
+//   judge_samples_per_generation  judge samples taken of each generation
+//
+// A count sits at the narrowest scope that is honest about it: run.counts when it is
+// the same for every case of every arm generated in this run, run.arms.<mode>.counts
+// when it holds for one arm, results.cases[i].counts otherwise. An absent count is
+// unknown, never 1 (agentskills discussion #544, comment 18409751, rule 1).
+
+const KINDS = ['generations_per_arm', 'judge_samples_per_generation'];
+
+// An arm that carries its own generated_at was generated in an earlier run. run.counts
+// describes this run's generations, so an archived arm never inherits it.
+function archived(receipt, mode) {
+  const a = receipt.run && receipt.run.arms && receipt.run.arms[mode];
+  return !!(a && a.generated_at);
+}
+
+const has = (o, k) => !!o && Object.prototype.hasOwnProperty.call(o, k) && Number.isInteger(o[k]);
+
+// Where a reader looks, narrowest first.
+const ORDER = ['case', 'arm', 'run'];
+const SCOPES = {
+  case: (r, c) => c.counts,
+  arm: (r, c) => { const a = r.run && r.run.arms && r.run.arms[c.mode]; return a && a.counts; },
+  run: (r) => r.run && r.run.counts,
+};
+
+// The count of `kind` for results.cases[index], or null when the receipt does not
+// establish it. run.judge.samples is the run-scope judge count (R-5), read only where
+// run.counts is silent and only for an arm generated in this run.
+function resolveCount(receipt, index, kind) {
+  if (!KINDS.includes(kind)) throw new Error(`unknown count kind: ${kind}`);
+  const c = receipt.results.cases[index];
+  for (const scope of ORDER) {
+    const at = SCOPES[scope](receipt, c);
+    if (has(at, kind)) return at[kind];
+    if (scope === 'run' && kind === 'judge_samples_per_generation' && receipt.run && receipt.run.judge && Number.isInteger(receipt.run.judge.samples)) return receipt.run.judge.samples;
+    if (scope === 'arm' && archived(receipt, c.mode)) return null;
+  }
+  return null;
+}
+
+// Which model generated an arm, and when: the arm's override, else the run's.
+function resolveArm(receipt, mode) {
+  const a = (receipt.run && receipt.run.arms && receipt.run.arms[mode]) || {};
+  return {
+    model_id: a.model_id || receipt.run.model_id,
+    generated_at: a.generated_at || receipt.run.generated_at || null,
+    archived: archived(receipt, mode),
+  };
+}
+
+// Write counts at the narrowest honest scope (spec 043 AC-3). `perCase` is one entry per
+// results.cases index: { index, counts: { <kind>: integer } } with a kind left out when
+// the writer cannot establish it. Mutates and returns the receipt; call before sealing.
+function placeCounts(receipt, perCase) {
+  const cases = receipt.results.cases;
+  const fresh = perCase.filter((p) => !archived(receipt, cases[p.index].mode));
+  const put = (obj, kind, v) => { obj.counts = { ...(obj.counts || {}), [kind]: v }; };
+  for (const kind of KINDS) {
+    const entries = fresh.map((p) => ({ p, v: p.counts && Number.isInteger(p.counts[kind]) ? p.counts[kind] : null }));
+    if (!entries.length) continue;
+    const allKnown = entries.length === cases.filter((c) => !archived(receipt, c.mode)).length && entries.every((e) => e.v !== null);
+    const values = new Set(entries.map((e) => e.v));
+    if (allKnown && values.size === 1) { receipt.run.counts = { ...(receipt.run.counts || {}), [kind]: entries[0].v }; continue; }
+    const byMode = new Map();
+    for (const e of entries) { const m = cases[e.p.index].mode; if (!byMode.has(m)) byMode.set(m, []); byMode.get(m).push(e); }
+    for (const [mode, es] of byMode) {
+      const modeKnown = allKnown && es.length === cases.filter((c) => c.mode === mode).length;
+      if (modeKnown && new Set(es.map((e) => e.v)).size === 1) {
+        receipt.run.arms = receipt.run.arms || {};
+        receipt.run.arms[mode] = receipt.run.arms[mode] || {};
+        put(receipt.run.arms[mode], kind, es[0].v);
+      } else {
+        for (const e of es) if (e.v !== null) put(cases[e.p.index], kind, e.v);
+      }
+    }
+  }
+  return receipt;
+}
+
+// The judge-sample count, or null when the receipt does not establish one at run scope.
+function judgeSamplesOrNull(receipt) {
+  const j = receipt && receipt.run && receipt.run.judge;
+  if (j && Number.isInteger(j.samples)) return j.samples;
+  const c = receipt && receipt.run && receipt.run.counts;
+  return has(c, 'judge_samples_per_generation') ? c.judge_samples_per_generation : null;
+}
+
+// v0.8 loader rule (spec 043 AC-2): the two spellings of the run's judge count agree.
+function judgeCountsDisagree(receipt) {
+  const j = receipt && receipt.run && receipt.run.judge;
+  const c = receipt && receipt.run && receipt.run.counts;
+  return !!(j && Number.isInteger(j.samples) && has(c, 'judge_samples_per_generation') && c.judge_samples_per_generation !== j.samples);
+}
+
+module.exports = { KINDS, ORDER, resolveCount, resolveArm, placeCounts, judgeSamplesOrNull, judgeCountsDisagree };