@holdyourvoice/hyv 3.6.1 → 4.0.0

package/dist/approval-context.test.js

@@ -1,38 +0,0 @@
-import assert from 'node:assert/strict';
-import { chmodSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { approvalContextMetadataIsSafe, loadApprovalContext } from './approval-context.js';
-const context = { now: 0, trustStore: { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [] }, authorizedSemanticEvaluatorIds: { normal: ['reviewer-1'], highAssurance: [] }, authorizedHumanFinalizerIds: ['human-1'] };
-test('loads only a permission-checked installed approval context and replaces its clock', () => {
-    const root = mkdtempSync(join(tmpdir(), 'hyv-approval-context-'));
-    try {
-        const safe = join(root, 'safe.json');
-        writeFileSync(safe, JSON.stringify(context), { mode: 0o600 });
-        const loaded = loadApprovalContext(safe);
-        assert.deepEqual(loaded.authorizedSemanticEvaluatorIds.normal, ['reviewer-1']);
-        assert.notEqual(loaded.now, 0);
-        chmodSync(safe, 0o644);
-        assert.throws(() => loadApprovalContext(safe), /unavailable or unsafe/);
-        chmodSync(safe, 0o600);
-        const link = join(root, 'link.json');
-        symlinkSync(safe, link);
-        assert.throws(() => loadApprovalContext(link), /unavailable or unsafe/);
-        const malformed = join(root, 'malformed.json');
-        writeFileSync(malformed, JSON.stringify({ ...context, authorizedSemanticEvaluatorIds: { normal: ['bad id'], highAssurance: [] } }), { mode: 0o600 });
-        assert.throws(() => loadApprovalContext(malformed), /unavailable or unsafe/);
-        const malformedTrust = join(root, 'malformed-trust.json');
-        writeFileSync(malformedTrust, JSON.stringify({ ...context, trustStore: { ...context.trustStore, maxCapabilityLifetimeSeconds: 0 } }), { mode: 0o600 });
-        assert.throws(() => loadApprovalContext(malformedTrust), /unavailable or unsafe/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('fails closed when POSIX ownership metadata is unavailable on this host', () => {
-    const metadata = { isFile: () => true, nlink: 1, size: 10, uid: 501, mode: 0o600 };
-    assert.equal(approvalContextMetadataIsSafe(metadata, undefined), process.platform === 'win32');
-    assert.equal(approvalContextMetadataIsSafe(metadata, 501), true);
-    assert.equal(approvalContextMetadataIsSafe({ ...metadata, mode: 0o644 }, 501), false);
-});

package/dist/backtest.test.js

@@ -1,20 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { evaluateIsolatedBacktest } from './backtest.js';
-import { buildProfile } from './voice-dna.js';
-test('keeps an isolated backtest generation-free and text-free in its report', () => {
-    const samples = [
-        'I name the constraint first and explain the mechanism with direct words for the person doing the work. The owner checks each source before the release moves into the production queue.',
-        'The owner checks the source before the release moves into the production queue and records the evidence for later review. I keep the next step clear for the person handling the release.',
-        'I keep evidence visible and choose one next step for the person doing the work before the deployment window opens. The operator records the trade-off and names the owner for the rollback.',
-    ];
-    const target = 'The owner checks the source before the release and records the rollback evidence for the operator doing the production work.';
-    const candidate = 'The owner checks the source before the release and uses leverage for the operator doing the production work while the team records each rollback decision in the release log.';
-    const report = evaluateIsolatedBacktest('Reply to the rollout question with the owner and check.', target, candidate, buildProfile(samples), samples);
-    assert.equal(report.version, '1');
-    assert.ok(report.preservation.score < 100);
-    assert.equal(report.heldout.selfSimilarity?.ceiling, 100);
-    assert.equal(JSON.stringify(report).includes(target), false);
-    assert.equal(JSON.stringify(report).includes(candidate), false);
-    assert.equal(JSON.stringify(report).includes('uses leverage for the operator'), false);
-});

package/dist/benchmark.test.js

@@ -1,328 +0,0 @@
-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 });
-        }
-    });
-});

package/dist/canonical-json.test.js

@@ -1,24 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { canonicalJson, canonicalJsonBytes, parseCanonicalJson } from './canonical-json.js';
-test('canonicalizes nested objects, arrays, escapes, unicode, and numbers', () => {
-    const value = { z: [3, { b: '\u20ac', a: '\n' }], a: 1e-7 };
-    assert.equal(canonicalJson(value), '{"a":1e-7,"z":[3,{"a":"\\n","b":"€"}]}');
-    assert.deepEqual(canonicalJsonBytes(value), Buffer.from(canonicalJson(value), 'utf8'));
-});
-test('rejects duplicate keys, lone surrogates, unsafe integers, negative zero, and unsupported values', () => {
-    assert.throws(() => parseCanonicalJson(Buffer.from('{"a":1,"a":1}')), /duplicate/i);
-    for (const value of ['\ud800', Number.MAX_SAFE_INTEGER + 1, -0, undefined]) {
-        assert.throws(() => canonicalJson(value), /canonical/i);
-    }
-});
-test('requires exact canonical payload bytes', () => {
-    assert.deepEqual(parseCanonicalJson(Buffer.from('{"a":1,"b":2}')), { a: 1, b: 2 });
-    assert.throws(() => parseCanonicalJson(Buffer.from('{ "a": 1, "b": 2 }')), /canonical/i);
-});
-test('rejects inputs beyond the canonical complexity budget', () => {
-    let value = 1;
-    for (let index = 0; index < 70; index += 1)
-        value = [value];
-    assert.throws(() => canonicalJson(value), /complexity limit/);
-});

package/dist/cli/context.test.js

@@ -1,55 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { buildProfile } from '../voice-dna.js';
-test('prepare-rewrite recognizes contexts in either order and rejects duplicates before writing', () => {
-    const directory = mkdtempSync(join(tmpdir(), 'hyv-cli-context-'));
-    try {
-        const draft = join(directory, 'draft.md');
-        const profile = join(directory, 'profile.json');
-        const task = join(directory, 'task.json');
-        const spec = join(directory, 'spec.json');
-        const brief = join(directory, 'brief.json');
-        const ambiguous = join(directory, 'ambiguous.json');
-        const invalid = join(directory, 'invalid.json');
-        const copySpec = { version: '1', audience: 'writers', intent: 'explain', channel: 'general', claims: [{ id: 'mechanism', text: 'I keep the mechanism clear.', evidence: 'The source draft.' }] };
-        const writingBrief = { version: '1', audience: 'writers', intent: 'explain', format: 'general' };
-        writeFileSync(draft, 'I keep the mechanism clear.');
-        writeFileSync(profile, JSON.stringify(buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'])));
-        writeFileSync(spec, JSON.stringify(copySpec));
-        writeFileSync(brief, JSON.stringify(writingBrief));
-        writeFileSync(ambiguous, JSON.stringify({ ...copySpec, ...writingBrief }));
-        writeFileSync(invalid, '{}');
-        const run = (contexts) => spawnSync(process.execPath, [new URL('../cli.js', import.meta.url).pathname, 'prepare-rewrite', draft, profile, task, ...contexts], { encoding: 'utf8' });
-        for (const contexts of [[spec, brief], [brief, spec]]) {
-            const result = run(contexts);
-            assert.equal(result.status, 0, result.stderr);
-            const prepared = JSON.parse(readFileSync(task, 'utf8'));
-            assert.deepEqual(prepared.copySpec, copySpec);
-            assert.deepEqual(prepared.writingBrief, writingBrief);
-        }
-        const result = run([ambiguous]);
-        assert.equal(result.status, 0, result.stderr);
-        const prepared = JSON.parse(readFileSync(task, 'utf8'));
-        assert.deepEqual(prepared.copySpec, { ...copySpec, ...writingBrief });
-        assert.equal(prepared.writingBrief, undefined);
-        for (const [contexts, error] of [
-            [[spec, spec], 'Prepare-rewrite accepts at most one CopySpec.'],
-            [[brief, brief], 'Prepare-rewrite accepts at most one WritingBrief.'],
-            [[invalid], `Expected a valid CopySpec or WritingBrief at ${invalid}.`],
-        ]) {
-            const before = readFileSync(task, 'utf8');
-            const rejected = run([...contexts]);
-            assert.equal(rejected.status, 1);
-            assert.equal(rejected.stdout, '');
-            assert.equal(rejected.stderr, `${error}\n`);
-            assert.equal(readFileSync(task, 'utf8'), before);
-        }
-    }
-    finally {
-        rmSync(directory, { recursive: true, force: true });
-    }
-});