@holdyourvoice/hyv 3.6.0 → 4.0.0

package/dist/mcp-tools.test.js

@@ -1,286 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash, generateKeyPairSync, sign } from 'node:crypto';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { analyzeBatchForMcp, analyzeForMcp, applyHiddenTextPolicyForMcp, applyRebuildForMcp, applyRewriteForMcp, buildProfileForMcp, clearLearningForMcp, finalOutputCheckForMcp, finalizeLifecycleForMcp, inspectHiddenTextForMcp, inspectHygieneForMcp, inspectLearningForMcp, inspectLifecycleForMcp, logicLintForMcp, patternsForMcp, prepareJudgmentForMcp, prepareLifecycleForMcp, prepareRebuildForMcp, prepareRewriteForMcp, ratifyLearningForMcp, recordApprovedLearningForMcp, recordLearningForMcp, rebuildWriterRequestForMcp, reduceJudgmentForMcp, rewritePromptForMcp, scoreHeldoutForMcp, strictCheckForMcp, submitSemanticVerdictForMcp, supersedeLearningForMcp, validateFinalApprovalForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
-import { canonicalJson } from './canonical-json.js';
-import { findWritingExamplesForMcp } from './mcp-tools.js';
-import { backtestForMcp } from './mcp-tools.js';
-const profile = buildProfileForMcp(['I write clearly. I keep the useful detail.', 'I make the call. Then I explain the trade-off.'], ['leverage']);
-const profileJson = JSON.stringify(profile);
-test('builds a portable profile for MCP without files', () => {
-    assert.equal(profile.version, '2');
-    assert.equal(profile.sampleCount, 2);
-});
-test('keeps the dual-engine analysis shape through MCP tools', () => {
-    const result = analyzeForMcp('I leverage a clear plan.\u200B', profileJson);
-    assert.equal(result.voiceDna.engine, 'voice_dna');
-    assert.equal(result.aiEditor.engine, 'ai_editor');
-    assert.equal(result.hygiene.suspiciousCount, 1);
-});
-test('exposes the strict local quality gate through MCP helpers', () => {
-    const report = strictCheckForMcp('I leverage a clear plan.', profileJson, ['one.', 'two.']);
-    assert.equal(report.disposition, 'blocked');
-    assert.ok(report.findings.some((finding) => finding.id === 'strict.profile.version'));
-});
-test('scores explicit held-out samples through MCP without storing them', () => {
-    const samples = [
-        'I write a direct note about the launch. The owner checks the evidence before we ship. The next step stays clear and small.',
-        'I name the trade-off before I make a decision. We keep the mechanism visible for the person doing the work. The release has one owner.',
-        'I start from evidence in the issue. Then I explain the constraint and choose a concrete next step. The team checks the result.',
-    ];
-    const result = scoreHeldoutForMcp(samples[0], JSON.stringify(buildProfileForMcp(samples)), samples);
-    assert.equal(result.version, '1');
-    assert.equal(result.selfSimilarity?.ceiling, 100);
-});
-test('runs an isolated backtest without returning target or candidate prose', () => {
-    const samples = ['I write direct evidence for the operator doing the release work today.', 'The owner checks each rollback and names the next step for production.', 'The report keeps the mechanism visible and gives the team one concrete action.'];
-    const report = backtestForMcp('Explain the rollout owner.', 'The owner checks rollback.', 'The owner checks rollback.', JSON.stringify(buildProfileForMcp(samples)), samples);
-    assert.equal(report.preservation.score, 100);
-    assert.equal(JSON.stringify(report).includes('The owner checks rollback.'), false);
-});
-test('finds and injects redacted local writing examples without storing an index', () => {
-    const examples = [{ basename: 'email.md', text: 'The retry queue stays local; owner@example.com receives the review.' }];
-    const found = findWritingExamplesForMcp('The retry queue needs review.', examples);
-    assert.equal(found[0]?.source, 'email.md');
-    assert.match(found[0]?.text ?? '', /REDACTED:EMAIL/);
-    const prompt = rewritePromptForMcp('The retry queue needs review.', profileJson, {}, undefined, examples);
-    assert.match(prompt.prompt, /Approved local writing examples/);
-    assert.doesNotMatch(prompt.prompt, /owner@example\.com/);
-});
-test('inspects Unicode hygiene through MCP without a voice profile', () => {
-    const result = inspectHygieneForMcp('one\u200Btwo\u00A0three');
-    assert.equal(result.suspiciousCount, 2);
-    assert.equal(result.fixableCount, 0);
-});
-test('exposes the deterministic logic gate through MCP helpers', () => {
-    const report = logicLintForMcp('The service records cache keys. Each build writes its cache key. Espresso machines use dual boilers for stable temperature control. The service uses cache keys during incident review.');
-    assert.equal(report.passed, false);
-    assert.equal(report.findings[0]?.kind, 'topic_drift');
-});
-test('applies only explicit hidden-text removals through MCP', () => {
-    const policy = JSON.stringify({ version: '1', name: 'minimal-text-control-cleanup', approvedRemovals: ['ascii_control'], acknowledgement: 'Removes only listed non-semantic controls; all other findings remain review-only.' });
-    const inspected = inspectHiddenTextForMcp('one\u0007two\uFEFFthree\u200D', policy);
-    assert.deepEqual(inspected.proposedChanges.map((change) => change.codepoint), ['U+0007']);
-    const applied = applyHiddenTextPolicyForMcp('one\u0007two\uFEFFthree\u200D', policy);
-    assert.equal(applied.output, 'onetwo\uFEFFthree\u200D');
-    assert.equal(applied.idempotent, true);
-});
-test('gates exact final output through MCP without a voice profile', () => {
-    const accepted = finalOutputCheckForMcp('exact output');
-    assert.equal(accepted.accepted && accepted.output, 'exact output');
-    const rejected = finalOutputCheckForMcp('hidden\u200Boutput');
-    assert.equal(rejected.accepted, false);
-    assert.equal('output' in rejected, false);
-});
-test('accepts optional WritingBrief context and exposes batch findings through MCP helpers', () => {
-    const brief = JSON.stringify({
-        version: '1', audience: 'founders', intent: 'start a discussion', format: 'social', evidenceStatus: 'unverified',
-        argumentMap: { observation: 'Founders repeat vague advice.', mechanism: 'The advice skips the work.', consequence: 'Readers cannot act.', readerValue: 'Avoid a vague post.' },
-    });
-    const analysis = analyzeForMcp('A pattern I keep seeing in founder posts is vague advice.', profileJson, brief);
-    assert.ok(analysis.editorial?.findings.some((item) => item.id === 'editorial.social.generic-opener'));
-    assert.ok(analysis.editorial?.findings.some((item) => item.id === 'editorial.evidence.unverified'));
-    const batch = analyzeBatchForMcp(['The launch needs a clear owner.', 'The launch needs a clear owner.']);
-    assert.equal(batch.findings.length, 2);
-});
-test('keeps MCP verification read-only', () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-'));
-    try {
-        const result = verifyForMcp('I leverage the answer with useful detail and clear mechanism.', 'I use the answer with useful detail and clear mechanism.', profileJson);
-        const brief = rewritePromptForMcp('I leverage a clear plan.', profileJson, { root });
-        assert.match(brief.prompt, /Tier 0/);
-        assert.doesNotMatch(brief.prompt, /Learned local preferences/);
-        assert.equal(result.preservationScore >= 70, true);
-        assert.equal('learning' in result, false);
-        assert.deepEqual(inspectLearningForMcp(profileJson, { root }), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('prepares, submits, and inspects the normal lifecycle through MCP helpers', () => {
-    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 deterministic = { ...deterministicBase, artifactFingerprint: createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(deterministicBase)}`).digest('hex') };
-    const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministic.artifactFingerprint, 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 prepared = prepareLifecycleForMcp(JSON.stringify(deterministic), JSON.stringify(binding), JSON.stringify(receipt), 'normal', ['action_change']);
-    const context = { now: 0, trustStore: { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 1, keys: [] }, authorizedSemanticEvaluatorIds: { normal: ['reviewer-1'], highAssurance: [] }, authorizedHumanFinalizerIds: [] };
-    const submitted = submitSemanticVerdictForMcp(JSON.stringify(prepared.artifact), JSON.stringify(prepared.task), 'reviewer-1', JSON.stringify({ approved: true, violations: [] }), context);
-    assert.equal(submitted.ok && submitted.artifact.status, 'ready_for_human_review');
-    assert.equal(inspectLifecycleForMcp(JSON.stringify(submitted.ok && submitted.artifact)).status, 'ready_for_human_review');
-    assert.throws(() => prepareLifecycleForMcp(JSON.stringify(deterministic), JSON.stringify(binding), JSON.stringify(receipt), 'high_assurance', ['action_change']), /trusted embedding/);
-    const forgedTask = { ...prepared.task, allowedViolations: ['unsupported_claim'] };
-    assert.throws(() => submitSemanticVerdictForMcp(JSON.stringify(prepared.artifact), JSON.stringify(forgedTask), 'reviewer-1', JSON.stringify({ approved: false, violations: ['unsupported_claim'] }), context));
-});
-test('validates and finalizes signed approval with helper/core parity and no bearer output', () => {
-    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 deterministic = { ...deterministicBase, artifactFingerprint: createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(deterministicBase)}`).digest('hex') };
-    const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministic.artifactFingerprint, 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 prepared = prepareLifecycleForMcp(JSON.stringify(deterministic), JSON.stringify(binding), JSON.stringify(receipt), 'normal', ['action_change']);
-    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 context = { now: 150, trustStore, authorizedSemanticEvaluatorIds: { normal: ['reviewer-1'], highAssurance: [] }, authorizedHumanFinalizerIds: ['human-1'] };
-    const submitted = submitSemanticVerdictForMcp(JSON.stringify(prepared.artifact), JSON.stringify(prepared.task), 'reviewer-1', JSON.stringify({ approved: true, violations: [] }), context);
-    assert.equal(submitted.ok, true);
-    if (!submitted.ok)
-        return;
-    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: 'mcp-secret-nonce' };
-    const payload = Buffer.from(canonicalJson(claims));
-    const capability = { payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') };
-    const validated = validateFinalApprovalForMcp(JSON.stringify(submitted.artifact), canonicalJson(capability), context);
-    assert.equal(validated.ok, true);
-    const finalized = finalizeLifecycleForMcp(JSON.stringify(submitted.artifact), JSON.stringify({ evaluatorId: 'human-1', decision: 'approve' }), context, canonicalJson(capability));
-    assert.equal(finalized.ok && finalized.artifact.status, 'approved');
-    assert.throws(() => finalizeLifecycleForMcp(JSON.stringify(submitted.artifact), JSON.stringify({ evaluatorId: 'human-1', decision: 'reject' }), context, canonicalJson(capability)), /does not accept/);
-    assert.doesNotMatch(JSON.stringify({ validated, finalized }), /mcp-secret-nonce|payload|signature/);
-});
-test('records approved learning once and treats an exact replay as a no-op', () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-approved-'));
-    const previousHome = process.env.HYV_HOME;
-    process.env.HYV_HOME = root;
-    try {
-        const source = 'I leverage the answer with useful detail and clear mechanism.';
-        const candidate = 'I use the answer with useful detail and clear mechanism.';
-        const rewriteTask = prepareRewriteForMcp(source, profileJson);
-        const evaluation = applyRewriteForMcp(JSON.stringify(rewriteTask), JSON.stringify({
-            version: '1', taskFingerprint: rewriteTask.fingerprint, replacements: [{ sentenceId: 1, text: candidate }],
-        }), profileJson);
-        assert.equal(evaluation.status, 'needs_semantic_review');
-        const prepared = prepareLifecycleForMcp(JSON.stringify(evaluation.deterministicArtifact), JSON.stringify(evaluation.lifecycleBinding), JSON.stringify(evaluation.receipt), 'normal', []);
-        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 context = { now: 150, trustStore, authorizedSemanticEvaluatorIds: { normal: ['reviewer-1'], highAssurance: [] }, authorizedHumanFinalizerIds: ['human-1'] };
-        const submitted = submitSemanticVerdictForMcp(JSON.stringify(prepared.artifact), JSON.stringify(prepared.task), 'reviewer-1', JSON.stringify({ approved: true, violations: [] }), context);
-        assert.equal(submitted.ok, true);
-        if (!submitted.ok)
-            return;
-        const binding = submitted.artifact.binding;
-        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: 'approved-learning-secret' };
-        const payload = Buffer.from(canonicalJson(claims));
-        const capability = canonicalJson({ payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') });
-        const decision = JSON.stringify({ evaluatorId: 'human-1', decision: 'approve' });
-        const finalized = finalizeLifecycleForMcp(JSON.stringify(submitted.artifact), decision, context, capability);
-        assert.equal(finalized.ok, true);
-        if (!finalized.ok)
-            return;
-        const request = { readyJson: JSON.stringify(submitted.artifact), approvedJson: JSON.stringify(finalized.artifact), source, candidate, profileJson, decisionJson: decision, capabilityJson: capability, context };
-        assert.equal(recordApprovedLearningForMcp(request), 'recorded');
-        assert.equal(recordApprovedLearningForMcp(request), 'nothing_to_learn');
-        const stored = JSON.stringify(inspectLearningForMcp(profileJson, { root }));
-        assert.equal(JSON.parse(stored).length, 1);
-        assert.doesNotMatch(stored, /approved-learning-secret|payload|signature|I leverage|I use/);
-    }
-    finally {
-        if (previousHome === undefined)
-            delete process.env.HYV_HOME;
-        else
-            process.env.HYV_HOME = previousHome;
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('exposes text-free learning inspection and explicit mutations through MCP helpers', () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-learning-'));
-    const unsigned = { ...profile, version: '3', id: 'founder.test', revision: 1, 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'] } };
-    const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(',')}]` : value && typeof value === 'object' ? `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}` : JSON.stringify(value);
-    const profileV3 = { ...unsigned, revisionDigest: createHash('sha256').update(canonical(unsigned)).digest('hex') };
-    const v3Json = JSON.stringify(profileV3);
-    try {
-        const recorded = recordLearningForMcp(v3Json, 'Keep the mechanism concrete.', { root, mutationId: 'm1', authority: 'founder', provenance: 'editor-review', weight: 2, compatibility: 'exact' });
-        assert.equal(recorded.status, 'recorded');
-        assert.equal(recordLearningForMcp(v3Json, 'Different instruction.', { root, mutationId: 'm1' }).status, 'conflict');
-        const inspection = inspectLearningForMcp(v3Json, { root });
-        assert.equal(inspection[0]?.eventType, 'instruction');
-        assert.equal(JSON.stringify(inspection).includes('Keep the mechanism concrete.'), false);
-        assert.equal(ratifyLearningForMcp(v3Json, recorded.eventId, { root, mutationId: 'm2', authority: 'founder' }).status, 'recorded');
-        assert.equal(supersedeLearningForMcp(v3Json, recorded.eventId, { root, mutationId: 'm3', authority: 'founder' }).status, 'recorded');
-        assert.equal(clearLearningForMcp(v3Json, { root }).cleared, true);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('exposes the executable pattern IDs through MCP tools', () => {
-    const catalog = patternsForMcp();
-    assert.ok(catalog.rules.some((rule) => rule.id === 'ai.leverage'));
-});
-test('fails closed on changed CopySpec claims through MCP tools', () => {
-    const result = verifyCopySpecForMcp('The launch is on 14 August.', 'The launch is next month.', profileJson, JSON.stringify({
-        version: '1', audience: 'operators', intent: 'explain', channel: 'email',
-        claims: [{ id: 'launch-date', text: 'The launch is on 14 August.', evidence: 'Release calendar.' }],
-    }));
-    assert.equal(result.passed, false);
-    assert.equal(result.claims.failures[0]?.code, 'missing_immutable_claim');
-    assert.equal('learning' in result, false);
-});
-test('allows declared CopySpec atoms to survive a split MCP rewrite', () => {
-    const spec = JSON.stringify({
-        version: '1', audience: 'operators', intent: 'explain', channel: 'email',
-        claims: [{ id: 'model-size', text: 'Kimi K2.6 has 600 GB of INT4 weights.', atoms: ['Kimi K2.6 uses INT4 weights', 'payload is 600 GB'], evidence: 'Technical report.' }],
-    });
-    const preserved = verifyCopySpecForMcp('Kimi K2.6 has 600 GB of INT4 weights.', 'Kimi K2.6 uses INT4 weights. The payload is 600 GB.', profileJson, spec);
-    assert.equal(preserved.claims.passed, true);
-    const missing = verifyCopySpecForMcp('Kimi K2.6 has 600 GB of INT4 weights.', 'Kimi K2.6 uses INT4 weights.', profileJson, spec);
-    assert.deepEqual(missing.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
-});
-test('prepares and applies the rewrite task through MCP helpers', () => {
-    const task = prepareRewriteForMcp('I leverage the answer with useful detail and clear mechanism.', profileJson);
-    const result = applyRewriteForMcp(JSON.stringify(task), JSON.stringify({
-        version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer with useful detail and clear mechanism.' }],
-    }), profileJson);
-    assert.equal(result.status, 'needs_semantic_review');
-    assert.equal(result.candidate, 'I use the answer with useful detail and clear mechanism.');
-});
-test('prepares and reduces judgment envelopes through MCP helpers', () => {
-    const draft = 'I leverage the answer.';
-    const envelopes = ['triage', 'argument', 'form'].map((kind) => {
-        const task = prepareJudgmentForMcp('pre-edit', kind, draft, profileJson);
-        return {
-            version: '1', stage: 'pre-edit', judgmentType: kind, taskFingerprint: task.taskFingerprint,
-            bindings: { ...task.bindings, evaluatorId: 'writer.1' }, findings: [], decision: 'SHIP',
-        };
-    });
-    assert.equal(reduceJudgmentForMcp(JSON.stringify(envelopes)).decision, 'SHIP');
-});
-test('prepares and evaluates authorized rebuild through MCP helpers', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August.';
-    const envelopes = ['triage', 'argument', 'form'].map((kind) => {
-        const task = prepareJudgmentForMcp('pre-edit', kind, draft, profileJson);
-        return {
-            version: '1', stage: 'pre-edit', judgmentType: kind, taskFingerprint: task.taskFingerprint,
-            bindings: { ...task.bindings, evaluatorId: 'writer.1' }, findings: kind === 'argument' ? [] : [], decision: kind === 'argument' ? 'REBUILD' : 'SHIP',
-        };
-    });
-    const reduction = reduceJudgmentForMcp(JSON.stringify(envelopes));
-    assert.equal(reduction.decision, 'REBUILD');
-    if (!('recommendationFingerprint' in reduction))
-        throw new Error('expected a pre-edit rebuild recommendation');
-    const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-    const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'host.example', keyId: 'key-1', publicKeySpki: publicKey.export({ format: 'der', type: 'spki' }).toString('base64url'), status: 'active' }] };
-    const sourceHash = createHash('sha256').update(draft).digest('hex');
-    const identity = `legacy-v2:${createHash('sha256').update(canonicalJson(profile)).digest('hex')}`;
-    const claims = {
-        version: '1', purpose: 'hyv.rebuild-authorization', issuer: 'host.example', audience: '@holdyourvoice/hyv',
-        subjectArtifactFingerprint: reduction.recommendationFingerprint, sourceHash, candidateHash: sourceHash,
-        profileId: identity, profileRevisionDigest: identity, keyId: 'key-1', issuedAt: 100, notBefore: 100, expiresAt: 200, nonce: 'mcp-rebuild',
-    };
-    const payload = Buffer.from(canonicalJson(claims));
-    const capability = { payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') };
-    const copySpec = JSON.stringify({ version: '1', audience: 'operators', intent: 'explain', channel: 'email', claims: [{ id: 'launch-date', text: 'The launch is on 14 August.', evidence: 'Release calendar, 7 August.' }] });
-    const context = { now: 150, trustStore, authorizedSemanticEvaluatorIds: { normal: [], highAssurance: [] }, authorizedHumanFinalizerIds: [] };
-    const policy = JSON.stringify({ version: '1', mode: 'meaning-first', lexicalResidual: { ngramSize: 5, maxSharedNgramFraction: 0, maxLongestSharedRunTokens: 4 }, acknowledgement: 'Measures shared wording only; does not detect or prove removal of a watermark.' });
-    const task = prepareRebuildForMcp(draft, profileJson, JSON.stringify(reduction), copySpec, JSON.stringify(capability), context, undefined, policy);
-    assert.doesNotMatch(task.prompt, /I leverage the answer/);
-    const writerRequest = rebuildWriterRequestForMcp(JSON.stringify(task));
-    assert.doesNotMatch(JSON.stringify(writerRequest), /I leverage the answer|capability|profile/i);
-    const result = applyRebuildForMcp(JSON.stringify(task), JSON.stringify({
-        version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint,
-        candidate: 'Ship planning now treats one calendar fact as fixed. The launch is on 14 August. Every other sentence in this note is new operational language for the release desk.',
-    }), profileJson, JSON.stringify(capability), context);
-    assert.equal(result.status, 'needs_semantic_review');
-    assert.equal(result.receipt.mode, 'REBUILD');
-    assert.equal(result.receipt.lexicalResidual?.passed, true);
-});

package/dist/mcp.test.js

@@ -1,312 +0,0 @@
-import assert from 'node:assert/strict';
-import { createHash, generateKeyPairSync, sign } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { once } from 'node:events';
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { profileFingerprint } from './learning.js';
-import { buildProfile } from './voice-dna.js';
-import { canonicalJson } from './canonical-json.js';
-import { applyRewriteForMcp, prepareLifecycleForMcp, prepareRewriteForMcp } from './mcp-tools.js';
-function profileV3Json() {
-    const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
-    const unsigned = { ...profile, version: '3', id: 'founder.test', revision: 1, 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'] } };
-    const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(',')}]` : value && typeof value === 'object' ? `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}` : JSON.stringify(value);
-    return JSON.stringify({ ...unsigned, revisionDigest: createHash('sha256').update(canonical(unsigned)).digest('hex') });
-}
-async function callMcp(tools, env = process.env) {
-    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'], env });
-    let stdout = '';
-    let stderr = '';
-    server.stdout.on('data', (chunk) => { stdout += chunk; });
-    server.stderr.on('data', (chunk) => { stderr += chunk; });
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-    tools.forEach((tool, index) => server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: index + 2, method: 'tools/call', params: tool })}\n`));
-    server.stdin.end();
-    const [code] = await once(server, 'close');
-    assert.equal(code, 0);
-    assert.equal(stderr, '');
-    return stdout.trim().split('\n').map((line) => JSON.parse(line)).filter((response) => response.id >= 2).sort((a, b) => a.id - b.id);
-}
-function toolPayload(response) {
-    return JSON.parse(response.result?.content?.[0]?.text ?? '{}');
-}
-function installedContextEnvironment(root, context) {
-    const home = join(root, 'home');
-    const config = join(home, '.config', 'holdyourvoice');
-    mkdirSync(config, { recursive: true, mode: 0o700 });
-    const contextPath = join(config, 'approval-context.json');
-    writeFileSync(contextPath, canonicalJson(context), { mode: 0o600 });
-    chmodSync(contextPath, 0o600);
-    const fakeOs = join(root, 'fake-os.mjs');
-    const hooks = join(root, 'hooks.mjs');
-    const register = join(root, 'register.mjs');
-    writeFileSync(fakeOs, `import * as actual from 'node:os'; export const userInfo = () => ({ ...actual.userInfo(), homedir: process.env.HYV_TEST_HOME });\n`);
-    writeFileSync(hooks, `export async function resolve(specifier, context, nextResolve) { if (specifier === 'node:os' && context.parentURL?.endsWith('/approval-context.js')) return { url: new URL('./fake-os.mjs', import.meta.url).href, shortCircuit: true }; return nextResolve(specifier, context); }\n`);
-    writeFileSync(register, `import { register } from 'node:module'; register(new URL('./hooks.mjs', import.meta.url));\n`);
-    return { ...process.env, NODE_NO_WARNINGS: '1', NODE_OPTIONS: `--import=${register}`, HYV_TEST_HOME: home };
-}
-test('serves local Claude tools over stdio', async () => {
-    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    server.stdout.on('data', (chunk) => { stdout += chunk; });
-    server.stderr.on('data', (chunk) => { stderr += chunk; });
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })}\n`);
-    server.stdin.end();
-    const [code] = await once(server, 'close');
-    assert.equal(stderr, '');
-    assert.equal(code, 0);
-    const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
-    const tools = responses.find((response) => response.id === 2)?.result?.tools;
-    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_profile_assess', 'hyv_analyze', 'hyv_strict_check', 'hyv_score', 'hyv_backtest', 'hyv_evaluate_local', 'hyv_hygiene', 'hyv_inspect_hidden_text', 'hyv_apply_hidden_text_policy', 'hyv_final_check', 'hyv_delivery_check', 'hyv_fact_lint', 'hyv_mcp_capabilities', 'hyv_logic_lint', 'hyv_rewrite_prompt', 'hyv_find_writing_examples', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_prepare_judgment', 'hyv_reduce_judgment', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns', 'hyv_learning_inspect', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear', 'hyv_lifecycle_prepare_semantic', 'hyv_lifecycle_submit_verdict', 'hyv_lifecycle_inspect', 'hyv_lifecycle_finalize']);
-    assert.ok(tools?.filter((tool) => !['hyv_verify', 'hyv_verify_copy_spec', 'hyv_apply_hidden_text_policy', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear'].includes(tool.name)).every((tool) => tool.annotations?.readOnlyHint));
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_verify_copy_spec')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.some((tool) => tool.name === 'hyv_lifecycle_validate_final_approval'), false);
-    assert.equal(tools?.some((tool) => tool.name === 'hyv_learning_record_approved'), false);
-    assert.equal(tools?.some((tool) => tool.name === 'hyv_prepare_rebuild'), false);
-    assert.equal(tools?.some((tool) => tool.name === 'hyv_apply_rebuild'), false);
-    assert.equal('capability_json' in (tools?.find((tool) => tool.name === 'hyv_lifecycle_finalize')?.inputSchema?.properties ?? {}), false);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_inspect')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_inspect_hidden_text')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_logic_lint')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_fact_lint')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_mcp_capabilities')?.annotations?.readOnlyHint, true);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_apply_hidden_text_policy')?.annotations?.readOnlyHint, false);
-    assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_clear')?.annotations?.readOnlyHint, false);
-    assert.deepEqual(tools?.filter((tool) => tool.name.startsWith('hyv_learning_')).map((tool) => [tool.name, tool.annotations?.readOnlyHint, tool.annotations?.destructiveHint]), [
-        ['hyv_learning_inspect', true, undefined], ['hyv_learning_record', false, false], ['hyv_learning_ratify', false, false],
-        ['hyv_learning_supersede', false, true], ['hyv_learning_migrate', false, false], ['hyv_learning_clear', false, true],
-    ]);
-});
-test('registers capability tools only with host redaction attestation', async () => {
-    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'], env: { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' } });
-    let stdout = '';
-    let stderr = '';
-    server.stdout.on('data', (chunk) => { stdout += chunk; });
-    server.stderr.on('data', (chunk) => { stderr += chunk; });
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })}\n`);
-    server.stdin.end();
-    const [code] = await once(server, 'close');
-    assert.equal(code, 0);
-    assert.equal(stderr, '');
-    const response = stdout.trim().split('\n').map((line) => JSON.parse(line)).find((item) => item.id === 2);
-    const names = response.result.tools.map((tool) => tool.name);
-    assert.equal(names.length, 40);
-    assert.ok(names.includes('hyv_lifecycle_validate_final_approval'));
-    assert.ok(names.includes('hyv_learning_record_approved'));
-    assert.ok(names.includes('hyv_prepare_rebuild'));
-    assert.ok(names.includes('hyv_apply_rebuild'));
-    assert.ok(names.includes('hyv_rebuild_writer_request'));
-    const finalize = response.result.tools.find((tool) => tool.name === 'hyv_lifecycle_finalize');
-    assert.equal('capability_json' in finalize.inputSchema.properties, true);
-});
-test('redacts rebuild prepare transport failures', async () => {
-    const secret = 'rebuild-prepare-secret-nonce';
-    const responses = await callMcp([{ name: 'hyv_prepare_rebuild', arguments: { draft: 'x', profile_json: '{}', reduction_json: '{}', copy_spec_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
-    const serialized = JSON.stringify(responses[0]);
-    assert.equal(responses[0]?.result?.isError, true);
-    assert.doesNotMatch(serialized, new RegExp(secret));
-    assert.match(serialized, /Rebuild preparation failed/);
-});
-test('redacts rebuild apply transport failures', async () => {
-    const secret = 'rebuild-apply-secret-nonce';
-    const responses = await callMcp([{ name: 'hyv_apply_rebuild', arguments: { task_json: '{}', response_json: '{}', profile_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
-    const serialized = JSON.stringify(responses[0]);
-    assert.equal(responses[0]?.result?.isError, true);
-    assert.doesNotMatch(serialized, new RegExp(secret));
-    assert.match(serialized, /Rebuild application failed/);
-});
-test('redacts capability-bearing transport failures', async () => {
-    const secret = 'transport-secret-nonce';
-    const responses = await callMcp([{ name: 'hyv_lifecycle_validate_final_approval', arguments: { artifact_json: '{}', capability_json: JSON.stringify({ payload: secret, signature: secret }) } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' });
-    const serialized = JSON.stringify(responses[0]);
-    assert.equal(responses[0]?.result?.isError, true);
-    assert.doesNotMatch(serialized, new RegExp(secret));
-    assert.match(serialized, /Capability validation failed/);
-});
-test('runs registered lifecycle preparation and inspection over stdio', async () => {
-    const base = { 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 deterministic = { ...base, artifactFingerprint: createHash('sha256').update(`hyv:deterministic-verification:v1\0${canonicalJson(base)}`).digest('hex') };
-    const binding = { rewriteTaskFingerprint: '1'.repeat(64), rewriteResponseFingerprint: '2'.repeat(64), deterministicArtifactFingerprint: deterministic.artifactFingerprint, 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 preparedResponse = await callMcp([{ name: 'hyv_lifecycle_prepare_semantic', arguments: { deterministic_json: JSON.stringify(deterministic), binding_json: JSON.stringify(binding), receipt_json: JSON.stringify(receipt), policy: 'normal', allowed_violations: ['action_change'] } }], { ...process.env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '' });
-    const prepared = toolPayload(preparedResponse[0]);
-    assert.equal(prepared.artifact.status, 'needs_semantic_review');
-    const inspectedResponse = await callMcp([{ name: 'hyv_lifecycle_inspect', arguments: { artifact_json: JSON.stringify(prepared.artifact) } }]);
-    const inspected = toolPayload(inspectedResponse[0]);
-    assert.equal(inspected.artifactFingerprint, prepared.artifact.artifactFingerprint);
-    assert.doesNotMatch(JSON.stringify(inspected), /sourceHash|candidateHash|payload|signature|nonce/);
-});
-test('runs signed lifecycle and approved-learning replay through registered stdio tools', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-approved-'));
-    try {
-        const source = 'I leverage the answer with useful detail and clear mechanism.';
-        const candidate = 'I use the answer with useful detail and clear mechanism.';
-        const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
-        const profileJson = JSON.stringify(profile);
-        const rewriteTask = prepareRewriteForMcp(source, profileJson);
-        const evaluation = applyRewriteForMcp(JSON.stringify(rewriteTask), JSON.stringify({ version: '1', taskFingerprint: rewriteTask.fingerprint, replacements: [{ sentenceId: 1, text: candidate }] }), profileJson);
-        assert.equal(evaluation.status, 'needs_semantic_review');
-        const prepared = prepareLifecycleForMcp(JSON.stringify(evaluation.deterministicArtifact), JSON.stringify(evaluation.lifecycleBinding), JSON.stringify(evaluation.receipt), 'normal', []);
-        const { publicKey, privateKey } = generateKeyPairSync('ed25519');
-        const now = Math.floor(Date.now() / 1000);
-        const trustStore = { version: '1', audience: '@holdyourvoice/hyv', maxCapabilityLifetimeSeconds: 300, keys: [{ issuer: 'test-host', keyId: 'test-key', publicKeySpki: publicKey.export({ type: 'spki', format: 'der' }).toString('base64url'), status: 'active' }] };
-        const context = { now: 0, trustStore, authorizedSemanticEvaluatorIds: { normal: ['test-reviewer'], highAssurance: [] }, authorizedHumanFinalizerIds: ['test-human'] };
-        const env = { ...installedContextEnvironment(root, context), HYV_HOME: join(root, 'state'), HYV_MCP_SENSITIVE_INPUT_REDACTION: '1' };
-        const submittedResponse = await callMcp([{ name: 'hyv_lifecycle_submit_verdict', arguments: { artifact_json: JSON.stringify(prepared.artifact), task_json: JSON.stringify(prepared.task), evaluator_id: 'test-reviewer', verdict_json: JSON.stringify({ approved: true, violations: [] }) } }], env);
-        const ready = toolPayload(submittedResponse[0]);
-        assert.equal(ready.status, 'ready_for_human_review');
-        const rejectedResponse = await callMcp([{ name: 'hyv_lifecycle_finalize', arguments: { artifact_json: JSON.stringify(ready), decision_json: JSON.stringify({ evaluatorId: 'test-human', decision: 'reject' }) } }], { ...env, HYV_MCP_SENSITIVE_INPUT_REDACTION: '' });
-        const rejected = toolPayload(rejectedResponse[0]);
-        assert.equal(rejected.status, 'needs_escalation');
-        assert.equal(rejected.reason, 'human_rejection');
-        const binding = ready.binding;
-        const claims = { version: '1', purpose: 'hyv.final-approval', issuer: 'test-host', audience: '@holdyourvoice/hyv', subjectArtifactFingerprint: ready.artifactFingerprint, sourceHash: binding.sourceHash, candidateHash: binding.candidateHash, profileId: binding.profileId, profileRevisionDigest: binding.profileRevisionDigest, keyId: 'test-key', issuedAt: now - 1, notBefore: now - 1, expiresAt: now + 120, nonce: 'registered-secret-nonce' };
-        const payload = Buffer.from(canonicalJson(claims));
-        const capability = canonicalJson({ payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') });
-        const decision = JSON.stringify({ evaluatorId: 'test-human', decision: 'approve' });
-        const approvalResponses = await callMcp([
-            { name: 'hyv_lifecycle_validate_final_approval', arguments: { artifact_json: JSON.stringify(ready), capability_json: capability } },
-            { name: 'hyv_lifecycle_finalize', arguments: { artifact_json: JSON.stringify(ready), decision_json: decision, capability_json: capability } },
-        ], env);
-        assert.equal(toolPayload(approvalResponses[0]).ok, true);
-        const approved = toolPayload(approvalResponses[1]);
-        assert.equal(approved.status, 'approved');
-        const learningArguments = { ready_json: JSON.stringify(ready), approved_json: JSON.stringify(approved), original: source, candidate, profile_json: profileJson, decision_json: decision, capability_json: capability };
-        const learned = await callMcp([
-            { name: 'hyv_learning_record_approved', arguments: learningArguments },
-            { name: 'hyv_learning_record_approved', arguments: learningArguments },
-        ], env);
-        assert.equal(toolPayload(learned[0]).status, 'recorded');
-        assert.equal(toolPayload(learned[1]).status, 'nothing_to_learn');
-        const serialized = JSON.stringify({ submittedResponse, rejectedResponse, approvalResponses, learned });
-        assert.doesNotMatch(serialized, /registered-secret-nonce|payload|signature|I leverage|I use/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('runs the registered MCP learning lifecycle and rejects invalid profile versions', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-lifecycle-'));
-    try {
-        const env = { ...process.env, HYV_HOME: root };
-        const v2Json = JSON.stringify(buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']));
-        const v3Json = profileV3Json();
-        const first = await callMcp([
-            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Keep the mechanism concrete.', mutation_id: 'm1', authority: 'founder', provenance: 'review', weight: 2, compatibility: 'exact' } },
-            { name: 'hyv_learning_inspect', arguments: { profile_json: v3Json } },
-            { name: 'hyv_learning_record', arguments: { profile_json: v2Json, instruction: 'Keep the evidence named.', mutation_id: 'legacy-1' } },
-            { name: 'hyv_learning_migrate', arguments: { source_profile_json: v2Json, target_profile_json: v3Json, mutation_id: 'migration-1' } },
-            { name: 'hyv_learning_ratify', arguments: { profile_json: v2Json, event_id: 'invalid' } },
-            { name: 'hyv_learning_migrate', arguments: { source_profile_json: v3Json, target_profile_json: v2Json } },
-            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Invalid schema.', mutation_id: 'm'.repeat(201) } },
-        ], env);
-        const recorded = toolPayload(first[0]);
-        assert.equal(recorded.status, 'recorded');
-        assert.equal(toolPayload(first[1])[0].eventType, 'instruction');
-        assert.equal(toolPayload(first[2]).status, 'recorded');
-        assert.equal(toolPayload(first[3]).status, 'recorded');
-        assert.equal(first[4]?.result?.isError, true);
-        assert.equal(first[5]?.result?.isError, true);
-        assert.equal(first[6]?.result?.isError, true);
-        const second = await callMcp([
-            { name: 'hyv_learning_record', arguments: { profile_json: v3Json, instruction: 'Different instruction.', mutation_id: 'm1' } },
-            { name: 'hyv_learning_ratify', arguments: { profile_json: v3Json, event_id: recorded.eventId, mutation_id: 'm2', authority: 'founder' } },
-            { name: 'hyv_learning_supersede', arguments: { profile_json: v3Json, event_id: recorded.eventId, mutation_id: 'm3', authority: 'founder' } },
-            { name: 'hyv_learning_clear', arguments: { profile_json: v3Json } },
-            { name: 'hyv_learning_inspect', arguments: { profile_json: v3Json } },
-        ], env);
-        assert.equal(toolPayload(second[0]).status, 'conflict');
-        assert.equal(toolPayload(second[1]).status, 'recorded');
-        assert.equal(toolPayload(second[2]).status, 'recorded');
-        assert.equal(toolPayload(second[3]).cleared, true);
-        assert.deepEqual(toolPayload(second[4]), []);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('accepts empty text for profile-free hygiene inspection', async () => {
-    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
-    let stdout = '';
-    server.stdout.on('data', (chunk) => { stdout += chunk; });
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'hyv_hygiene', arguments: { draft: '' } } })}\n`);
-    server.stdin.end();
-    const [code] = await once(server, 'close');
-    assert.equal(code, 0);
-    const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
-    const report = JSON.parse(responses.find((response) => response.id === 2)?.result?.content?.[0]?.text ?? '{}');
-    assert.equal(report.suspiciousCount, 0);
-});
-test('gates exact final output through the registered profile-free MCP tool', async () => {
-    const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], { stdio: ['pipe', 'pipe', 'pipe'] });
-    let stdout = '';
-    server.stdout.on('data', (chunk) => { stdout += chunk; });
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'hyv_final_check', arguments: { text: 'Exact output.' } } })}\n`);
-    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'hyv_final_check', arguments: { text: 'Hidden\u200B output.' } } })}\n`);
-    server.stdin.end();
-    const [code] = await once(server, 'close');
-    assert.equal(code, 0);
-    const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
-    const accepted = JSON.parse(responses.find((response) => response.id === 2)?.result?.content?.[0]?.text ?? '{}');
-    const rejected = JSON.parse(responses.find((response) => response.id === 3)?.result?.content?.[0]?.text ?? '{}');
-    assert.equal(accepted.accepted, true);
-    assert.equal(accepted.output, 'Exact output.');
-    assert.equal(rejected.accepted, false);
-    assert.equal('output' in rejected, false);
-});
-test('keeps registered MCP verification read-only', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-server-'));
-    try {
-        const profile = buildProfile(['I write plainly. I name the work.', 'I keep the mechanism clear. I avoid filler.'], ['leverage']);
-        const server = spawn(process.execPath, [new URL('./cli.js', import.meta.url).pathname, 'mcp'], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: { ...process.env, HYV_HOME: root },
-        });
-        let stdout = '';
-        let stderr = '';
-        server.stdout.on('data', (chunk) => { stdout += chunk; });
-        server.stderr.on('data', (chunk) => { stderr += chunk; });
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'hyv_verify', arguments: { original: 'I leverage the answer with useful detail and clear mechanism.', candidate: 'I use the answer with useful detail and clear mechanism.', profile_json: JSON.stringify(profile) } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'hyv_rewrite_prompt', arguments: { draft: 'I use the answer with useful detail and clear mechanism.', profile_json: JSON.stringify(profile) } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 4, method: 'tools/call', params: { name: 'hyv_analyze', arguments: { draft: 'A pattern I keep seeing in founder posts is vague advice.\u200B', profile_json: JSON.stringify(profile), writing_brief_json: JSON.stringify({ version: '1', audience: 'founders', intent: 'start a discussion', format: 'social' }) } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'hyv_batch_analyze', arguments: { drafts: ['The launch needs a clear owner.', 'The launch needs a clear owner.'] } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 6, method: 'tools/call', params: { name: 'hyv_analyze', arguments: { draft: 'Plain draft.', profile_json: JSON.stringify(profile), writing_brief_json: '{' } } })}\n`);
-        server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 7, method: 'tools/call', params: { name: 'hyv_hygiene', arguments: { draft: 'Plain\u200B draft.' } } })}\n`);
-        server.stdin.end();
-        const [code] = await once(server, 'close');
-        assert.equal(stderr, '');
-        assert.equal(code, 0);
-        const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
-        const prompt = JSON.parse(responses.find((response) => response.id === 3)?.result?.content?.[0]?.text ?? '{}').prompt;
-        const contextual = JSON.parse(responses.find((response) => response.id === 4)?.result?.content?.[0]?.text ?? '{}');
-        const batch = JSON.parse(responses.find((response) => response.id === 5)?.result?.content?.[0]?.text ?? '{}');
-        const malformed = responses.find((response) => response.id === 6)?.result;
-        const hygiene = JSON.parse(responses.find((response) => response.id === 7)?.result?.content?.[0]?.text ?? '{}');
-        assert.doesNotMatch(prompt, /Learned local preferences/);
-        assert.equal(contextual.editorial.findings[0].id, 'editorial.social.generic-opener');
-        assert.equal(contextual.hygiene.suspiciousCount, 1);
-        assert.deepEqual(batch.findings.map((finding) => finding.id), ['batch.repeated-opening', 'batch.repeated-ending']);
-        assert.equal(malformed?.isError, true);
-        assert.equal(hygiene.suspiciousCount, 1);
-        assert.equal(existsSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`)), false);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});