@holdyourvoice/hyv 3.6.1 → 4.0.0

package/dist/learning.test.js

@@ -1,325 +0,0 @@
-import assert from 'node:assert/strict';
-import { appendFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { addLearningInstruction, clearLearning, composeLearning, inspectLearning, migrateLearningV2ToV3, profileFingerprint, ratifyLearningEvent, recordLearningInstruction, recordVerifiedCandidate, supersedeLearningEvent } from './learning.js';
-import { verify } from './pipeline.js';
-import { buildProfile } from './voice-dna.js';
-const profile = buildProfile([
-    'I write plainly. I name the work.',
-    'I keep the mechanism clear. I avoid filler.',
-], ['leverage']);
-function directory() {
-    return mkdtempSync(join(tmpdir(), 'holdyourvoice-learning-'));
-}
-function version3(id, revision) {
-    return {
-        ...profile,
-        version: '3', id, revision, revisionDigest: String(revision).padStart(64, '0'),
-        provenance: { source: 'test', rights: 'test', createdAt: '2026-08-13T00:00:00.000Z' },
-        rulePolicy: {},
-        fingerprint: { contractionRate: 0, sentenceLengthDistribution: { short: 1, medium: 0, long: 0 }, bulletRate: 0, enDashRate: 0 },
-        tolerances: {
-            contractionRate: { absolute: 0.1, calibrated: false }, sentenceLengthDistribution: { absolute: 0.1, calibrated: false },
-            bulletRate: { absolute: 0.1, calibrated: false }, enDashRate: { absolute: 0.1, calibrated: false },
-        },
-        metricFixtures: { contractionRate: ['test'], sentenceLengthDistribution: ['test'], bulletRate: ['test'], enDashRate: ['test'] },
-    };
-}
-test('keeps compatible learning across Profile v3 revisions by stable identity', () => {
-    const root = directory();
-    try {
-        assert.equal(addLearningInstruction(version3('founder.jane', 1), 'Keep the mechanism.', { root }), true);
-        assert.deepEqual(composeLearning(version3('founder.jane', 2), { root }), [{ text: 'Keep the mechanism.', count: 1 }]);
-        assert.deepEqual(composeLearning(version3('founder.other', 2), { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('migrates v2 learning explicitly and idempotently without crossing identities', () => {
-    const root = directory();
-    try {
-        addLearningInstruction(profile, 'Keep it direct.', { root });
-        const first = migrateLearningV2ToV3(profile, version3('founder.jane', 1), { root, mutationId: 'migration-1' });
-        const replay = migrateLearningV2ToV3(profile, version3('founder.jane', 1), { root, mutationId: 'migration-1' });
-        assert.equal(first.status, 'recorded');
-        assert.equal(replay.status, 'already_recorded');
-        assert.deepEqual(composeLearning(version3('founder.jane', 1), { root }), [{ text: 'Keep it direct.', count: 1 }]);
-        assert.deepEqual(composeLearning(version3('founder.other', 1), { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('imports legacy v1 JSONL and makes default migration replay idempotent', () => {
-    const root = directory();
-    try {
-        const legacyFile = join(root, 'learning', `${profileFingerprint(profile)}.jsonl`);
-        addLearningInstruction(profile, 'bootstrap', { root });
-        const legacy = { version: '1', timestamp: '2026-08-13T00:00:00.000Z', kind: 'instruction', instruction: 'Keep the legacy cadence.' };
-        appendFileSync(legacyFile, `${JSON.stringify(legacy)}\n`);
-        const target = version3('founder.jane', 1);
-        const first = migrateLearningV2ToV3(profile, target, { root });
-        const replay = migrateLearningV2ToV3(profile, target, { root });
-        assert.equal(first.status, 'recorded');
-        assert.equal(replay.status, 'already_recorded');
-        assert.ok(composeLearning(target, { root }).some((item) => item.text === 'Keep the legacy cadence.'));
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('inspects bounded learning metadata without leaking prose', () => {
-    const root = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        recordLearningInstruction(current, 'Never expose this instruction.', { root, mutationId: 'inspect-1', authority: 'founder', provenance: 'author-interview' });
-        const inspection = inspectLearning(current, { root });
-        assert.equal(inspection.length, 1);
-        assert.equal(inspection[0]?.status, 'active');
-        assert.equal(inspection[0]?.authority, 'founder');
-        const serialized = JSON.stringify(inspection);
-        assert.doesNotMatch(serialized, /Never expose this instruction|candidate text|source text/);
-        assert.ok(inspection.every((item) => !('text' in item) && !('instruction' in item) && !('candidate' in item)));
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('makes mutation replay atomic and returns a text-free receipt', () => {
-    const root = directory();
-    try {
-        const first = recordLearningInstruction(version3('founder.jane', 1), 'Keep it direct.', { root, mutationId: 'instruction-1', authority: 'founder' });
-        const replay = recordLearningInstruction(version3('founder.jane', 1), 'Keep it direct.', { root, mutationId: 'instruction-1', authority: 'founder' });
-        assert.equal(first.status, 'recorded');
-        assert.equal(replay.status, 'already_recorded');
-        assert.equal(JSON.stringify(first).includes('Keep it direct.'), false);
-        assert.deepEqual(composeLearning(version3('founder.jane', 1), { root }), [{ text: 'Keep it direct.', count: 1 }]);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects conflicting mutation-id reuse without changing stored learning', () => {
-    const root = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        assert.equal(recordLearningInstruction(current, 'First instruction.', { root, mutationId: 'same' }).status, 'recorded');
-        assert.equal(recordLearningInstruction(current, 'Conflicting instruction.', { root, mutationId: 'same' }).status, 'conflict');
-        assert.deepEqual(composeLearning(current, { root }), [{ text: 'First instruction.', count: 1 }]);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('fails closed on corrupt learning without rewriting the original', () => {
-    const root = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        recordLearningInstruction(current, 'Valid.', { root, mutationId: 'valid' });
-        const file = join(root, 'learning', 'founder.jane.jsonl');
-        appendFileSync(file, '{corrupt}\n');
-        const before = readFileSync(file, 'utf8');
-        assert.throws(() => composeLearning(current, { root }), /corrupt/i);
-        assert.equal(recordLearningInstruction(current, 'Must not write.', { root, mutationId: 'blocked' }).status, 'corrupt');
-        assert.equal(readFileSync(file, 'utf8'), before);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects lower-authority ratification and supersession', () => {
-    const root = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        const founder = recordLearningInstruction(current, 'Founder ruling.', { root, mutationId: 'founder-rule', authority: 'founder' });
-        assert.equal(ratifyLearningEvent(current, founder.eventId, { root, mutationId: 'team-ratify', authority: 'team' }).status, 'unauthorized');
-        assert.equal(supersedeLearningEvent(current, founder.eventId, { root, mutationId: 'team-supersede', authority: 'team' }).status, 'unauthorized');
-        assert.deepEqual(composeLearning(current, { root }), [{ text: 'Founder ruling.', count: 1 }]);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('inspection identifiers and digests do not depend on secret prose or provenance', () => {
-    const firstRoot = directory();
-    const secondRoot = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        recordLearningInstruction(current, 'Secret alpha.', { root: firstRoot, mutationId: 'public-id', provenance: 'secret provenance alpha' });
-        recordLearningInstruction(current, 'Secret beta.', { root: secondRoot, mutationId: 'public-id', provenance: 'secret provenance beta' });
-        const publicFields = (root) => inspectLearning(current, { root }).map(({ timestamp: _timestamp, ...item }) => item);
-        assert.deepEqual(publicFields(firstRoot), publicFields(secondRoot));
-    }
-    finally {
-        rmSync(firstRoot, { recursive: true, force: true });
-        rmSync(secondRoot, { recursive: true, force: true });
-    }
-});
-test('migration fails atomically when all intended imports cannot fit', () => {
-    const root = directory();
-    try {
-        for (let index = 0; index < 40; index += 1)
-            recordLearningInstruction(profile, `Legacy ${index}.`, { root, mutationId: `legacy-${index}` });
-        const target = version3('founder.capacity', 1);
-        assert.equal(migrateLearningV2ToV3(profile, target, { root }).status, 'capacity_exceeded');
-        assert.deepEqual(composeLearning(target, { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('ratifies incompatible events and supersedes them without deleting audit history', () => {
-    const root = directory();
-    try {
-        const recorded = recordLearningInstruction(version3('founder.jane', 1), 'Keep the old cadence.', { root, mutationId: 'old', compatibility: 'exact' });
-        assert.deepEqual(composeLearning(version3('founder.jane', 2), { root }), []);
-        assert.equal(ratifyLearningEvent(version3('founder.jane', 2), recorded.eventId, { root, mutationId: 'ratify-old' }).status, 'recorded');
-        assert.deepEqual(composeLearning(version3('founder.jane', 2), { root }), [{ text: 'Keep the old cadence.', count: 1 }]);
-        assert.equal(supersedeLearningEvent(version3('founder.jane', 2), recorded.eventId, { root, mutationId: 'supersede-old' }).status, 'recorded');
-        assert.deepEqual(composeLearning(version3('founder.jane', 2), { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('compaction retains higher-authority learning before lower-authority observations', () => {
-    const root = directory();
-    try {
-        const current = version3('founder.jane', 1);
-        recordLearningInstruction(current, 'Founder ruling.', { root, mutationId: 'founder', authority: 'founder', weight: 1 });
-        for (let index = 0; index < 45; index += 1)
-            recordLearningInstruction(current, `Team observation ${index}.`, { root, mutationId: `team-${index}`, authority: 'team', weight: 100 });
-        assert.ok(composeLearning(current, { root }).some((item) => item.text === 'Founder ruling.'));
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('compaction preserves a retained target with its ratification control', () => {
-    const root = directory();
-    try {
-        const first = version3('founder.controls', 1);
-        const second = version3('founder.controls', 2);
-        const old = recordLearningInstruction(first, 'Ratified founder ruling.', { root, mutationId: 'old-founder', authority: 'founder', compatibility: 'exact' });
-        ratifyLearningEvent(second, old.eventId, { root, mutationId: 'ratify-founder', authority: 'founder' });
-        for (let index = 0; index < 45; index += 1)
-            recordLearningInstruction(second, `Team churn ${index}.`, { root, mutationId: `churn-${index}`, authority: 'team' });
-        assert.ok(composeLearning(second, { root }).some((item) => item.text === 'Ratified founder ruling.'));
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('records only resolved findings from successful verification without draft text', () => {
-    const root = directory();
-    try {
-        const original = 'I leverage the answer with useful detail and clear mechanism.';
-        const candidate = 'I use the answer with useful detail and clear mechanism.';
-        const result = verify(original, candidate, profile);
-        assert.equal(result.passed, true);
-        assert.equal(recordVerifiedCandidate(profile, result, candidate, { root }), 'recorded');
-        const eventFile = join(root, 'learning', `${profileFingerprint(profile)}.jsonl`);
-        const stored = readFileSync(eventFile, 'utf8');
-        assert.match(stored, /ai\.leverage/);
-        assert.doesNotMatch(stored, /I leverage the answer/);
-        assert.doesNotMatch(stored, /I use the answer/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('keeps learning isolated by profile and bounds composed preferences', () => {
-    const root = directory();
-    try {
-        const other = buildProfile(['We explain the mechanism.', 'We keep the useful detail.']);
-        for (let index = 0; index < 12; index += 1)
-            addLearningInstruction(profile, `Keep preference ${index}.`, { root });
-        addLearningInstruction(other, 'Use a different preference.', { root });
-        const composed = composeLearning(profile, { root });
-        assert.equal(composed.length, 10);
-        assert.ok(composed.every((item) => item.text.startsWith('Keep preference')));
-        assert.ok(!composed.some((item) => item.text === 'Use a different preference.'));
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('does not create an event for a failed candidate and clears a single profile', () => {
-    const root = directory();
-    try {
-        const failed = verify('I name the work.', 'I leverage the work.', profile);
-        assert.equal(failed.passed, false);
-        assert.equal(recordVerifiedCandidate(profile, failed, 'I leverage the work.', { root }), 'nothing_to_learn');
-        assert.equal(existsSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`)), false);
-        addLearningInstruction(profile, 'Keep it direct.', { root });
-        assert.equal(clearLearning(profile, { root }), true);
-        assert.deepEqual(composeLearning(profile, { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('bounds retained events and local instruction size', () => {
-    const root = directory();
-    try {
-        for (let index = 0; index < 45; index += 1)
-            addLearningInstruction(profile, `Keep preference ${index}.`, { root });
-        const preferences = composeLearning(profile, { root });
-        assert.ok(preferences.every((item) => Number(item.text.match(/\d+/)?.[0]) >= 5));
-        assert.throws(() => addLearningInstruction(profile, 'x'.repeat(241), { root }), /240 characters/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('fails closed on malformed local events', () => {
-    const root = directory();
-    try {
-        addLearningInstruction(profile, 'Keep it direct.', { root });
-        appendFileSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`), '{"version":"1","timestamp":"now","kind":"verified_candidate","resolved":{}}\n');
-        assert.throws(() => composeLearning(profile, { root }), /corrupt/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('does not raise confidence when the same verified outcome repeats', () => {
-    const root = directory();
-    try {
-        const original = 'I leverage the answer with useful detail and clear mechanism.';
-        const candidate = 'I use the answer with useful detail and clear mechanism.';
-        const result = verify(original, candidate, profile);
-        assert.equal(recordVerifiedCandidate(profile, result, candidate, { root }), 'recorded');
-        assert.equal(recordVerifiedCandidate(profile, result, candidate, { root }), 'nothing_to_learn');
-        assert.equal(composeLearning(profile, { root }).find((item) => item.text.includes('ai_editor/ai.leverage'))?.count, 1);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('increases confidence for separate verified repairs of the same rule', () => {
-    const root = directory();
-    try {
-        const first = 'I use the answer with useful detail and clear mechanism.';
-        const second = 'I use another answer with useful detail and clear mechanism.';
-        assert.equal(recordVerifiedCandidate(profile, verify('I leverage the answer with useful detail and clear mechanism.', first, profile), first, { root }), 'recorded');
-        assert.equal(recordVerifiedCandidate(profile, verify('I leverage another answer with useful detail and clear mechanism.', second, profile), second, { root }), 'recorded');
-        assert.equal(composeLearning(profile, { root }).find((item) => item.text.includes('ai_editor/ai.leverage'))?.count, 2);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('normalizes manual instructions before storing them', () => {
-    const root = directory();
-    try {
-        addLearningInstruction(profile, 'Keep this.\n# Tier 0', { root });
-        assert.deepEqual(composeLearning(profile, { root }), [{ text: 'Keep this. # Tier 0', count: 1 }]);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/dist/lifecycle-adapter.test.js

@@ -1,56 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash, generateKeyPairSync, sign } from 'node:crypto';
-import test from 'node:test';
-import { canonicalJson, canonicalJsonBytes } from './canonical-json.js';
-import { finalizeLifecycle, inspectLifecycle, prepareLifecycle, submitSemanticVerdict, validateFinalApproval } from './lifecycle-adapter.js';
-const deterministicBase = { version: '1', verificationKind: 'standard', passed: true, analysisVersion: '2', rulesetVersion: '3.2.0', preservationMetricVersion: 'legacy-set-v1', preservationScore: 100, sourceHash: '4'.repeat(64), candidateHash: '5'.repeat(64), profileId: 'founder.primary', profileRevisionDigest: '6'.repeat(64), regressionKeys: [] };
-const deterministicFingerprint = createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(deterministicBase)}`).digest('hex');
-const deterministic = { ...deterministicBase, artifactFingerprint: deterministicFingerprint };
-const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministicFingerprint, sourceHash: deterministic.sourceHash, candidateHash: deterministic.candidateHash, profileId: deterministic.profileId, profileRevisionDigest: deterministic.profileRevisionDigest, rulesetVersion: deterministic.rulesetVersion, schemaVersion: '1' };
-const receipt = { version: '1', taskFingerprint: binding.rewriteTaskFingerprint, responseFingerprint: binding.rewriteResponseFingerprint, adapterIds: [], replacementSentenceIds: [1] };
-const emptyTrust = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [] };
-const context = { now: 150, trustStore: emptyTrust, authorizedSemanticEvaluatorIds: { normal: ['reviewer-1'], highAssurance: [] }, authorizedHumanFinalizerIds: ['human-1'] };
-test('prepares and submits a normal semantic verdict through the shared adapter', () => {
-    const prepared = prepareLifecycle(deterministic, binding, receipt, 'normal', ['action_change']);
-    assert.equal(prepared.task.policy, 'normal');
-    assert.equal(prepared.artifact.status, 'needs_semantic_review');
-    const submitted = submitSemanticVerdict(prepared.artifact, prepared.task, 'reviewer-1', { approved: true, violations: [] }, context);
-    assert.equal(submitted.ok && submitted.artifact.status, 'ready_for_human_review');
-    const forged = submitSemanticVerdict({ ...prepared.artifact, artifactFingerprint: '9'.repeat(64) }, prepared.task, 'reviewer-1', { approved: true, violations: [] }, context);
-    assert.deepEqual(forged, { ok: false, error: 'invalid_action' });
-});
-test('inspection validates the artifact fingerprint and returns metadata only', () => {
-    const { artifact } = prepareLifecycle(deterministic, binding, receipt, 'normal', ['action_change']);
-    const inspected = inspectLifecycle(artifact);
-    assert.equal(inspected.status, 'needs_semantic_review');
-    assert.equal(inspected.artifactFingerprint, artifact.artifactFingerprint);
-    assert.doesNotMatch(JSON.stringify(inspected), /sourceHash|candidateHash|capability|signature|nonce|verdicts/);
-    assert.throws(() => inspectLifecycle({ ...artifact, artifactFingerprint: '9'.repeat(64) }), /invalid lifecycle artifact/i);
-    const { artifactFingerprint: _fingerprint, ...base } = artifact;
-    const malformedBase = { ...base, status: 'ready_for_human_review', parentArtifactFingerprint: artifact.artifactFingerprint };
-    const malformed = { ...malformedBase, artifactFingerprint: createHash('sha256').update(`hyv:lifecycle-artifact:v1\0${canonicalJson(malformedBase)}`).digest('hex') };
-    assert.throws(() => inspectLifecycle(malformed), /invalid lifecycle artifact/i);
-    for (const invalid of [{ ...base, status: 'garbage' }, { ...base, status: 'needs_escalation', parentArtifactFingerprint: artifact.artifactFingerprint, reason: 'garbage' }]) {
-        const recomputed = { ...invalid, artifactFingerprint: createHash('sha256').update(`hyv:lifecycle-artifact:v1\0${canonicalJson(invalid)}`).digest('hex') };
-        assert.throws(() => inspectLifecycle(recomputed), /invalid lifecycle artifact/i);
-    }
-});
-test('capability validation collapses verifier details and finalization stays reducer-backed', () => {
-    const prepared = prepareLifecycle(deterministic, binding, receipt, 'normal', ['action_change']);
-    const submitted = submitSemanticVerdict(prepared.artifact, prepared.task, 'reviewer-1', { approved: true, violations: [] }, context);
-    assert.equal(submitted.ok, true);
-    if (!submitted.ok)
-        return;
-    assert.deepEqual(validateFinalApproval(submitted.artifact, { payload: 'bad', signature: 'bad' }, context), { ok: false, error: 'capability_invalid' });
-    const rejected = finalizeLifecycle(submitted.artifact, { evaluatorId: 'human-1', decision: 'reject' }, context);
-    assert.equal(rejected.ok && rejected.artifact.status, 'needs_escalation');
-    const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-    const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'host', keyId: 'k1', publicKeySpki: publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'), status: 'active' }] };
-    const claims = { version: '1', purpose: 'hyv.final-approval', issuer: 'host', audience: '@holdyourvoice/hyv', subjectArtifactFingerprint: submitted.artifact.artifactFingerprint, sourceHash: binding.sourceHash, candidateHash: binding.candidateHash, profileId: binding.profileId, profileRevisionDigest: binding.profileRevisionDigest, keyId: 'k1', issuedAt: 100, notBefore: 100, expiresAt: 200, nonce: 'secret-nonce' };
-    const payload = canonicalJsonBytes(claims);
-    const capability = { payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') };
-    assert.equal(validateFinalApproval(submitted.artifact, capability, { ...context, trustStore }).ok, true);
-    const approved = finalizeLifecycle(submitted.artifact, { evaluatorId: 'human-1', decision: 'approve' }, { ...context, trustStore }, capability);
-    assert.equal(approved.ok && approved.artifact.status, 'approved');
-    assert.doesNotMatch(JSON.stringify(approved), /secret-nonce|payload|signature/);
-});

package/dist/local-eval.test.js

@@ -1,20 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { evaluateLocalComposite } from './local-eval.js';
-test('groups paragraph IDs before optional local composite evaluation', () => {
-    const user = [{ paragraphId: 'u1', text: 'I check the source and explain the mechanism.' }, { paragraphId: 'u2', text: 'The owner names one next step for the release.' }, { paragraphId: 'u3', text: 'I keep the evidence visible for the operator.' }];
-    const shadow = [{ paragraphId: 's1', text: 'This transformative framework unlocks synergy.' }, { paragraphId: 's2', text: 'The holistic ecosystem creates value.' }, { paragraphId: 's3', text: 'This is a game-changer for every stakeholder.' }];
-    const report = evaluateLocalComposite('We leverage a holistic framework.', 'We check the source and name the next step.', user, shadow);
-    assert.equal(report.version, '1');
-    assert.equal(report.split.trainParagraphIds.some((id) => report.split.testParagraphIds.includes(id)), false);
-    assert.ok(report.contentF1 >= 0 && report.contentF1 <= 1);
-    assert.ok(report.stylometricCosine9 >= 0 && report.stylometricCosine9 <= 1);
-    assert.equal(report.aiTellReduction.candidateFindings < report.aiTellReduction.inputFindings, true);
-});
-test('keeps every paragraph variant on one side of the local evaluation split', () => {
-    const user = [{ paragraphId: 'u1', text: 'I inspect the source.' }, { paragraphId: 'u1', text: 'I inspect the source before shipping.' }, { paragraphId: 'u2', text: 'I name the mechanism.' }];
-    const shadow = [{ paragraphId: 's1', text: 'This holistic framework transforms outcomes.' }, { paragraphId: 's1', text: 'This transformative framework unlocks outcomes.' }, { paragraphId: 's2', text: 'The ecosystem creates value.' }];
-    const report = evaluateLocalComposite('The source is visible.', 'I inspect the source before shipping.', user, shadow);
-    assert.equal(report.split.trainParagraphIds.includes('u1'), report.split.testParagraphIds.includes('u1') === false);
-    assert.equal(report.split.trainParagraphIds.includes('s1'), report.split.testParagraphIds.includes('s1') === false);
-});

package/dist/logic-linter-corpus.test.js

@@ -1,22 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import test from 'node:test';
-import { lintLogic } from './logic-linter.js';
-import { words } from './text.js';
-const domains = ['marketing', 'engineering', 'deep-tech'];
-function corpus(domain) {
-    return JSON.parse(readFileSync(new URL(`../test-fixtures/logic-linter/${domain}.json`, import.meta.url), 'utf8'));
-}
-test('keeps a 54-post long-form corpus cohesive across marketing, engineering, and deep tech', () => {
-    const posts = domains.flatMap(corpus);
-    assert.equal(posts.length, 54);
-    assert.equal(new Set(posts.map((post) => post.id)).size, 54);
-    for (const domain of domains)
-        assert.equal(corpus(domain).length, 18);
-    for (const post of posts) {
-        const wordCount = words(post.text).length;
-        assert.ok(wordCount >= 350 && wordCount <= 1_500, `${post.id} must contain 350–1,500 words; got ${wordCount}`);
-        const report = lintLogic(post.text);
-        assert.equal(report.passed, true, `${post.id}: ${JSON.stringify(report.findings)}`);
-    }
-});

package/dist/logic-linter.test.js

@@ -1,39 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { lintLogic } from './logic-linter.js';
-test('accepts a post that develops one connected marketing argument', () => {
-    const report = lintLogic('Most marketing teams measure clicks before they measure qualified conversations. That choice rewards cheap attention. We changed the weekly review to start with qualified conversations, then used click data to explain movement. The review now tells the team which message created demand.');
-    assert.equal(report.passed, true);
-    assert.deepEqual(report.findings, []);
-});
-test('blocks an abrupt, unsupported topic jump', () => {
-    const report = lintLogic('The release checklist makes rollback ownership explicit. Each service owner signs the same checklist before deployment. The best espresso machines use a dual boiler for stable temperature control. The checklist now catches missing rollback steps before they become incidents.');
-    assert.equal(report.passed, false);
-    assert.equal(report.findings[0]?.kind, 'topic_drift');
-    assert.equal(report.findings[0]?.severity, 'error');
-});
-test('allows an explicit bridge into a consequence', () => {
-    const report = lintLogic('The compiler now records each cache key. This means the build dashboard can explain a cache miss without replaying the job. That explanation makes incident review faster.');
-    assert.equal(report.passed, true);
-});
-test('does not treat an isolated rhetorical question as a hard topic-drift finding', () => {
-    const report = lintLogic('The migration writes its recovery marker before it changes customer data. What happens if execution stops between two writes? The recovery marker lets the worker resume the migration safely.');
-    assert.equal(report.passed, true);
-});
-test('blocks directly contradictory claims', () => {
-    const report = lintLogic('The migration is ready for production. The migration is not ready for production.');
-    assert.equal(report.passed, false);
-    assert.equal(report.findings[0]?.kind, 'internal_contradiction');
-});
-test('uses the brief argument map as an additional topical anchor', () => {
-    const report = lintLogic('Operators still reconcile customer changes by hand. A small approval queue records the owner and reason for each change. The queue turns a vague audit request into a traceable review.', {
-        version: '1', audience: 'operators', intent: 'explain', format: 'social',
-        argumentMap: { observation: 'manual customer change reconciliation', mechanism: 'approval queue', consequence: 'traceable audit review', readerValue: 'faster operator review' },
-    });
-    assert.equal(report.passed, true);
-});
-test('does not make a drift verdict for a short post', () => {
-    const report = lintLogic('The release is ready. Espresso needs fresh beans.');
-    assert.equal(report.passed, true);
-    assert.deepEqual(report.skippedChecks, ['topic_drift_short_post']);
-});