📦 deps(thirdparty): update snapshots

antigravity-awesome-skills/tools/scripts/tests/parity_benchmark.test.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const { buildParityManifest, duplicateGroups, EXPANSION_RULE, expandParityManifest, OVERLAY_MINIMUMS, validateParityExpansion, validateParityManifest } = require("../../local-skill-reviewer/parity-benchmark");
+
+const repoRoot = path.resolve(__dirname, "../../..");
+const options = {
+  repoRoot,
+  seed: "parity-benchmark-test-seed",
+  pluginChecksum: "1".repeat(64),
+  rubricChecksum: "2".repeat(64),
+};
+
+const first = buildParityManifest(options);
+const second = buildParityManifest(options);
+assert.deepStrictEqual(second, first, "same frozen Git index and seed must produce the same manifest");
+assert.strictEqual(validateParityManifest(first), first);
+
+assert.deepStrictEqual(first.sizes, { validation: 14, final_blind: 18 });
+assert.strictEqual(first.splits.validation.length, 14);
+assert.strictEqual(first.splits.final_blind.length, 18);
+
+const splitIds = Object.fromEntries(Object.entries(first.splits).map(([split, items]) => [split, new Set(items.map((item) => item.id))]));
+const allIds = Object.values(splitIds).flatMap((ids) => [...ids]);
+assert.strictEqual(new Set(allIds).size, 32, "skill IDs must be unique and splits disjoint");
+const calibration = JSON.parse(fs.readFileSync(path.join(repoRoot, "tools/config/local-skill-review-calibration.json"), "utf8"));
+const reviewedIds = [...calibration.tuning, ...calibration.holdout].map((item) => item.id).sort();
+assert.deepStrictEqual(first.excludedCalibrationIds, reviewedIds, "exclusions must come from the reviewed calibration manifest");
+for (const id of reviewedIds) assert(!allIds.includes(id), `reviewed calibration skill leaked into parity cohort: ${id}`);
+
+const splitGroups = Object.fromEntries(Object.entries(first.splits).map(([split, items]) => [split, new Set(items.map((item) => item.duplicateGroupSha256))]));
+const allGroups = Object.values(splitGroups).flatMap((groups) => [...groups]);
+assert.strictEqual(new Set(allGroups).size, 32, "no exact/near-duplicate group may cross or repeat within splits");
+assert.deepStrictEqual(first.stabilityPanel, first.splits.validation.slice(0, 4).map((item) => item.id), "stability panel must be an ordered validation subset");
+assert.strictEqual(new Set(first.reserveOrder).size, first.reserveOrder.length, "reserve order must be unique");
+assert(first.reserveOrder.every((id) => !allIds.includes(id) && !reviewedIds.includes(id)), "reserve must exclude selected and reviewed skills");
+
+const grouped = duplicateGroups([
+  { id: "exact-a", contentHash: "a", tokenCount: 100, simhash: 0n },
+  { id: "exact-b", contentHash: "a", tokenCount: 100, simhash: ~0n },
+  { id: "near", contentHash: "b", tokenCount: 95, simhash: 3n },
+  { id: "different", contentHash: "c", tokenCount: 100, simhash: 0xffffn },
+]);
+assert.strictEqual(grouped[0], grouped[1], "exact normalized content must group");
+assert.strictEqual(grouped[0], grouped[2], "near content signature must group transitively");
+assert.notStrictEqual(grouped[0], grouped[3], "materially different content must stay separate");
+
+for (const split of Object.keys(first.splits)) {
+  const primaryTotal = Object.values(first.coverage[split].primaryStrata).reduce((sum, value) => sum + value, 0);
+  assert.strictEqual(primaryTotal, first.sizes[split], `${split} primary strata counts must cover its whole split`);
+  assert(Object.keys(first.coverage[split].primaryStrata).every((key) => /^length-s[1-6]:(?:bundle|no-bundle)$/.test(key)));
+  for (const [overlay, minimum] of Object.entries(OVERLAY_MINIMUMS[split])) {
+    assert(first.coverage[split].overlays[overlay] >= minimum, `${split} must cover ${overlay} at least ${minimum} time(s)`);
+  }
+}
+
+const tampered = JSON.parse(JSON.stringify(first));
+tampered.unexpected = true;
+assert.throws(() => validateParityManifest(tampered), /schema is not closed/);
+const belowMinimum = JSON.parse(JSON.stringify(first));
+belowMinimum.coverage.validation.overlays.nonEnglish = 0;
+assert.throws(() => validateParityManifest(belowMinimum), /overlay coverage minimum not met/);
+
+const expanded = expandParityManifest({ repoRoot, parentManifest: first });
+const expandedAgain = expandParityManifest({ repoRoot, parentManifest: first });
+assert.deepStrictEqual(expandedAgain, expanded, "v2 expansion must be deterministic from the frozen v1 reserve");
+assert.strictEqual(validateParityManifest(expanded), expanded);
+assert.strictEqual(validateParityExpansion(first, expanded), expanded);
+assert.strictEqual(expanded.manifestVersion, 2);
+assert.deepStrictEqual(expanded.sizes, { validation: 25, final_blind: 35 });
+assert.deepStrictEqual(expanded.expansionRule, EXPANSION_RULE);
+assert.strictEqual(expanded.parentSelectionSha256, first.integrity.selectionSha256);
+assert.deepStrictEqual(expanded.splits.validation.slice(0, 14), first.splits.validation, "v2 must preserve the v1 validation prefix");
+assert.deepStrictEqual(expanded.splits.validation.slice(14).map((item) => item.id), first.reserveOrder.slice(0, 11), "validation must consume the first 11 reserve IDs");
+assert.deepStrictEqual(expanded.splits.final_blind.slice(0, 18), first.splits.final_blind, "v2 must preserve the v1 final-blind prefix");
+assert.deepStrictEqual(expanded.splits.final_blind.slice(18).map((item) => item.id), first.reserveOrder.slice(11, 28), "final blind must consume the next 17 reserve IDs");
+assert.deepStrictEqual(expanded.reserveOrder, first.reserveOrder.slice(28), "v2 reserve must remove exactly the consumed prefix");
+assert.deepStrictEqual(expanded.stabilityPanel.slice(0, 4), first.stabilityPanel, "v2 stability panel must preserve the original four first");
+assert.deepStrictEqual(expanded.stabilityPanel, expanded.splits.validation.slice(0, 15).map((item) => item.id));
+assert.strictEqual(new Set(Object.values(expanded.splits).flat().map((item) => item.duplicateGroupSha256)).size, 60);
+assert(/^[0-9a-f]{64}$/.test(expanded.integrity.parentManifestSha256));
+assert(/^[0-9a-f]{64}$/.test(expanded.integrity.expansionSha256));
+
+const prefixTamper = JSON.parse(JSON.stringify(expanded));
+[prefixTamper.splits.validation[14], prefixTamper.splits.validation[15]] = [prefixTamper.splits.validation[15], prefixTamper.splits.validation[14]];
+assert.throws(() => validateParityExpansion(first, prefixTamper), /invalid|integrity|prefix/i, "reordered reserve-prefix expansion must be rejected");
+const expandedUnknownKey = JSON.parse(JSON.stringify(expanded));
+expandedUnknownKey.expansionRule.unexpected = true;
+assert.throws(() => validateParityManifest(expandedUnknownKey), /schema is not closed/);
+
+process.stdout.write("parity benchmark tests passed\n");