@holdyourvoice/hyv 3.3.5 → 3.4.1

package/dist/mcp.js

@@ -35,31 +35,33 @@ function failure(error) {
 function lifecycleResult(result) {
     return json(result.ok ? result.artifact : { error: result.error });
 }
+function guardedJson(run, publicError) {
+    try {
+        return json(run());
+    }
+    catch (error) {
+        return failure(publicError ? new Error(publicError) : error);
+    }
+}
+function guardedLifecycle(run, publicError) {
+    try {
+        return lifecycleResult(run());
+    }
+    catch (error) {
+        return failure(publicError ? new Error(publicError) : error);
+    }
+}
 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 },
     annotations: { readOnlyHint: true },
-}, async ({ samples: writingSamples, avoid: phrases }) => {
-    try {
-        return json(buildProfileForMcp(writingSamples, phrases));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ samples: writingSamples, avoid: phrases }) => guardedJson(() => buildProfileForMcp(writingSamples, phrases)));
 server.registerTool('hyv_analyze', {
     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 }) => {
-    try {
-        return json(analyzeForMcp(draft, profile_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => analyzeForMcp(draft, profile_json, writing_brief_json)));
 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 },
@@ -82,50 +84,22 @@ server.registerTool('hyv_logic_lint', {
     description: 'Run the deterministic document-coherence gate. It detects configured topic drift, unanchored inference, and direct internal contradictions; it does not verify facts or approve publication.',
     inputSchema: { draft: writing, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, writing_brief_json }) => {
-    try {
-        return json(logicLintForMcp(draft, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, writing_brief_json }) => guardedJson(() => logicLintForMcp(draft, writing_brief_json)));
 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() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, profile_json, writing_brief_json }) => {
-    try {
-        return json(rewritePromptForMcp(draft, profile_json, {}, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => rewritePromptForMcp(draft, profile_json, {}, writing_brief_json)));
 server.registerTool('hyv_prepare_rewrite', {
     description: 'Prepare a local, versioned rewrite task. The caller may forward it to a provider; doing so shares the draft and must be an explicit choice.',
     inputSchema: { draft: writing, profile_json: profileJson, copy_spec_json: copySpecJson.optional(), writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, profile_json, copy_spec_json, writing_brief_json }) => {
-    try {
-        return json(prepareRewriteForMcp(draft, profile_json, copy_spec_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, profile_json, copy_spec_json, writing_brief_json }) => guardedJson(() => prepareRewriteForMcp(draft, profile_json, copy_spec_json, writing_brief_json)));
 server.registerTool('hyv_apply_rewrite', {
     description: 'Validate and apply a model response to a prepared task, then run the local gates. It never calls a provider or stores source or candidate text.',
     inputSchema: { task_json: z.string().min(1).max(250_000), response_json: z.string().min(1).max(100_000), profile_json: profileJson },
     annotations: { readOnlyHint: true },
-}, async ({ task_json, response_json, profile_json }) => {
-    try {
-        return json(applyRewriteForMcp(task_json, response_json, profile_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ task_json, response_json, profile_json }) => guardedJson(() => applyRewriteForMcp(task_json, response_json, profile_json)));
 server.registerTool('hyv_prepare_judgment', {
     description: 'Prepare a versioned pre-edit or post-candidate judgment task. It does not call a model.',
     inputSchema: {
@@ -136,62 +110,27 @@ server.registerTool('hyv_prepare_judgment', {
         candidate: writing.optional(),
     },
     annotations: { readOnlyHint: true },
-}, async ({ stage, kind, draft, profile_json, candidate }) => {
-    try {
-        return json(prepareJudgmentForMcp(stage, kind, draft, profile_json, candidate));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ stage, kind, draft, profile_json, candidate }) => guardedJson(() => prepareJudgmentForMcp(stage, kind, draft, profile_json, candidate)));
 server.registerTool('hyv_reduce_judgment', {
     description: 'Reduce bound judgment envelopes into SHIP, EDIT, REBUILD, CLEAR, or ESCALATE. It does not call a model.',
     inputSchema: { envelopes_json: z.string().min(1).max(250_000) },
     annotations: { readOnlyHint: true },
-}, async ({ envelopes_json }) => {
-    try {
-        return json(reduceJudgmentForMcp(envelopes_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ envelopes_json }) => guardedJson(() => reduceJudgmentForMcp(envelopes_json)));
 server.registerTool('hyv_verify', {
     description: 'Verify a revised candidate against an original draft and portable profile without changing learning state.',
     inputSchema: { original: writing, candidate: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async ({ original, candidate, profile_json, writing_brief_json }) => {
-    try {
-        return json(verifyForMcp(original, candidate, profile_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ original, candidate, profile_json, writing_brief_json }) => guardedJson(() => verifyForMcp(original, candidate, profile_json, writing_brief_json)));
 server.registerTool('hyv_verify_copy_spec', {
     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: true, destructiveHint: false, openWorldHint: false },
-}, async ({ original, candidate, profile_json, copy_spec_json, writing_brief_json }) => {
-    try {
-        return json(verifyCopySpecForMcp(original, candidate, profile_json, copy_spec_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ original, candidate, profile_json, copy_spec_json, writing_brief_json }) => guardedJson(() => verifyCopySpecForMcp(original, candidate, profile_json, copy_spec_json, writing_brief_json)));
 server.registerTool('hyv_batch_analyze', {
     description: 'Inspect two to one hundred drafts for repeated opening and closing sentences. It returns advisory batch findings and does not store the drafts.',
     inputSchema: { drafts: z.array(writing).min(2).max(100) },
     annotations: { readOnlyHint: true },
-}, async ({ drafts }) => {
-    try {
-        return json(analyzeBatchForMcp(drafts));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ drafts }) => guardedJson(() => analyzeBatchForMcp(drafts)));
 server.registerTool('hyv_patterns', {
     description: 'List the exact AI Editor rules that run in this extension.',
     inputSchema: {},
@@ -200,116 +139,56 @@ server.registerTool('hyv_patterns', {
 server.registerTool('hyv_learning_inspect', {
     description: 'Inspect profile-scoped learning receipts without returning stored instruction or draft text.',
     inputSchema: { profile_json: profileJson }, annotations: { readOnlyHint: true },
-}, async ({ profile_json }) => { try {
-    return json(inspectLearningForMcp(profile_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ profile_json }) => guardedJson(() => inspectLearningForMcp(profile_json)));
 server.registerTool('hyv_learning_record', {
     description: 'Record an explicit profile-scoped learning instruction with authority and provenance metadata.',
     inputSchema: { profile_json: profileJson, instruction: z.string().min(1).max(240), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(recordLearningForMcp(args.profile_json, args.instruction, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => recordLearningForMcp(args.profile_json, args.instruction, learningArgs(args))));
 server.registerTool('hyv_learning_ratify', {
     description: 'Ratify a learning event for a Profile v3 revision.',
     inputSchema: { profile_json: profileJson, event_id: z.string().min(1).max(200), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(ratifyLearningForMcp(args.profile_json, args.event_id, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => ratifyLearningForMcp(args.profile_json, args.event_id, learningArgs(args))));
 server.registerTool('hyv_learning_supersede', {
     description: 'Supersede a learning event for a Profile v3 revision.',
     inputSchema: { profile_json: profileJson, event_id: z.string().min(1).max(200), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-}, async (args) => { try {
-    return json(supersedeLearningForMcp(args.profile_json, args.event_id, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => supersedeLearningForMcp(args.profile_json, args.event_id, learningArgs(args))));
 server.registerTool('hyv_learning_migrate', {
     description: 'Migrate Profile v2 learning into a Profile v3 identity.',
     inputSchema: { source_profile_json: profileJson, target_profile_json: profileJson, ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(migrateLearningForMcp(args.source_profile_json, args.target_profile_json, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => migrateLearningForMcp(args.source_profile_json, args.target_profile_json, learningArgs(args))));
 server.registerTool('hyv_learning_clear', {
     description: 'Delete all local learning state for a profile.',
     inputSchema: { profile_json: profileJson }, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-}, async ({ profile_json }) => { try {
-    return json(clearLearningForMcp(profile_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ profile_json }) => guardedJson(() => clearLearningForMcp(profile_json)));
 server.registerTool('hyv_lifecycle_prepare_semantic', {
     description: 'Prepare a normal semantic-review task and its initial immutable lifecycle artifact.',
     inputSchema: { deterministic_json: lifecycleJson, binding_json: lifecycleJson, receipt_json: lifecycleJson, policy: z.literal('normal'), allowed_violations: z.array(semanticViolation).max(5) },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(prepareLifecycleForMcp(args.deterministic_json, args.binding_json, args.receipt_json, args.policy, args.allowed_violations));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => prepareLifecycleForMcp(args.deterministic_json, args.binding_json, args.receipt_json, args.policy, args.allowed_violations)));
 server.registerTool('hyv_lifecycle_submit_verdict', {
     description: 'Submit one normal-policy semantic verdict using the server-installed evaluator authorization context.',
     inputSchema: { artifact_json: lifecycleJson, task_json: lifecycleJson, evaluator_id: evaluatorId, verdict_json: lifecycleJson },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return lifecycleResult(submitSemanticVerdictForMcp(args.artifact_json, args.task_json, args.evaluator_id, args.verdict_json, loadApprovalContext()));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedLifecycle(() => submitSemanticVerdictForMcp(args.artifact_json, args.task_json, args.evaluator_id, args.verdict_json, loadApprovalContext())));
 server.registerTool('hyv_lifecycle_inspect', {
     description: 'Validate and inspect an immutable lifecycle artifact without exposing bound source or candidate hashes.',
     inputSchema: { artifact_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async ({ artifact_json }) => { try {
-    return json(inspectLifecycleForMcp(artifact_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ artifact_json }) => guardedJson(() => inspectLifecycleForMcp(artifact_json)));
 if (redactsSensitiveInputs) {
     server.registerTool('hyv_lifecycle_finalize', {
         description: 'Finalize an authorized human approval or rejection. Capability input requires host-guaranteed sensitive-input redaction.',
         inputSchema: { artifact_json: lifecycleJson, decision_json: lifecycleJson, capability_json: lifecycleJson.optional() },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return lifecycleResult(finalizeLifecycleForMcp(args.artifact_json, args.decision_json, loadApprovalContext(), args.capability_json));
-    }
-    catch {
-        return failure(new Error('Lifecycle finalization failed.'));
-    } });
+    }, async (args) => guardedLifecycle(() => finalizeLifecycleForMcp(args.artifact_json, args.decision_json, loadApprovalContext(), args.capability_json), 'Lifecycle finalization failed.'));
     server.registerTool('hyv_lifecycle_validate_final_approval', {
         description: 'Validate a final-approval capability against the server-installed trust context.',
         inputSchema: { artifact_json: lifecycleJson, capability_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return json(validateFinalApprovalForMcp(args.artifact_json, args.capability_json, loadApprovalContext()));
-    }
-    catch {
-        return failure(new Error('Capability validation failed.'));
-    } });
+    }, async (args) => guardedJson(() => validateFinalApprovalForMcp(args.artifact_json, args.capability_json, loadApprovalContext()), 'Capability validation failed.'));
     server.registerTool('hyv_learning_record_approved', {
         description: 'Record one approval-revalidated, deterministic, text-free learning event.',
         inputSchema: { ready_json: lifecycleJson, approved_json: lifecycleJson, original: approvedLearningText, candidate: approvedLearningText, profile_json: profileJson, decision_json: lifecycleJson, capability_json: lifecycleJson, copy_spec_json: copySpecJson.optional(), writing_brief_json: writingBriefJson.optional() },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return json({ status: recordApprovedLearningForMcp({ readyJson: args.ready_json, approvedJson: args.approved_json, source: args.original, candidate: args.candidate, profileJson: args.profile_json, decisionJson: args.decision_json, capabilityJson: args.capability_json, context: loadApprovalContext(), copySpecJson: args.copy_spec_json, writingBriefJson: args.writing_brief_json }) });
-    }
-    catch {
-        return failure(new Error('Approved learning was not authorized.'));
-    } });
+    }, async (args) => guardedJson(() => ({ status: recordApprovedLearningForMcp({ readyJson: args.ready_json, approvedJson: args.approved_json, source: args.original, candidate: args.candidate, profileJson: args.profile_json, decisionJson: args.decision_json, capabilityJson: args.capability_json, context: loadApprovalContext(), copySpecJson: args.copy_spec_json, writingBriefJson: args.writing_brief_json }) }), 'Approved learning was not authorized.'));
     server.registerTool('hyv_prepare_rebuild', {
         description: 'Prepare a rebuild task only after an upstream REBUILD recommendation, CopySpec, and signed rebuild-authorization capability. Capability input requires host-guaranteed sensitive-input redaction.',
         inputSchema: {
@@ -322,49 +201,21 @@ if (redactsSensitiveInputs) {
             recomposition_policy_json: lifecycleJson.optional(),
         },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => {
-        try {
-            return json(prepareRebuildForMcp(args.draft, args.profile_json, args.reduction_json, args.copy_spec_json, args.capability_json, loadApprovalContext(), args.writing_brief_json, args.recomposition_policy_json));
-        }
-        catch {
-            return failure(new Error('Rebuild preparation failed.'));
-        }
-    });
+    }, async (args) => guardedJson(() => prepareRebuildForMcp(args.draft, args.profile_json, args.reduction_json, args.copy_spec_json, args.capability_json, loadApprovalContext(), args.writing_brief_json, args.recomposition_policy_json), 'Rebuild preparation failed.'));
     server.registerTool('hyv_apply_rebuild', {
         description: 'Validate and evaluate a whole-document rebuild response against a prepared authorized rebuild task. Capability input requires host-guaranteed sensitive-input redaction. It never calls a provider.',
         inputSchema: { task_json: lifecycleJson, response_json: z.string().min(1).max(100_000), profile_json: profileJson, capability_json: lifecycleJson },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => {
-        try {
-            return json(applyRebuildForMcp(args.task_json, args.response_json, args.profile_json, args.capability_json, loadApprovalContext()));
-        }
-        catch {
-            return failure(new Error('Rebuild application failed.'));
-        }
-    });
+    }, async (args) => guardedJson(() => applyRebuildForMcp(args.task_json, args.response_json, args.profile_json, args.capability_json, loadApprovalContext()), 'Rebuild application failed.'));
     server.registerTool('hyv_rebuild_writer_request', {
         description: 'Create the writer-only payload for a prepared rebuild. It excludes source draft, capability, profile body, and validation evidence.',
         inputSchema: { task_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async ({ task_json }) => {
-        try {
-            return json(rebuildWriterRequestForMcp(task_json));
-        }
-        catch {
-            return failure(new Error('Writer request could not be prepared.'));
-        }
-    });
+    }, async ({ task_json }) => guardedJson(() => rebuildWriterRequestForMcp(task_json), 'Writer request could not be prepared.'));
 }
 else {
     server.registerTool('hyv_lifecycle_finalize', {
         description: 'Record an authorized human rejection. Approval is unavailable because this host does not guarantee sensitive-input redaction.',
         inputSchema: { artifact_json: lifecycleJson, decision_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => {
-        try {
-            return lifecycleResult(finalizeRejectionForMcp(args.artifact_json, args.decision_json, loadApprovalContext()));
-        }
-        catch {
-            return failure(new Error('Only rejection is available without sensitive-input redaction.'));
-        }
-    });
+    }, async (args) => guardedLifecycle(() => finalizeRejectionForMcp(args.artifact_json, args.decision_json, loadApprovalContext()), 'Only rejection is available without sensitive-input redaction.'));
 }
 await server.connect(new StdioServerTransport());

package/dist/rebuild-task.test.js

@@ -174,7 +174,7 @@ test('CLI and MCP rebuild helpers share fingerprints', () => {
         version: '1', audience: 'operators', intent: 'explain', format: 'outreach',
     });
     assert.match(briefTask.prompt, /# WritingBrief/);
-    assert.equal(HYV_VERSION, '3.3.5');
+    assert.equal(HYV_VERSION, '3.4.1');
 });
 test('apply rejects forged tasks, missing capability, and substituted profiles', () => {
     const reduction = rebuildRecommendation();

package/dist/release-audit.test.js

@@ -23,7 +23,7 @@ function fixture(files) {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-audit-'));
     execFileSync('git', ['init', '--quiet'], { cwd: directory });
     const defaults = {
-        'package.json': JSON.stringify({ name: 'audit-fixture', license: 'MIT', files: ['dist', 'Readme.md', 'LICENSE'], scripts: { 'stage1:evaluate': 'node scripts/evaluate-rewrite-benchmark.mjs', 'stage1:dry-run': 'npm run build && node scripts/run-stage1-dry-run.mjs', 'stage1:human-packet': 'npm run build && node scripts/run-stage1-human-packet.mjs', 'stage2:human-packet': 'npm run build && node scripts/run-stage2-human-packet.mjs' }, version: '1.0.0', type: 'module', bin: { hyv: 'dist/cli.js' }, engines: { node: '>=20' } }),
+        'package.json': JSON.stringify({ name: 'audit-fixture', license: 'MIT', files: ['dist', 'skills', 'Readme.md', 'LICENSE'], scripts: { 'stage1:evaluate': 'node scripts/evaluate-rewrite-benchmark.mjs', 'stage1:dry-run': 'npm run build && node scripts/run-stage1-dry-run.mjs', 'stage1:human-packet': 'npm run build && node scripts/run-stage1-human-packet.mjs', 'stage2:human-packet': 'npm run build && node scripts/run-stage2-human-packet.mjs' }, version: '1.0.0', type: 'module', bin: { hyv: 'dist/cli.js' }, engines: { node: '>=20' } }),
         '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' }] }),
@@ -36,6 +36,9 @@ function fixture(files) {
         ].join('\n'),
         'src/version.ts': "export const HYV_VERSION = '1.0.0';",
         'src/stage1-evaluation.ts': "const baseline = '4e6269121d551c008a34db73077e1e4fea41b3f9'; const stage1 = '550ea24f652291dca13757fdbd2f0fa0b5e3f621';",
+        'skills/hyv-test/agent.json': '{}',
+        'skills/hyv-test/SKILL.md': '# test',
+        'skills/hyv-test/agents/openai.yaml': 'name: test',
         ...Object.fromEntries(stage1Files.map((file) => [file, '{}'])),
     };
     for (const [file, text] of Object.entries({ ...defaults, ...files })) {
@@ -146,6 +149,7 @@ test('requires the npm package runtime contract', () => {
         const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
         assert.notEqual(result.status, 0);
         assert.match(result.stderr, /npm package must include dist/);
+        assert.match(result.stderr, /npm package must include skills/);
         assert.match(result.stderr, /npm package must include Readme\.md/);
         assert.match(result.stderr, /npm package must use the ESM runtime contract/);
         assert.match(result.stderr, /npm hyv binary must point to dist\/cli\.js/);

package/dist/stage1-evaluation.js

@@ -432,77 +432,103 @@ export function sealRatings(packetInput, mappingInput, ratingsInput) {
     const base = { kind: 'hyv-stage1-ratings-seal', version: '1', protocolDigest: packet.protocolDigest, candidateDigest: packet.candidateDigest, packetDigest: packet.packetDigest, mappingDigest: packet.mappingDigest, ratingsDigest: sha256Canonical(ratings), recordCount: ratings.length };
     return { ...base, sealDigest: sha256Canonical(base) };
 }
-export function reduceEvaluation(protocolInput, runsInput, packetInput, mappingInput, ratingsInput, sealInput, releaseAuditInput) {
-    const protocol = assertCommittedProtocol(protocolInput);
-    const summary = validateRuns(protocol, runsInput);
-    const packet = parsePacket(packetInput);
+function validateEvaluationPacket(protocol, runs, summary, packet) {
     if (packet.protocolDigest !== protocol.protocolDigest || packet.candidateDigest !== candidateDigest(protocol) || packet.runsDigest !== summary.runsDigest)
         fail('packet_digest_chain_mismatch');
-    const runRows = runsInput;
-    const expectedReviewableCount = protocol.cases.filter((entry) => runRows.filter((run) => run.caseId === entry.caseId && effectiveRunOutcome(run) === 'completed').length === 2).length;
-    if (packet.reviewableCount !== expectedReviewableCount || packet.nonReviewableCount !== protocol.cases.length - expectedReviewableCount)
+    const reviewableCount = protocol.cases.filter((entry) => runs.filter((run) => run.caseId === entry.caseId && effectiveRunOutcome(run) === 'completed').length === 2).length;
+    if (packet.reviewableCount !== reviewableCount || packet.nonReviewableCount !== protocol.cases.length - reviewableCount)
         fail('blind_packet_count_mismatch');
-    const mapping = parseMapping(mappingInput);
-    validateMappingOpening(protocol, mapping);
-    const ratings = validateReviewerLog(protocol, packet, ratingsInput, true);
-    const seal = sealRatings(packet, mapping, ratings);
-    if (sha256Canonical(seal) !== sha256Canonical(sealInput))
-        fail('ratings_seal_mismatch');
-    const audit = record(releaseAuditInput);
+}
+function parseReleaseAudit(protocol, input) {
+    const audit = record(input);
     exactKeys(audit, ['kind', 'version', 'candidateCommit', 'protocolDigest', 'contractDigest', 'passed', 'digest']);
     const { digest: auditDigest, ...auditCore } = audit;
     if (auditDigest !== sha256Canonical(auditCore))
         fail('release_audit_digest_mismatch');
     if (audit.kind !== 'hyv-release-audit' || audit.version !== '1' || audit.candidateCommit !== protocol.stage1.sourceCommit || audit.protocolDigest !== protocol.protocolDigest || audit.contractDigest !== protocol.releaseAuditContractDigest || audit.passed !== true)
         fail('release_audit_binding_mismatch');
+    return audit;
+}
+function correctionCount(ratings, mapping, arm, result) {
+    const label = mapping.labels.A === arm ? 'A' : 'B';
+    return ratings.filter((rating) => rating.correctionVersusConfirm[label] === result).length;
+}
+function workflowForArm(runs, arm) {
+    const armRuns = runs.filter((run) => run.arm === arm);
+    return { completed: armRuns.filter((run) => effectiveRunOutcome(run) === 'completed').length, denominator: armRuns.length };
+}
+function calculateEvaluation(protocol, runs, ratings, mapping, summary) {
+    const completedRatings = ratings.filter((rating) => rating.workflow === 'completed');
+    const preferenceDenominator = protocol.intentToTreat.expectedReviewers * protocol.cases.length;
+    const preferred = completedRatings.reduce((total, rating) => total + (rating.preferredLabel === 'tie' ? 0.5 : mapping.labels[rating.preferredLabel] === 'stage1' ? 1 : 0), 0);
+    const preferenceRate = preferenceDenominator ? preferred / preferenceDenominator : 0;
+    const stage1Confirm = correctionCount(completedRatings, mapping, 'stage1', 'confirm');
+    const baselineConfirm = correctionCount(completedRatings, mapping, 'baseline', 'confirm');
+    const stage1Correction = correctionCount(completedRatings, mapping, 'stage1', 'correction');
+    const baselineCorrection = correctionCount(completedRatings, mapping, 'baseline', 'correction');
+    const baselineWorkflow = workflowForArm(runs, 'baseline');
+    const stage1Workflow = workflowForArm(runs, 'stage1');
+    const correctionMarginMet = (stage1Confirm - baselineConfirm) / preferenceDenominator >= protocol.analysis.margin;
+    const workflowRegressed = stage1Workflow.denominator === 0 || baselineWorkflow.denominator === 0 || stage1Workflow.completed / stage1Workflow.denominator < baselineWorkflow.completed / baselineWorkflow.denominator;
+    const metrics = {
+        preference: { numerator: preferred, denominator: preferenceDenominator, rate: preferenceRate, uncertainty95: wilson95(preferred, preferenceDenominator) },
+        correctionVersusConfirm: { stage1: { corrections: stage1Correction, confirms: stage1Confirm, denominator: preferenceDenominator, correctionRate: stage1Correction / preferenceDenominator, uncertainty95: wilson95(stage1Correction, preferenceDenominator) }, baseline: { corrections: baselineCorrection, confirms: baselineConfirm, denominator: preferenceDenominator, correctionRate: baselineCorrection / preferenceDenominator, uncertainty95: wilson95(baselineCorrection, preferenceDenominator) } },
+        completion: { numerator: completedRatings.length, denominator: preferenceDenominator, rate: completedRatings.length / preferenceDenominator, uncertainty95: wilson95(completedRatings.length, preferenceDenominator) },
+        abandonment: { numerator: ratings.length - completedRatings.length, denominator: preferenceDenominator, rate: (ratings.length - completedRatings.length) / preferenceDenominator, uncertainty95: wilson95(ratings.length - completedRatings.length, preferenceDenominator) },
+        providerRuns: { completed: summary.completed, abandoned: summary.abandonments, hardFailures: summary.hardFailures, timeouts: summary.timeouts, denominator: summary.denominator },
+    };
+    return { correctionMarginMet, metrics, preferenceDenominator, preferenceRate, workflowRegressed };
+}
+function mappingCustodyIsValid(protocol, packet, mapping) {
+    const { attestation, ...openingCore } = mapping;
+    try {
+        validateAttestation(attestation, sha256Canonical(openingCore), protocol.protocolDigest, packet.packetDigest);
+        return attestation.purpose === 'stage1-mapping-custody';
+    }
+    catch {
+        return false;
+    }
+}
+function evaluationBlockers(protocol, runs, packet, ratings, mapping, calculation) {
     const blockers = ['human_writer_evidence_deferred'];
-    if (protocol.benchmark.synthetic || ratings.some((r) => r.evidenceClass === 'synthetic-dry-run'))
+    if (protocol.benchmark.synthetic || ratings.some((rating) => rating.evidenceClass === 'synthetic-dry-run'))
         blockers.push('synthetic_fixture_evidence');
     if (protocol.mode !== 'locked-human')
         blockers.push('locked_human_evidence_required');
     if (protocol.mode === 'locked-human') {
         blockers.push('reviewer_roster_verification_deferred');
-        const { attestation, ...openingCore } = mapping;
-        try {
-            validateAttestation(attestation, sha256Canonical(openingCore), protocol.protocolDigest, packet.packetDigest);
-            if (attestation.purpose !== 'stage1-mapping-custody')
-                throw new Error('purpose');
-        }
-        catch {
+        if (!mappingCustodyIsValid(protocol, packet, mapping))
             blockers.push('mapping_custody_attestation_required');
-        }
     }
-    if (ratings.length !== protocol.intentToTreat.expectedReviewers * protocol.cases.length)
+    if (ratings.length !== calculation.preferenceDenominator)
         blockers.push('reviewer_denominator_mismatch');
     if (protocol.cases.length < protocol.analysis.minimumCases || ratings.length < protocol.analysis.minimumRatings)
         blockers.push('preregistered_minimum_not_met');
-    if (runsInput.some((run) => run.hardGates && Object.values(run.hardGates).some((passed) => !passed)))
+    if (runs.some((run) => run.hardGates && Object.values(run.hardGates).some((passed) => !passed)))
         blockers.push('hard_gate_regression');
-    const completedRatings = ratings.filter((rating) => rating.workflow === 'completed');
-    const preferred = completedRatings.reduce((total, rating) => total + (rating.preferredLabel === 'tie' ? 0.5 : mapping.labels[rating.preferredLabel] === 'stage1' ? 1 : 0), 0);
-    const preferenceDenominator = protocol.intentToTreat.expectedReviewers * protocol.cases.length;
-    const preferenceRate = preferenceDenominator ? preferred / preferenceDenominator : 0;
-    const stage1Confirm = completedRatings.filter((rating) => rating.correctionVersusConfirm[mapping.labels.A === 'stage1' ? 'A' : 'B'] === 'confirm').length;
-    const baselineConfirm = completedRatings.filter((rating) => rating.correctionVersusConfirm[mapping.labels.A === 'baseline' ? 'A' : 'B'] === 'confirm').length;
-    const correctionMarginMet = (stage1Confirm - baselineConfirm) / preferenceDenominator >= protocol.analysis.margin;
-    if (preferenceRate < 0.5 + protocol.analysis.margin && !correctionMarginMet)
+    if (calculation.preferenceRate < 0.5 + protocol.analysis.margin && !calculation.correctionMarginMet)
         blockers.push('checkpoint_threshold_not_met');
-    const workflowByArm = (arm) => ({ completed: runRows.filter((run) => run.arm === arm && effectiveRunOutcome(run) === 'completed').length, denominator: runRows.filter((run) => run.arm === arm).length });
-    const baselineWorkflow = workflowByArm('baseline');
-    const stage1Workflow = workflowByArm('stage1');
-    if (stage1Workflow.denominator === 0 || baselineWorkflow.denominator === 0 || stage1Workflow.completed / stage1Workflow.denominator < baselineWorkflow.completed / baselineWorkflow.denominator)
+    if (calculation.workflowRegressed)
         blockers.push('workflow_regression');
-    const stage1Correction = completedRatings.filter((rating) => rating.correctionVersusConfirm[mapping.labels.A === 'stage1' ? 'A' : 'B'] === 'correction').length;
-    const baselineCorrection = completedRatings.filter((rating) => rating.correctionVersusConfirm[mapping.labels.A === 'baseline' ? 'A' : 'B'] === 'correction').length;
-    const metrics = {
-        preference: { numerator: preferred, denominator: preferenceDenominator, rate: preferenceRate, uncertainty95: wilson95(preferred, preferenceDenominator) },
-        correctionVersusConfirm: { stage1: { corrections: stage1Correction, confirms: stage1Confirm, denominator: preferenceDenominator, correctionRate: stage1Correction / preferenceDenominator, uncertainty95: wilson95(stage1Correction, preferenceDenominator) }, baseline: { corrections: baselineCorrection, confirms: baselineConfirm, denominator: preferenceDenominator, correctionRate: baselineCorrection / preferenceDenominator, uncertainty95: wilson95(baselineCorrection, preferenceDenominator) } },
-        completion: { numerator: completedRatings.length, denominator: preferenceDenominator, rate: completedRatings.length / preferenceDenominator, uncertainty95: wilson95(completedRatings.length, preferenceDenominator) },
-        abandonment: { numerator: ratings.length - completedRatings.length, denominator: preferenceDenominator, rate: (ratings.length - completedRatings.length) / preferenceDenominator, uncertainty95: wilson95(ratings.length - completedRatings.length, preferenceDenominator) },
-        providerRuns: { completed: summary.completed, abandoned: summary.abandonments, hardFailures: summary.hardFailures, timeouts: summary.timeouts, denominator: summary.denominator },
-    };
-    const intentToTreat = { ...summary, expectedRatings: preferenceDenominator, observedRatings: ratings.length, missingRatings: Math.max(0, preferenceDenominator - ratings.length), reconciled: summary.denominator === protocol.intentToTreat.expectedAssignments && ratings.length === preferenceDenominator };
-    const base = { kind: 'hyv-stage1-evaluation-report', version: '1', protocolDigest: protocol.protocolDigest, candidateDigest: candidateDigest(protocol), runsDigest: summary.runsDigest, packetDigest: packet.packetDigest, mappingDigest: packet.mappingDigest, sealDigest: seal.sealDigest, releaseAuditDigest: audit.digest, intentToTreat, metrics, decision: blockers.length ? 'BLOCKED' : 'PASS', promotable: blockers.length === 0, blockers };
+    return blockers;
+}
+export function reduceEvaluation(protocolInput, runsInput, packetInput, mappingInput, ratingsInput, sealInput, releaseAuditInput) {
+    const protocol = assertCommittedProtocol(protocolInput);
+    const summary = validateRuns(protocol, runsInput);
+    const runs = runsInput;
+    const packet = parsePacket(packetInput);
+    validateEvaluationPacket(protocol, runs, summary, packet);
+    const mapping = parseMapping(mappingInput);
+    validateMappingOpening(protocol, mapping);
+    const ratings = validateReviewerLog(protocol, packet, ratingsInput, true);
+    const seal = sealRatings(packet, mapping, ratings);
+    if (sha256Canonical(seal) !== sha256Canonical(sealInput))
+        fail('ratings_seal_mismatch');
+    const audit = parseReleaseAudit(protocol, releaseAuditInput);
+    const calculation = calculateEvaluation(protocol, runs, ratings, mapping, summary);
+    const blockers = evaluationBlockers(protocol, runs, packet, ratings, mapping, calculation);
+    const intentToTreat = { ...summary, expectedRatings: calculation.preferenceDenominator, observedRatings: ratings.length, missingRatings: Math.max(0, calculation.preferenceDenominator - ratings.length), reconciled: summary.denominator === protocol.intentToTreat.expectedAssignments && ratings.length === calculation.preferenceDenominator };
+    const base = { kind: 'hyv-stage1-evaluation-report', version: '1', protocolDigest: protocol.protocolDigest, candidateDigest: candidateDigest(protocol), runsDigest: summary.runsDigest, packetDigest: packet.packetDigest, mappingDigest: packet.mappingDigest, sealDigest: seal.sealDigest, releaseAuditDigest: audit.digest, intentToTreat, metrics: calculation.metrics, decision: blockers.length ? 'BLOCKED' : 'PASS', promotable: blockers.length === 0, blockers };
     return { ...base, reportDigest: sha256Canonical(base) };
 }
 export function preflight(protocolInput) {

package/dist/version.js

@@ -1 +1 @@
-export const HYV_VERSION = '3.3.5';
+export const HYV_VERSION = '3.4.1';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "3.3.5",
+  "version": "3.4.1",
   "description": "A local-first dual-engine writing gate that protects voice and catches generic AI patterns.",
   "type": "module",
   "bin": { "hyv": "dist/cli.js" },
-  "files": ["dist", "Readme.md", "LICENSE"],
-  "scripts": { "build": "tsc -p tsconfig.json", "bundle:claude": "esbuild src/mcp.ts --bundle --platform=node --format=esm --target=node20 --outfile=mcpb/server/index.js", "build:claude": "npm run build && npm run bundle:claude", "pack:claude": "npm run build:claude && node scripts/pack-claude.mjs", "stage1:evaluate": "node scripts/evaluate-rewrite-benchmark.mjs", "stage1:dry-run": "npm run build && node scripts/run-stage1-dry-run.mjs", "stage1:human-packet": "npm run build && node scripts/run-stage1-human-packet.mjs", "stage2:human-packet": "npm run build && node scripts/run-stage2-human-packet.mjs", "test": "npm run build && node --test dist/**/*.test.js", "check:release": "node scripts/release-audit.mjs", "prepack": "npm run check:release && npm test" },
+  "files": ["dist", "skills", "Readme.md", "LICENSE"],
+  "scripts": { "build": "tsc -p tsconfig.json", "bundle:claude": "esbuild src/mcp.ts --bundle --platform=node --format=esm --target=node20 --outfile=mcpb/server/index.js", "build:claude": "npm run build && npm run bundle:claude", "pack:claude": "npm run build:claude && node scripts/pack-claude.mjs", "stage1:evaluate": "node scripts/evaluate-rewrite-benchmark.mjs", "stage1:dry-run": "npm run build && node scripts/run-stage1-dry-run.mjs", "stage1:human-packet": "npm run build && node scripts/run-stage1-human-packet.mjs", "stage2:human-packet": "npm run build && node scripts/run-stage2-human-packet.mjs", "test": "npm run build && node --test \"dist/**/*.test.js\"", "check:release": "node scripts/release-audit.mjs", "prepack": "npm run check:release && npm test" },
   "engines": { "node": ">=20" },
   "license": "MIT",
   "keywords": ["ai-writing", "cli", "editing", "voice", "writing"],

package/skills/hyv-analyze/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: hyv-analyze
+description: Run separate VoiceDNA and AI Editor checks plus a non-scoring Unicode hygiene inspection against a draft.
+---
+
+# hyv-analyze
+
+Run independent VoiceDNA and AI Editor reports plus a separate non-scoring Unicode hygiene report against a draft using a portable profile. An optional WritingBrief adds local audience, intent, and format context without changing the profile. Analysis is read-only; it never rewrites the draft or calls a model.
+
+## Usage
+
+```text
+hyv analyze draft.md profile.json [writing-brief.json]
+```
+
+## Behavior
+
+- Deterministic and local-first: this command never calls a provider and never sends drafts, samples, profiles, or telemetry to a service.
+- Commands that write use an explicit output path. Confirm that path before running the command.
+- This agent describes how to invoke the command and what it returns. It does not change command behavior or exit codes.
+
+## Handoff
+
+Run `hyv analyze` directly to execute the operation. Follow-on agents: hyv-rewrite-prompt, hyv-prepare-rewrite.