@holdyourvoice/hyv 3.2.0 → 3.3.0

package/dist/benchmark.js

@@ -0,0 +1,232 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
+export class BenchmarkAccessError extends Error {
+    code;
+    constructor(code) {
+        super(`Private benchmark unavailable (${code}).`);
+        this.code = code;
+        this.name = 'BenchmarkAccessError';
+    }
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function isInside(parent, child) {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith(`..${sep}`) && path !== '..' && !isAbsolute(path));
+}
+function isInsideGitRepository(path) {
+    let current = path;
+    while (true) {
+        if (existsSync(join(current, '.git')))
+            return true;
+        const parent = dirname(current);
+        if (parent === current)
+            return false;
+        current = parent;
+    }
+}
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const GIT_COMMIT_PATTERN = /^[a-f0-9]{40}$/;
+const PUBLIC_MEASURES = ['writer_preference', 'correction_versus_confirm', 'workflow_completion', 'workflow_abandonment'];
+const PUBLIC_PARTITIONS = ['development', 'calibration', 'locked-test'];
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isSha256(value) {
+    return typeof value === 'string' && SHA256_PATTERN.test(value);
+}
+function isNormalizedRelativeFile(value) {
+    return typeof value === 'string' && value.length > 0 && !isAbsolute(value) && !value.includes('\\')
+        && posix.normalize(value) === value && value !== '..' && !value.startsWith('../') && !value.startsWith('/');
+}
+function parsePublicManifest(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ['version', 'provenance', 'baseline', 'partitions', 'preregisteredMeasures'])
+        || value.version !== '1' || !isNonEmptyString(value.provenance) || !isRecord(value.baseline)
+        || !hasExactKeys(value.baseline, ['packageVersion', 'sourceCommit', 'rulesetVersion', 'ruleCount', 'orderedRuleIdsSha256', 'serializedRulesSha256', 'sha256'])
+        || !isNonEmptyString(value.baseline.packageVersion) || typeof value.baseline.sourceCommit !== 'string' || !GIT_COMMIT_PATTERN.test(value.baseline.sourceCommit)
+        || !isNonEmptyString(value.baseline.rulesetVersion) || !Number.isSafeInteger(value.baseline.ruleCount) || value.baseline.ruleCount < 1
+        || !isSha256(value.baseline.orderedRuleIdsSha256) || !isSha256(value.baseline.serializedRulesSha256) || !isSha256(value.baseline.sha256)
+        || !Array.isArray(value.partitions) || value.partitions.length !== PUBLIC_PARTITIONS.length
+        || !Array.isArray(value.preregisteredMeasures) || value.preregisteredMeasures.length !== PUBLIC_MEASURES.length
+        || value.preregisteredMeasures.some((measure, index) => measure !== PUBLIC_MEASURES[index]))
+        return undefined;
+    const partitionIds = new Set();
+    for (const [index, partition] of value.partitions.entries()) {
+        if (!isRecord(partition) || !hasExactKeys(partition, ['id', 'sha256', 'cases']) || !isNonEmptyString(partition.id) || partition.id !== PUBLIC_PARTITIONS[index]
+            || partitionIds.has(partition.id) || !isSha256(partition.sha256) || !Array.isArray(partition.cases) || partition.cases.length === 0)
+            return undefined;
+        partitionIds.add(partition.id);
+        for (const entry of partition.cases) {
+            if (!isRecord(entry) || !hasExactKeys(entry, ['id', 'file', 'sha256']) || !isNonEmptyString(entry.id)
+                || !isNormalizedRelativeFile(entry.file) || !entry.file.startsWith('cases/') || !isSha256(entry.sha256))
+                return undefined;
+        }
+    }
+    return value;
+}
+const HYV_320_BASELINE = {
+    packageVersion: '3.2.0',
+    sourceCommit: '4e6269121d551c008a34db73077e1e4fea41b3f9',
+    rulesetVersion: '2.9.24-static.2',
+    ruleCount: 145,
+    orderedRuleIdsSha256: '04bc3d8f5631cc1eb3b42c1cd8b627d0d9a30fa02d8db094bae312f4f37b35b4',
+    serializedRulesSha256: 'f24434156d237a00c3f86b7a745661841f79e011930d7fb978cb07b1a0d8ebe4',
+};
+export function validatePublicBenchmark(benchmarkRoot) {
+    const root = realpathSync(benchmarkRoot);
+    const manifestPath = realpathSync(resolve(root, 'manifest.json'));
+    if (!isInside(root, manifestPath))
+        throw new Error('Public benchmark manifest is invalid.');
+    const manifest = parsePublicManifest(JSON.parse(readFileSync(manifestPath, 'utf8')));
+    if (!manifest)
+        throw new Error('Public benchmark manifest is invalid.');
+    const { sha256: baselineSha256, ...baseline } = manifest.baseline;
+    if (JSON.stringify(baseline) !== JSON.stringify(HYV_320_BASELINE) || sha256(JSON.stringify(baseline)) !== baselineSha256)
+        throw new Error('Public benchmark baseline has drifted.');
+    const seenIds = new Set();
+    const seenFiles = new Set();
+    for (const partition of manifest.partitions) {
+        const partitionBinding = { version: manifest.version, provenance: manifest.provenance, baselineSha256, partition: { id: partition.id, cases: partition.cases } };
+        if (sha256(JSON.stringify(partitionBinding)) !== partition.sha256)
+            throw new Error('Public benchmark partition digest has drifted.');
+        for (const entry of partition.cases) {
+            if (seenIds.has(entry.id))
+                throw new Error('Public benchmark case belongs to multiple partitions.');
+            seenIds.add(entry.id);
+            const file = realpathSync(resolve(root, entry.file));
+            if (!isInside(root, file))
+                throw new Error('Public benchmark case digest has drifted.');
+            const contents = readFileSync(file);
+            if (sha256(contents) !== entry.sha256)
+                throw new Error('Public benchmark case digest has drifted.');
+            if (seenFiles.has(file))
+                throw new Error('Public benchmark fixture belongs to multiple partitions.');
+            seenFiles.add(file);
+            const fixture = JSON.parse(contents.toString('utf8'));
+            if (!isRecord(fixture) || !hasExactKeys(fixture, ['version', 'id', 'provenance', 'partition', 'task_class', 'draft', 'expectation', ...('candidate' in fixture ? ['candidate'] : []), ...('counterexample' in fixture ? ['counterexample'] : []), ...('copy_spec' in fixture ? ['copy_spec'] : [])])
+                || fixture.version !== '1' || !isNonEmptyString(fixture.task_class) || typeof fixture.draft !== 'string' || !isRecord(fixture.expectation)
+                || ('candidate' in fixture && typeof fixture.candidate !== 'string') || ('counterexample' in fixture && typeof fixture.counterexample !== 'string')
+                || ('copy_spec' in fixture && !isRecord(fixture.copy_spec)))
+                throw new Error('Public benchmark case is invalid.');
+            if (fixture.id !== entry.id)
+                throw new Error('Public benchmark case identity has drifted.');
+            if (fixture.partition !== partition.id || fixture.provenance !== manifest.provenance)
+                throw new Error('Public benchmark fixture placement has drifted.');
+        }
+    }
+    return manifest;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isIsoInstant(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value))
+        return false;
+    const parsed = new Date(value);
+    const canonical = value.includes('.') ? value : `${value.slice(0, -1)}.000Z`;
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString() === canonical;
+}
+function parsePrivateRightsManifest(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ['version', 'custodian', 'rights', 'encryptedLocalStorageAttestation', 'permittedUsers', 'permittedEnvironments', 'retention', 'incidentOwner', 'corpus'])
+        || value.version !== '1' || !isNonEmptyString(value.custodian) || !isRecord(value.rights) || !hasExactKeys(value.rights, ['basis', 'status', 'approvedBy', 'approvedAt'])
+        || !isNonEmptyString(value.rights.basis) || value.rights.status !== 'approved' || !isNonEmptyString(value.rights.approvedBy) || !isIsoInstant(value.rights.approvedAt)
+        || !isRecord(value.encryptedLocalStorageAttestation) || !hasExactKeys(value.encryptedLocalStorageAttestation, ['approved', 'attestedBy', 'attestedAt']) || value.encryptedLocalStorageAttestation.approved !== true
+        || !isNonEmptyString(value.encryptedLocalStorageAttestation.attestedBy) || !isIsoInstant(value.encryptedLocalStorageAttestation.attestedAt)
+        || !Array.isArray(value.permittedUsers) || value.permittedUsers.length === 0 || !value.permittedUsers.every(isNonEmptyString) || new Set(value.permittedUsers).size !== value.permittedUsers.length
+        || !Array.isArray(value.permittedEnvironments) || value.permittedEnvironments.length === 0 || !value.permittedEnvironments.every(isNonEmptyString) || new Set(value.permittedEnvironments).size !== value.permittedEnvironments.length
+        || !isRecord(value.retention) || !hasExactKeys(value.retention, ['expiresAt', 'deletionProcedure']) || !isIsoInstant(value.retention.expiresAt) || !isNonEmptyString(value.retention.deletionProcedure)
+        || !isNonEmptyString(value.incidentOwner) || !isRecord(value.corpus) || !hasExactKeys(value.corpus, ['sha256', 'cases']) || !isSha256(value.corpus.sha256)
+        || !Array.isArray(value.corpus.cases) || value.corpus.cases.length === 0)
+        return undefined;
+    const caseIds = new Set();
+    for (const entry of value.corpus.cases) {
+        if (!isRecord(entry) || !hasExactKeys(entry, ['id', 'sha256', 'provenance']) || !isNonEmptyString(entry.id) || caseIds.has(entry.id) || !isSha256(entry.sha256)
+            || !isRecord(entry.provenance) || !hasExactKeys(entry.provenance, ['sourceId', 'rightsBasis', 'approvedBy', 'approvedAt'])
+            || !isNonEmptyString(entry.provenance.sourceId) || !isNonEmptyString(entry.provenance.rightsBasis)
+            || !isNonEmptyString(entry.provenance.approvedBy) || !isIsoInstant(entry.provenance.approvedAt))
+            return undefined;
+        caseIds.add(entry.id);
+    }
+    return value;
+}
+function validatePrivateCorpus(contents, manifest) {
+    const lines = contents.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    if (lines.length !== manifest.corpus.cases.length)
+        return false;
+    const seen = new Set();
+    for (const [index, line] of lines.entries()) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        const expected = manifest.corpus.cases[index];
+        if (!isRecord(value) || !isNonEmptyString(value.id) || value.id !== expected.id || seen.has(value.id) || sha256(line) !== expected.sha256)
+            return false;
+        seen.add(value.id);
+    }
+    return true;
+}
+export function validatePrivateBenchmark(options) {
+    if (!options.enabled)
+        throw new BenchmarkAccessError('opt_in_required');
+    if (Boolean(process.env.CI) || options.ci === true)
+        throw new BenchmarkAccessError('ci_forbidden');
+    let root;
+    let approvedRoot;
+    let repositoryRoot;
+    try {
+        root = realpathSync(options.privateRoot);
+        approvedRoot = realpathSync(options.approvedStorageRoot);
+        repositoryRoot = realpathSync(options.repositoryRoot);
+    }
+    catch {
+        throw new BenchmarkAccessError('location_unavailable');
+    }
+    if (!isInside(approvedRoot, root) || isInside(repositoryRoot, root) || isInsideGitRepository(root))
+        throw new BenchmarkAccessError('location_unapproved');
+    let manifest;
+    try {
+        const manifestPath = realpathSync(resolve(root, 'rights-manifest.json'));
+        if (!isInside(root, manifestPath))
+            throw new Error('outside root');
+        manifest = parsePrivateRightsManifest(JSON.parse(readFileSync(manifestPath, 'utf8')));
+    }
+    catch {
+        throw new BenchmarkAccessError('manifest_unavailable');
+    }
+    if (!manifest || !manifest.permittedUsers.includes(options.user) || !manifest.permittedEnvironments.includes(options.environment))
+        throw new BenchmarkAccessError('manifest_unapproved');
+    const expiresAt = Date.parse(manifest.retention.expiresAt);
+    if (!Number.isFinite(expiresAt) || expiresAt <= (options.now ?? new Date()).getTime())
+        throw new BenchmarkAccessError('retention_expired');
+    let corpusSha256;
+    try {
+        const corpusPath = realpathSync(resolve(root, 'corpus.ndjson'));
+        if (!isInside(root, corpusPath))
+            throw new Error('outside root');
+        const corpusContents = readFileSync(corpusPath, 'utf8');
+        corpusSha256 = sha256(corpusContents);
+        if (!validatePrivateCorpus(corpusContents, manifest))
+            throw new BenchmarkAccessError('corpus_digest_mismatch');
+    }
+    catch (error) {
+        if (error instanceof BenchmarkAccessError)
+            throw error;
+        throw new BenchmarkAccessError('corpus_unavailable');
+    }
+    if (corpusSha256 !== manifest.corpus.sha256)
+        throw new BenchmarkAccessError('corpus_digest_mismatch');
+    return { version: '1', corpusSha256 };
+}

package/dist/benchmark.test.js

@@ -0,0 +1,328 @@
+import assert from 'node:assert/strict';
+import { cpSync, mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { createHash } from 'node:crypto';
+import { analyzeAiEditor } from './ai-editor.js';
+import { BenchmarkAccessError, validatePrivateBenchmark, validatePublicBenchmark } from './benchmark.js';
+import { finalOutputCheck } from './hygiene.js';
+import { comparePreservation } from './preservation.js';
+import { applyRewriteResponse, prepareRewriteTask } from './rewrite-task.js';
+import { buildProfile } from './voice-dna.js';
+const repositoryRoot = process.cwd();
+function sha256Json(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function bindPublicPartition(manifest, index = 0) {
+    const partition = manifest.partitions[index];
+    partition.sha256 = sha256Json({
+        version: manifest.version,
+        provenance: manifest.provenance,
+        baselineSha256: manifest.baseline.sha256,
+        partition: { id: partition.id, cases: partition.cases },
+    });
+}
+function withPublicBenchmarkCopy(check) {
+    const temporaryRoot = mkdtempSync(join(tmpdir(), 'hyv-public-benchmark-'));
+    const benchmarkRoot = join(temporaryRoot, 'benchmarks');
+    cpSync(join(repositoryRoot, 'benchmarks'), benchmarkRoot, { recursive: true });
+    try {
+        check(benchmarkRoot);
+    }
+    finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
+function withoutCi(check) {
+    const previousCi = process.env.CI;
+    delete process.env.CI;
+    try {
+        check();
+    }
+    finally {
+        if (previousCi === undefined)
+            delete process.env.CI;
+        else
+            process.env.CI = previousCi;
+    }
+}
+test('locks the historical public partitions, Hyv 3.2.0 baseline, and preregistered measures independently of the live catalog', () => {
+    const manifest = validatePublicBenchmark(join(repositoryRoot, 'benchmarks'));
+    assert.deepEqual(manifest.preregisteredMeasures, ['writer_preference', 'correction_versus_confirm', 'workflow_completion', 'workflow_abandonment']);
+    assert.deepEqual(manifest.partitions.map((partition) => partition.id), ['development', 'calibration', 'locked-test']);
+    assert.equal(manifest.partitions.flatMap((partition) => partition.cases).length, 5);
+    const polarity = JSON.parse(readFileSync(join(repositoryRoot, 'benchmarks/cases/synthetic-004.json'), 'utf8'));
+    assert.ok(comparePreservation(polarity.draft, polarity.candidate).orderedToken.wordSurvival >= 0.8);
+    assert.equal(polarity.expectation.semantic_polarity, 'reject');
+});
+test('rejects public baseline, partition membership, identity, and fixture digest drift', () => {
+    const manifestPath = (benchmarkRoot) => join(benchmarkRoot, 'manifest.json');
+    const readManifest = (benchmarkRoot) => JSON.parse(readFileSync(manifestPath(benchmarkRoot), 'utf8'));
+    const writeManifest = (benchmarkRoot, manifest) => writeFileSync(manifestPath(benchmarkRoot), JSON.stringify(manifest));
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        manifest.baseline.packageVersion = 'mutated-baseline';
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark baseline has drifted/);
+    });
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        manifest.partitions[0].cases.push({ ...manifest.partitions[0].cases[0], id: 'synthetic-001-alias' });
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark partition digest has drifted/);
+    });
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        const partition = manifest.partitions[0];
+        partition.cases[0] = { ...manifest.partitions[0].cases[1], id: 'synthetic-001-alias' };
+        bindPublicPartition(manifest);
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark case identity has drifted/);
+    });
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        writeFileSync(join(benchmarkRoot, 'cases/synthetic-001.json'), '{"mutated":true}\n');
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark case digest has drifted/);
+    });
+});
+test('rejects malformed or under-bound public benchmark manifests before reading fixtures', () => {
+    const manifestPath = (benchmarkRoot) => join(benchmarkRoot, 'manifest.json');
+    const readManifest = (benchmarkRoot) => JSON.parse(readFileSync(manifestPath(benchmarkRoot), 'utf8'));
+    const writeManifest = (benchmarkRoot, manifest) => writeFileSync(manifestPath(benchmarkRoot), JSON.stringify(manifest));
+    for (const mutate of [
+        (manifest) => { manifest.unknown = true; },
+        (manifest) => { manifest.provenance = ''; },
+        (manifest) => { manifest.baseline.unknown = true; },
+        (manifest) => { manifest.partitions = 'development'; },
+        (manifest) => { manifest.partitions[0].sha256 = 'not-a-digest'; },
+        (manifest) => { manifest.partitions[0].cases[0].unknown = true; },
+        (manifest) => { manifest.preregisteredMeasures.push('made_up_measure'); },
+        (manifest) => { manifest.preregisteredMeasures[1] = manifest.preregisteredMeasures[0]; },
+    ]) {
+        withPublicBenchmarkCopy((benchmarkRoot) => {
+            const manifest = readManifest(benchmarkRoot);
+            mutate(manifest);
+            writeManifest(benchmarkRoot, manifest);
+            assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark manifest is invalid/);
+        });
+    }
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        manifest.partitions[0].cases[0].file = '../outside.json';
+        bindPublicPartition(manifest);
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark manifest is invalid/);
+    });
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        manifest.partitions[0].cases[0].file = 'cases/../cases/synthetic-001.json';
+        bindPublicPartition(manifest);
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark manifest is invalid/);
+    });
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const manifest = readManifest(benchmarkRoot);
+        manifest.provenance = `${manifest.provenance} mutated`;
+        writeManifest(benchmarkRoot, manifest);
+        assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark partition digest has drifted/);
+    });
+});
+test('rejects a public case symlink outside the benchmark before reading it', () => {
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const outsideRoot = mkdtempSync(join(tmpdir(), 'hyv-public-outside-'));
+        const outsideFile = join(outsideRoot, 'outside.json');
+        writeFileSync(outsideFile, '{"private":"must not be read"}\n');
+        const casePath = join(benchmarkRoot, 'cases/synthetic-001.json');
+        rmSync(casePath);
+        symlinkSync(outsideFile, casePath);
+        try {
+            assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark case digest has drifted/);
+        }
+        finally {
+            rmSync(outsideRoot, { recursive: true, force: true });
+        }
+    });
+});
+test('rejects a public manifest symlink outside the benchmark before reading it', () => {
+    withPublicBenchmarkCopy((benchmarkRoot) => {
+        const outsideRoot = mkdtempSync(join(tmpdir(), 'hyv-public-manifest-outside-'));
+        const outsideFile = join(outsideRoot, 'manifest.json');
+        writeFileSync(outsideFile, '{"private":"must not be read"}\n');
+        const manifestPath = join(benchmarkRoot, 'manifest.json');
+        rmSync(manifestPath);
+        symlinkSync(outsideFile, manifestPath);
+        try {
+            assert.throws(() => validatePublicBenchmark(benchmarkRoot), /Public benchmark manifest is invalid/);
+        }
+        finally {
+            rmSync(outsideRoot, { recursive: true, force: true });
+        }
+    });
+});
+test('executes the synthetic rule, byte-preservation, and hygiene expectations', () => {
+    const readCase = (id) => JSON.parse(readFileSync(join(repositoryRoot, `benchmarks/cases/${id}.json`), 'utf8'));
+    for (const id of ['synthetic-001', 'synthetic-002']) {
+        const fixture = readCase(id);
+        assert.deepEqual(analyzeAiEditor(fixture.draft).findings.map((finding) => finding.id), fixture.expectation.finding_ids);
+        if (fixture.counterexample)
+            assert.deepEqual(analyzeAiEditor(fixture.counterexample).findings.map((finding) => finding.id), fixture.expectation.counterexample_finding_ids);
+    }
+    const clean = readCase('synthetic-003');
+    const profile = buildProfile([clean.draft, clean.draft]);
+    const task = prepareRewriteTask(clean.draft, profile);
+    const result = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] });
+    assert.deepEqual(task.eligibleSentenceIds, []);
+    assert.equal(result.candidate, clean.draft);
+    const hygiene = readCase('synthetic-005');
+    const checked = finalOutputCheck(hygiene.candidate);
+    assert.equal(checked.accepted, false);
+    assert.deepEqual(checked.remaining.hits.map((hit) => hit.codepoint), hygiene.expectation.codepoints);
+});
+test('private evaluation is opt-in, local-only, rights-gated, current, and digest-locked', () => {
+    withoutCi(() => {
+        const approvedRoot = mkdtempSync(join(tmpdir(), 'hyv-private-approved-'));
+        const privateRoot = join(approvedRoot, 'corpus');
+        mkdirSync(privateRoot);
+        const privateCase = { id: 'private-001', text: 'private' };
+        const source = `${JSON.stringify(privateCase)}\n`;
+        writeFileSync(join(privateRoot, 'corpus.ndjson'), source);
+        const manifest = {
+            version: '1', custodian: 'custodian-1',
+            rights: { basis: 'documented distribution approval', status: 'approved', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' },
+            encryptedLocalStorageAttestation: { approved: true, attestedBy: 'security-1', attestedAt: '2026-08-01T00:00:00Z' },
+            permittedUsers: ['reviewer-1'], permittedEnvironments: ['local-evaluation'],
+            retention: { expiresAt: '2026-09-01T00:00:00Z', deletionProcedure: 'Secure deletion ticket RET-1.' },
+            incidentOwner: 'incident-owner-1', corpus: {
+                sha256: createHash('sha256').update(source).digest('hex'),
+                cases: [{
+                        id: privateCase.id,
+                        sha256: createHash('sha256').update(JSON.stringify(privateCase)).digest('hex'),
+                        provenance: { sourceId: 'source-001', rightsBasis: 'documented distribution approval', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' },
+                    }],
+            },
+        };
+        writeFileSync(join(privateRoot, 'rights-manifest.json'), JSON.stringify(manifest));
+        const options = { enabled: true, privateRoot, approvedStorageRoot: approvedRoot, repositoryRoot, user: 'reviewer-1', environment: 'local-evaluation', now: new Date('2026-08-13T00:00:00Z'), ci: false };
+        try {
+            assert.equal(validatePrivateBenchmark(options).corpusSha256, manifest.corpus.sha256);
+            assert.throws(() => validatePrivateBenchmark({ ...options, enabled: false }), (error) => error instanceof BenchmarkAccessError && error.code === 'opt_in_required');
+            assert.throws(() => validatePrivateBenchmark({ ...options, ci: true }), (error) => error instanceof BenchmarkAccessError && error.code === 'ci_forbidden');
+            assert.throws(() => validatePrivateBenchmark({ ...options, privateRoot: join(approvedRoot, 'missing') }), (error) => error instanceof BenchmarkAccessError && error.code === 'location_unavailable');
+            const previousCi = process.env.CI;
+            process.env.CI = '1';
+            try {
+                assert.throws(() => validatePrivateBenchmark({ ...options, ci: false }), (error) => error instanceof BenchmarkAccessError && error.code === 'ci_forbidden');
+            }
+            finally {
+                if (previousCi === undefined)
+                    delete process.env.CI;
+                else
+                    process.env.CI = previousCi;
+            }
+            assert.throws(() => validatePrivateBenchmark({ ...options, now: new Date('2026-10-01T00:00:00Z') }), (error) => error instanceof BenchmarkAccessError && error.code === 'retention_expired');
+            rmSync(join(privateRoot, 'rights-manifest.json'));
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'manifest_unavailable');
+            writeFileSync(join(privateRoot, 'rights-manifest.json'), 'null');
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'manifest_unapproved');
+            writeFileSync(join(privateRoot, 'rights-manifest.json'), JSON.stringify({ ...manifest, rights: { ...manifest.rights, status: 'pending' } }));
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'manifest_unapproved');
+            writeFileSync(join(privateRoot, 'rights-manifest.json'), JSON.stringify(manifest));
+            writeFileSync(join(privateRoot, 'corpus.ndjson'), `${source}source text that must stay private`);
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'corpus_digest_mismatch' && !error.message.includes('source text'));
+            rmSync(join(privateRoot, 'corpus.ndjson'));
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'corpus_unavailable');
+        }
+        finally {
+            rmSync(approvedRoot, { recursive: true, force: true });
+        }
+    });
+});
+test('private evaluation requires strict per-case rights and provenance without disclosing corpus data', () => {
+    withoutCi(() => {
+        const approvedRoot = mkdtempSync(join(tmpdir(), 'hyv-private-case-rights-'));
+        const privateRoot = join(approvedRoot, 'corpus');
+        mkdirSync(privateRoot);
+        const privateCase = { id: 'private-001', text: 'sensitive source text' };
+        const source = `${JSON.stringify(privateCase)}\n`;
+        const caseRecord = {
+            id: privateCase.id,
+            sha256: createHash('sha256').update(JSON.stringify(privateCase)).digest('hex'),
+            provenance: { sourceId: 'source-001', rightsBasis: 'approved study use', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' },
+        };
+        const manifest = {
+            version: '1', custodian: 'custodian-1',
+            rights: { basis: 'documented distribution approval', status: 'approved', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' },
+            encryptedLocalStorageAttestation: { approved: true, attestedBy: 'security-1', attestedAt: '2026-08-01T00:00:00Z' },
+            permittedUsers: ['reviewer-1'], permittedEnvironments: ['local-evaluation'],
+            retention: { expiresAt: '2026-09-01T00:00:00Z', deletionProcedure: 'Secure deletion ticket RET-1.' },
+            incidentOwner: 'incident-owner-1',
+            corpus: { sha256: createHash('sha256').update(source).digest('hex'), cases: [caseRecord] },
+        };
+        writeFileSync(join(privateRoot, 'corpus.ndjson'), source);
+        const manifestPath = join(privateRoot, 'rights-manifest.json');
+        const options = { enabled: true, privateRoot, approvedStorageRoot: approvedRoot, repositoryRoot, user: 'reviewer-1', environment: 'local-evaluation', now: new Date('2026-08-13T00:00:00Z'), ci: false };
+        try {
+            for (const corpus of [
+                { sha256: manifest.corpus.sha256 },
+                { ...manifest.corpus, cases: [{ ...caseRecord, provenance: { ...caseRecord.provenance, approvedBy: '' } }] },
+                { ...manifest.corpus, cases: [{ ...caseRecord, provenance: { ...caseRecord.provenance, approvedAt: '2026-02-31T00:00:00Z' } }] },
+                { ...manifest.corpus, cases: [{ ...caseRecord, sha256: 'bad' }] },
+                { ...manifest.corpus, cases: [caseRecord, caseRecord] },
+            ]) {
+                writeFileSync(manifestPath, JSON.stringify({ ...manifest, corpus }));
+                assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'manifest_unapproved' && !error.message.includes(privateCase.text));
+            }
+            writeFileSync(manifestPath, JSON.stringify({ ...manifest, corpus: { ...manifest.corpus, cases: [{ ...caseRecord, id: 'private-002' }] } }));
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'corpus_digest_mismatch' && !error.message.includes(privateCase.text));
+            writeFileSync(manifestPath, JSON.stringify(manifest));
+            writeFileSync(join(privateRoot, 'corpus.ndjson'), `${JSON.stringify({ ...privateCase, id: 'private-002' })}\n`);
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'corpus_digest_mismatch' && !error.message.includes(privateCase.text));
+        }
+        finally {
+            rmSync(approvedRoot, { recursive: true, force: true });
+        }
+    });
+});
+test('private evaluation refuses repository storage and missing manifests without disclosing a path', () => {
+    const insideRepository = join(repositoryRoot, 'benchmarks');
+    for (const options of [
+        { enabled: true, privateRoot: insideRepository, approvedStorageRoot: repositoryRoot, repositoryRoot, user: 'x', environment: 'x', ci: false },
+        { enabled: true, privateRoot: tmpdir(), approvedStorageRoot: tmpdir(), repositoryRoot, user: 'x', environment: 'x', ci: false },
+    ]) {
+        assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && !error.message.includes(options.privateRoot));
+    }
+});
+test('private evaluation refuses a benchmark root carrying nested Git metadata', () => {
+    withoutCi(() => {
+        const approvedRoot = mkdtempSync(join(tmpdir(), 'hyv-private-git-metadata-'));
+        const privateRoot = join(approvedRoot, 'corpus');
+        mkdirSync(privateRoot);
+        const privateCase = { id: 'private-001', text: 'private' };
+        const source = `${JSON.stringify(privateCase)}\n`;
+        const manifest = {
+            version: '1', custodian: 'custodian-1',
+            rights: { basis: 'documented distribution approval', status: 'approved', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' },
+            encryptedLocalStorageAttestation: { approved: true, attestedBy: 'security-1', attestedAt: '2026-08-01T00:00:00Z' },
+            permittedUsers: ['reviewer-1'], permittedEnvironments: ['local-evaluation'],
+            retention: { expiresAt: '2026-09-01T00:00:00Z', deletionProcedure: 'Secure deletion ticket RET-1.' },
+            incidentOwner: 'incident-owner-1', corpus: {
+                sha256: createHash('sha256').update(source).digest('hex'),
+                cases: [{ id: privateCase.id, sha256: createHash('sha256').update(JSON.stringify(privateCase)).digest('hex'), provenance: { sourceId: 'source-001', rightsBasis: 'approved study use', approvedBy: 'approver-1', approvedAt: '2026-08-01T00:00:00Z' } }],
+            },
+        };
+        writeFileSync(join(privateRoot, 'corpus.ndjson'), source);
+        writeFileSync(join(privateRoot, 'rights-manifest.json'), JSON.stringify(manifest));
+        const options = { enabled: true, privateRoot, approvedStorageRoot: approvedRoot, repositoryRoot, user: 'reviewer-1', environment: 'local-evaluation', now: new Date('2026-08-13T00:00:00Z'), ci: false };
+        try {
+            writeFileSync(join(privateRoot, '.git'), 'gitdir: /private/tmp/elsewhere\n');
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'location_unapproved');
+            rmSync(join(privateRoot, '.git'));
+            mkdirSync(join(privateRoot, '.git'));
+            writeFileSync(join(privateRoot, '.git/HEAD'), 'ref: refs/heads/main\n');
+            assert.throws(() => validatePrivateBenchmark(options), (error) => error instanceof BenchmarkAccessError && error.code === 'location_unapproved');
+        }
+        finally {
+            rmSync(approvedRoot, { recursive: true, force: true });
+        }
+    });
+});