@holdyourvoice/hyv 3.6.1 → 4.0.1

package/dist/voice-dna.js

@@ -16,12 +16,18 @@ function top(items, limit) {
         counts.set(item, (counts.get(item) ?? 0) + 1);
     return [...counts].sort((left, right) => right[1] - left[1]).slice(0, limit).map(([item]) => item);
 }
+function measureWriting(text, tokens) {
+    const mapped = sentences(text);
+    return { text, mapped, tokens: tokens ?? words(text), sentenceWords: mapped.map((sentence) => words(sentence.text)) };
+}
 export function profileMetrics(text) {
-    const draftSentences = sentences(text);
-    const draftWords = words(text);
-    const lengths = draftSentences.map((sentence) => words(sentence.text).length);
-    const starters = draftSentences.map((sentence) => words(sentence.text)[0]?.toLowerCase() ?? '');
-    const structures = draftSentences.map((sentence) => words(sentence.text).slice(0, 3).map((word) => word.toLowerCase()).join(' '));
+    return metricsFor(measureWriting(text));
+}
+function metricsFor(writing) {
+    const { text, mapped: draftSentences, tokens: draftWords, sentenceWords } = writing;
+    const lengths = sentenceWords.map((tokens) => tokens.length);
+    const starters = sentenceWords.map((tokens) => tokens[0]?.toLowerCase() ?? '');
+    const structures = sentenceWords.map((tokens) => tokens.slice(0, 3).map((word) => word.toLowerCase()).join(' '));
     const lowerWords = draftWords.map((word) => word.toLowerCase());
     const nonStop = lowerWords.filter((word) => word.length > 3 && !STOP_WORDS.has(word));
     const first = lowerWords.filter((word) => ['i', 'we', 'my', 'our', 'us'].includes(word)).length;
@@ -52,17 +58,18 @@ export function profileMetrics(text) {
     };
 }
 export function measureFounderFingerprint(text) {
-    const draftWords = words(text);
+    return fingerprintFor(measureWriting(text, words(text)));
+}
+function fingerprintFor(writing) {
+    const { text, mapped: draftSentences, tokens: draftWords, sentenceWords } = writing;
     const wordDenominator = Math.max(1, draftWords.length);
     const contractionCount = draftWords.filter((word) => CONTRACTIONS.has(word.toLowerCase().replaceAll('’', "'"))).length;
-    const draftSentences = sentences(text);
     const sentenceDenominator = Math.max(1, draftSentences.length);
     const buckets = { short: 0, medium: 0, long: 0 };
-    for (const sentence of draftSentences) {
-        const length = words(sentence.text).length;
-        if (length <= 8)
+    for (const tokens of sentenceWords) {
+        if (tokens.length <= 8)
             buckets.short += 1;
-        else if (length <= 20)
+        else if (tokens.length <= 20)
             buckets.medium += 1;
         else
             buckets.long += 1;
@@ -81,16 +88,21 @@ export function measureFounderFingerprint(text) {
         enDashRate: (text.match(/–/g) ?? []).length / wordDenominator,
     };
 }
-export function buildProfile(samples, avoid = []) {
+function measureSamples(samples, avoid) {
     if (samples.length < 2)
         throw new Error('Provide at least two local writing samples.');
     if (samples.some((sample) => !words(sample).length))
         throw new Error('Every local writing sample must contain writing.');
-    return { version: '2', sampleCount: samples.length, metrics: profileMetrics(samples.join('\n\n')), avoid };
+    const writing = measureWriting(samples.join('\n\n'));
+    const profile = { version: '2', sampleCount: samples.length, metrics: metricsFor(writing), avoid };
+    return { writing, profile };
+}
+export function buildProfile(samples, avoid = []) {
+    return measureSamples(samples, avoid).profile;
 }
 export function buildProfileV3(samples, id, channel, avoid = [], tone) {
-    const base = buildProfile(samples, avoid);
-    const sampleText = samples.join('\n\n');
+    const { profile: base, writing } = measureSamples(samples, avoid);
+    const ruleAllowances = deriveRuleAllowances(samples);
     const fixtureIds = samples.map((_, index) => 'sample.' + String(index + 1).padStart(3, '0'));
     const unsigned = {
         version: '3',
@@ -101,10 +113,10 @@ export function buildProfileV3(samples, id, channel, avoid = [], tone) {
         avoid: base.avoid,
         provenance: { source: 'local-author-owned-samples', rights: 'author-owned', createdAt: new Date().toISOString() },
         rulePolicy: {},
-        ...(Object.keys(deriveRuleAllowances(samples)).length ? { ruleAllowances: deriveRuleAllowances(samples) } : {}),
+        ...(Object.keys(ruleAllowances).length ? { ruleAllowances } : {}),
         channel,
         ...(tone ? { tone } : {}),
-        fingerprint: measureFounderFingerprint(sampleText),
+        fingerprint: fingerprintFor(writing),
         tolerances: {
             contractionRate: { absolute: 0.1, calibrated: false },
             sentenceLengthDistribution: { absolute: 0.15, calibrated: false },
@@ -121,11 +133,12 @@ function finding(id, severity, sentence, excerpt, reason, suggestion) {
     return { engine: 'voice_dna', id, severity, sentence, excerpt, reason, suggestion };
 }
 export function analyzeVoiceDna(text, profile) {
-    const metrics = profileMetrics(text);
+    const writing = measureWriting(text);
+    const metrics = metricsFor(writing);
     const findings = [];
     const tolerance = Math.max(8, profile.metrics.sentenceVariation * 2.2);
-    for (const sentence of sentences(text)) {
-        const count = words(sentence.text).length;
+    for (const [index, sentence] of writing.mapped.entries()) {
+        const count = writing.sentenceWords[index].length;
         if (Math.abs(count - profile.metrics.sentenceLength) > tolerance)
             findings.push(finding('dna.sentence-length', 'yellow', sentence.index, sentence.text, `Sentence length (${count}) is outside the profile band around ${profile.metrics.sentenceLength}.`, 'Restore the writer’s usual sentence length where it improves clarity.'));
         for (const banned of profile.avoid)
@@ -139,7 +152,7 @@ export function analyzeVoiceDna(text, profile) {
     if (metrics.pointOfView !== profile.metrics.pointOfView && profile.metrics.pointOfView !== 'mixed')
         findings.push(finding('dna.point-of-view', 'yellow', 1, text.slice(0, 160), `Draft point of view is ${metrics.pointOfView}; profile is ${profile.metrics.pointOfView}.`, 'Restore the writer’s normal narrative distance.'));
     if (profile.version === '3') {
-        const measured = measureFounderFingerprint(text);
+        const measured = fingerprintFor(writing);
         const fingerprintChecks = [
             ['contraction-rate', measured.contractionRate, profile.fingerprint.contractionRate, profile.tolerances.contractionRate],
             ['sentence-length-distribution', Math.max(Math.abs(measured.sentenceLengthDistribution.short - profile.fingerprint.sentenceLengthDistribution.short), Math.abs(measured.sentenceLengthDistribution.medium - profile.fingerprint.sentenceLengthDistribution.medium), Math.abs(measured.sentenceLengthDistribution.long - profile.fingerprint.sentenceLengthDistribution.long)), 0, profile.tolerances.sentenceLengthDistribution],

package/dist/writing-examples.js

@@ -31,19 +31,14 @@ function validate(inputs) {
 function indexExamples(inputs) {
     const entries = inputs.flatMap((input) => sentences(input.text).map((sentence, position) => ({ source: input.basename, position, text: sentence.text, terms: tokens(sentence.text) })));
     const postings = new Map();
-    const documentFrequency = new Map();
     for (const [entryIndex, entry] of entries.entries()) {
-        const seen = new Set();
         for (const term of entry.terms) {
             const posting = postings.get(term) ?? new Map();
             posting.set(entryIndex, (posting.get(entryIndex) ?? 0) + 1);
             postings.set(term, posting);
-            seen.add(term);
         }
-        for (const term of seen)
-            documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
     }
-    return { entries, postings, documentFrequency };
+    return { entries, postings };
 }
 /** Finds redacted local examples in supplied memory only; it never creates a corpus or index on disk. */
 export function findWritingExamples(query, inputs, limit = 3) {
@@ -58,7 +53,7 @@ export function findWritingExamples(query, inputs, limit = 3) {
         const posting = index.postings.get(term);
         if (!posting)
             continue;
-        const idf = Math.log(1 + (index.entries.length - (index.documentFrequency.get(term) ?? 0) + 0.5) / ((index.documentFrequency.get(term) ?? 0) + 0.5));
+        const idf = Math.log(1 + (index.entries.length - posting.size + 0.5) / (posting.size + 0.5));
         for (const [entryIndex, frequency] of posting) {
             const entry = index.entries[entryIndex];
             const denominator = frequency + 1.2 * (1 - 0.75 + 0.75 * entry.terms.length / Math.max(1, averageLength));

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "3.6.1",
-  "description": "A local-first dual-engine writing gate that protects voice and catches generic AI patterns.",
+  "version": "4.0.1",
+  "description": "Local writing checks, voice profiles, and verified editing workflows for humans and agents.",
   "type": "module",
   "bin": {
     "hyv": "dist/cli.js"
   },
   "files": [
     "dist",
+    "!dist/**/*.test.js",
     "skills",
     "Readme.md",
     "LICENSE"
@@ -17,6 +18,7 @@
     "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",
+    "pack:chatgpt-plugin": "node scripts/pack-chatgpt-plugin.mjs",
     "scorecard": "node scripts/public-scorecard.mjs benchmarks",
     "validate:rule-contributions": "node scripts/validate-rule-contributions.mjs",
     "stage1:evaluate": "node scripts/evaluate-rewrite-benchmark.mjs",
@@ -25,7 +27,8 @@
     "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 && npm run pack:claude"
+    "prepack": "npm run check:release && npm test && npm run pack:claude",
+    "check:compatibility": "node scripts/verify-compatibility.mjs"
   },
   "engines": {
     "node": ">=20"

package/skills/hyv-prepare-judgment/SKILL.md

@@ -19,6 +19,10 @@ hyv prepare-judgment pre-edit|post-candidate kind draft.md profile.json task.jso
 - 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.
 
+## Word economy review
+
+For a post-candidate form judgment, review whether every word earns its place before final verification and delivery. Name the phrase and sentence range, propose a cut, and explain why meaning, evidence, clarity, and voice survive it. Preserve necessary uncertainty, attribution, emphasis, rhythm, and transitions. Do not use a word-count target. Record unresolved cuts as findings and use ESCALATE; do not return CLEAR merely because the candidate is shorter. Report concerns outside the authorized edit scope without changing text. The local command prepares the task; it does not perform this editorial judgment.
+
 ## Handoff
 
 Run `hyv prepare-judgment` directly to execute the operation. Follow-on agents: hyv-reduce-judgment.

package/dist/agents/catalog.test.js

@@ -1,60 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { resolveHost, listHosts, runtime } from './catalog.js';
-import { AGENT_SCHEMA_VERSION } from './types.js';
-function minimalDescriptor(id, permissions) {
-    return {
-        schema_version: AGENT_SCHEMA_VERSION,
-        id,
-        title: id,
-        description: 'test',
-        instruction_file: 'SKILL.md',
-        role: 'Tester',
-        workflow_phase: 'test',
-        input: { required: ['draft'], optional: [] },
-        output: { required: ['report'], optional: [] },
-        evidence_requirements: ['evidence'],
-        permissions,
-        stop_conditions: ['stop'],
-        tool_free_mode: { available: true, behavior: 'report', unavailable_statuses: ['NOT_AVAILABLE'] },
-        handoff_to: [],
-    };
-}
-test('resolves known hosts and falls back to generic for unknown ids', () => {
-    assert.equal(resolveHost('codex').id, 'codex');
-    assert.equal(resolveHost('future-ide').id, 'generic');
-    assert.equal(resolveHost('future-ide').native_skills, false);
-    assert.equal(resolveHost('future-ide').cli, true);
-});
-test('catalog has unique host ids and includes generic', () => {
-    const hosts = listHosts();
-    const ids = hosts.map((host) => host.id);
-    assert.ok(ids.includes('generic'));
-    assert.equal(new Set(ids).size, ids.length);
-});
-test('runtime marks unsupported permissions unavailable and switches to prompt-only', () => {
-    const descriptor = minimalDescriptor('hyv-verify', ['read_repository', 'network', 'subagents']);
-    const resolved = runtime(descriptor, 'generic');
-    assert.deepEqual(resolved.available_capabilities, []);
-    assert.deepEqual(resolved.unavailable_capabilities, [
-        { capability: 'read_repository', status: 'NOT_AVAILABLE' },
-        { capability: 'network', status: 'NOT_AVAILABLE' },
-        { capability: 'subagents', status: 'NOT_AVAILABLE' },
-    ]);
-    assert.equal(resolved.execution_mode, 'prompt-only');
-});
-test('runtime uses native mode when the host supports every permission', () => {
-    const descriptor = minimalDescriptor('hyv-verify', ['read_repository', 'execute_commands']);
-    const resolved = runtime(descriptor, 'codex');
-    assert.deepEqual(resolved.available_capabilities, ['read_repository', 'execute_commands']);
-    assert.deepEqual(resolved.unavailable_capabilities, []);
-    assert.equal(resolved.execution_mode, 'native');
-});
-test('network is never available on any host', () => {
-    for (const host of listHosts()) {
-        const resolved = runtime(minimalDescriptor('hyv-verify', ['network']), host.id);
-        assert.deepEqual(resolved.available_capabilities, []);
-        assert.deepEqual(resolved.unavailable_capabilities, [{ capability: 'network', status: 'NOT_AVAILABLE' }]);
-        assert.equal(resolved.execution_mode, 'prompt-only');
-    }
-});

package/dist/agents/emit.test.js

@@ -1,64 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { describe, emitJson, emitPrompt } from './emit.js';
-import { AGENT_SCHEMA_VERSION } from './types.js';
-function makePackage(id) {
-    return {
-        directory: '/pkg',
-        instructions: 'Usage: hyv verify original.md candidate.md profile.json',
-        descriptor: {
-            schema_version: AGENT_SCHEMA_VERSION,
-            id,
-            title: 'hyv-verify',
-            description: 'verify a candidate',
-            instruction_file: 'SKILL.md',
-            role: 'Verifier',
-            workflow_phase: 'verify',
-            input: { required: ['original', 'candidate'], optional: ['writing brief'] },
-            output: { required: ['verification report'], optional: [] },
-            evidence_requirements: ['preserve revision evidence'],
-            permissions: ['read_repository', 'network'],
-            stop_conditions: ['stop when evidence is stale'],
-            tool_free_mode: {
-                available: true,
-                behavior: 'report the decision and exact unavailable capability',
-                unavailable_statuses: ['NOT_AVAILABLE', 'NOT_CONFIGURED', 'NOT_RUN', 'STALE', 'ERROR'],
-            },
-            handoff_to: ['hyv-lifecycle'],
-        },
-    };
-}
-test('describe resolves a host and returns a runtime descriptor', () => {
-    const resolved = describe(makePackage('hyv-verify'), 'codex');
-    assert.equal(resolved.agent.id, 'hyv-verify');
-    assert.equal(resolved.host.id, 'codex');
-    assert.ok(resolved.available_capabilities.includes('read_repository'));
-    assert.deepEqual(resolved.unavailable_capabilities, [{ capability: 'network', status: 'NOT_AVAILABLE' }]);
-    assert.equal(resolved.execution_mode, 'prompt-only');
-});
-test('emitJson renders a valid JSON runtime descriptor', () => {
-    const body = emitJson(makePackage('hyv-verify'), 'generic');
-    const parsed = JSON.parse(body);
-    assert.equal(parsed.agent.id, 'hyv-verify');
-    assert.equal(parsed.host.id, 'generic');
-    assert.ok(Array.isArray(parsed.unavailable_capabilities));
-    assert.deepEqual(parsed.unavailable_capabilities, [
-        { capability: 'read_repository', status: 'NOT_AVAILABLE' },
-        { capability: 'network', status: 'NOT_AVAILABLE' },
-    ]);
-});
-test('emitPrompt includes instructions, capability boundary, and required statuses', () => {
-    const prompt = emitPrompt(makePackage('hyv-verify'), 'codex');
-    assert.match(prompt, /# hyv-verify/);
-    assert.match(prompt, /Role: Verifier/);
-    assert.match(prompt, /Usage: hyv verify original\.md candidate\.md profile\.json/);
-    assert.match(prompt, /Available: read_repository/);
-    assert.match(prompt, /Unavailable: network \(NOT_AVAILABLE\)/);
-    assert.match(prompt, /NOT_AVAILABLE, NOT_CONFIGURED, NOT_RUN, STALE, ERROR/);
-    assert.match(prompt, /Next agents: hyv-lifecycle/);
-});
-test('emitPrompt reports no available capabilities for a fully unavailable host', () => {
-    const prompt = emitPrompt(makePackage('hyv-verify'), 'generic');
-    assert.match(prompt, /Available: none/);
-    assert.match(prompt, /Execution mode: prompt-only/);
-});

package/dist/agents/load.test.js

@@ -1,149 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadAll, loadAllFrom, validateAll, validateId, sortedIds } from './load.js';
-import { AGENT_SCHEMA_VERSION } from './types.js';
-function makePackage(dir, id, overrides = {}) {
-    const packageDir = join(dir, 'skills', id);
-    mkdirSync(join(packageDir, 'agents'), { recursive: true });
-    const descriptor = {
-        schema_version: AGENT_SCHEMA_VERSION,
-        id,
-        title: id,
-        description: 'test agent',
-        instruction_file: 'SKILL.md',
-        role: 'Tester',
-        workflow_phase: 'test',
-        input: { required: ['draft'], optional: [] },
-        output: { required: ['report'], optional: [] },
-        evidence_requirements: ['preserve evidence'],
-        permissions: ['read_repository'],
-        stop_conditions: ['stop when evidence missing'],
-        tool_free_mode: {
-            available: true,
-            behavior: 'report NOT_AVAILABLE',
-            unavailable_statuses: ['NOT_AVAILABLE', 'NOT_RUN'],
-        },
-        handoff_to: [],
-        ...overrides,
-    };
-    writeFileSync(join(packageDir, 'agent.json'), JSON.stringify(descriptor));
-    writeFileSync(join(packageDir, 'SKILL.md'), `# ${id}\n\nUsage: hyv ${id} draft.md\n`);
-    writeFileSync(join(packageDir, 'agents', 'openai.yaml'), `interface:\n  display_name: "${id}"\n  short_description: "test agent"\n  default_prompt: "Use ${id}"\n`);
-    return packageDir;
-}
-function makeTempRoot() {
-    return mkdtempSync(join(tmpdir(), 'hyv-agents-'));
-}
-test('loads all valid packages and rejects unknown schema version', () => {
-    const root = makeTempRoot();
-    try {
-        const first = makePackage(root, 'hyv-alpha');
-        makePackage(root, 'hyv-beta', { handoff_to: ['hyv-alpha'] });
-        const packages = loadAllFrom(root);
-        assert.deepEqual(sortedIds(packages), ['hyv-alpha', 'hyv-beta']);
-        assert.equal(packages.get('hyv-alpha').directory, first);
-        assert.match(packages.get('hyv-alpha').instructions, /^# hyv-alpha/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects a package whose id does not match its directory name', () => {
-    const root = makeTempRoot();
-    try {
-        makePackage(root, 'hyv-alpha', { id: 'hyv-mismatch' });
-        assert.throws(() => loadAllFrom(root), /id must match skill directory/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects a handoff target that does not exist', () => {
-    const root = makeTempRoot();
-    try {
-        makePackage(root, 'hyv-alpha', { handoff_to: ['hyv-ghost'] });
-        assert.throws(() => loadAllFrom(root), /hands off to unknown agent/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects an unsupported permission and an unsupported status', () => {
-    const root = makeTempRoot();
-    try {
-        makePackage(root, 'hyv-alpha', { permissions: ['definitely-not-real'] });
-        assert.throws(() => loadAllFrom(root), /unsupported permission/);
-        rmSync(root, { recursive: true, force: true });
-        const root2 = makeTempRoot();
-        makePackage(root2, 'hyv-beta', {
-            tool_free_mode: { available: true, behavior: 'x', unavailable_statuses: ['NOPE'] },
-        });
-        assert.throws(() => loadAllFrom(root2), /tool_free_mode requires/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('validateAll and validateId report PASS or unknown id', () => {
-    const root = makeTempRoot();
-    try {
-        makePackage(root, 'hyv-alpha');
-        const packages = loadAllFrom(root);
-        validateAll(packages);
-        validateId(packages, 'hyv-alpha');
-        assert.throws(() => validateId(packages, 'hyv-missing'), /unknown agent/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects a malformed agent.json', () => {
-    const root = makeTempRoot();
-    try {
-        const packageDir = join(root, 'skills', 'hyv-alpha');
-        mkdirSync(join(packageDir, 'agents'), { recursive: true });
-        writeFileSync(join(packageDir, 'agent.json'), '{ not json');
-        writeFileSync(join(packageDir, 'SKILL.md'), '# x');
-        assert.throws(() => loadAllFrom(root), /not valid JSON/);
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('rejects unknown contract fields and invalid OpenAI interface metadata', () => {
-    const root = makeTempRoot();
-    try {
-        makePackage(root, 'hyv-alpha', { unsupported: true });
-        assert.throws(() => loadAllFrom(root), /supported contract fields/);
-        rmSync(root, { recursive: true, force: true });
-        const root2 = makeTempRoot();
-        const packageDir = makePackage(root2, 'hyv-beta');
-        rmSync(join(packageDir, 'agents', 'openai.yaml'));
-        assert.throws(() => loadAllFrom(root2), /openai\.yaml/);
-        rmSync(root2, { recursive: true, force: true });
-        const root3 = makeTempRoot();
-        const invalidPackageDir = makePackage(root3, 'hyv-gamma');
-        writeFileSync(join(invalidPackageDir, 'agents', 'openai.yaml'), 'interface:\n  display_name: "unterminated\n  short_description: "test"\n  default_prompt: "Use hyv-gamma"\n');
-        assert.throws(() => loadAllFrom(root3), /supported interface metadata/);
-        rmSync(root3, { recursive: true, force: true });
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-test('published packages declare command execution and required writes', () => {
-    const packages = loadAll();
-    const writers = new Set(['hyv-profile', 'hyv-ingest', 'hyv-hygiene', 'hyv-apply-hidden-text-policy', 'hyv-prepare-rewrite', 'hyv-prepare-judgment', 'hyv-prepare-rebuild', 'hyv-rebuild-writer-request', 'hyv-lifecycle', 'hyv-learning']);
-    for (const [id, pkg] of packages) {
-        assert.ok(pkg.descriptor.permissions.includes('execute_commands'), `${id} must require command execution`);
-        assert.equal(pkg.descriptor.permissions.includes('write_repository'), writers.has(id), `${id} write permission mismatch`);
-    }
-});
-test('published instructions document command-specific argument requirements', () => {
-    const packages = loadAll();
-    assert.match(packages.get('hyv-reduce-judgment').instructions, /hyv reduce-judgment envelope\.json envelope\.json envelope\.json \[envelope\.json\.\.\.\]/);
-    assert.match(packages.get('hyv-learning').instructions, /record-approved/);
-});