feat(evals): trial planner, slice exit split and panel-verdict report

Planner: behavior and quarantined cases become panels of isolated trial
shards (<file>#<id>~t<N>) bound by EVALS_SELECTION_JSON=[id] and the exact
test name; the file shard excludes them by name. Trials of one case never
share a slice, result slugs are unique, panels are validated whole, unknown
registrations throw, and the planner prints a capacity preflight.

Executor: each trial shard gets its TRIAL_ENV identity and a trial record
(outcome, failure class, cause, cost); every shard writes a JUnit report.
The slice exit now means execution completeness: a failed rule shard or a
trial without a record reds the runner, a failed trial does not.

Report: panelVerdict() decides every panel of the first run attempt (later
attempts are reported, never replacing it); rule shards keep the unchanged
fail-closed checks; collector records all count (no last-attempt wins);
census runs enforce the quarantine cap and expiry. It writes
collector-outcomes v2, trial-outcomes.jsonl (trials plus JUnit rule/judge
cases), report-summary.md, and one headline + failure block with rerun
commands, and flags INFRA/INCOMPLETE-only reds for the one re-dispatch.

The fail-open suite gains the panel cases: behavior 1/3 red, 2/3 green
with its failed trial shown, missing trial INCOMPLETE, contract at 2/3 red,
quarantined 1/3 green, 0/3 and contract red, missing slice red, and a later
attempt never replacing the first.

test/ci-paid-coordination.test.ts

@@ -248,7 +248,8 @@ describe('dependency-free CI planner and report execution', () => {
       const red = run(['--report', reportDir], tier);
       expect(red.status).toBe(1);
       expect(red.stderr).toContain(`${failed.outcomes[0].files[0]}: failed`);
-      expect(red.stdout).toContain('3 executed, 0 reused; 1 passed, 2 failed, 0 manual accepted (unscored; no score-cache credit) (6 attempt records from 1 collectors)');
+      // Paid evals never retry: every record counts, a later pass never hides an earlier failure.
+      expect(red.stdout).toContain('6 executed, 0 reused; 2 passed, 4 failed, 0 manual accepted (unscored; no score-cache credit) (6 attempt records from 1 collectors');
       expect(red.stdout).toContain('3 cases with multiple attempts this run:');
       expect(red.stdout).not.toMatch(/passed only on retry|not blocking/);
 

test/paid-pr-profile.test.ts

@@ -241,7 +241,7 @@ describe('PR profile paid-runner integration', () => {
     expect(guarded[0].status).toBe('passed-empty');
   });
 
-  test('report distinguishes retained/deferred coverage and final executed/reused outcomes from attempts', () => {
+  test('report distinguishes retained/deferred coverage and counts every executed/reused record', () => {
     const manifest = ceoManifest();
     const lines = formatProfileCoverage(manifest).join('\n');
     expect(lines).toContain('profile=pr mode=pr');
@@ -252,6 +252,7 @@ describe('PR profile paid-runner integration', () => {
       { name: 'retry', suite: 'judge', passed: true, execution: 'executed' },
       { name: 'cached', suite: 'judge', passed: true, execution: 'reused' },
       { name: 'failed', suite: 'native', passed: false },
-    ] }])).toEqual({ executed: 2, reused: 1, passed: 2, failed: 1, manual_accepted: 0, attempts: 4 });
+      // Paid evals never retry: a later pass never replaces an earlier failed record.
+    ] }])).toEqual({ executed: 3, reused: 1, passed: 2, failed: 2, manual_accepted: 0, attempts: 4 });
   });
 });

test/paid-report-fail-open.test.ts

@@ -108,3 +108,110 @@ describe('rule shards stay fail-closed through --report', () => {
     expect(r.out).toContain(`${RULE_B} planned for slice 2 but reported by slice 1`);
   });
 });
+
+describe('behavior and quarantined panels through --report', () => {
+  const FILE = 'test/skill-e2e-review.test.ts';
+  const ID = 'review-design-lite';
+  const key = (trial: number) => `${FILE}#${ID}~t${trial}`;
+  const plan = (quarantined = false) => manifest([
+    ...[1, 2, 3].map(trial => ({ file: key(trial), slice: trial, status: 'planned' as const,
+      trial: { kind: 'behavior' as const, panel: { n: 3, k: 2 }, quarantined } })),
+    { file: RULE_A, slice: 4, status: 'planned' },
+  ], 4);
+  type TrialResult = 'passed' | 'failed' | 'contract' | 'missing' | 'harness';
+  const trialOutcome = (trial: number, result: TrialResult, quarantined = false): Outcome | null => {
+    if (result === 'missing') return null;
+    const record = { case: ID, trial, kind: 'behavior' as const, panel: { n: 3, k: 2 }, quarantined, cost_usd: 0, duration_ms: 1_000 };
+    if (result === 'harness') return passed(key(trial), { status: 'never-started', exitCode: null, executedTests: null, skippedTests: null,
+      trial: { ...record, outcome: null, harness: 'never started' } });
+    if (result === 'passed') return passed(key(trial), { trial: { ...record, outcome: 'passed' } });
+    return passed(key(trial), { status: 'failed', exitCode: 1,
+      trial: { ...record, outcome: 'failed', failure_class: result === 'contract' ? 'contract' : 'timeout',
+        exit_reason: 'timeout', timeout_at_turn: 14, error: result === 'contract' ? 'handoff missing' : 'no posture match' } });
+  };
+  const run = (results: TrialResult[], quarantined = false, dropSlice?: number) => report(plan(quarantined), [1, 2, 3, 4]
+    .filter(index => index !== dropSlice)
+    .map(index => slice(index, 4, index === 4 ? [passed(RULE_A)]
+      : [trialOutcome(index, results[index - 1]!, quarantined)].filter((o): o is Outcome => o !== null))));
+
+  test('behavior 3/3: green', () => {
+    const r = run(['passed', 'passed', 'passed']);
+    expect(r.status, r.out).toBe(0);
+    expect(r.out).toContain('VERDICT GREEN');
+  });
+
+  test('behavior 2/3: green, the failed trial shown with its cause', () => {
+    const r = run(['passed', 'failed', 'passed']);
+    expect(r.status, r.out).toBe(0);
+    expect(r.out).toContain(`⚠ ${ID}  behavior  PASS 2/3 (✓✗✓)`);
+    expect(r.out).toContain('t2: timeout at turn 14');
+    const summary = JSON.parse(fs.readFileSync(path.join(r.dir, 'collector-outcomes.json'), 'utf8'));
+    expect(summary.version).toBe(2);
+    expect(summary.panels[0]).toMatchObject({ case: ID, status: 'PASS', split: true, failsLane: false });
+    const history = fs.readFileSync(path.join(r.dir, 'trial-outcomes.jsonl'), 'utf8').trim().split('\n').map(line => JSON.parse(line));
+    expect(history.map(h => [h.trial, h.outcome])).toEqual([[1, 'passed'], [2, 'failed'], [3, 'passed']]);
+  });
+
+  test('behavior 1/3: red', () => {
+    const r = run(['passed', 'failed', 'failed']);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain(`PANEL ${ID} FAIL 1/3`);
+  });
+
+  test('a missing trial record: INCOMPLETE, red', () => {
+    const r = run(['passed', 'missing', 'passed']);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain(`PANEL ${ID} INCOMPLETE`);
+  });
+
+  test('a trial the harness never started: red, machine-classified for one re-dispatch', () => {
+    const r = run(['passed', 'harness', 'passed']);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain('no trial record (never started)');
+    expect(r.out).toContain('INFRA-ONLY RED');
+  });
+
+  test('a contract trial at 2/3: red', () => {
+    const r = run(['passed', 'passed', 'contract']);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain(`PANEL ${ID} FAIL 2/3`);
+    expect(r.out).toContain('contract violation');
+    expect(r.out).not.toContain('INFRA-ONLY RED');
+  });
+
+  test('quarantined 1/3: reported, does not fail the lane', () => {
+    const r = run(['passed', 'failed', 'failed'], true);
+    expect(r.status, r.out).toBe(0);
+    expect(r.out).toContain(`◌ ${ID}  behavior (quarantined)  FAIL 1/3`);
+  });
+
+  test('quarantined 0/3: hard break, red', () => {
+    const r = run(['failed', 'failed', 'failed'], true);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain('quarantined hard break');
+  });
+
+  test('quarantined contract violation: red', () => {
+    const r = run(['passed', 'passed', 'contract'], true);
+    expect(r.status).toBe(1);
+  });
+
+  test('a missing trial slice: red', () => {
+    const r = run(['passed', 'passed', 'passed'], false, 2);
+    expect(r.status).toBe(1);
+    expect(r.out).toContain('slice 2/4 reported NO result');
+    expect(r.out).toContain(`PANEL ${ID} INCOMPLETE`);
+  });
+
+  test('a later run attempt never replaces the first attempt verdict', () => {
+    const r = run(['passed', 'failed', 'failed']);
+    expect(r.status).toBe(1);
+    const retry = slice(3, 4, [trialOutcome(3, 'passed')!]);
+    fs.mkdirSync(path.join(r.dir, 'paid-slice-3-a2'), { recursive: true });
+    fs.writeFileSync(path.join(r.dir, 'paid-slice-3-a2', 'slice-3.json'), JSON.stringify({ ...retry, attempt: 2 }));
+    const again = spawnSync(process.execPath, [path.join(ROOT, 'scripts/test-paid-shards.ts'), '--tier', 'periodic', '--report', r.dir],
+      { cwd: ROOT, encoding: 'utf8', timeout: 30_000 });
+    expect(again.status).toBe(1);
+    expect(again.stdout).toContain('attempt 1 (later attempts 2 reported, never replacing it)');
+  });
+});

test/paid-run-manifest.test.ts

@@ -37,11 +37,16 @@ import {
   summarize,
   summaryExitCode,
   verifySliceResults,
+  expandTrialShards,
+  formatCapacityPreflight,
+  shardSlug,
   type PaidRunManifest,
   type ShardOutcome,
   type SliceResult,
 } from '../scripts/test-paid-shards';
 
+import { E2E_KINDS } from './helpers/touchfiles-data';
+
 const ROOT = path.resolve(__dirname, '..');
 
 const outcome = (over: Partial<ShardOutcome>): ShardOutcome => ({
@@ -508,3 +513,98 @@ describe('retry parity', () => {
     expect(buildPaidShardArgs(['x'], 1000, 4).join(' ')).toContain('--retry 0');
   });
 });
+
+describe('trial planner (behavior and quarantined panels)', () => {
+  const REVIEW = 'test/skill-e2e-review.test.ts';
+  const budgetPlan = (tier: 'gate' | 'periodic', kinds: Record<string, 'rule' | 'behavior' | 'judge'>, quarantine: Record<string, unknown> = {}) =>
+    buildRunManifest({ tier, sliceBudgetMs: 540_000, jobs: 2, evalsAll: true, env: { EVALS_ALL: '1' },
+      kinds: { ...E2E_KINDS, ...kinds }, quarantine });
+
+  test('a behavior case becomes three trial shards on three different slices; its file shard runs the rest', () => {
+    const manifest = budgetPlan('gate', { 'review-sql-injection': 'behavior' });
+    const trials = manifest.entries.filter(entry => entry.file.startsWith(`${REVIEW}#review-sql-injection~t`));
+    expect(trials.map(entry => entry.file)).toEqual([1, 2, 3].map(n => `${REVIEW}#review-sql-injection~t${n}`));
+    expect(trials.every(entry => entry.status === 'planned')).toBe(true);
+    expect(new Set(trials.map(entry => entry.slice)).size).toBe(3);
+    expect(trials[0]!.trial).toEqual({ kind: 'behavior', panel: { n: 3, k: 2 }, quarantined: false });
+    const fileShard = manifest.entries.find(entry => entry.file === REVIEW)!;
+    expect(fileShard.excludeCases).toEqual(['review-sql-injection']);
+    const slugs = manifest.entries.map(entry => shardSlug([entry.file]));
+    expect(new Set(slugs).size).toBe(slugs.length);
+    expect(parseRunManifest(JSON.stringify(manifest))).toEqual(manifest);
+  });
+
+  test('a file whose only tier case is isolated drops its file shard', () => {
+    const manifest = budgetPlan('periodic', { 'review-design-lite': 'behavior' });
+    expect(manifest.entries.some(entry => entry.file === REVIEW)).toBe(false);
+    expect(manifest.entries.filter(entry => entry.file.startsWith(`${REVIEW}#`)).map(entry => entry.file))
+      .toEqual([1, 2, 3].map(n => `${REVIEW}#review-design-lite~t${n}`));
+  });
+
+  test('a quarantined rule case runs a full panel with k = n', () => {
+    const manifest = budgetPlan('gate', {}, { 'review-enum-completeness': { reason: 'r' } });
+    const trial = manifest.entries.find(entry => entry.file === `${REVIEW}#review-enum-completeness~t1`)!;
+    expect(trial.trial).toEqual({ kind: 'rule', panel: { n: 3, k: 3 }, quarantined: true });
+  });
+
+  test('slice-count plans keep trials on different slices too', () => {
+    const manifest = buildRunManifest({ tier: 'gate', sliceCount: 5, evalsAll: true, env: { EVALS_ALL: '1' },
+      kinds: { ...E2E_KINDS, 'review-sql-injection': 'behavior', 'review-enum-completeness': 'behavior' } });
+    for (const id of ['review-sql-injection', 'review-enum-completeness']) {
+      const slices = manifest.entries.filter(entry => entry.file.startsWith(`${REVIEW}#${id}~t`)).map(entry => entry.slice);
+      expect(new Set(slices).size).toBe(3);
+    }
+  });
+
+  test('judges and unknown ids cannot be isolated; unknown registrations throw', () => {
+    expect(() => budgetPlan('gate', { 'review/SKILL.md workflow': 'behavior' })).toThrow(/Only live E2E cases/);
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'trial-unknown-'));
+    try {
+      fs.mkdirSync(path.join(dir, 'test'));
+      fs.writeFileSync(path.join(dir, 'test/skill-e2e-x.test.ts'), 'const name = pick(); runSkillTest({ testName: name });');
+      expect(() => expandTrialShards(['test/skill-e2e-x.test.ts'], 'gate', dir, {
+        kinds: { x: 'behavior' }, touchfiles: { x: ['test/skill-e2e-x.test.ts'] }, tiers: { x: 'gate' },
+      })).toThrow(/statically known case registration/);
+    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test('parse rejects partial panels, shared runners, forged plans and stray exclusions', () => {
+    const manifest = budgetPlan('gate', { 'review-sql-injection': 'behavior' });
+    const trialFiles = [1, 2, 3].map(n => `${REVIEW}#review-sql-injection~t${n}`);
+    const mutate = (fn: (m: PaidRunManifest) => void) => { const m = structuredClone(manifest); fn(m); return JSON.stringify(m); };
+    expect(() => parseRunManifest(mutate(m => { m.entries = m.entries.filter(e => e.file !== trialFiles[1]); })))
+      .toThrow(/exactly its 3 trials/);
+    expect(() => parseRunManifest(mutate(m => {
+      const [a, b] = trialFiles.map(f => m.entries.find(e => e.file === f)!);
+      b!.slice = a!.slice;
+    }))).toThrow(/share a slice/);
+    expect(() => parseRunManifest(mutate(m => { m.entries.find(e => e.file === trialFiles[0])!.trial!.panel.k = 1; })))
+      .toThrow(/fixed policy panel/);
+    expect(() => parseRunManifest(mutate(m => { m.entries.find(e => e.file === trialFiles[0])!.trial = undefined; })))
+      .toThrow(/fixed policy panel/);
+    expect(() => parseRunManifest(mutate(m => { m.entries.find(e => e.file === REVIEW)!.excludeCases = ['review-design-lite']; })))
+      .toThrow(/exclude only cases/);
+    expect(() => parseRunManifest(mutate(m => { m.entries.find(e => e.file === REVIEW)!.trial = m.entries.find(e => e.file === trialFiles[0])!.trial; })))
+      .toThrow(/Only trial shards/);
+  });
+
+  test('capacity preflight names slices, shards, waves and the longest indivisible trial', () => {
+    const manifest = budgetPlan('gate', { 'review-sql-injection': 'behavior' });
+    const lines = formatCapacityPreflight(manifest, 16).join('\n');
+    expect(lines).toContain(`${manifest.sliceCount} slice(s)`);
+    expect(lines).toContain('3 trial shard(s)');
+    expect(lines).toContain(`wave(s) at max-parallel 16: ${Math.ceil(manifest.sliceCount / 16)}`);
+    expect(lines).toMatch(/longest indivisible trial ~\d+\.\dm \(test\/skill-e2e-review\.test\.ts#review-sql-injection~t\d\)/);
+  });
+
+  test('durations: trials record their longest wall under the case key and seed their own estimate', () => {
+    const key = `${REVIEW}#review-sql-injection`;
+    const merged = mergePaidTestDurations({}, [{ version: 1, tier: 'gate', sliceIndex: 1, sliceCount: 1, outcomes: [1, 2, 3].map(n => ({
+      files: [`${key}~t${n}`], status: 'passed' as const, exitCode: 0, elapsedMs: n * 60_000, executedTests: 1, skippedTests: 0,
+    })) }]);
+    expect(merged).toEqual({ [key]: 180_000 });
+    const packed = packBySliceBudget([1, 2, 3].map(n => `${key}~t${n}`), 540_000, 2, merged);
+    expect(packed.slices).toHaveLength(3);
+    expect(Object.values(packed.estimates)).toEqual([180_000, 180_000, 180_000]);
+  });
+});

test/paid-shards.test.ts

@@ -47,6 +47,14 @@ import {
   selectPaidTestFiles,
   buildRunManifest,
   parseRunManifest,
+  classifyTrialShard,
+  sliceExitCode,
+  guardTrialRecords,
+  parseJUnitCases,
+  caseIdForTestName,
+  shardTrial,
+  excludedCasesNamePattern,
+  type CaseTrialPlan,
   type ShardOutcome,
 } from '../scripts/test-paid-shards';
 
@@ -578,3 +586,92 @@ describe('all-skipped pass census', () => {
     expect(reviewLine).not.toContain('SKIPPED');
   });
 });
+
+describe('isolated trial shards: record, classification and slice exit', () => {
+  const plan: CaseTrialPlan = { kind: 'behavior', panel: { n: 3, k: 2 }, quarantined: false };
+  const key = (n: number) => `test/skill-e2e-review.test.ts#review-sql-injection~t${n}`;
+  const base = { status: 'passed' as const, executedTests: 1, skippedTests: 0, elapsedMs: 5 };
+  const none = { records: [], contract: null };
+
+  test('trial keys keep their case id, file and index', () => {
+    expect(shardCaseId(key(2))).toBe('review-sql-injection');
+    expect(shardFile(key(2))).toBe('test/skill-e2e-review.test.ts');
+    expect(shardTrial(key(2))).toBe(2);
+    expect(shardTrial('test/skill-e2e-review.test.ts#review-sql-injection')).toBeNull();
+    expect(shardSlug([key(2)])).toBe('skill-e2e-review--review-sql-injection.t2');
+  });
+
+  test('classification: verdicts versus harness problems', () => {
+    const c = (over: Partial<ShardOutcome>, evidence: { records: any[]; contract: string | null } = none) =>
+      classifyTrialShard({ ...base, ...over }, 'review-sql-injection', 1, plan, evidence);
+    expect(c({}).outcome).toBe('passed');
+    expect(c({}, { records: [], contract: 'handoff missing' })).toMatchObject({ outcome: 'failed', failure_class: 'contract', error: 'handoff missing' });
+    expect(c({ status: 'failed' }, { records: [{ passed: false, exit_reason: 'timeout', timeout_at_turn: 9, error: 'x' }], contract: null }))
+      .toMatchObject({ outcome: 'failed', failure_class: 'timeout', timeout_at_turn: 9 });
+    expect(c({ status: 'failed' }, { records: [{ passed: false, error: 'expected 3' }], contract: null })).toMatchObject({ outcome: 'failed', failure_class: 'assertion' });
+    expect(c({ status: 'timed-out', executedTests: null, skippedTests: null })).toMatchObject({ outcome: 'failed', failure_class: 'timeout' });
+    expect(c({ status: 'failed', executedTests: null, skippedTests: null })).toMatchObject({ outcome: 'failed', failure_class: 'infra' });
+    expect(c({ status: 'failed', executedTests: 0, skippedTests: 0 })).toMatchObject({ outcome: 'failed', failure_class: 'infra' });
+    expect(c({ executedTests: 1, skippedTests: 1 })).toMatchObject({ outcome: 'skipped' });
+    for (const over of [{ status: 'never-started' as const }, { status: 'passed-empty' as const }, { executedTests: 2 },
+      { runnerError: 'spawn failed' }, { executedTests: 0, skippedTests: 0 }]) {
+      expect(c(over).outcome, JSON.stringify(over)).toBeNull();
+    }
+  });
+
+  test('slice exit: rule shards stay strict; failed trials never red the runner, missing records do', () => {
+    const trial = (outcome: 'passed' | 'failed' | null) => ({ status: outcome === 'failed' ? 'failed' as const : 'passed' as const,
+      trial: { case: 'c', trial: 1, ...plan, outcome, cost_usd: 0, duration_ms: 1, ...(outcome === null ? { harness: 'never started' } : {}) } });
+    expect(sliceExitCode([{ status: 'passed' }, trial('failed')])).toBe(0);
+    expect(sliceExitCode([{ status: 'failed' }, trial('passed')])).toBe(1);
+    expect(sliceExitCode([{ status: 'passed' }, trial(null)])).toBe(1);
+    expect(sliceExitCode([{ status: 'timed-out' }])).toBe(1);
+    const hollow = guardTrialRecords([{ ...trial('passed'), status: 'passed-empty' as const }]);
+    expect(hollow[0]!.trial!.outcome).toBeNull();
+    expect(sliceExitCode(hollow)).toBe(1);
+  });
+
+  test('runPaidShards binds each trial to its case, index and panel and records its outcome', async () => {
+    const evalDirBase = fs.mkdtempSync(path.join(os.tmpdir(), 'trial-shards-'));
+    try {
+      const script = (fail: boolean) => `const fs = require('fs'), path = require('path');
+const dir = process.env.GSTACK_EVAL_DIR; fs.mkdirSync(dir, { recursive: true });
+const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith('GSTACK_EVAL_') || k === 'EVALS_SELECTION_JSON'));
+fs.writeFileSync(path.join(dir, 'env.json'), JSON.stringify(env));
+fs.writeFileSync(path.join(dir, 'run.json'), JSON.stringify({ tests: [{ name: 'review-sql-injection', passed: ${!fail}, cost_usd: 0.5,
+  duration_ms: 1, exit_reason: ${fail ? "'timeout'" : "'success'"}, timeout_at_turn: 4, model: 'm' }] }));
+console.log("Ran 1 tests across 1 files. [1ms]"); process.exit(${fail ? 1 : 0});`;
+      const summary = await runPaidShards([[key(1)], [key(2)], [key(3)]], {
+        jobs: 3, evalDirBase, log: () => {}, trials: { [key(1)]: plan, [key(2)]: plan, [key(3)]: plan },
+        commandFor: files => ({ command: process.execPath, args: ['-e', script(files[0] === key(2))] }),
+      });
+      const byKey = (n: number) => summary.outcomes.find(o => o.files[0] === key(n))!;
+      expect(byKey(1).trial).toMatchObject({ case: 'review-sql-injection', trial: 1, outcome: 'passed', cost_usd: 0.5, model: 'm' });
+      expect(byKey(2).trial).toMatchObject({ trial: 2, outcome: 'failed', failure_class: 'timeout', exit_reason: 'timeout', timeout_at_turn: 4 });
+      expect(sliceExitCode(summary.outcomes)).toBe(0);
+      const env = JSON.parse(fs.readFileSync(path.join(evalDirBase, 'shards', shardSlug([key(3)]), 'env.json'), 'utf8'));
+      expect(env).toMatchObject({ GSTACK_EVAL_CASE_ID: 'review-sql-injection', GSTACK_EVAL_KIND: 'behavior', GSTACK_EVAL_TRIAL: '3',
+        GSTACK_EVAL_PANEL_N: '3', GSTACK_EVAL_PANEL_K: '2', GSTACK_EVAL_POLICY_VERSION: '1' });
+      expect(JSON.parse(env.EVALS_SELECTION_JSON).selected).toEqual(['review-sql-injection']);
+    } finally { fs.rmSync(evalDirBase, { recursive: true, force: true }); }
+  });
+
+  test('file shards exclude isolated names; JUnit cases map to registry ids or stay unattributed', () => {
+    const pattern = new RegExp(excludedCasesNamePattern(['review-sql-injection']));
+    expect(pattern.test('suite > review-sql-injection')).toBe(false);
+    expect(pattern.test('suite > review-enum-completeness')).toBe(true);
+    const cases = parseJUnitCases(`<testsuites><testsuite name="f">
+  <testcase name="review-sql-injection" classname="s" time="1.5" />
+  <testcase name="review-enum-completeness" classname="s" time="0.1"><failure type="TimeoutError" message="test &amp; timed out" /></testcase>
+  <testcase name="plain helper" classname="" time="0"><skipped /></testcase>
+</testsuite></testsuites>`);
+    expect(cases).toEqual([
+      { name: 'review-sql-injection', classname: 's', outcome: 'passed', timeMs: 1500 },
+      { name: 'review-enum-completeness', classname: 's', outcome: 'failed', timeMs: 100, failureType: 'TimeoutError', message: 'test & timed out' },
+      { name: 'plain helper', classname: '', outcome: 'skipped', timeMs: 0 },
+    ]);
+    expect(caseIdForTestName('review-sql-injection')).toBe('review-sql-injection');
+    expect(caseIdForTestName(CASE_TEST_NAMES['plan-review-report']!)).toBe('plan-review-report');
+    expect(caseIdForTestName('plain helper')).toBeNull();
+  });
+});