Report blank grading evidence distinctly

Preserve the parser's null-or-object contract while reporting blank
evidence separately from malformed grader output. Keep rejected
responses on the raw-only persistence path.

Add CLI regressions for both verdicts, whitespace variants, malformed
grading, valid output, and stale scored-artifact cleanup.

scripts/run-evals-test.js

@@ -67,6 +67,91 @@ function run(root, args = []) {
   });
 }
 
+function runBehavioralWithGrading(root, raw) {
+  writeSkill(root, 'alpha-skill', 'Handles alpha widgets.');
+  const evalCase = completeCase('alpha-skill', 'change alpha widget');
+  evalCase.evals = [{ ...behavioralEval([]), kind: 'dialogue' }];
+  writeJson(path.join(root, 'evals', 'cases', 'alpha-skill.json'), evalCase);
+  const stub = path.join(root, 'stub-claude.cjs');
+  fs.writeFileSync(stub, `
+    const assert = require('node:assert/strict');
+    require('child_process').execFileSync = (command, args) => {
+      assert.equal(command, 'claude');
+      return args.includes('--output-format')
+        ? '{"type":"result","result":"done"}\\n'
+        : ${JSON.stringify(raw)};
+    };
+  `);
+  return spawnSync(process.execPath, [
+    '--require', stub, path.join(root, 'scripts', 'run-evals.js'),
+    '--behavioral', 'alpha-skill',
+  ], { cwd: root, encoding: 'utf8' });
+}
+
+for (const passed of [true, false]) {
+  for (const evidence of ['', ' \t\r\n', '\u00a0\u2003']) {
+    test(`behavioral CLI diagnoses blank evidence for ${passed ? 'passing' : 'failing'} verdict ${JSON.stringify(evidence)}`, () => {
+      const root = makeSandbox();
+      try {
+        const raw = JSON.stringify({
+          expectations: [{ id: 1, text: 'check the result', passed, evidence }],
+          summary: { passed: Number(passed), failed: Number(!passed), total: 1, pass_rate: Number(passed) },
+        });
+        const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+        writeJson(`${base}.grading.json`, { stale: true });
+
+        const result = runBehavioralWithGrading(root, raw);
+
+        assert.equal(result.status, 1, result.stdout + result.stderr);
+        assert.match(result.stdout, /grader returned blank evidence/);
+        assert.doesNotMatch(result.stdout, /invalid JSON/);
+        assert.match(result.stdout, /raw saved to .*alpha-skill\.eval-1\.grading\.raw\.txt/);
+        assert.equal(fs.readFileSync(`${base}.grading.raw.txt`, 'utf8'), raw);
+        assert.equal(fs.existsSync(`${base}.grading.json`), false);
+      } finally {
+        fs.rmSync(root, { recursive: true, force: true });
+      }
+    });
+  }
+}
+
+for (const raw of ['not JSON', '{"expectations":', '{"expectations":[]}']) {
+  test(`behavioral CLI retains the generic diagnostic for invalid grading ${raw}`, () => {
+    const root = makeSandbox();
+    try {
+      const result = runBehavioralWithGrading(root, raw);
+      assert.equal(result.status, 1, result.stdout + result.stderr);
+      assert.match(result.stdout, /grader returned invalid JSON/);
+      assert.doesNotMatch(result.stdout, /blank evidence/);
+      const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+      assert.equal(fs.readFileSync(`${base}.grading.raw.txt`, 'utf8'), raw);
+      assert.equal(fs.existsSync(`${base}.grading.json`), false);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+}
+
+test('behavioral CLI still publishes valid grading without a rejection diagnostic', () => {
+  const root = makeSandbox();
+  try {
+    const evidence = '  observed in the trace  ';
+    const raw = JSON.stringify({
+      expectations: [{ id: 1, text: 'check the result', passed: true, evidence }],
+      summary: { passed: 1, failed: 0, total: 1, pass_rate: 1 },
+    });
+    const result = runBehavioralWithGrading(root, raw);
+    assert.equal(result.status, 0, result.stdout + result.stderr);
+    assert.doesNotMatch(result.stdout, /grader returned/);
+    const base = path.join(root, 'evals', 'results', 'alpha-skill.eval-1');
+    const grading = JSON.parse(fs.readFileSync(`${base}.grading.json`, 'utf8'));
+    assert.equal(grading.expectations[0].evidence, evidence);
+    assert.equal(fs.existsSync(`${base}.grading.raw.txt`), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('accepts a complete and consistent grader result', () => {
   const raw = JSON.stringify({
     expectations: [

scripts/run-evals.js

@@ -426,7 +426,7 @@ function materializeWorkspace(ev) {
   return workspace;
 }
 
-function parseGrading(raw, expectations) {
+function parseGrading(raw, expectations, onInvalid = () => {}) {
   // Grader output may arrive fenced; extract the JSON object and validate shape.
   const m = raw.match(/\{[\s\S]*\}/);
   if (!m) return null;
@@ -449,7 +449,10 @@ function parseGrading(raw, expectations) {
     if (r === null || typeof r !== 'object') return null;
     if (typeof r.text !== 'string' || typeof r.passed !== 'boolean' || typeof r.evidence !== 'string') return null;
     // An unexplained verdict is not a scored result; retain it as raw grading.
-    if (!r.evidence.trim()) return null;
+    if (!r.evidence.trim()) {
+      onInvalid('grader returned blank evidence');
+      return null;
+    }
     if (!Number.isInteger(r.id) || r.id < 1 || r.id > n) return null;
     if (seenIds.has(r.id)) return null;
     seenIds.add(r.id);
@@ -589,14 +592,15 @@ function runBehavioral(skillName, dryRun) {
     // The trace can be megabytes; pass the grader prompt via stdin, never
     // argv, or it would blow past the OS argument-size limit (E2BIG).
     const raw = execFileSync('claude', ['-p'], { input: graderPrompt, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: GRADER_TIMEOUT_MS });
-    const grading = parseGrading(raw, ev.expectations);
+    let gradingError = 'grader returned invalid JSON';
+    const grading = parseGrading(raw, ev.expectations, (reason) => { gradingError = reason; });
     const runMeta = {
       executor_model: extractExecutorModel(trace),
       grader_model: 'unknown',
       timestamp: new Date().toISOString(),
     };
     if (!persistGradingOutcome(base, grading, raw, runMeta)) {
-      console.log(`  ✗  eval ${ev.id}: grader returned invalid JSON — raw saved to ${path.relative(ROOT, base)}.grading.raw.txt`);
+      console.log(`  ✗  eval ${ev.id}: ${gradingError} — raw saved to ${path.relative(ROOT, base)}.grading.raw.txt`);
       failures++;
       continue;
     }