@holdyourvoice/hyv 3.4.4 → 3.5.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { closeSync, constants, fstatSync, linkSync, mkdtempSync, openSync, readFileSync, readSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, extname, join, resolve } from 'node:path';
+import { closeSync, constants, fstatSync, linkSync, lstatSync, mkdtempSync, openSync, readFileSync, readSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
 import { RULESET_VERSION, serializedRules } from './ai-editor.js';
 import { parseCopySpec } from './copy-spec.js';
 import { analyzeBatch, parseWritingBrief } from './editorial-packs.js';
@@ -15,16 +15,24 @@ import { evaluateRebuildResponse, parseRebuildTask, prepareRebuildTask, writerRe
 import { canonicalJson, parseCanonicalJson } from './canonical-json.js';
 import { MAX_JSON_BYTES } from './internal.js';
 import { finalizeLifecycle, inspectLifecycle, prepareLifecycle, recordApprovedLearning, submitSemanticVerdict, validateFinalApproval } from './lifecycle-adapter.js';
-import { buildProfile } from './voice-dna.js';
+import { buildProfile, buildProfileV3 } from './voice-dna.js';
 import { loadApprovalContext } from './approval-context.js';
 import { formatFactLintReport, lintFacts } from './fact-linter.js';
 import { lintLogic } from './logic-linter.js';
 import { loadAll, validateAll, validateId, sortedIds, describe, emitJson, emitPrompt } from './agents/index.js';
 import { inspectDeliveryIntegrity, parseDeliveryIntegrityPolicy } from './delivery-integrity.js';
 import { assessProfileReadiness } from './profile-quality.js';
+import { evaluateStrictQuality } from './strict-quality.js';
 import { normalizeFinding, parseSurfacePolicy } from './disposition.js';
 import { composeTeamProfile, parseTeamProfileBundle } from './team-profile.js';
-const usage = 'Commands: agent, profile, team-profile, analyze, hygiene, inspect-hidden-text, apply-hidden-text-policy, final-check, delivery-check, fact-lint, logic-lint, batch-analyze, rewrite-prompt, prepare-rewrite, apply-rewrite, prepare-judgment, reduce-judgment, prepare-rebuild, rebuild-writer-request, apply-rebuild, verify, verify-spec, lifecycle, learning, patterns, dispositions, mcp';
+import { composeProfiles, parseProfileRatio } from './profile-compose.js';
+import { scoreHeldoutProfile } from './profile-score.js';
+import { ingestGmailSentMbox, ingestTelegramDesktopJson } from './sample-ingest.js';
+import { evaluateIsolatedBacktest } from './backtest.js';
+import { watchProfileSamples } from './profile-watch.js';
+import { evaluateLocalComposite } from './local-eval.js';
+import { findWritingExamples } from './writing-examples.js';
+const usage = 'Commands: agent, profile, team-profile, analyze, score, backtest, evaluate-local, ingest, strict-check, hygiene, inspect-hidden-text, apply-hidden-text-policy, final-check, delivery-check, fact-lint, logic-lint, batch-analyze, rewrite-prompt, prepare-rewrite, apply-rewrite, prepare-judgment, reduce-judgment, prepare-rebuild, rebuild-writer-request, apply-rebuild, verify, verify-spec, lifecycle, learning, patterns, dispositions, mcp';
 function input(path) {
     return path === '-' ? readFileSync(0, 'utf8') : readFileSync(path, 'utf8');
 }
@@ -382,17 +390,206 @@ function runAgent(args) {
     }
     throw new Error('Usage: hyv agent <list|validate|describe|emit> ...');
 }
+async function runProfileWatch(args) {
+    const [output, ...rest] = args;
+    const samples = [];
+    let id = '';
+    let channel;
+    let debounceMs = 500;
+    for (const value of rest) {
+        if (value.startsWith('--id='))
+            id = value.slice('--id='.length);
+        else if (value.startsWith('--channel='))
+            channel = value.slice('--channel='.length);
+        else if (value.startsWith('--debounce-ms='))
+            debounceMs = Number(value.slice('--debounce-ms='.length));
+        else
+            samples.push(value);
+    }
+    if (!output || !isAbsolute(output) || !id || !channel || samples.length < 2)
+        throw new Error('Usage: hyv profile watch /absolute/profile.json --id=writer.channel --channel=email sample-a.md sample-b.md [--debounce-ms=500]');
+    outputOutsideGitCheckout(dirname(output));
+    let initial = true;
+    const rebuild = () => {
+        const profile = buildProfileV3(samples.map(input), id, channel);
+        writeFileSync(output, JSON.stringify(profile, null, 2) + '\n', { encoding: 'utf8', flag: initial ? 'wx' : 'w', mode: 0o600 });
+        initial = false;
+        json({ version: '1', status: 'rebuilt', sampleCount: samples.length, profileId: profile.id, revisionDigest: profile.revisionDigest });
+    };
+    rebuild();
+    const handle = watchProfileSamples({ samples, debounceMs, rebuild });
+    await new Promise((resolve) => process.once('SIGINT', resolve));
+    handle.close();
+    return 0;
+}
 function runProfile(args) {
+    if (args[0] === 'watch')
+        return runProfileWatch(args.slice(1));
     if (args[0] === 'assess') {
         if (args.length < 3)
             throw new Error('Usage: hyv profile assess sample-a.md sample-b.md [sample-c.md]');
         json(assessProfileReadiness(args.slice(1).map(input)));
         return 0;
     }
+    if (args[0] === 'compose') {
+        const rest = args.slice(1);
+        const ratioIndex = rest.findIndex((value) => value === '--ratio' || value.startsWith('--ratio='));
+        if (ratioIndex < 0)
+            throw new Error('Usage: hyv profile compose --ratio 70:30 profile-a.json profile-b.json [profile-c.json]');
+        const ratio = rest[ratioIndex] === '--ratio' ? rest[ratioIndex + 1] : rest[ratioIndex].slice('--ratio='.length);
+        const profilePaths = rest.filter((_, index) => index !== ratioIndex && index !== ratioIndex + Number(rest[ratioIndex] === '--ratio'));
+        if (!ratio || profilePaths.length < 2)
+            throw new Error('Usage: hyv profile compose --ratio 70:30 profile-a.json profile-b.json [profile-c.json]');
+        const profiles = profilePaths.map(readProfile);
+        if (profiles.some((profile) => profile.version !== '3'))
+            throw new Error('Profile composition requires Profile v3 inputs.');
+        json(composeProfiles(profiles, parseProfileRatio(ratio, profiles.length)));
+        return 0;
+    }
+    if (args[0] === 'v3') {
+        const [output, ...rest] = args.slice(1);
+        const samples = [];
+        const avoid = [];
+        let id = '';
+        let channel;
+        let tone;
+        for (const argument of rest) {
+            if (argument.startsWith('--id='))
+                id = argument.slice('--id='.length);
+            else if (argument.startsWith('--channel='))
+                channel = argument.slice('--channel='.length);
+            else if (argument.startsWith('--avoid='))
+                avoid.push(argument.slice('--avoid='.length));
+            else if (argument.startsWith('--tone=')) {
+                const values = argument.slice('--tone='.length).split(',').map(Number);
+                if (values.length !== 5 || values.some((value) => !Number.isFinite(value) || value < 0 || value > 1))
+                    throw new Error('Tone must use five 0–1 comma-separated values: formality,confidence,warmth,energy,complexity.');
+                tone = { formality: values[0], confidence: values[1], warmth: values[2], energy: values[3], complexity: values[4] };
+            }
+            else
+                samples.push(argument);
+        }
+        if (!output || !id || !channel || samples.length < 2)
+            throw new Error('Usage: hyv profile v3 profile.json --id=writer.channel --channel=email sample-a.md sample-b.md [--tone=0,0,0,0,0] [--avoid=phrase]');
+        writeJson(output, buildProfileV3(samples.map(input), id, channel, avoid, tone));
+        return 0;
+    }
     const { output, samples, avoid } = profileArguments(args);
     writeJson(output, buildProfile(samples.map(input), avoid));
     return 0;
 }
+function runScore(args) {
+    const [draftPath, profilePath, ...rest] = args;
+    if (!draftPath || !profilePath)
+        throw new Error('Usage: hyv score draft.md profile.json heldout-a.md heldout-b.md heldout-c.md [--channel=channel]');
+    const samplePaths = [];
+    let channel;
+    for (const value of rest) {
+        if (value.startsWith('--channel='))
+            channel = value.slice('--channel='.length);
+        else
+            samplePaths.push(value);
+    }
+    if (samplePaths.length < 3)
+        throw new Error('Usage: hyv score draft.md profile.json heldout-a.md heldout-b.md heldout-c.md [--channel=channel]');
+    json(scoreHeldoutProfile(input(draftPath), readProfile(profilePath), samplePaths.map(input), channel));
+    return 0;
+}
+function runBacktest(args) {
+    const [contextPath, targetPath, candidatePath, profilePath, ...heldoutPaths] = args;
+    if (!contextPath || !targetPath || !candidatePath || !profilePath || heldoutPaths.length < 3)
+        throw new Error('Usage: hyv backtest context.md heldout-target.md candidate.md profile.json heldout-a.md heldout-b.md heldout-c.md');
+    json(evaluateIsolatedBacktest(input(contextPath), input(targetPath), input(candidatePath), readProfile(profilePath), heldoutPaths.map(input)));
+    return 0;
+}
+function readEvalParagraphs(path, label) {
+    const value = readJson(path);
+    if (!Array.isArray(value) || !value.every((item) => item && typeof item === 'object' && typeof item.paragraph_id === 'string' && typeof item.text === 'string'))
+        throw new Error(`${label} must be a JSON array of { paragraph_id, text } values.`);
+    return value.map((item) => ({ paragraphId: item.paragraph_id, text: item.text }));
+}
+function runEvaluateLocal(args) {
+    const [inputPath, candidatePath, userPath, aiShadowPath] = args;
+    if (!inputPath || !candidatePath || !userPath || !aiShadowPath || args.length !== 4)
+        throw new Error('Usage: hyv evaluate-local input.md candidate.md user-paragraphs.json ai-shadow-paragraphs.json');
+    json(evaluateLocalComposite(input(inputPath), input(candidatePath), readEvalParagraphs(userPath, 'User paragraphs'), readEvalParagraphs(aiShadowPath, 'AI-shadow paragraphs')));
+    return 0;
+}
+function outputOutsideGitCheckout(path) {
+    if (!isAbsolute(path))
+        throw new Error('Sample ingest output must be an absolute path outside a Git checkout.');
+    let current;
+    try {
+        const stats = lstatSync(path);
+        if (!stats.isDirectory() || stats.isSymbolicLink())
+            throw new Error('Sample ingest output directory must be an existing non-symlink directory outside a Git checkout.');
+        current = realpathSync(path);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Sample ingest output directory'))
+            throw error;
+        throw new Error('Sample ingest output directory must already exist and remain outside a Git checkout.');
+    }
+    for (;;) {
+        try {
+            lstatSync(join(current, '.git'));
+            throw new Error('Sample ingest output must be outside a Git checkout.');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'Sample ingest output must be outside a Git checkout.')
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return;
+        current = parent;
+    }
+}
+function runIngest(args) {
+    const [sourceType, sourcePath, ...options] = args;
+    let owner = '';
+    let output = '';
+    const blockedWords = [];
+    for (const option of options) {
+        if (option.startsWith('--owner='))
+            owner = option.slice('--owner='.length);
+        else if (option.startsWith('--output='))
+            output = option.slice('--output='.length);
+        else if (option.startsWith('--blocked='))
+            blockedWords.push(option.slice('--blocked='.length));
+        else
+            throw new Error('Usage: hyv ingest <gmail-sent-mbox|telegram-desktop-json> export --owner=owner --output=/absolute/safe-directory [--blocked=word]');
+    }
+    if (!sourcePath || !owner || !output || !['gmail-sent-mbox', 'telegram-desktop-json'].includes(sourceType ?? ''))
+        throw new Error('Usage: hyv ingest <gmail-sent-mbox|telegram-desktop-json> export --owner=owner --output=/absolute/safe-directory [--blocked=word]');
+    outputOutsideGitCheckout(output);
+    const result = sourceType === 'gmail-sent-mbox'
+        ? ingestGmailSentMbox(input(sourcePath), owner, blockedWords)
+        : ingestTelegramDesktopJson(input(sourcePath), owner, blockedWords);
+    const outputDirectory = realpathSync(output);
+    const samplesPath = join(outputDirectory, 'samples.jsonl');
+    const receiptPath = join(outputDirectory, 'receipt.json');
+    try {
+        writeFileSync(samplesPath, result.samples.map((sample) => JSON.stringify({ text: sample })).join('\n') + (result.samples.length ? '\n' : ''), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new Error('Sample ingest output directory must already exist and remain outside a Git checkout.');
+        throw error;
+    }
+    try {
+        writeFileSync(receiptPath, JSON.stringify(result.receipt, null, 2) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        try {
+            rmSync(samplesPath, { force: true });
+        }
+        catch { }
+        throw error;
+    }
+    json(result.receipt);
+    return 0;
+}
 function runTeamProfile(args) {
     const [action, bundlePath, authorPath, ...brandPaths] = args;
     if (action === 'validate' && bundlePath && !authorPath) {
@@ -423,6 +620,14 @@ function runAnalyze(args) {
     json(analyze(input(draft), readProfile(profilePath), readBrief(briefPath)));
     return 0;
 }
+function runStrictCheck(args) {
+    const [draft, profilePath, ...samplePaths] = args;
+    if (!draft || !profilePath || samplePaths.length < 2)
+        throw new Error('Usage: hyv strict-check draft.md profile-v3.json sample-a.md sample-b.md [sample-c.md ...]');
+    const report = evaluateStrictQuality(input(draft), readProfile(profilePath), samplePaths.map(input));
+    json(report);
+    return report.disposition === 'strict-ready' ? 0 : 2;
+}
 function runHygiene(args) {
     const { path, fix, output } = hygieneArguments(args);
     if (fix && path === '-')
@@ -527,11 +732,18 @@ function runBatchAnalyze(args) {
     return 0;
 }
 function runRewritePrompt(args) {
-    const [draft, profilePath, briefPath] = args;
-    if (!draft || !profilePath)
-        throw new Error('Usage: hyv rewrite-prompt draft.md profile.json [writing-brief.json]');
+    const [draft, profilePath, ...rest] = args;
+    const exampleOption = rest.find((value) => value.startsWith('--examples-json='));
+    const briefPaths = rest.filter((value) => !value.startsWith('--'));
+    const briefPath = briefPaths[0];
+    if (!draft || !profilePath || briefPaths.length > 1 || rest.some((value) => value.startsWith('--') && !value.startsWith('--examples-json=')))
+        throw new Error('Usage: hyv rewrite-prompt draft.md profile.json [writing-brief.json] [--examples-json=local-examples.json]');
     const profile = readProfile(profilePath);
-    console.log(rewritePrompt(input(draft), profile, composeLearning(profile), readBrief(briefPath)));
+    const examplesValue = exampleOption ? readJson(exampleOption.slice('--examples-json='.length)) : undefined;
+    if (examplesValue !== undefined && (!Array.isArray(examplesValue) || !examplesValue.every((item) => item && typeof item === 'object' && typeof item.basename === 'string' && typeof item.text === 'string')))
+        throw new Error('Local examples must be a JSON array of { basename, text } values.');
+    const draftText = input(draft);
+    console.log(rewritePrompt(draftText, profile, composeLearning(profile), readBrief(briefPath), examplesValue ? findWritingExamples(draftText, examplesValue) : []));
     return 0;
 }
 function runPrepareRewrite(args) {
@@ -773,6 +985,11 @@ const commandHandlers = {
     profile: runProfile,
     'team-profile': runTeamProfile,
     analyze: runAnalyze,
+    score: runScore,
+    backtest: runBacktest,
+    'evaluate-local': runEvaluateLocal,
+    ingest: runIngest,
+    'strict-check': runStrictCheck,
     hygiene: runHygiene,
     'inspect-hidden-text': runInspectHiddenText,
     'apply-hidden-text-policy': runApplyHiddenTextPolicy,

package/dist/cli.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
@@ -45,13 +45,32 @@ test('creates an explicit local avoid list and exposes the ruleset', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('builds a channel-specific Profile v3 from local samples', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-profile-v3-cli-'));
+    try {
+        const first = join(directory, 'first.md');
+        const second = join(directory, 'second.md');
+        const profile = join(directory, 'profile.json');
+        writeFileSync(first, 'I write directly about the release. The owner checks the evidence.');
+        writeFileSync(second, 'I keep the mechanism visible. The next step stays clear.');
+        const result = run(['profile', 'v3', profile, '--id=founder.email', '--channel=email', '--tone=0.4,0.7,0.6,0.3,0.5', first, second]);
+        assert.equal(result.status, 0, result.stderr);
+        const parsed = JSON.parse(readFileSync(profile, 'utf8'));
+        assert.equal(parsed.version, '3');
+        assert.equal(parsed.channel, 'email');
+        assert.equal(parsed.tone.warmth, 0.6);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('publishes the same normalized reconciled catalog and version through CLI and MCP', () => {
     const result = run(['patterns']);
     assert.equal(result.status, 0, result.stderr);
     const cliCatalog = JSON.parse(result.stdout);
     const mcpCatalog = patternsForMcp();
-    assert.equal(cliCatalog.version, '3.2.0-reconciled.1');
-    assert.equal(cliCatalog.rules.length, 148);
+    assert.equal(cliCatalog.version, '3.5.0-local.3');
+    assert.equal(cliCatalog.rules.length, 182);
     assert.deepEqual(cliCatalog, mcpCatalog);
 });
 test('runs contextual analysis and batch analysis without changing the profile contract', () => {
@@ -82,6 +101,78 @@ test('runs contextual analysis and batch analysis without changing the profile c
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('scores a candidate only against explicit held-out local samples', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-score-cli-'));
+    try {
+        const samples = Array.from({ length: 3 }, (_, index) => join(directory, 'sample-' + index + '.md'));
+        const profile = join(directory, 'profile.json');
+        const draft = join(directory, 'draft.md');
+        const text = [
+            'I write a direct note about the launch. The owner checks the evidence before we ship. The next step stays clear and small. The report remains useful.',
+            'I name the trade-off before I make the decision. We keep the mechanism visible for the person doing the work. The release has one owner. The report stays useful.',
+            'I start from evidence in the issue. Then I explain the constraint and choose a concrete next step. The team checks the result. The report stays useful.',
+        ];
+        for (const [index, sample] of samples.entries())
+            writeFileSync(sample, text[index]);
+        writeFileSync(draft, 'I name the evidence, explain the trade-off, and choose a next step. The owner checks the work before release. The report stays useful for the team.');
+        assert.equal(run(['profile', profile, ...samples]).status, 0);
+        const result = run(['score', draft, profile, ...samples]);
+        assert.equal(result.status, 0, result.stderr);
+        const score = JSON.parse(result.stdout);
+        assert.equal(score.version, '1');
+        assert.equal(score.selfSimilarity.ceiling, 100);
+        assert.equal(Object.keys(score.components).length, 13);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('ingests an explicit Gmail export only to an absolute directory outside a Git checkout', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-ingest-cli-'));
+    try {
+        const source = join(directory, 'sent.mbox');
+        writeFileSync(source, [
+            'From sender@example.com Mon Jan 1 00:00:00 2026',
+            'From: Owner <owner@example.com>',
+            '',
+            'Reach owner@example.com before we ship.',
+        ].join('\n'));
+        const result = run(['ingest', 'gmail-sent-mbox', source, '--owner=Owner <owner@example.com>', '--output=' + directory]);
+        assert.equal(result.status, 0, result.stderr);
+        const receipt = JSON.parse(result.stdout);
+        assert.equal(receipt.samplesAccepted, 1);
+        assert.equal(JSON.stringify(receipt).includes('owner@example.com'), false);
+        assert.equal(readFileSync(join(directory, 'samples.jsonl'), 'utf8').includes('REDACTED:EMAIL'), true);
+        assert.equal(run(['ingest', 'gmail-sent-mbox', source, '--owner=Owner <owner@example.com>', '--output=' + process.cwd()]).status, 1);
+        const linkedOutput = join(directory, 'linked-output');
+        symlinkSync(process.cwd(), linkedOutput);
+        const linked = run(['ingest', 'gmail-sent-mbox', source, '--owner=Owner <owner@example.com>', '--output=' + linkedOutput]);
+        assert.equal(linked.status, 1);
+        assert.match(linked.stderr, /non-symlink directory/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('exposes strict quality as an opt-in v3-only CLI gate', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-strict-cli-'));
+    try {
+        const profile = join(directory, 'profile.json');
+        const draft = join(directory, 'draft.md');
+        const samples = Array.from({ length: 5 }, (_, index) => join(directory, `sample-${index}.md`));
+        for (const [index, sample] of samples.entries())
+            writeFileSync(sample, `i write sample ${index}. `.repeat(300));
+        writeFileSync(profile, JSON.stringify({ version: '2', sampleCount: 2, metrics: { sentenceLength: 5, sentenceVariation: 1, sentenceStructure: [], rhythm: 1, paragraphLength: 1, openingMoves: [], vocabulary: [], lexicalDensity: 0.5, pointOfView: 'mixed', punctuation: { '!': 0, '?': 0, ';': 0, ':': 0, '—': 0 }, caseStyle: 'mixed', questionRate: 0, transitions: [] }, avoid: [] }));
+        writeFileSync(draft, 'The launch starts Tuesday.');
+        const result = run(['strict-check', draft, profile, ...samples]);
+        assert.equal(result.status, 2, result.stderr);
+        assert.equal(JSON.parse(result.stdout).disposition, 'blocked');
+        assert.equal(JSON.parse(result.stdout).findings[0].id, 'strict.profile.version');
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('inspects and conservatively fixes Unicode hygiene without overwriting either file', () => {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-cli-'));
     try {
@@ -560,12 +651,18 @@ test('agent list enumerates every command as one portable package', () => {
     const result = run(['agent', 'list']);
     assert.equal(result.status, 0, result.stderr);
     const entries = JSON.parse(result.stdout);
-    assert.equal(entries.length, 23);
+    assert.equal(entries.length, 29);
     const ids = entries.map((entry) => entry.id);
     assert.equal(new Set(ids).size, ids.length);
-    for (const id of ['hyv-profile', 'hyv-analyze', 'hyv-verify', 'hyv-mcp', 'hyv-patterns']) {
+    for (const id of ['hyv-profile', 'hyv-score', 'hyv-ingest', 'hyv-backtest', 'hyv-evaluate-local', 'hyv-find-writing-examples', 'hyv-analyze', 'hyv-verify', 'hyv-mcp', 'hyv-patterns', 'hyv-strict-check']) {
         assert.ok(ids.includes(id), `missing ${id}`);
     }
+    const strict = JSON.parse(run(['agent', 'describe', 'hyv-strict-check']).stdout).agent;
+    const analyze = JSON.parse(run(['agent', 'describe', 'hyv-analyze']).stdout).agent;
+    const verify = JSON.parse(run(['agent', 'describe', 'hyv-verify']).stdout).agent;
+    assert.deepEqual(strict.handoff_to, ['hyv-final-check']);
+    assert.ok(analyze.handoff_to.includes('hyv-strict-check'));
+    assert.ok(verify.handoff_to.includes('hyv-strict-check'));
     for (const entry of entries) {
         assert.ok(entry.role);
         assert.ok(entry.workflow_phase);

package/dist/editorial-packs.js

@@ -47,6 +47,7 @@ export function parseWritingBrief(value) {
     const brief = value;
     if (brief.version !== '1' || !isText(brief.audience, 500) || !isText(brief.intent, 500) || !formats.includes(brief.format)
         || (brief.readerKnowsAuthor !== undefined && typeof brief.readerKnowsAuthor !== 'boolean')
+        || (brief.personality !== undefined && !isText(brief.personality, 500))
         || (brief.vocabulary !== undefined && !isTerms(brief.vocabulary))
         || (brief.prohibitedTerms !== undefined && !isTerms(brief.prohibitedTerms))
         || (brief.title !== undefined && !isText(brief.title, 500))

package/dist/local-eval.js

@@ -0,0 +1,98 @@
+import { analyzeAiEditor } from './ai-editor.js';
+import { profileMetrics } from './voice-dna.js';
+import { words } from './text.js';
+const STOP = new Set(['the', 'and', 'that', 'with', 'this', 'from', 'your', 'have', 'were', 'they', 'will', 'into', 'about']);
+function terms(text) { return words(text.toLowerCase()).filter((word) => word.length > 2 && !STOP.has(word)); }
+function f1(left, right) {
+    const a = new Set(terms(left));
+    const b = new Set(terms(right));
+    const intersection = [...a].filter((word) => b.has(word)).length;
+    return a.size + b.size === 0 ? 1 : Number((2 * intersection / (a.size + b.size)).toFixed(3));
+}
+function vector(text) {
+    const m = profileMetrics(text);
+    const punctuation = Object.values(m.punctuation).reduce((sum, value) => sum + value, 0);
+    return [m.sentenceLength, m.sentenceVariation, m.rhythm, m.paragraphLength, m.lexicalDensity, m.questionRate, punctuation, m.openingMoves.length, m.transitions.length];
+}
+function cosine(left, right) {
+    const dot = left.reduce((sum, value, index) => sum + value * right[index], 0);
+    const magnitude = Math.sqrt(left.reduce((sum, value) => sum + value * value, 0) * right.reduce((sum, value) => sum + value * value, 0));
+    return Number((magnitude ? dot / magnitude : 0).toFixed(3));
+}
+function groupedParagraphs(values, label) {
+    if (values.length < 2 || values.some((value) => !value.paragraphId || !value.text.trim()) || new Set(values.map((value) => value.paragraphId)).size < 2)
+        throw new Error(`${label} needs at least two paragraph IDs with text.`);
+}
+function tfIdf(documents) {
+    const documentTerms = documents.map((document) => terms(document));
+    const df = new Map();
+    for (const document of documentTerms)
+        for (const term of new Set(document))
+            df.set(term, (df.get(term) ?? 0) + 1);
+    const vocabulary = [...df.keys()].sort();
+    const idf = new Map([...df].map(([term, frequency]) => [term, Math.log((documents.length + 1) / (frequency + 1)) + 1]));
+    const toVector = (document) => {
+        const termsInDocument = terms(document);
+        const count = new Map();
+        for (const term of termsInDocument)
+            count.set(term, (count.get(term) ?? 0) + 1);
+        const vector = {};
+        for (const [term, occurrences] of count)
+            if (idf.has(term))
+                vector[term] = (occurrences / Math.max(1, termsInDocument.length)) * idf.get(term);
+        return vector;
+    };
+    return {
+        vocabulary,
+        idf,
+        vectors: documents.map(toVector),
+    };
+}
+function vectorWithIdf(document, idf) {
+    const documentTerms = terms(document);
+    const count = new Map();
+    for (const term of documentTerms)
+        count.set(term, (count.get(term) ?? 0) + 1);
+    const vector = {};
+    for (const [term, occurrences] of count)
+        if (idf.has(term))
+            vector[term] = (occurrences / Math.max(1, documentTerms.length)) * idf.get(term);
+    return vector;
+}
+function sigmoid(value) { return value >= 0 ? 1 / (1 + Math.exp(-value)) : Math.exp(value) / (1 + Math.exp(value)); }
+/** Deterministic, train-only logistic regression over sparse TF-IDF vectors. */
+function localAuthorshipProbability(candidate, user, shadow) {
+    const training = [...user.map((item) => ({ text: item.text, label: 1 })), ...shadow.map((item) => ({ text: item.text, label: 0 }))];
+    const transformed = tfIdf(training.map((item) => item.text));
+    const weights = {};
+    let bias = 0;
+    for (let epoch = 0; epoch < 80; epoch += 1) {
+        for (let index = 0; index < training.length; index += 1) {
+            const vector = transformed.vectors[index];
+            const error = training[index].label - sigmoid(bias + Object.entries(vector).reduce((sum, [term, value]) => sum + (weights[term] ?? 0) * value, 0));
+            bias += 0.12 * error;
+            for (const [term, value] of Object.entries(vector))
+                weights[term] = (weights[term] ?? 0) + 0.12 * error * value;
+        }
+    }
+    const candidateVector = vectorWithIdf(candidate, transformed.idf);
+    const score = bias + Object.entries(candidateVector).reduce((sum, [term, value]) => sum + (weights[term] ?? 0) * value, 0);
+    return Number(sigmoid(score).toFixed(3));
+}
+/** Optional local evaluation. Groups whole paragraph IDs before train/test to prevent variant leakage. */
+export function evaluateLocalComposite(input, candidate, user, aiShadow) {
+    groupedParagraphs(user, 'User paragraphs');
+    groupedParagraphs(aiShadow, 'AI-shadow paragraphs');
+    const ids = [...new Set([...user, ...aiShadow].map((value) => value.paragraphId))].sort();
+    const testIds = ids.filter((id, index) => index % 3 === 0);
+    const trainIds = ids.filter((id) => !testIds.includes(id));
+    const trainUser = user.filter((value) => trainIds.includes(value.paragraphId));
+    const trainShadow = aiShadow.filter((value) => trainIds.includes(value.paragraphId));
+    const author = trainUser.length && trainShadow.length ? {
+        candidateUserProbability: localAuthorshipProbability(candidate, trainUser, trainShadow),
+        trainExamples: trainUser.length + trainShadow.length,
+    } : { disposition: 'abstain', reason: 'The paragraph-grouped split leaves no train examples for one class.' };
+    const inputFindings = analyzeAiEditor(input).findings.length;
+    const candidateFindings = analyzeAiEditor(candidate).findings.length;
+    return { version: '1', split: { trainParagraphIds: trainIds, testParagraphIds: testIds }, authorshipTfIdfLogReg: author, contentF1: f1(input, candidate), aiTellReduction: { inputFindings, candidateFindings, reduction: inputFindings ? Number(((inputFindings - candidateFindings) / inputFindings).toFixed(3)) : 0 }, stylometricCosine9: cosine(vector(input), vector(candidate)) };
+}

package/dist/local-eval.test.js

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { evaluateLocalComposite } from './local-eval.js';
+test('groups paragraph IDs before optional local composite evaluation', () => {
+    const user = [{ paragraphId: 'u1', text: 'I check the source and explain the mechanism.' }, { paragraphId: 'u2', text: 'The owner names one next step for the release.' }, { paragraphId: 'u3', text: 'I keep the evidence visible for the operator.' }];
+    const shadow = [{ paragraphId: 's1', text: 'This transformative framework unlocks synergy.' }, { paragraphId: 's2', text: 'The holistic ecosystem creates value.' }, { paragraphId: 's3', text: 'This is a game-changer for every stakeholder.' }];
+    const report = evaluateLocalComposite('We leverage a holistic framework.', 'We check the source and name the next step.', user, shadow);
+    assert.equal(report.version, '1');
+    assert.equal(report.split.trainParagraphIds.some((id) => report.split.testParagraphIds.includes(id)), false);
+    assert.ok(report.contentF1 >= 0 && report.contentF1 <= 1);
+    assert.ok(report.stylometricCosine9 >= 0 && report.stylometricCosine9 <= 1);
+    assert.equal(report.aiTellReduction.candidateFindings < report.aiTellReduction.inputFindings, true);
+});
+test('keeps every paragraph variant on one side of the local evaluation split', () => {
+    const user = [{ paragraphId: 'u1', text: 'I inspect the source.' }, { paragraphId: 'u1', text: 'I inspect the source before shipping.' }, { paragraphId: 'u2', text: 'I name the mechanism.' }];
+    const shadow = [{ paragraphId: 's1', text: 'This holistic framework transforms outcomes.' }, { paragraphId: 's1', text: 'This transformative framework unlocks outcomes.' }, { paragraphId: 's2', text: 'The ecosystem creates value.' }];
+    const report = evaluateLocalComposite('The source is visible.', 'I inspect the source before shipping.', user, shadow);
+    assert.equal(report.split.trainParagraphIds.includes('u1'), report.split.testParagraphIds.includes('u1') === false);
+    assert.equal(report.split.trainParagraphIds.includes('s1'), report.split.testParagraphIds.includes('s1') === false);
+});

package/dist/mcp-tools.js

@@ -16,6 +16,11 @@ import { MAX_JSON_BYTES } from './internal.js';
 import { lintFacts } from './fact-linter.js';
 import { inspectDeliveryIntegrity, parseDeliveryIntegrityPolicy } from './delivery-integrity.js';
 import { assessProfileReadiness } from './profile-quality.js';
+import { evaluateStrictQuality } from './strict-quality.js';
+import { scoreHeldoutProfile } from './profile-score.js';
+import { findWritingExamples } from './writing-examples.js';
+import { evaluateIsolatedBacktest } from './backtest.js';
+import { evaluateLocalComposite } from './local-eval.js';
 function profileFromJson(profileJson) {
     try {
         return parseProfile(JSON.parse(profileJson));
@@ -54,15 +59,30 @@ export function buildProfileForMcp(samples, avoid = []) {
 export function analyzeForMcp(draft, profileJson, writingBriefJson) {
     return analyze(draft, profileFromJson(profileJson), writingBriefFromJson(writingBriefJson));
 }
+export function strictCheckForMcp(draft, profileJson, samples, writingBriefJson) {
+    return evaluateStrictQuality(draft, profileFromJson(profileJson), samples, writingBriefFromJson(writingBriefJson));
+}
+export function scoreHeldoutForMcp(draft, profileJson, samples, channel) {
+    return scoreHeldoutProfile(draft, profileFromJson(profileJson), samples, channel);
+}
+export function backtestForMcp(context, target, candidate, profileJson, samples) {
+    return evaluateIsolatedBacktest(context, target, candidate, profileFromJson(profileJson), samples);
+}
+export function evaluateLocalForMcp(input, candidate, user, aiShadow) {
+    return evaluateLocalComposite(input, candidate, user, aiShadow);
+}
 export function inspectHygieneForMcp(draft) {
     return inspectHygiene(draft);
 }
 export function finalOutputCheckForMcp(text) {
     return finalOutputCheck(text);
 }
-export function rewritePromptForMcp(draft, profileJson, options = {}, writingBriefJson) {
+export function findWritingExamplesForMcp(query, samples) {
+    return findWritingExamples(query, samples);
+}
+export function rewritePromptForMcp(draft, profileJson, options = {}, writingBriefJson, samples) {
     const profile = profileFromJson(profileJson);
-    return { prompt: rewritePrompt(draft, profile, composeLearning(profile, options), writingBriefFromJson(writingBriefJson)) };
+    return { prompt: rewritePrompt(draft, profile, composeLearning(profile, options), writingBriefFromJson(writingBriefJson), samples ? findWritingExamples(draft, samples) : []) };
 }
 export function prepareRewriteForMcp(draft, profileJson, copySpecJson, writingBriefJson) {
     return prepareRewriteTask(draft, profileFromJson(profileJson), copySpecJson ? copySpecFromJson(copySpecJson) : undefined, writingBriefFromJson(writingBriefJson));