@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/ai-editor.test.js

@@ -1,265 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { analyzeAiEditor, maskNonProse, RULESET_VERSION, rules, serializedRules } from './ai-editor.js';
-import { createHash } from 'node:crypto';
-import { AI_SHADOW_FAIL_SET_V1 } from './ai-shadow-fixtures.js';
-import { generateAiShadowFailSetV1 } from './ai-shadow-generator.js';
-test('publishes executable rules with stable IDs and repair directions', () => {
-    assert.equal(RULESET_VERSION, '3.5.0-local.3');
-    assert.equal(rules.length, 182);
-    assert.equal(createHash('sha256').update(JSON.stringify(rules.map((rule) => rule.id))).digest('hex'), '172563cd3f55b363c895bb97c37f636dd718253799c369f329bb943dad416f16');
-    assert.equal(createHash('sha256').update(JSON.stringify(serializedRules())).digest('hex'), '542534f1223d65e7ae7d4c3da8ba22bd31b4ddae2dfe399f7672ca9e6a9cee6b');
-    assert.equal(new Set(rules.map((rule) => rule.id)).size, rules.length);
-    for (const rule of rules) {
-        assert.match(rule.id, /^(ai|formula|hedge|struct|punct|bait|cringe|insider|ogilvy|format)\./);
-        assert.ok(rule.reason.length > 0);
-        assert.ok(rule.suggestion.length > 0);
-        assert.equal(rule.expression.global, false, rule.id);
-        assert.equal(rule.expression.sticky, false, rule.id);
-    }
-});
-function profileWithPolicies(rulePolicy) {
-    return {
-        version: '3', id: 'founder.test', revision: 1, revisionDigest: '0'.repeat(64), sampleCount: 2,
-        metrics: { sentenceLength: 5, sentenceVariation: 1, sentenceStructure: [], rhythm: 1, paragraphLength: 1, openingMoves: [], vocabulary: [], lexicalDensity: 0.5, pointOfView: 'mixed', punctuation: {}, caseStyle: 'mixed', questionRate: 0, transitions: [] },
-        avoid: [], 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, calibrated: false }, sentenceLengthDistribution: { absolute: 0, calibrated: false }, bulletRate: { absolute: 0, calibrated: false }, enDashRate: { absolute: 0, calibrated: false } },
-        metricFixtures: { contractionRate: ['test'], sentenceLengthDistribution: ['test'], bulletRate: ['test'], enDashRate: ['test'] },
-    };
-}
-test('applies all four v3 policy states after matching and preserves catalog order', () => {
-    const report = analyzeAiEditor('Firstly, perhaps we leverage a holistic plan.', profileWithPolicies({
-        'formula.firstly': 'blocking',
-        'hedge.perhaps': 'advisory',
-        'ai.leverage': 'judgment-required',
-        'ai.holistic': 'disabled',
-    }));
-    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.appliedPolicy, finding.severity]), [
-        ['ai.leverage', 'judgment-required', 'yellow'],
-        ['formula.firstly', 'blocking', 'red'],
-        ['hedge.perhaps', 'advisory', 'yellow'],
-    ]);
-    assert.equal(report.passed, false);
-});
-test('fails closed when a v3 policy names a rule outside the catalog', () => {
-    assert.throws(() => analyzeAiEditor('Plain text.', profileWithPolicies({ 'ai.missing': 'blocking' })), /unknown rule ID/);
-});
-test('allows a sample-derived punctuation exception only when no explicit policy exists', () => {
-    const profile = profileWithPolicies({});
-    profile.ruleAllowances = { 'punct.em-dash': { sampleCount: 2, evidenceDigest: 'a'.repeat(64) } };
-    assert.equal(analyzeAiEditor('The scheduler failed — retry later.', profile).findings.some((finding) => finding.id === 'punct.em-dash'), false);
-    profile.rulePolicy['punct.em-dash'] = 'blocking';
-    assert.equal(analyzeAiEditor('The scheduler failed — retry later.', profile).findings.find((finding) => finding.id === 'punct.em-dash')?.appliedPolicy, 'blocking');
-});
-test('keeps non-prose regions out of AI Editor while scanning adjacent prose', () => {
-    const tick = String.fromCharCode(96);
-    const fence = tick.repeat(3);
-    const draft = [
-        '---',
-        'title: We leverage the launch',
-        '---',
-        'We leverage the launch.',
-        fence + 'ts',
-        'const message = "We leverage logs";',
-        fence,
-        'Use ' + tick + 'we leverage logs' + tick + ' only as an example.',
-        '[A link](https://example.com/we-leverage) stays useful.',
-    ].join('\n');
-    const report = analyzeAiEditor(draft);
-    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => finding.sentence), [1]);
-    assert.equal(maskNonProse(draft).includes('https://example.com/we-leverage'), false);
-});
-test('preserves protected-region offsets after a supplementary Unicode character', () => {
-    const tick = String.fromCharCode(96);
-    const draft = '🚀 We leverage the launch. Use ' + tick + 'we leverage logs' + tick + ' as an example.';
-    const report = analyzeAiEditor(draft);
-    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => [finding.sentence, finding.excerpt]), [
-        [1, '🚀 We leverage the launch.'],
-    ]);
-});
-test('uses reconciled defaults for v2 profiles and suppresses inherited duplicate emissions', () => {
-    const report = analyzeAiEditor("It's worth noting: in other words, I think the same plan. Better results.");
-    assert.equal(report.findings.some((finding) => finding.id === 'hedge.worth-noting'), false);
-    assert.equal(report.findings.some((finding) => finding.id === 'struct.in-other-words'), false);
-    assert.equal(report.findings.some((finding) => finding.id === 'hedge.i-think'), false);
-    assert.equal(report.findings.some((finding) => finding.id === 'struct.same-better'), false);
-    assert.ok(report.findings.every((finding) => finding.appliedPolicy !== undefined));
-});
-test('treats bare red vocabulary as pending judgment and clear sincerity or dashes as blocking', () => {
-    const vocabulary = analyzeAiEditor('We leverage the existing scheduler.');
-    assert.deepEqual(vocabulary.findings.find((finding) => finding.id === 'ai.leverage')?.appliedPolicy, 'judgment-required');
-    assert.equal(vocabulary.passed, true);
-    const blocked = analyzeAiEditor('To be honest, the scheduler failed — twice.');
-    assert.ok(blocked.findings.some((finding) => finding.id === 'formula.performative-sincerity' && finding.appliedPolicy === 'blocking'));
-    assert.ok(blocked.findings.some((finding) => finding.id === 'punct.em-dash' && finding.appliedPolicy === 'blocking'));
-    assert.equal(blocked.passed, false);
-    const advisory = analyzeAiEditor('Honestly, the scheduler failed twice.');
-    assert.ok(advisory.findings.some((finding) => finding.id === 'hedge.performative-sincerity-adverb' && finding.appliedPolicy === 'advisory'));
-    assert.equal(advisory.passed, true);
-});
-test('only applies the question-hook policy to document sentence one', () => {
-    assert.ok(analyzeAiEditor('Have you checked the invoice? It is overdue.').findings.some((finding) => finding.id === 'ai.question-hook'));
-    assert.equal(analyzeAiEditor('The invoice is overdue. Have you checked it?').findings.some((finding) => finding.id === 'ai.question-hook'), false);
-});
-test('detects representative rules from every inherited rule family', () => {
-    const examples = [
-        ['ai.delve', 'we will delve into it.'],
-        ['ai.leverage', 'we leverage the existing logs.'],
-        ['ai.tapestry', 'the tapestry explains the work.'],
-        ['ai.holistic', 'a holistic review starts today.'],
-        ['ai.robust', 'robust evidence supports the claim.'],
-        ['ai.landscape', 'the market landscape changed.'],
-        ['ai.game-changer', 'this is a game-changer.'],
-        ['formula.firstly', 'Firstly, check the invoice.'],
-        ['hedge.perhaps', 'Perhaps the invoice is late.'],
-        ['struct.this-is-why', 'This is why the invoice matters.'],
-        ['struct.not-just-but-also', 'this is not just fast but reliable.'],
-        ['struct.rhetorical-truth', 'the hard truth is in the logs.'],
-        ['punct.em-dash', 'the logs failed — retry later.'],
-        ['bait.let-that-sink', 'Let that sink in.'],
-        ['cringe.10x', 'The change delivered a 10x result.'],
-        ['insider.nobody-tells', 'What nobody tells you is in the report.'],
-        ['ogilvy.bandwidth', 'We lack the bandwidth this week.'],
-    ];
-    for (const [id, example] of examples) {
-        const report = analyzeAiEditor(example);
-        assert.ok(report.findings.some((finding) => finding.id === id && finding.sentence === 1), id);
-    }
-});
-test('covers the narrow 3.5 pattern additions with an editorial example for each rule', () => {
-    const examples = [
-        ['ai.inflated-significance', 'This marks a pivotal moment for the project.'],
-        ['ai.notability-name-drop', 'The renowned Ada Lovelace writer changed the field.'],
-        ['ai.shallow-participle-analysis', 'The result matters, highlighting its importance.'],
-        ['ai.promotional-scene-setting', 'In today’s changing technology landscape, the work starts.'],
-        ['ai.vague-attribution', 'Experts say the change will help.'],
-        ['ai.challenges-outlook', 'Despite these challenges, the future remains open.'],
-        ['ai.copula-avoidance', 'The launch is serving as a testament to patience.'],
-        ['ai.false-range', 'The course runs from the Big Bang to dark matter.'],
-        ['ai.actorless-claim', 'It is important that we check the source.'],
-        ['ai.chatbot-offer', 'Let me know if you would like another draft.'],
-        ['ai.knowledge-limit-disclaimer', 'As an AI, I cannot verify that.'],
-        ['ai.agreement-preamble', 'Absolutely, the invoice is overdue.'],
-        ['ai.qualifier-stack', 'This is very important for the launch.'],
-        ['ai.generic-positive-ending', 'The possibilities are endless.'],
-        ['ai.at-its-core', 'At its core, the work is a queue.'],
-        ['ai.section-announcement', 'Let us now explore the next step.'],
-        ['ai.historical-implementation-aside', 'The tool was once known as Alpha and now has a new name.'],
-        ['ai.unraised-objection', 'Some might argue that the queue is unnecessary.'],
-        ['ai.fake-alternative', 'Whether you choose email or chat, start today.'],
-        ['format.bold-bullet-label', '- **Decision:** Ship Tuesday.'],
-        ['format.title-case-heading', '# Generic Title Case Heading'],
-        ['format.emoji-heading', '# 🚀 Launch plan'],
-        ['format.curly-quotes', 'The operator wrote “ship Tuesday” in the release note.'],
-        ['format.hyphenated-modifier-stack', 'Use a high-trust-low-friction process.'],
-    ];
-    for (const [id, example] of examples)
-        assert.ok(analyzeAiEditor(example).findings.some((finding) => finding.id === id), id);
-});
-test('keeps bounded Humanizer and Ghostwriter document cues advisory', () => {
-    const examples = [
-        ['ai.forced-triplet', 'The template promises speed, scale, and alignment.'],
-        ['ai.repeated-sentence-opening', 'We checked the logs. We checked the queue. We checked the retry.'],
-        ['format.bold-density', '**Plan** stays visible. **Owner** checks it. **Proof** ships. **Next** is Tuesday.'],
-        ['format.repeated-heading-body', '# Release plan\n\nRelease plan explains the verified rollback.'],
-        ['ai.clipped-fragment-run', 'No demos. No decks. No distractions. The owner checked the logs.'],
-        ['ai.formulaic-aphorism', 'Quality over quantity is the whole lesson.'],
-        ['ai.fake-candid-opener', "I'm going to be honest: the queue failed."],
-        ['ai.metric-theater', 'At 3:47 AM, the slide promised a 23.6x ROI.'],
-        ['ai.jargon-stack', 'The scalable ecosystem needs alignment, leverage, and a holistic framework.'],
-        ['ai.sentence-length-cluster', 'The release owner carefully checks each visible rollback instruction before the scheduled production deployment window opens this morning. The release operator carefully records each visible rollback instruction before the scheduled production deployment window opens this morning. The release reviewer carefully reviews each visible rollback instruction before the scheduled production deployment window opens this morning. The release manager carefully confirms each visible rollback instruction before the scheduled production deployment window opens this morning.'],
-    ];
-    for (const [id, example] of examples) {
-        const finding = analyzeAiEditor(example).findings.find((item) => item.id === id);
-        assert.ok(finding, id);
-        assert.equal(finding.appliedPolicy, 'advisory', id);
-    }
-    assert.equal(analyzeAiEditor('Three source IDs appear in the manifest.').findings.some((finding) => finding.id === 'ai.forced-triplet'), false);
-    assert.equal(analyzeAiEditor('Owners checked the queue. Operators checked the log. Reviewers checked the proof.').findings.some((finding) => finding.id === 'ai.repeated-sentence-opening'), false);
-});
-test('keeps the frozen synthetic AI-shadow fail set generated in CI and executable without runtime generation', () => {
-    assert.deepEqual(generateAiShadowFailSetV1(), AI_SHADOW_FAIL_SET_V1);
-    for (const fixture of AI_SHADOW_FAIL_SET_V1)
-        assert.ok(analyzeAiEditor(fixture.text).findings.some((finding) => finding.id === fixture.rule), fixture.id);
-});
-test('keeps counterexamples for representative inherited rules', () => {
-    const counterexamples = [
-        ['ai.delve', 'we inspect the logs.'],
-        ['ai.leverage', 'we use the existing logs.'],
-        ['ai.tapestry', 'the report explains the work.'],
-        ['ai.holistic', 'the review covers the named files.'],
-        ['ai.robust', 'the evidence includes three dated reports.'],
-        ['ai.landscape', 'the market changed after the price cut.'],
-        ['ai.game-changer', 'the release removed a manual step.'],
-        ['formula.firstly', 'next, check the invoice.'],
-        ['hedge.perhaps', 'the invoice is late.'],
-        ['struct.this-is-why', 'the invoice matters because it is overdue.'],
-        ['struct.not-just-but-also', 'the service is fast and reliable.'],
-        ['struct.rhetorical-truth', 'the logs show the service failed.'],
-        ['punct.em-dash', 'the logs failed; retry later.'],
-        ['bait.let-that-sink', 'The invoice is overdue.'],
-        ['cringe.10x', 'The result rose from 2 to 20.'],
-        ['insider.nobody-tells', 'The report explains the missing step.'],
-        ['ogilvy.bandwidth', 'We lack time this week.'],
-    ];
-    for (const [id, example] of counterexamples) {
-        assert.equal(analyzeAiEditor(example).findings.some((finding) => finding.id === id), false, id);
-    }
-});
-test('keeps yellow findings as review cues rather than release blockers', () => {
-    const report = analyzeAiEditor('Firstly, the editor checked the invoice.');
-    assert.ok(report.findings.every((finding) => finding.severity === 'yellow'));
-    assert.equal(report.passed, true);
-});
-test('restores the benchmark signals from the 2.9.24 executable catalog', () => {
-    const report = analyzeAiEditor("This work is meaningful. Here's the part nobody is talking about. The change delivered a 10x result.");
-    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.sentence]), [
-        ['ai.meaningful', 1],
-        ['struct.heres-where', 2],
-        ['cringe.10x', 3],
-    ]);
-});
-test('returns the same findings across repeated sentence and line analysis', () => {
-    for (const text of ['We leverage logs. We leverage traces.', 'No demos. No decks. No distractions. Same team. Better results.']) {
-        assert.deepEqual(analyzeAiEditor(text), analyzeAiEditor(text));
-    }
-});
-test('reports the same rule in multiple sentences', () => {
-    const report = analyzeAiEditor('We leverage logs. We leverage traces.');
-    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => finding.sentence), [1, 2]);
-});
-test('executes inherited cross-sentence rules and maps them to the first sentence', () => {
-    const report = analyzeAiEditor('No demos. No decks. No distractions. Same team. Better results.');
-    assert.deepEqual(report.findings
-        .filter((finding) => finding.id === 'struct.negation-cascade' || finding.id === 'struct.same-better')
-        .map((finding) => [finding.id, finding.sentence]), [['struct.negation-cascade', 1]]);
-});
-test('preserves inherited physical-line matching and line-start anchors', () => {
-    const sameLine = analyzeAiEditor("This isn't positioning. This is proof. Forget vanity metrics. You need retention.");
-    assert.ok(sameLine.findings.some((finding) => finding.id === 'struct.this-isnt-x-this-is-y'));
-    assert.ok(sameLine.findings.some((finding) => finding.id === 'struct.forget-x'));
-    assert.equal(analyzeAiEditor("This isn't positioning.\nThis is proof.").findings.some((finding) => finding.id === 'struct.this-isnt-x-this-is-y'), false);
-    assert.equal(analyzeAiEditor('The logs failed. Of course we can retry.').findings.some((finding) => finding.id === 'cringe.of-course'), false);
-    assert.ok(analyzeAiEditor('The logs failed.\nOf course we can retry.').findings.some((finding) => finding.id === 'cringe.of-course'));
-});
-test('retains the current question-hook and abstract-cluster detectors', () => {
-    assert.ok(analyzeAiEditor('Have you checked the invoice?').findings.some((finding) => finding.id === 'ai.question-hook'));
-    assert.ok(analyzeAiEditor('Clarity and strategy are missing.').findings.some((finding) => finding.id === 'ai.abstract-cluster'));
-});
-test('serializes reconstructable regular expressions and explicit scopes', () => {
-    const catalog = serializedRules();
-    assert.equal(catalog.length, 182);
-    assert.ok(catalog.every((rule) => rule.scope === 'sentence' || rule.scope === 'line' || rule.scope === 'document'));
-    const meaningful = catalog.find((rule) => rule.id === 'ai.meaningful');
-    assert.ok(meaningful);
-    assert.equal(new RegExp(meaningful.expression.source, meaningful.expression.flags).test('Meaningful work.'), true);
-});
-test('suppresses intentional inherited overlaps before scoring', () => {
-    const report = analyzeAiEditor('In other words, use logs.');
-    assert.deepEqual(report.findings.map((finding) => finding.id), ['formula.in-other-words']);
-    assert.equal(report.score, 82);
-});
-test('returns zero AI findings for clean input', () => {
-    assert.deepEqual(analyzeAiEditor('The launch starts Tuesday. The owner signed the release checklist.').findings, []);
-});

package/dist/approval-capability.test.js

@@ -1,52 +0,0 @@
-import assert from 'node:assert/strict';
-import { generateKeyPairSync, sign } from 'node:crypto';
-import test from 'node:test';
-import { canonicalJsonBytes } from './canonical-json.js';
-import { verifyApprovalCapability } from './approval-capability.js';
-const binding = {
-    rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: '3'.repeat(64),
-    sourceHash: '4'.repeat(64), candidateHash: '5'.repeat(64), profileId: 'founder.primary', profileRevisionDigest: '6'.repeat(64),
-    rulesetVersion: '3.2.0', schemaVersion: '1',
-};
-const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-const publicKeySpki = publicKey.export({ format: 'der', type: 'spki' }).toString('base64url');
-const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'host.example', keyId: 'key-1', publicKeySpki, status: 'active' }] };
-function envelope(overrides = {}, signer = privateKey) {
-    const claims = {
-        version: '1', purpose: 'hyv.final-approval', issuer: 'host.example', audience: '@holdyourvoice/hyv',
-        subjectArtifactFingerprint: '7'.repeat(64), sourceHash: binding.sourceHash, candidateHash: binding.candidateHash,
-        profileId: binding.profileId, profileRevisionDigest: binding.profileRevisionDigest, keyId: 'key-1',
-        issuedAt: 100, notBefore: 100, expiresAt: 200, nonce: 'nonce-1', ...overrides,
-    };
-    const payload = canonicalJsonBytes(claims);
-    return { payload: payload.toString('base64url'), signature: sign(null, payload, signer).toString('base64url') };
-}
-test('verifies one canonical bound Ed25519 final-approval capability', () => {
-    const result = verifyApprovalCapability(envelope(), trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' });
-    assert.equal(result.ok, true);
-    if (result.ok)
-        assert.match(result.capabilityFingerprint, /^[a-f0-9]{64}$/);
-});
-test('fails closed for purpose, binding, trust, time, signature, and canonical encoding', () => {
-    assert.deepEqual(verifyApprovalCapability(envelope({ purpose: 'hyv.rebuild-authorization' }), trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'wrong_purpose' });
-    assert.deepEqual(verifyApprovalCapability(envelope({ candidateHash: '8'.repeat(64) }), trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'binding_mismatch' });
-    assert.deepEqual(verifyApprovalCapability(envelope(), { ...trustStore, keys: [{ ...trustStore.keys[0], status: 'revoked' }] }, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'revoked_key' });
-    assert.deepEqual(verifyApprovalCapability(envelope(), trustStore, { now: 201, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'expired' });
-    const forged = envelope();
-    const forgedBytes = Buffer.from(forged.signature, 'base64url');
-    forgedBytes[0] = forgedBytes[0] ^ 1;
-    forged.signature = forgedBytes.toString('base64url');
-    assert.deepEqual(verifyApprovalCapability(forged, trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'invalid_signature' });
-    const nonCanonical = envelope();
-    nonCanonical.payload = Buffer.from(` ${Buffer.from(nonCanonical.payload, 'base64url').toString('utf8')}`).toString('base64url');
-    assert.deepEqual(verifyApprovalCapability(nonCanonical, trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'non_canonical' });
-});
-test('rejects malformed envelopes and invalid trust stores without returning secret material', () => {
-    const result = verifyApprovalCapability({ payload: `${envelope().payload}=`, signature: envelope().signature }, trustStore, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' });
-    assert.deepEqual(result, { ok: false, error: 'invalid_encoding' });
-    assert.doesNotMatch(JSON.stringify(result), /nonce-1|signature|publicKeySpki/);
-    assert.deepEqual(verifyApprovalCapability(envelope(), { ...trustStore, keys: [...trustStore.keys, trustStore.keys[0]] }, { now: 150, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'invalid_schema' });
-});
-test('rejects an invalid host clock', () => {
-    assert.deepEqual(verifyApprovalCapability(envelope(), trustStore, { now: Number.NaN, expectedSubjectArtifactFingerprint: '7'.repeat(64), binding, expectedPurpose: 'hyv.final-approval' }), { ok: false, error: 'invalid_schema' });
-});

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);
-});