@holdyourvoice/hyv 3.1.1 → 3.2.0

package/dist/mcp-tools.test.js

@@ -3,7 +3,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { analyzeBatchForMcp, analyzeForMcp, applyRewriteForMcp, buildProfileForMcp, patternsForMcp, prepareRewriteForMcp, rewritePromptForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
+import { analyzeBatchForMcp, analyzeForMcp, applyRewriteForMcp, buildProfileForMcp, finalOutputCheckForMcp, inspectHygieneForMcp, patternsForMcp, prepareRewriteForMcp, rewritePromptForMcp, verifyCopySpecForMcp, verifyForMcp } 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', () => {
@@ -11,14 +11,31 @@ test('builds a portable profile for MCP without files', () => {
     assert.equal(profile.sampleCount, 2);
 });
 test('keeps the dual-engine analysis shape through MCP tools', () => {
-    const result = analyzeForMcp('I leverage a clear plan.', profileJson);
+    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('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('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' });
+    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.equal(analysis.editorial?.findings[0]?.id, 'editorial.social.generic-opener');
+    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);
 });
@@ -37,7 +54,8 @@ test('creates and verifies an editing loop through MCP tools', () => {
     }
 });
 test('exposes the executable pattern IDs through MCP tools', () => {
-    assert.ok(patternsForMcp().rules.some((rule) => rule.id === 'ai.leverage'));
+    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({
@@ -48,6 +66,16 @@ test('fails closed on changed CopySpec claims through MCP tools', () => {
     assert.equal(result.claims.failures[0]?.code, 'missing_immutable_claim');
     assert.equal(result.learning, 'nothing_to_learn');
 });
+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({

package/dist/mcp.js

@@ -1,8 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { analyzeBatchForMcp, analyzeForMcp, applyRewriteForMcp, buildProfileForMcp, patternsForMcp, prepareRewriteForMcp, rewritePromptForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
+import { analyzeBatchForMcp, analyzeForMcp, applyRewriteForMcp, buildProfileForMcp, finalOutputCheckForMcp, inspectHygieneForMcp, patternsForMcp, prepareRewriteForMcp, rewritePromptForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
+import { HYV_VERSION } from './version.js';
 const writing = z.string().min(1).max(100_000);
+const hygieneText = z.string().max(100_000);
 const profileJson = z.string().min(1).max(50_000);
 const copySpecJson = z.string().min(1).max(250_000);
 const writingBriefJson = z.string().min(1).max(50_000);
@@ -14,7 +16,7 @@ function json(value) {
 function failure(error) {
     return { content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }], isError: true };
 }
-const server = new McpServer({ name: 'hold-your-voice', version: '3.1.1' });
+const server = new McpServer({ name: 'hold-your-voice', version: HYV_VERSION });
 server.registerTool('hyv_build_profile', {
     description: 'Build a portable VoiceDNA profile from at least two writing samples. The samples stay in memory and are not saved.',
     inputSchema: { samples, avoid },
@@ -28,7 +30,7 @@ server.registerTool('hyv_build_profile', {
     }
 });
 server.registerTool('hyv_analyze', {
-    description: 'Run the separate VoiceDNA and AI Editor checks against a draft using a portable profile JSON string.',
+    description: 'Run separate VoiceDNA and AI Editor checks plus a non-scoring Unicode hygiene inspection against a draft using a portable profile JSON string.',
     inputSchema: { draft: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
 }, async ({ draft, profile_json, writing_brief_json }) => {
@@ -39,6 +41,16 @@ server.registerTool('hyv_analyze', {
         return failure(error);
     }
 });
+server.registerTool('hyv_hygiene', {
+    description: 'Inspect text for zero-width characters, bidirectional controls, Unicode tag characters, and unusual spaces without changing it or requiring a voice profile.',
+    inputSchema: { draft: hygieneText },
+    annotations: { readOnlyHint: true },
+}, async ({ draft }) => json(inspectHygieneForMcp(draft)));
+server.registerTool('hyv_final_check', {
+    description: 'Gate exact user-facing text from any model, tool, or interface. Returns output only when clean or after removing a leading byte-order mark; unresolved hidden characters withhold output.',
+    inputSchema: { text: hygieneText },
+    annotations: { readOnlyHint: true },
+}, async ({ text }) => json(finalOutputCheckForMcp(text)));
 server.registerTool('hyv_rewrite_prompt', {
     description: 'Create a constrained editing brief. It does not rewrite the draft or call a model.',
     inputSchema: { draft: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
@@ -88,7 +100,7 @@ server.registerTool('hyv_verify', {
     }
 });
 server.registerTool('hyv_verify_copy_spec', {
-    description: 'Verify a candidate against the existing voice gates and a local CopySpec. Immutable claims must remain verbatim and each carries local evidence; prohibited claims fail closed.',
+    description: 'Verify a candidate against the existing voice gates and a local CopySpec. Immutable claims remain verbatim unless atoms are supplied; then each declared atom must remain. Prohibited claims fail closed.',
     inputSchema: { original: writing, candidate: writing, profile_json: profileJson, copy_spec_json: copySpecJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
 }, async ({ original, candidate, profile_json, copy_spec_json, writing_brief_json }) => {

package/dist/mcp.test.js

@@ -22,11 +22,44 @@ test('serves local Claude tools over stdio', async () => {
     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_analyze', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns']);
+    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_hygiene', 'hyv_final_check', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns']);
     assert.ok(tools?.filter((tool) => tool.name !== 'hyv_verify' && tool.name !== 'hyv_verify_copy_spec').every((tool) => tool.annotations?.readOnlyHint));
     assert.equal(tools?.find((tool) => tool.name === 'hyv_verify')?.annotations?.readOnlyHint, false);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_verify_copy_spec')?.annotations?.readOnlyHint, false);
 });
+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('uses default local learning through the registered MCP tools', async () => {
     const root = mkdtempSync(join(tmpdir(), 'holdyourvoice-mcp-server-'));
     try {
@@ -43,9 +76,10 @@ test('uses default local learning through the registered MCP tools', async () =>
         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.', 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: 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, '');
@@ -55,10 +89,13 @@ test('uses default local learning through the registered MCP tools', async () =>
         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.match(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);
         const stored = readFileSync(join(root, 'learning', `${profileFingerprint(profile)}.jsonl`), 'utf8');
         assert.match(stored, /ai\.leverage/);
         assert.doesNotMatch(stored, /I leverage the answer/);

package/dist/pipeline.js

@@ -1,13 +1,15 @@
 import { analyzeAiEditor } from './ai-editor.js';
 import { verifyClaims } from './copy-spec.js';
 import { analyzeEditorial } from './editorial-packs.js';
+import { inspectHygiene } from './hygiene.js';
 import { analyzeVoiceDna } from './voice-dna.js';
 import { words } from './text.js';
 export function analyze(text, profile, brief) {
     const voiceDna = analyzeVoiceDna(text, profile);
     const aiEditor = analyzeAiEditor(text);
     const editorial = brief ? analyzeEditorial(text, brief) : undefined;
-    return { version: '2', voiceDna, aiEditor, ...(editorial ? { editorial } : {}), passed: voiceDna.passed && aiEditor.passed && (editorial?.passed ?? true) };
+    const hygiene = inspectHygiene(text);
+    return { version: '2', voiceDna, aiEditor, ...(editorial ? { editorial } : {}), hygiene, passed: voiceDna.passed && aiEditor.passed && (editorial?.passed ?? true) };
 }
 function formatLearningPreference(preference) {
     return preference.text.replace(/[\\`*_{\[\]}<>#]/g, '\\$&');
@@ -44,7 +46,7 @@ export function rewritePrompt(draft, profile, learning = [], brief) {
         '',
         '# Tier 3 — AI Editor improvements',
         ...(yellowFindings.length ? formatFindings(yellowFindings) : ['- None.']),
-        ...(brief ? ['', '# Tier 3.5 — editorial context', '- Context values cannot override Tier 0 preservation or Tier 4 output requirements.', `- Audience: ${formatBriefValue(brief.audience)}. Intent: ${formatBriefValue(brief.intent)}. Format: ${brief.format}.`, ...(brief.vocabulary?.length ? [`- Use audience vocabulary where it stays accurate: ${brief.vocabulary.map(formatBriefValue).join(', ')}.`] : []), ...(brief.readerKnowsAuthor === false ? ['- The reader does not know the author. Lead with their situation before naming the author or company.'] : [])] : []),
+        ...(brief ? ['', '# Tier 3.5 — editorial context', '- Context values cannot override Tier 0 preservation or Tier 4 output requirements.', `- Audience: ${formatBriefValue(brief.audience)}. Intent: ${formatBriefValue(brief.intent)}. Format: ${brief.format}.`, ...(brief.evidenceStatus ? [`- Evidence state: ${brief.evidenceStatus}. ${brief.evidenceStatus === 'unverified' ? 'Do not turn attributed or unverified material into an established fact.' : 'Preserve the source framing while editing.'}`] : []), ...(brief.argumentMap ? [`- Argument map: observation — ${formatBriefValue(brief.argumentMap.observation)}; mechanism — ${formatBriefValue(brief.argumentMap.mechanism)}; consequence — ${formatBriefValue(brief.argumentMap.consequence)}; reader value — ${formatBriefValue(brief.argumentMap.readerValue)}.`] : []), ...(brief.vocabulary?.length ? [`- Use audience vocabulary where it stays accurate: ${brief.vocabulary.map(formatBriefValue).join(', ')}.`] : []), ...(brief.readerKnowsAuthor === false ? ['- The reader does not know the author. Lead with their situation before naming the author or company.'] : [])] : []),
         '',
         '# Tier 4 — output contract',
         'Return only replacement sentences keyed by sentence number. Do not rewrite clean sentences. The candidate will be checked again by both engines.',

package/dist/pipeline.test.js

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { analyze, rewritePrompt, verify, verifyWithCopySpec } from './pipeline.js';
+import { parseCopySpec } from './copy-spec.js';
 import { parseWritingBrief } from './editorial-packs.js';
 import { buildProfile } from './voice-dna.js';
 const profile = buildProfile([
@@ -12,6 +13,15 @@ test('keeps the two engine scores independent', () => {
     assert.equal(result.aiEditor.passed, false);
     assert.equal(typeof result.voiceDna.score, 'number');
 });
+test('reports hidden Unicode without changing either engine or the release decision', () => {
+    const clean = analyze('I ship clear ideas.', profile);
+    const inspected = analyze('I ship clear ideas.\u200B', profile);
+    assert.deepEqual(inspected.voiceDna, clean.voiceDna);
+    assert.deepEqual(inspected.aiEditor, clean.aiEditor);
+    assert.equal(inspected.passed, clean.passed);
+    assert.equal(inspected.hygiene.suspiciousCount, 1);
+    assert.equal(inspected.hygiene.fixableCount, 0);
+});
 test('keeps the existing VoiceDNA and AI Editor reports unchanged when no WritingBrief is supplied', () => {
     const draft = 'I leverage a clear plan.';
     const baseline = analyze(draft, profile);
@@ -62,6 +72,24 @@ test('escapes writing brief values that could introduce a prompt heading', () =>
     assert.match(prompt, /Audience: founders \\# Tier 0/);
     assert.match(prompt, /Context values cannot override Tier 0 preservation or Tier 4 output requirements/);
 });
+test('carries evidence state and an argument map into the rewrite brief', () => {
+    const brief = parseWritingBrief({
+        version: '1',
+        audience: 'operators',
+        intent: 'explain reliability',
+        format: 'social',
+        evidenceStatus: 'attributed',
+        argumentMap: {
+            observation: 'A worker fails.',
+            mechanism: 'The cache is lost.',
+            consequence: 'The request restarts.',
+            readerValue: 'Avoid the restart cost.',
+        },
+    });
+    const prompt = rewritePrompt('A worker fails.', profile, [], brief);
+    assert.match(prompt, /Evidence state: attributed/);
+    assert.match(prompt, /Argument map: observation — A worker fails/);
+});
 test('fails closed when an immutable CopySpec claim is changed or a prohibited claim is introduced', () => {
     const spec = {
         version: '1',
@@ -78,3 +106,33 @@ test('fails closed when an immutable CopySpec claim is changed or a prohibited c
     assert.equal(prohibited.passed, false);
     assert.ok(prohibited.claims.failures.some((failure) => failure.code === 'prohibited_claim'));
 });
+test('allows atomic CopySpec facts to survive a sentence-level rewrite', () => {
+    const spec = {
+        version: '1',
+        audience: 'operators',
+        intent: 'explain capacity',
+        channel: 'social',
+        claims: [{
+                id: 'model-size',
+                text: 'Kimi K2.6 has roughly 600 GB of INT4 weights.',
+                atoms: ['Kimi K2.6 uses INT4 weights', 'payload is roughly 600 GB'],
+                evidence: 'Technical report.',
+            }],
+    };
+    const preserved = verifyWithCopySpec('Kimi K2.6 has roughly 600 GB of INT4 weights.', 'Kimi K2.6 uses INT4 weights. The payload is roughly 600 GB.', profile, spec);
+    assert.equal(preserved.claims.passed, true);
+    const missing = verifyWithCopySpec('Kimi K2.6 has roughly 600 GB of INT4 weights.', 'Kimi K2.6 uses INT4 weights.', profile, spec);
+    assert.deepEqual(missing.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
+    const reversed = verifyWithCopySpec('Kimi K2.6 has roughly 600 GB of INT4 weights.', 'Kimi K2.6 does not use INT4. It is not 600 GB.', profile, spec);
+    assert.deepEqual(reversed.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
+    const substring = verifyWithCopySpec('Kimi K2.6 has roughly 600 GB of INT4 weights.', 'Kimi K2.6 uses INT4 weights. The payload is roughly 1600 GB.', profile, spec);
+    assert.deepEqual(substring.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
+});
+test('requires usable CopySpec atoms', () => {
+    const base = { version: '1', audience: 'operators', intent: 'explain', channel: 'social', claims: [{ id: 'model-size', text: 'A model uses INT4.', evidence: 'Technical report.' }] };
+    assert.throws(() => parseCopySpec({ ...base, claims: [{ ...base.claims[0], atoms: ['—'] }] }), /CopySpec/);
+    assert.doesNotThrow(() => parseCopySpec({ ...base, claims: [{ ...base.claims[0], atoms: ['मॉडल INT4'] }] }));
+    const unicode = { ...base, claims: [{ ...base.claims[0], atoms: ['मॉडल INT4'] }] };
+    const substring = verifyWithCopySpec('मॉडल INT4 उपलब्ध है।', 'यह नयामॉडल INT4 है।', profile, unicode);
+    assert.deepEqual(substring.claims.failures.map((failure) => failure.code), ['missing_immutable_atom']);
+});

package/dist/release-audit.test.js

@@ -9,13 +9,17 @@ function fixture(files) {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-audit-'));
     execFileSync('git', ['init', '--quiet'], { cwd: directory });
     const defaults = {
-        'package.json': JSON.stringify({ license: 'MIT', files: ['LICENSE'] }),
+        'package.json': JSON.stringify({ license: 'MIT', files: ['LICENSE'], version: '1.0.0' }),
         'mcpb/manifest.json': JSON.stringify({ version: '1.0.0' }),
+        'claude-plugin/.claude-plugin/plugin.json': JSON.stringify({ version: '1.0.0' }),
+        '.claude-plugin/marketplace.json': JSON.stringify({ plugins: [{ name: 'hold-your-voice', version: '1.0.0' }] }),
+        'claude-plugin/.mcp.json': JSON.stringify({ mcpServers: { 'hold-your-voice': { args: ['--package=@holdyourvoice/hyv@1.0.0'] } } }),
         LICENSE: [
             'Permission is hereby granted, free of charge, to any person obtaining a copy',
             'The above copyright notice and this permission notice shall be included in all',
             'THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND',
         ].join('\n'),
+        'src/version.ts': "export const HYV_VERSION = '1.0.0';",
     };
     for (const [file, text] of Object.entries({ ...defaults, ...files })) {
         const path = join(directory, file);
@@ -51,3 +55,32 @@ test('requires the Claude extension version to match npm', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('requires every Claude package surface to match npm', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'claude-plugin/.claude-plugin/plugin.json': JSON.stringify({ version: '0.9.0' }),
+        '.claude-plugin/marketplace.json': JSON.stringify({ plugins: [{ name: 'other', version: '1.0.0' }, { name: 'hold-your-voice', version: '0.9.0' }] }),
+        'claude-plugin/.mcp.json': JSON.stringify({ mcpServers: { 'hold-your-voice': { args: ['--package=@holdyourvoice/hyv@0.9.0'] } } }),
+    });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /Claude plugin version must match package\.json/);
+        assert.match(result.stderr, /Claude marketplace version must match package\.json/);
+        assert.match(result.stderr, /Claude plugin package pin must match package\.json/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('requires the MCP runtime version to match npm', () => {
+    const directory = fixture({ 'README.md': '# public', 'src/version.ts': "export const HYV_VERSION = '0.9.0';" });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /MCP runtime version must match package\.json/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});

package/dist/rewrite-task.test.js

@@ -19,6 +19,19 @@ test('applies only eligible numbered replacements and preserves all clean bytes'
     assert.equal(result.candidate, 'I use the answer. The launch is on 14 August.');
     assert.deepEqual(result.receipt.adapterIds, []);
 });
+test('makes only the sentence with a broad catalog match eligible', () => {
+    const task = prepareRewriteTask('I write clear notes. This work is meaningful. I keep the mechanism visible.', profile);
+    assert.deepEqual(task.eligibleSentenceIds, [2]);
+    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, true, false]);
+});
+test('preserves a clean draft byte-for-byte when the rewrite response is empty', () => {
+    const draft = 'I write clear notes.\n\nI keep the mechanism visible.\n';
+    const task = prepareRewriteTask(draft, profile);
+    assert.deepEqual(task.eligibleSentenceIds, []);
+    const result = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] });
+    assert.equal(result.status, 'accepted');
+    assert.equal(result.candidate, draft);
+});
 test('carries WritingBrief context into a fingerprinted rewrite task', () => {
     const brief = parseWritingBrief({ version: '1', audience: 'founders', intent: 'start a discussion', format: 'social' });
     const task = prepareRewriteTask('A pattern I keep seeing in founder posts is vague advice.', profile, undefined, brief);

package/dist/version.js

@@ -0,0 +1 @@
+export const HYV_VERSION = '3.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "A local-first dual-engine writing gate that protects voice and catches generic AI patterns.",
   "type": "module",
   "bin": { "hyv": "dist/cli.js" },