@holdyourvoice/hyv 3.6.1 → 4.0.1

package/dist/editorial-packs.test.js

@@ -1,94 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { analyzeBatch, analyzeEditorial, parseWritingBrief } from './editorial-packs.js';
-test('uses only the selected format pack and keeps advisory format findings non-blocking', () => {
-    const brief = parseWritingBrief({
-        version: '1', audience: 'founders', intent: 'start a discussion', format: 'social',
-    });
-    const report = analyzeEditorial('A pattern I keep seeing in founder posts is vague advice.', brief);
-    assert.equal(report.engine, 'editorial');
-    assert.equal(report.passed, true);
-    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.severity, finding.sentence]), [['editorial.social.generic-opener', 'yellow', 1]]);
-});
-test('enforces explicit local disclosure terms independently from format guidance', () => {
-    const brief = parseWritingBrief({
-        version: '1', audience: 'operators', intent: 'write an update', format: 'general', prohibitedTerms: ['internal contract value'],
-    });
-    const report = analyzeEditorial('The internal contract value is $12,000.', brief);
-    assert.equal(report.passed, false);
-    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.severity]), [['editorial.prohibited-term', 'red']]);
-});
-test('matches prohibited terms as complete normalized words or phrases', () => {
-    const brief = parseWritingBrief({ version: '1', audience: 'operators', intent: 'write an update', format: 'general', prohibitedTerms: ['art'] });
-    assert.equal(analyzeEditorial('We start with the delivery date.', brief).passed, true);
-    assert.equal(analyzeEditorial('The art needs a signed owner.', brief).passed, false);
-});
-test('covers the remaining contextual format checks without applying packs outside their format', () => {
-    const social = parseWritingBrief({ version: '1', audience: 'founders', intent: 'write', format: 'social' });
-    assert.deepEqual(analyzeEditorial('One point.\n\nSecond point.\n\nThird point.', social).findings.map((item) => item.id), ['editorial.social.one-line-run']);
-    const deck = parseWritingBrief({ version: '1', audience: 'buyers', intent: 'present', format: 'deck', title: '3 ways to improve delivery' });
-    assert.deepEqual(analyzeEditorial('We make delivery simpler.', deck).findings.map((item) => item.id), ['editorial.deck.first-slide-we', 'editorial.deck.numeric-title']);
-    const outreach = parseWritingBrief({ version: '1', audience: 'operators', intent: 'start a conversation', format: 'outreach' });
-    assert.deepEqual(analyzeEditorial('Does that sound interesting?', outreach).findings.map((item) => item.id), ['editorial.outreach.generic-question-cta']);
-    assert.deepEqual(analyzeEditorial('We make delivery simpler.', outreach).findings, []);
-});
-test('detects exact repeated openings and endings across a batch without judging deliberate variation', () => {
-    const report = analyzeBatch([
-        'The launch needs a clear owner. Start with the dependency map.',
-        'The launch needs a clear owner. Start with the dependency map.',
-        'The invoice needs a clear owner. Check the due date.',
-    ]);
-    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.draftIndexes]), [
-        ['batch.repeated-opening', [1, 2]],
-        ['batch.repeated-ending', [1, 2]],
-    ]);
-});
-test('rejects malformed writing briefs before they activate editorial checks', () => {
-    assert.throws(() => parseWritingBrief({ version: '1', audience: '', intent: 'write', format: 'social' }), /WritingBrief/);
-    assert.throws(() => parseWritingBrief({ version: '1', audience: 'founders', intent: 'write', format: 'unknown' }), /WritingBrief/);
-    assert.throws(() => parseWritingBrief({ version: '1', audience: 'founders', intent: 'write', format: 'social', evidenceStatus: 'unknown' }), /WritingBrief/);
-    assert.throws(() => parseWritingBrief({ version: '1', audience: 'founders', intent: 'write', format: 'social', argumentMap: { observation: 'A', mechanism: 'B', consequence: 'C' } }), /WritingBrief/);
-});
-test('adds opt-in evidence and reader-value review cues without blocking publication', () => {
-    const brief = parseWritingBrief({
-        version: '1',
-        audience: 'operators',
-        intent: 'explain a reliability cost',
-        format: 'social',
-        evidenceStatus: 'unverified',
-        argumentMap: {
-            observation: 'A worker failed.',
-            mechanism: 'The cache was lost.',
-            consequence: 'The request restarts.',
-            readerValue: 'Avoid the cold restart cost.',
-        },
-    });
-    const report = analyzeEditorial('A worker failed. The request restarts.', brief);
-    assert.equal(report.passed, true);
-    assert.deepEqual(report.findings.map((finding) => finding.id), [
-        'editorial.evidence.unverified',
-        'editorial.argument-map.reader-value-missing',
-    ]);
-});
-test('does not flag an argument map when the draft carries the reader value', () => {
-    const brief = parseWritingBrief({
-        version: '1',
-        audience: 'operators',
-        intent: 'explain a reliability cost',
-        format: 'social',
-        argumentMap: {
-            observation: 'A worker failed.',
-            mechanism: 'The cache was lost.',
-            consequence: 'The request restarts.',
-            readerValue: 'Avoid the cold restart cost.',
-        },
-    });
-    assert.deepEqual(analyzeEditorial('A worker failed. Avoid the cold restart cost.', brief).findings, []);
-});
-test('keeps the reader-value cue when only one generic term overlaps', () => {
-    const brief = parseWritingBrief({
-        version: '1', audience: 'operators', intent: 'explain a reliability cost', format: 'social',
-        argumentMap: { observation: 'A worker failed.', mechanism: 'The cache was lost.', consequence: 'The request restarts.', readerValue: 'Avoid the cold restart cost.' },
-    });
-    assert.ok(analyzeEditorial('A worker failed. We avoid a delay.', brief).findings.some((item) => item.id === 'editorial.argument-map.reader-value-missing'));
-});

package/dist/fact-linter.test.js

@@ -1,85 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import test from 'node:test';
-import { lintFacts } from './fact-linter.js';
-test('supports evidence-backed facts and harmless paraphrases', () => {
-    const report = lintFacts({
-        sources: [{ id: 'release-notes', text: 'Acme launched Atlas on 14 August 2026. Atlas exports reports as CSV.' }],
-        draft: 'Atlas shipped on August 14, 2026. It can export reports as CSV.',
-    });
-    assert.equal(report.summary.supported, 2);
-    assert.equal(report.findings.length, 0);
-});
-test('flags numeric, date, entity, quote, and capability drift with exact evidence', () => {
-    const report = lintFacts({
-        sources: [{ id: 'brief', text: 'Maya Chen said, "We support 12 teams." The launch is on 14 August 2026. Atlas exports CSV reports.' }],
-        draft: 'Maya Chan said, "We support 20 teams." The launch is on 15 August 2026. Atlas exports PDF reports.',
-    });
-    assert.deepEqual(new Set(report.findings.map((finding) => finding.kind)), new Set(['entity_drift', 'quote_drift', 'date_drift', 'capability_drift']));
-    assert.ok(report.findings.every((finding) => finding.evidence[0]?.sourceId === 'brief' && finding.evidence[0]?.excerpt));
-});
-test('flags numeric values and units that differ from relevant evidence', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Acme retains exports for 12 days.' }], draft: 'Acme retains exports for 12 hours.' });
-    assert.equal(report.findings[0]?.kind, 'number_drift');
-});
-test('flags a capability whose polarity reverses the supplied source', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Atlas supports CSV exports.' }], draft: 'Atlas does not support CSV exports.' });
-    assert.equal(report.findings[0]?.kind, 'capability_drift');
-});
-test('routes an unsupported product capability to human review', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Atlas supports CSV exports.' }], draft: 'Atlas supports real-time API alerts.' });
-    assert.equal(report.findings[0]?.kind, 'missing_evidence');
-    assert.equal(report.findings[0]?.severity, 'needs_human_review');
-});
-test('routes sparse overlap without a matching predicate to human review', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Harbor Studio exists.' }], draft: 'Harbor Studio grows.' });
-    assert.equal(report.findings[0]?.kind, 'missing_evidence');
-    assert.equal(report.findings[0]?.severity, 'needs_human_review');
-});
-test('flags a single-token product name that drifts from source evidence', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Atlas exports CSV reports.' }], draft: 'Atlus exports CSV reports.' });
-    assert.equal(report.findings[0]?.kind, 'entity_drift');
-});
-test('flags unsupported facts and draft-internal contradictions', () => {
-    const report = lintFacts({
-        sources: [{ id: 'brief', text: 'The service is available in India.' }],
-        draft: 'The service is available in India. The service is not available in India. The service has 99.99% uptime.',
-    });
-    assert.ok(report.findings.some((finding) => finding.kind === 'draft_contradiction'));
-    assert.ok(report.findings.some((finding) => finding.kind === 'unsupported_claim'));
-});
-test('treats causal and comparative overreach as reviewable material problems', () => {
-    const report = lintFacts({
-        sources: [{ id: 'study', text: 'After the training, support tickets fell from 12 to 8. The study did not test causes or competitors.' }],
-        draft: 'The training caused support tickets to fall and is better than every alternative.',
-    });
-    assert.deepEqual(new Set(report.findings.map((finding) => finding.kind)), new Set(['causal_overreach', 'comparative_overreach']));
-});
-test('does not flag opinions or approved hypotheses, and routes ambiguous gaps to human review', () => {
-    const report = lintFacts({
-        sources: [{ id: 'brief', text: 'The team is exploring a mobile app.' }],
-        draft: 'I think the mobile app is a good idea. The app may reduce churn. The team is popular.',
-        metadata: { approvedHypotheses: ['The app may reduce churn.'], allowedAssumptions: ['The team is popular.'] },
-    });
-    assert.equal(report.findings.some((finding) => finding.claim.includes('good idea')), false);
-    assert.equal(report.findings.some((finding) => finding.claim.includes('may reduce churn')), false);
-    assert.equal(report.findings.some((finding) => finding.claim.includes('popular')), false);
-});
-test('reports skipped semantic checks unless an explicitly configured adapter runs them', () => {
-    const report = lintFacts({ sources: [{ id: 'brief', text: 'Atlas exists.' }], draft: 'Atlas exists.' });
-    assert.deepEqual(report.skippedChecks, ['semantic_matching']);
-    const external = { id: 'remote', external: true, compare: () => 'supported' };
-    assert.deepEqual(lintFacts({ sources: [{ id: 'brief', text: 'Atlas exists.' }], draft: 'Atlas exists.', semanticAdapter: external }).skippedChecks, ['semantic_matching']);
-    assert.deepEqual(lintFacts({ sources: [{ id: 'brief', text: 'Atlas exists.' }], draft: 'Atlas exists.', semanticAdapter: external, allowExternalSemantic: true }).skippedChecks, []);
-    const contradicted = lintFacts({ sources: [{ id: 'brief', text: 'Atlas exists.' }], draft: 'Atlas is reliable.', semanticAdapter: { id: 'local', compare: () => 'contradicted' } });
-    assert.equal(contradicted.findings[0]?.kind, 'semantic_contradiction');
-});
-test('keeps twenty synthetic source-grounded posts as supported regression fixtures', () => {
-    const fixture = new URL('../fixtures/fact-linter/posts.json', import.meta.url);
-    const posts = JSON.parse(readFileSync(fixture, 'utf8'));
-    assert.equal(posts.length, 20);
-    for (const post of posts) {
-        const report = lintFacts({ sources: [{ id: post.id, text: post.source }], draft: post.draft });
-        assert.equal(report.findings.filter((finding) => finding.severity === 'error').length, 0, post.id);
-    }
-});

package/dist/hidden-text.test.js

@@ -1,26 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { applyHiddenTextPolicy, inspectHiddenText, minimalHiddenTextPolicy, parseHiddenTextPolicy } from './hidden-text.js';
-test('removes only explicitly approved ASCII controls and mid-document BOMs with a stable receipt', () => {
-    const source = 'start\u0007middle\uFEFFend';
-    const receipt = applyHiddenTextPolicy(source);
-    assert.equal(receipt.output, 'startmiddleend');
-    assert.deepEqual(receipt.proposedChanges.map((item) => [item.codepoint, item.offset]), [['U+0007', 5], ['U+FEFF', 12]]);
-    assert.equal(receipt.remaining.length, 0);
-    assert.equal(receipt.idempotent, true);
-    assert.notEqual(receipt.inputHash, receipt.outputHash);
-});
-test('keeps bidi, script joiners, emoji joiners, Markdown and tabs review-only', () => {
-    const source = '```ts\nconst x = 1;\n```\nالعربية\u202E ไทย\u200Bภาษา 👩\u200D💻\tend';
-    const report = inspectHiddenText(source);
-    const receipt = applyHiddenTextPolicy(source);
-    assert.equal(receipt.output, source);
-    assert.equal(receipt.proposedChanges.length, 0);
-    assert.ok(report.findings.some((item) => item.kind === 'bidi' && item.action === 'review'));
-    assert.ok(report.findings.some((item) => item.kind === 'zero_width' && item.action === 'review'));
-});
-test('requires the exact policy shape and never broadens removals from malformed input', () => {
-    assert.deepEqual(parseHiddenTextPolicy(minimalHiddenTextPolicy), minimalHiddenTextPolicy);
-    assert.throws(() => parseHiddenTextPolicy({ ...minimalHiddenTextPolicy, approvedRemovals: ['zero_width'] }), /not valid/);
-    assert.throws(() => parseHiddenTextPolicy({ ...minimalHiddenTextPolicy, acknowledgement: 'watermark removed' }), /not valid/);
-});

package/dist/hygiene.test.js

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { cleanHygiene, finalOutputCheck, hygieneSourceFindings, inspectHygiene } from './hygiene.js';
-test('reports zero-width, bidi, tag, and unusual-space characters with exact offsets', () => {
-    const text = `one\u200Btwo\u202Ethree\u{E0001}\u00A0four`;
-    const report = inspectHygiene(text);
-    assert.equal(report.suspiciousCount, 4);
-    assert.equal(report.fixableCount, 0);
-    assert.deepEqual(report.hits.map((hit) => [hit.codepoint, hit.kind, hit.count]), [
-        ['U+00A0', 'unusual_space', 1],
-        ['U+200B', 'zero_width', 1],
-        ['U+202E', 'bidi', 1],
-        ['U+E0001', 'tag', 1],
-    ]);
-    assert.deepEqual(report.hits.find((hit) => hit.codepoint === 'U+E0001')?.offsets, [13]);
-});
-test('removes byte-order marks and preserves language, spacing, bidi, and tag controls', () => {
-    const text = `\uFEFFa\u200Bb\uFEFFc\u00A0d\u200Ce\u200Df\u202Eg\u{E0001}`;
-    const result = cleanHygiene(text);
-    assert.equal(result.cleaned, `a\u200Bbc\u00A0d\u200Ce\u200Df\u202Eg\u{E0001}`);
-    assert.equal(result.changed, true);
-    assert.deepEqual(result.changes.map((change) => [change.codepoint, change.action]), [['U+FEFF', 'removed'], ['U+FEFF', 'removed']]);
-    assert.equal(result.report.suspiciousCount, 8);
-    assert.equal(result.report.fixableCount, 2);
-});
-test('leaves clean text byte-for-byte unchanged', () => {
-    const text = 'plain text\nwith normal spaces.';
-    const result = cleanHygiene(text);
-    assert.equal(result.cleaned, text);
-    assert.equal(result.changed, false);
-    assert.deepEqual(result.changes, []);
-    assert.deepEqual(result.report.hits, []);
-});
-test('projects eligible hygiene hits as source-offset findings', () => {
-    const findings = hygieneSourceFindings('\uFEFFplain');
-    assert.equal(findings.length, 1);
-    assert.equal(findings[0]?.start, 0);
-    assert.equal(findings[0]?.eligible, true);
-});
-test('groups repeated report-only hits and preserves supplementary characters', () => {
-    const text = `😀\u200Bword\u200B`;
-    const result = cleanHygiene(text);
-    assert.equal(result.cleaned, text);
-    assert.equal(result.report.suspiciousCount, 2);
-    assert.equal(result.report.hits.length, 1);
-    assert.equal(result.report.hits[0]?.count, 2);
-    assert.deepEqual(result.report.hits[0]?.offsets, [2, 7]);
-});
-test('preserves multilingual spacing and word-boundary controls byte-for-byte', () => {
-    const text = `ไทย\u200Bภาษา 10\u00A0kg 日本語\u3000本文 ᠮ\u180Eᠣ a\u2060b`;
-    const result = cleanHygiene(text);
-    assert.equal(result.cleaned, text);
-    assert.equal(result.changed, false);
-    assert.equal(result.report.suspiciousCount, 5);
-    assert.equal(result.report.fixableCount, 0);
-});
-test('accepts exact clean output and removes only non-semantic controls by default', () => {
-    const clean = finalOutputCheck('exact output\n');
-    assert.equal(clean.accepted, true);
-    assert.equal(clean.accepted && clean.output, 'exact output\n');
-    assert.equal(clean.changed, false);
-    const bom = finalOutputCheck('\uFEFFexact output');
-    assert.equal(bom.accepted, true);
-    assert.equal(bom.accepted && bom.output, 'exact output');
-    assert.deepEqual(bom.changes, [{ offset: 0, codepoint: 'U+FEFF', action: 'removed' }]);
-    const controls = finalOutputCheck('one\u0007two\uFEFFthree');
-    assert.equal(controls.accepted, true);
-    assert.equal(controls.accepted && controls.output, 'onetwothree');
-    assert.deepEqual(controls.changes.map((change) => change.codepoint), ['U+0007', 'U+FEFF']);
-});
-test('withholds output when hidden characters remain unresolved', () => {
-    const result = finalOutputCheck('Thai\u200Bboundary 👩\u200D💻');
-    assert.equal(result.accepted, false);
-    assert.equal('output' in result, false);
-    assert.equal(result.changed, false);
-    assert.deepEqual(result.remaining.hits.map((hit) => hit.codepoint), ['U+200B', 'U+200D']);
-});
-test('withholds C1 controls rather than removing them', () => {
-    const result = finalOutputCheck('safe\u009Bhidden');
-    assert.equal(result.accepted, false);
-    assert.equal('output' in result, false);
-    assert.deepEqual(result.remaining.hits.map((hit) => [hit.codepoint, hit.kind]), [['U+009B', 'c1_control']]);
-});

package/dist/judgment-task.test.js

@@ -1,162 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { bindJudgmentEnvelope, preparePostCandidateJudgment, preparePreEditJudgment, reducePostCandidate, reducePreEdit } from './judgment-task.js';
-import { applyRewriteResponse, applyShip, prepareRewriteTask } from './rewrite-task.js';
-import { hygieneSourceFindings } from './hygiene.js';
-import { buildProfile } from './voice-dna.js';
-const profile = buildProfile([
-    'I write clear notes. I keep the mechanism visible.',
-    'I name the trade-off. Then I make the next step plain.',
-], ['leverage']);
-function envelope(task, decision, extra = {}) {
-    return {
-        version: '1',
-        stage: task.stage,
-        judgmentType: task.judgmentType,
-        taskFingerprint: task.taskFingerprint,
-        bindings: { ...task.bindings, evaluatorId: 'writer.1' },
-        findings: [],
-        decision,
-        ...extra,
-    };
-}
-test('pre-edit findings select SHIP, bounded EDIT, or REBUILD', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August.';
-    const triage = preparePreEditJudgment(draft, profile, 'triage');
-    const argument = preparePreEditJudgment(draft, profile, 'argument');
-    const form = preparePreEditJudgment(draft, profile, 'form');
-    const ship = reducePreEdit([
-        bindJudgmentEnvelope(triage, envelope(triage, 'SHIP')),
-        bindJudgmentEnvelope(argument, envelope(argument, 'SHIP')),
-        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
-    ]);
-    assert.equal(ship.decision, 'SHIP');
-    const edit = reducePreEdit([
-        bindJudgmentEnvelope(triage, envelope(triage, 'EDIT', { editScope: { ranges: [{ startSentenceId: 1, endSentenceId: 1 }] } })),
-        bindJudgmentEnvelope(argument, envelope(argument, 'SHIP')),
-        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
-    ]);
-    assert.equal(edit.decision, 'EDIT');
-    assert.deepEqual(edit.editScope.ranges, [{ startSentenceId: 1, endSentenceId: 1 }]);
-    const rebuild = reducePreEdit([
-        bindJudgmentEnvelope(triage, envelope(triage, 'SHIP')),
-        bindJudgmentEnvelope(argument, envelope(argument, 'REBUILD')),
-        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
-    ]);
-    assert.equal(rebuild.decision, 'REBUILD');
-    assert.match(rebuild.recommendationFingerprint, /^[a-f0-9]{64}$/);
-});
-test('unbounded argument failure can recommend only rebuild', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August.';
-    const triage = preparePreEditJudgment(draft, profile, 'triage');
-    const argument = preparePreEditJudgment(draft, profile, 'argument');
-    const form = preparePreEditJudgment(draft, profile, 'form');
-    const reduced = reducePreEdit([
-        bindJudgmentEnvelope(triage, envelope(triage, 'EDIT', { editScope: { ranges: [{ startSentenceId: 1, endSentenceId: 1 }] } })),
-        bindJudgmentEnvelope(argument, envelope(argument, 'EDIT', { findings: [{ kind: 'argument', unbounded: true }] })),
-        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
-    ]);
-    assert.equal(reduced.decision, 'REBUILD');
-    assert.equal(reduced.reason, 'unbounded_argument_failure');
-});
-test('paragraph-level findings cannot unlock text without named ranges', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August.';
-    const triage = preparePreEditJudgment(draft, profile, 'triage');
-    const argument = preparePreEditJudgment(draft, profile, 'argument');
-    const form = preparePreEditJudgment(draft, profile, 'form');
-    assert.throws(() => reducePreEdit([
-        bindJudgmentEnvelope(triage, envelope(triage, 'EDIT')),
-        bindJudgmentEnvelope(argument, envelope(argument, 'SHIP')),
-        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
-    ]), /contiguous sentence ranges/);
-});
-test('deleting one eligible sentence or merging two adjacent sentences succeeds', () => {
-    const draft = 'I leverage the answer. I leverage the second point. The launch is on 14 August.';
-    const task = prepareRewriteTask(draft, profile, undefined, undefined, [1, 2]);
-    const deleted = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [{ startSentenceId: 1, endSentenceId: 1, text: '' }],
-    });
-    assert.equal(deleted.status, 'accepted');
-    assert.equal(deleted.candidate, ' I leverage the second point. The launch is on 14 August.');
-    const merged = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [{ startSentenceId: 1, endSentenceId: 2, text: 'I use both points.' }],
-    });
-    assert.equal(merged.status, 'accepted');
-    assert.equal(merged.candidate, 'I use both points. The launch is on 14 August.');
-});
-test('overlapping, noncontiguous, out-of-order, or partly locked ranges fail before candidate construction', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August. I keep the mechanism visible.';
-    const task = prepareRewriteTask(draft, profile);
-    const overlap = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [
-            { startSentenceId: 1, endSentenceId: 1, text: 'I use the answer.' },
-            { startSentenceId: 1, endSentenceId: 1, text: 'I choose the answer.' },
-        ],
-    });
-    assert.equal(overlap.status, 'repairable');
-    assert.equal(overlap.candidate, undefined);
-    assert.equal(overlap.failures[0]?.code, 'overlapping_range');
-    const locked = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [{ startSentenceId: 1, endSentenceId: 2, text: 'I use the answer. The launch is on 14 August.' }],
-    });
-    assert.equal(locked.status, 'repairable');
-    assert.equal(locked.failures[0]?.code, 'partly_locked_range');
-});
-test('SHIP returns original bytes without a model response body', () => {
-    const draft = 'I leverage the answer. The launch is on 14 August.';
-    const task = prepareRewriteTask(draft, profile);
-    const shipped = applyShip(task);
-    assert.equal(shipped.status, 'accepted');
-    assert.equal(shipped.candidate, draft);
-    assert.equal(shipped.receipt.mode, 'SHIP');
-    const viaResponse = applyRewriteResponse(task, { version: '1', mode: 'SHIP', taskFingerprint: task.fingerprint });
-    assert.equal(viaResponse.candidate, draft);
-});
-test('hygiene changes occur only through eligible source-offset findings', () => {
-    const draft = `\uFEFFI leverage the answer.`;
-    const findings = hygieneSourceFindings(draft);
-    assert.equal(findings[0]?.eligible, true);
-    const task = prepareRewriteTask(draft, profile);
-    const rejected = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [],
-        hygieneOperations: [{ start: 1, end: 2, text: '' }],
-    });
-    assert.equal(rejected.status, 'repairable');
-    assert.equal(rejected.failures[0]?.code, 'ineligible_hygiene_offset');
-    const cleaned = applyRewriteResponse(task, {
-        version: '2',
-        taskFingerprint: task.fingerprint,
-        operations: [{ startSentenceId: 1, endSentenceId: 1, text: 'I use the answer.' }],
-        hygieneOperations: [{ start: findings[0].start, end: findings[0].end, text: '' }],
-    });
-    assert.equal(cleaned.status, 'accepted');
-    assert.equal(cleaned.candidate, 'I use the answer.');
-});
-test('post-candidate reduction requires the full judgment set', () => {
-    const draft = 'I write clear notes.';
-    const candidate = 'I write clear notes.';
-    const kinds = ['argument', 'polarity', 'form', 'flatness', 'semantic'];
-    const envelopes = kinds.map((kind) => {
-        const task = preparePostCandidateJudgment(draft, candidate, profile, kind);
-        return bindJudgmentEnvelope(task, {
-            version: '1',
-            stage: 'post-candidate',
-            judgmentType: kind,
-            taskFingerprint: task.taskFingerprint,
-            bindings: { ...task.bindings, evaluatorId: 'writer.1' },
-            findings: [],
-            decision: 'CLEAR',
-        });
-    });
-    assert.equal(reducePostCandidate(envelopes).decision, 'CLEAR');
-});