driftproof 0.11.2 → 0.12.0

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, listReceipts, receiptBaseName, fileSlug, REGRADE_SIDECAR, SUMMARY_SIDECAR } = 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
@@ -31,7 +33,7 @@ function writeTranscripts(receipt, transcripts) {
   const manifest = { receipt_hash: receipt.receipt_hash, model_id: receipt.run.model_id, date_utc: receipt.run.date_utc, entries: [] };
   for (const t of transcripts) {
     if (!t) continue;
-    const base = `${slug(t.id)}-${t.mode}`;
+    const base = `${fileSlug(t.id)}-${t.mode}`;
     fs.writeFileSync(path.join(dir, `${base}.json`), JSON.stringify({ id: t.id, mode: t.mode, generation: t.generation, judge_outputs: t.judge_outputs }, null, 2));
     manifest.entries.push(`${base}.json`);
   }
@@ -59,24 +61,81 @@ function refuseUnverified(receipt, file, command) {
   process.exit(4);
 }
 
-// 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.
+// ── 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);
+}
+
+// ── A RECEIPT THAT DOES NOT VALIDATE IS NOT RENDERED (spec 062, register row 2) ─
+// badge and decide verified the hash and never validated, so a sealed receipt whose
+// schema_version named an Object.prototype property rendered `passing` and decided
+// `helped`. Called after refuseUnverified, and after refuseAmbiguous where a surface
+// calls that, so spec 050's exit 2 for an ambiguous receipt stands: nothing on
+// stdout, no file, the reason on stderr naming the file, exit 4 as for a receipt
+// whose hash does not verify.
+function refuseInvalid(receipt, file, command) {
+  const { valid, errors } = validateReceipt(receipt);
+  if (valid) return;
+  const first = errors[0] || {};
+  console.error(`  ✗ REFUSED (${command}): ${path.basename(file)} does not validate against its schema (${errors.length} error(s); ${first.instancePath || '/'} ${first.message || ''}); nothing rendered. Run driftproof validate on it for the list.`);
+  process.exit(4);
+}
+
+// Read an optional .driftproofrc (JSON) for per-project run defaults: the CWD's,
+// then the skill dir's (where `driftproof init` writes it). CLI flags always win
+// over the rc; the rc wins over built-in defaults.
+//
+// Spec 062 (register row 6): an rc that does not parse is REFUSED, exit 2, naming
+// the file. It used to be ignored, so a trailing comma ran the project with the
+// built-in budget and caps instead of the ones the file set.
+//
+// Spec 062 (register row 4): the skill directory is the skill's content (in the
+// Action, pull-request content), and it may not narrow the run that measures it.
+// max_cases, samples and judge_model are read from the working directory's rc
+// only; set in the skill directory's they are ignored and named on stderr. When
+// the working directory IS the skill directory, its rc is the skill's.
+//
+// Spec 069: in the Action the checkout's root is pull-request content too, so
+// action/run.sh starts `run` from an empty directory and no working-directory
+// rc is read there at all.
+const SKILL_RC_IGNORED = ['max_cases', 'samples', 'judge_model'];
+function readRc(p) {
+  if (!fs.existsSync(p)) return {};
+  let rc;
+  try { rc = JSON.parse(fs.readFileSync(p, 'utf8')); } catch (e) {
+    console.error(`  ✗ REFUSED: ${p} is not valid JSON (${e.message}); nothing run. Fix the file or remove it.`);
+    process.exit(2);
+  }
+  if (!rc || typeof rc !== 'object' || Array.isArray(rc)) {
+    console.error(`  ✗ REFUSED: ${p} is not a JSON object; nothing run. Fix the file or remove it.`);
+    process.exit(2);
+  }
+  return rc;
+}
 function loadRc(skillDir) {
   const merged = {};
-  for (const dir of [process.cwd(), skillDir].filter(Boolean)) {
-    const p = path.join(dir, '.driftproofrc');
-    try {
-      if (fs.existsSync(p)) Object.assign(merged, JSON.parse(fs.readFileSync(p, 'utf8')));
-    } catch (_e) { /* a malformed rc is ignored, not fatal */ }
+  const skillRcDir = skillDir ? path.resolve(skillDir) : null;
+  if (path.resolve(process.cwd()) !== skillRcDir) Object.assign(merged, readRc(path.join(process.cwd(), '.driftproofrc')));
+  if (skillRcDir) {
+    const p = path.join(skillRcDir, '.driftproofrc');
+    const rc = readRc(p);
+    const dropped = SKILL_RC_IGNORED.filter((k) => Object.hasOwn(rc, k));
+    for (const k of dropped) delete rc[k];
+    if (dropped.length) console.error(`  note: ${p} sets ${dropped.join(', ')}; ignored, because a skill directory may not narrow the run that measures it (set them as flags, or in the working directory's .driftproofrc when you run the CLI yourself; the GitHub Action reads no working-directory .driftproofrc)`);
+    Object.assign(merged, rc);
   }
   return merged;
 }
 
-// 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']);
-
 // ── 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
 // them; specs/026-receipt-integrity/fixtures/input-contract.json carries the
@@ -152,21 +211,75 @@ function checkNumericInputs(flags, rc) {
   return out;
 }
 
+// Spec 062 (register row 6): `--name=value` is the flag `name` with the value
+// `value`, the empty value included. It used to be a flag named `name=value`, which
+// no command read, so `--max-usd=0.01` ran with the default budget.
+//
+// A flag that takes no value is set by its name alone, so `--trusted-skill <skill-dir>`
+// keeps the dir positional instead of swallowing it as the flag's value (spec 106: all
+// eight, where three used to take the next argument). Given with `=`, or followed by a
+// boolean word, it is refused, exit 2, naming it, for every command (A-062-3, spec 106):
+// `--trusted-skill=false` and `--trusted-skill false` each turned the same-user lane on.
+const NO_VALUE_FLAGS = new Set(['trusted-skill', 'svg', 'count-errored-runs', 'strict', 'no-harness-check', 'keep-transcripts', 'github-output', 'enforce']);
+const BOOLEAN_WORD = /^(true|false|yes|no|on|off|1|0)$/i;
+function refuseValue(key, given) {
+  console.error(`  \u2717 REFUSED: --${key} takes no value, and was given one (${given}). Give --${key} alone to set it, or leave it out. Nothing run, no receipt written.`);
+  process.exit(2);
+}
 function parseArgs(argv) {
   const positional = [];
   const flags = {};
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    const eq = a.startsWith('--') ? a.indexOf('=') : -1;
+    if (eq > 2 && NO_VALUE_FLAGS.has(a.slice(2, eq))) refuseValue(a.slice(2, eq), a);
+    if (eq > 2) { flags[a.slice(2, eq)] = a.slice(eq + 1); continue; }
     if (a.startsWith('--')) {
       const key = a.slice(2);
       const next = argv[i + 1];
-      if (BOOLEAN_FLAGS.has(key) || next === undefined || next.startsWith('--')) { flags[key] = true; }
+      if (NO_VALUE_FLAGS.has(key) && next !== undefined && BOOLEAN_WORD.test(next)) refuseValue(key, `${a} ${next}`);
+      if (NO_VALUE_FLAGS.has(key) || next === undefined || next.startsWith('--')) { flags[key] = true; }
       else { flags[key] = next; i++; }
     } else positional.push(a);
   }
   return { positional, flags };
 }
 
+// Spec 062 (register row 6): the two commands that spend refuse a flag they do not
+// take, exit 2, naming it, before anything is read or printed. A misspelt cap flag
+// used to be read by nothing, and the run went ahead with the default cap. The
+// `node:util` parseArgs rewrite, one table per command, is later work.
+const COMMAND_FLAGS = {
+  run: ['models', 'samples', 'max-cases', 'max-calls', 'judge-model', 'concurrency', 'max-usd', 'keep-transcripts', 'out', 'trusted-skill'],
+  regrade: ['skill', 'answers', 'judge-model', 'samples', 'max-calls', 'max-usd', 'out', 'trusted-skill'],
+};
+function refuseUnknownFlags(command, flags) {
+  const unknown = Object.keys(flags).filter((k) => !COMMAND_FLAGS[command].includes(k));
+  if (!unknown.length) return;
+  console.error(`  ✗ REFUSED (${command}): unknown flag ${unknown.map((k) => `--${k}`).join(', ')}; ${command} takes ${COMMAND_FLAGS[command].map((k) => `--${k}`).join(', ')}. Nothing run, no receipt written.`);
+  process.exit(2);
+}
+
+// Spec 106: the same two commands take one argument. Another positional is refused, exit 2,
+// naming each one given and the one taken, before anything is read. A word after a flag that
+// takes no value (`--trusted-skill maybe`), or a single-dash `-trusted-skill`, used to be
+// dropped with no word.
+function refuseExtraPositionals(command, positional, placeholder) {
+  if (positional.length <= 1) return;
+  console.error(`  ✗ REFUSED (${command}): ${command} takes one argument and was given ${positional.length}: ${positional.join(', ')}. It took ${positional[0]} as ${placeholder}, and would read none of ${positional.slice(1).join(', ')}. A flag that takes no value is given alone. Nothing run, no receipt written.`);
+  process.exit(2);
+}
+
+// A skill that cannot be loaded because a link stands where it is read (spec 062,
+// register row 5) is refused like any other input, naming the path.
+function loadSkillOrRefuse(skillDir, command) {
+  try { return loadSkill(skillDir); } catch (e) {
+    if (!e || e.code !== 'SKILL_LINK') throw e;
+    console.error(`  ✗ REFUSED (${command}): ${e.message}. Nothing measured, no receipt written.`);
+    process.exit(2);
+  }
+}
+
 function usage() {
   console.log(`${PROJECT_NAME} v${RUNNER_VERSION} — continuous verification of agent skills
 
@@ -176,12 +289,17 @@ 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} export <receipt.json> [--to summary-json] [--report-url URL] [--out FILE]
+  ${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|DIR]
 
 ENV
   CLAUDE_PROVIDER   api | cli   (default: cli — spawns \`claude -p\`, strips ANTHROPIC_API_KEY)
@@ -228,16 +346,38 @@ 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];
   if (!skillDir) { usage(); process.exit(2); }
+  refuseUnknownFlags('run', flags);
+  refuseExtraPositionals('run', positional, '<skill-dir>');
 
   // Per-project defaults from .driftproofrc (if any); CLI flags override these.
   const rc = loadRc(skillDir);
@@ -279,7 +419,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 = loadSkillOrRefuse(skillDir, 'run'); } 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
@@ -392,10 +539,13 @@ async function cmdRun(positional, flags) {
       process.exitCode = 1;
     }
 
-    const base = `${slug(skill.name)}-${slug(receipt.run.model_id)}-${dateStamp(receipt.run.date_utc)}`;
+    // Spec 062 (register row 3): the name carries the receipt's own hash, so a second
+    // run on the same day names a second file, and the file is created, never
+    // replaced: a name already taken is a receipt already written.
+    const base = receiptBaseName({ skill: skill.name, model: receipt.run.model_id, date: dateStamp(receipt.run.date_utc), hash: receipt.receipt_hash });
     const jsonPath = path.join(outDir, `${base}.json`);
     const mdPath = path.join(outDir, `${base}.summary.md`);
-    fs.writeFileSync(jsonPath, JSON.stringify(receipt, null, 2));
+    fs.writeFileSync(jsonPath, JSON.stringify(receipt, null, 2), { flag: 'wx' });
     fs.writeFileSync(mdPath, summarizeReceipt(receipt));
     emitted.push(jsonPath);
 
@@ -467,6 +617,122 @@ 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); }
+  refuseUnknownFlags('regrade', flags);
+  refuseExtraPositionals('regrade', positional, '<receipt.json>');
+  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 = loadSkillOrRefuse(flags.skill, 'regrade');
+  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 = receiptBaseName({ skill: out.skill.name, model: out.run.model_id, tag: `regrade-${fileSlug(judgeModel)}`, date: dateStamp(out.run.date_utc), hash: out.receipt_hash });
+  const jsonPath = path.join(outDir, `${base}.json`);
+  fs.writeFileSync(jsonPath, JSON.stringify(out, null, 2), { flag: 'wx' });
+  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 } };
+  // The sidecar's name is lib/receipt.js's, which the directory readers skip by (spec 069).
+  const sidecar = `${base}${REGRADE_SIDECAR.suffix}`;
+  fs.writeFileSync(path.join(outDir, sidecar), JSON.stringify(provenance, null, 2));
+  console.log(`  → ${path.relative(process.cwd(), jsonPath)}  (${result.calls} judge calls)`);
+  console.log(`  → verification_level ${out.verification_level}; provenance: ${sidecar}\n`);
+}
+
 function cmdValidate(positional) {
   const p = positional[0];
   if (!p) { usage(); process.exit(2); }
@@ -515,6 +781,8 @@ 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');
+  refuseInvalid(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.
@@ -552,7 +820,8 @@ function cmdBadge(positional, flags) {
 // read; when --models is given the requested list governs, so a model with no
 // receipt is `refused` and can be the worst state.
 function cmdBadgeSet(dir, flags) {
-  const files = decision.receiptFiles(dir);
+  const listed = listReceipts(dir);
+  const files = listed.map((l) => l.file);
   if (files.length === 0) {
     console.error(`  \u2717 REFUSED (badge): ${dir} holds no receipts; a badge over nothing is a badge about nothing.`);
     process.exit(2);
@@ -560,13 +829,17 @@ function cmdBadgeSet(dir, flags) {
   // Every receipt is verified before it is displayed, exactly as the
   // single-receipt path does (spec 026 AC-20): a set is not a way around the
   // check, and the file that fails is named.
-  for (const f of files) {
-    const r = JSON.parse(fs.readFileSync(f, 'utf8'));
-    refuseUnverified(r, f, 'badge');
+  // An unreadable file is left to the decision, which fails its model closed and
+  // names it (spec 030 AC-2), as `decide` does.
+  for (const { file, receipt } of listed) {
+    if (!receipt) continue;
+    refuseUnverified(receipt, file, 'badge');
+    // Spec 062: validated too. A receipt with duplicate rows is left to the decision's
+    // `refused` state (spec 050 AC-3), which fails closed.
+    if (!duplicateCaseRows(receipt).length) refuseInvalid(receipt, file, 'badge');
   }
-  const models = flags.models || files
-    .map((f) => JSON.parse(fs.readFileSync(f, 'utf8')))
-    .map((r) => r.run && r.run.model_id).filter(Boolean).join(',');
+  const models = flags.models || listed
+    .map((l) => l.receipt && l.receipt.run && l.receipt.run.model_id).filter(Boolean).join(',');
   const d = decision.decideSet(dir, models);
   if (flags['github-output']) { console.log(decision.githubOutputLines(d)); return; }
   const badge = decision.badgeEndpointForSet(d);
@@ -619,10 +892,11 @@ function cmdDecide(positional, flags) {
   // is unreadable and fails closed on both, naming which (spec 030 AC-2,
   // absence-vs-unreadable). Refusing it here would collapse that distinction
   // into an exit code.
-  for (const f of decision.receiptFiles(dir)) {
-    let receipt;
-    try { receipt = JSON.parse(fs.readFileSync(f, 'utf8')); } catch (_e) { continue; }
-    refuseUnverified(receipt, f, 'decide');
+  for (const { file, receipt } of listReceipts(dir)) {
+    if (!receipt) continue;
+    refuseUnverified(receipt, file, 'decide');
+    // Spec 062 (register row 2): and validated, as badge is.
+    if (!duplicateCaseRows(receipt).length) refuseInvalid(receipt, file, 'decide');
   }
   const failOnRegression = String(flags['fail-on-regression'] ?? 'true') !== 'false';
   const d = decision.decideSet(dir, flags.models, { failOnRegression });
@@ -661,12 +935,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,30 +963,43 @@ 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.
+  // The same base-name rule as a run's (spec 062), with the source document's hash in
+  // the receipt hash's place, so the name spec 049 gave an import is unchanged.
+  const doc = receipt.run.import && ANTHROPIC_TOOLS.includes(from) ? receipt.run.import.source_sha256 : null;
+  const base = receiptBaseName({ skill: receipt.skill.name, model: receipt.run.model_id, tag: `imported-${fileSlug(from)}`, date: dateStamp(receipt.run.date_utc), hash: 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).
 function cmdExport(positional, flags) {
   const p = positional[0];
   const to = flags.to || 'summary-json';
-  if (!p) { console.error('usage: driftproof export <receipt.json> [--to summary-json] [--report-url URL] [--out FILE]'); process.exit(2); }
+  if (!p) { console.error('usage: driftproof export <receipt.json> [--to summary-json] [--report-url URL] [--out FILE|DIR]'); process.exit(2); }
   if (to !== 'summary-json') { console.error(`unknown export target "${to}" — supported: summary-json`); process.exit(2); }
   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) {
-    const out = path.resolve(flags.out);
+    // An existing directory gets the receipt's base name with the summary suffix, the name
+    // listReceipts skips beside its receipt (spec 107); any other path is written as given.
+    let shown = flags.out;
+    if (fs.existsSync(path.resolve(shown)) && fs.statSync(path.resolve(shown)).isDirectory()) shown = path.join(shown, path.basename(p, '.json') + SUMMARY_SIDECAR.suffix);
+    const out = path.resolve(shown);
     fs.mkdirSync(path.dirname(out), { recursive: true });
     fs.writeFileSync(out, json + '\n');
-    console.log(`summary written to ${flags.out}  (${summary.verdict}, delta ${summary.delta === null ? 'n/a' : summary.delta})`);
+    console.log(`summary written to ${shown}  (${summary.verdict}, delta ${summary.delta === null ? 'n/a' : summary.delta})`);
   } else {
     console.log(json);
   }
@@ -710,6 +1012,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.12.0';
 
 // 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,