test(benchmark): calibrate again after the protocol and judge against the slower value

The relative gate calibrated once before the scenarios, so load that
started afterwards (the push and pull_request runs of one commit overlap
on the same runner, next to the test, build and image jobs) slowed the
scenarios but not the yardstick. A pull_request run failed `two years`
at 1653.1 ms against a 1648.7 ms budget this way.

The spec now repeats the calibration after the protocol and uses the
slower of the two values. The budgets can only loosen, never tighten,
and the log reprints the table with the budgets actually applied when
they change.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

src/app/benchmark/leave-planner-benchmark.spec.ts

@@ -3,6 +3,7 @@ import { calculatePlanningAsyncInternal } from '../services/frozen-engine/leave-
 import { createPlanningCalculation } from '../services/leave-planner.service';
 import {
 	BENCHMARK_BUDGET_MULTIPLIERS,
+	type BenchmarkMeasurement,
 	benchmarkReport,
 	benchmarkScenarios,
 	benchmarkSummaryHeader,
@@ -71,23 +72,43 @@ describe('leave planner benchmark protocol', () => {
 			}
 			// Calibration engine (frozen at a871f8f) on 'two years', best of three: the runner-speed yardstick.
 			const calibrationRequest = scenarios.find((item) => item.name === 'two years')!.request;
-			let calibrationMs = Infinity;
-			for (let run = 0; run < 3; run++) {
-				const request = structuredClone(calibrationRequest);
-				const start = performance.now();
-				await calculatePlanningAsyncInternal({ ...request, calculationDate: '2024-01-01' });
-				calibrationMs = Math.min(calibrationMs, performance.now() - start);
-			}
+			const calibrate = async () => {
+				let best = Infinity;
+				for (let run = 0; run < 3; run++) {
+					const request = structuredClone(calibrationRequest);
+					const start = performance.now();
+					await calculatePlanningAsyncInternal({
+						...request,
+						calculationDate: '2024-01-01',
+					});
+					best = Math.min(best, performance.now() - start);
+				}
+				return best;
+			};
+			const calibrationBefore = await calibrate();
 			// Direct stdout writes show each row as soon as its scenario finishes.
 			const print = (text: string) => process.stdout.write(`${text}\n`);
 			print(
-				`\nCalibration: frozen engine on "two years", best of 3 = ${calibrationMs.toFixed(1)} ms` +
+				`\nCalibration: frozen engine on "two years", best of 3 = ${calibrationBefore.toFixed(1)} ms` +
 					'\nBudget = limit x calibration; ratio = mean / calibration.\n',
 			);
 			print(benchmarkSummaryHeader());
-			const measurements = await runLeavePlannerBenchmark(2, (rows) =>
-				print(benchmarkSummaryRow(rows, calibrationMs)),
-			);
+			const scenarioRows: BenchmarkMeasurement[][] = [];
+			const measurements = await runLeavePlannerBenchmark(2, (rows) => {
+				scenarioRows.push(rows);
+				print(benchmarkSummaryRow(rows, calibrationBefore));
+			});
+			// Load that starts after the first calibration slows the scenarios but not the yardstick;
+			// calibrating again and judging against the slower value absorbs it. Never tighter than before.
+			const calibrationAfter = await calibrate();
+			const calibrationMs = Math.max(calibrationBefore, calibrationAfter);
+			if (calibrationMs !== calibrationBefore) {
+				print(
+					`\nCalibration after the protocol = ${calibrationAfter.toFixed(1)} ms; budgets use the slower: ${calibrationMs.toFixed(1)} ms\n`,
+				);
+				print(benchmarkSummaryHeader());
+				for (const rows of scenarioRows) print(benchmarkSummaryRow(rows, calibrationMs));
+			}
 			for (const [name, placements] of [
 				['two years', 60],
 				['three years', 90],