@holdyourvoice/hyv 3.2.0 → 3.3.0

package/dist/release-audit.test.js

@@ -5,21 +5,38 @@ import { dirname, join } from 'node:path';
 import { execFileSync, spawnSync } from 'node:child_process';
 import test from 'node:test';
 const audit = new URL('../scripts/release-audit.mjs', import.meta.url).pathname;
+const stage1Files = [
+    'scripts/evaluate-rewrite-benchmark.mjs',
+    'scripts/run-stage1-dry-run.mjs',
+    'scripts/run-stage1-human-packet.mjs',
+    'scripts/run-stage2-human-packet.mjs',
+    'benchmarks/schema/protocol-manifest.v1.schema.json',
+    'benchmarks/schema/run-event.v1.schema.json',
+    'benchmarks/schema/blind-packet.v1.schema.json',
+    'benchmarks/schema/blind-mapping.v1.schema.json',
+    'benchmarks/schema/reviewer-record.v1.schema.json',
+    'benchmarks/schema/ratings-seal.v1.schema.json',
+    'benchmarks/schema/aggregate-report.v1.schema.json',
+    'benchmarks/schema/checkpoint-disposition.v1.schema.json',
+];
 function fixture(files) {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-audit-'));
     execFileSync('git', ['init', '--quiet'], { cwd: directory });
     const defaults = {
-        'package.json': JSON.stringify({ license: 'MIT', files: ['LICENSE'], version: '1.0.0' }),
+        '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' } }),
         'mcpb/manifest.json': JSON.stringify({ version: '1.0.0' }),
         'claude-plugin/.claude-plugin/plugin.json': JSON.stringify({ version: '1.0.0' }),
         '.claude-plugin/marketplace.json': JSON.stringify({ plugins: [{ name: 'hold-your-voice', version: '1.0.0' }] }),
         'claude-plugin/.mcp.json': JSON.stringify({ mcpServers: { 'hold-your-voice': { args: ['--package=@holdyourvoice/hyv@1.0.0'] } } }),
+        'Readme.md': '# public',
         LICENSE: [
             'Permission is hereby granted, free of charge, to any person obtaining a copy',
             'The above copyright notice and this permission notice shall be included in all',
             'THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND',
         ].join('\n'),
         'src/version.ts': "export const HYV_VERSION = '1.0.0';",
+        'src/stage1-evaluation.ts': "const baseline = '4e6269121d551c008a34db73077e1e4fea41b3f9'; const stage1 = '550ea24f652291dca13757fdbd2f0fa0b5e3f621';",
+        ...Object.fromEntries(stage1Files.map((file) => [file, '{}'])),
     };
     for (const [file, text] of Object.entries({ ...defaults, ...files })) {
         const path = join(directory, file);
@@ -29,6 +46,34 @@ function fixture(files) {
     execFileSync('git', ['add', 'README.md'], { cwd: directory });
     return directory;
 }
+test('accepts the complete public package contract', () => {
+    const directory = fixture({ 'README.md': '# public' });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.equal(result.status, 0, result.stderr);
+        assert.match(result.stdout, /release audit passed/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('requires exact Stage 1 scripts even when the checkpoint files remain', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'package.json': JSON.stringify({ name: 'audit-fixture', license: 'MIT', files: ['dist', 'Readme.md', 'LICENSE'], scripts: { 'stage1:evaluate': 'node changed.mjs' }, version: '1.0.0', type: 'module', bin: { hyv: 'dist/cli.js' }, engines: { node: '>=20' } }),
+    });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /Stage 1 script contract has drifted: stage1:evaluate/);
+        assert.match(result.stderr, /Stage 1 script contract has drifted: stage1:dry-run/);
+        assert.match(result.stderr, /Stage 1 script contract has drifted: stage1:human-packet/);
+        assert.match(result.stderr, /Stage 1 script contract has drifted: stage2:human-packet/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('rejects unquoted credentials in an untracked source file', () => {
     const directory = fixture({ 'README.md': '# public', 'src/unsafe.ts': ['const ', 'API_KEY', '=topsecret;'].join('') });
     try {
@@ -43,7 +88,7 @@ test('rejects unquoted credentials in an untracked source file', () => {
 test('requires the Claude extension version to match npm', () => {
     const directory = fixture({
         'README.md': '# public',
-        'package.json': JSON.stringify({ license: 'MIT', files: ['LICENSE'], version: '1.0.0' }),
+        'package.json': JSON.stringify({ name: 'audit-fixture', license: 'MIT', files: ['dist', 'Readme.md', 'LICENSE'], version: '1.0.0', type: 'module', bin: { hyv: 'dist/cli.js' }, engines: { node: '>=20' } }),
         'mcpb/manifest.json': JSON.stringify({ version: '1.0.1' }),
     });
     try {
@@ -84,3 +129,67 @@ test('requires the MCP runtime version to match npm', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('requires the npm package runtime contract', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'package.json': JSON.stringify({
+            name: 'audit-fixture',
+            license: 'MIT',
+            files: ['LICENSE'],
+            version: '1.0.0',
+            type: 'commonjs',
+            bin: { hyv: 'src/cli.ts' },
+            engines: { node: '>=18' },
+        }),
+    });
+    try {
+        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 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/);
+        assert.match(result.stderr, /npm package must require Node 20 or newer/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('rejects every package manifest path outside the public allowlist', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'package.json': JSON.stringify({
+            name: 'audit-fixture',
+            license: 'MIT',
+            files: ['dist', 'Readme.md', 'LICENSE', 'docs', 'benchmarks/private', 'profiles'],
+            version: '1.0.0',
+            type: 'module',
+            bin: { hyv: 'dist/cli.js' },
+            engines: { node: '>=20' },
+        }),
+    });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /npm package exposes an unexpected path: docs/);
+        assert.match(result.stderr, /npm package exposes an unexpected path: benchmarks\/private/);
+        assert.match(result.stderr, /npm package exposes an unexpected path: profiles/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('rejects a forbidden nested file from the actual npm package list', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'dist/profiles/private.json': '{"secret":true}',
+    });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /npm package contains an unexpected file: dist\/profiles\/private\.json/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});

package/dist/rewrite-task.js

@@ -1,12 +1,14 @@
 import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.js';
 import { parseWritingBrief } from './editorial-packs.js';
-import { rewritePrompt, verify, verifyWithCopySpec } from './pipeline.js';
+import { hygieneSourceFindings } from './hygiene.js';
+import { analyze, deriveEditScope, renderRewritePrompt, verifyDeterministically } from './pipeline.js';
 import { sentences } from './text.js';
 const MAX_RESPONSE_BYTES = 100_000;
 const MAX_REPLACEMENTS = 100;
 const MAX_REPLACEMENT_CHARACTERS = 10_000;
 function fingerprint(value) {
-    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+    return createHash('sha256').update(typeof value === 'string' ? value : canonicalJson(value)).digest('hex');
 }
 function failure(code, message, path) {
     return { code, message, ...(path ? { path } : {}) };
@@ -34,10 +36,40 @@ function parseResponse(value) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return failure('invalid_response_shape', 'Response must be an object.');
     const response = raw;
-    if (response.version !== '1')
-        return failure('invalid_response_version', 'Response version must be "1".', 'version');
     if (typeof response.taskFingerprint !== 'string' || response.taskFingerprint.length !== 64)
         return failure('invalid_response_shape', 'Response must include the task fingerprint.', 'taskFingerprint');
+    if (response.mode === 'REBUILD')
+        return failure('rebuild_response_on_edit_task', 'Rebuild responses cannot satisfy edit tasks.', 'mode');
+    if (response.mode === 'SHIP' && response.version === '1') {
+        return { version: '1', mode: 'SHIP', taskFingerprint: response.taskFingerprint };
+    }
+    if (response.version === '2') {
+        if (!Array.isArray(response.operations))
+            return failure('invalid_response_shape', 'Version 2 responses require an operations array.', 'operations');
+        if (response.operations.length > MAX_REPLACEMENTS)
+            return failure('invalid_response_shape', `Response may include at most ${MAX_REPLACEMENTS} replacements.`, 'operations');
+        for (const [index, operation] of response.operations.entries()) {
+            if (!operation || typeof operation !== 'object' || !Number.isInteger(operation.startSentenceId) || !Number.isInteger(operation.endSentenceId) || typeof operation.text !== 'string') {
+                return failure('invalid_response_shape', 'Every operation requires integer startSentenceId, endSentenceId, and string text.', `operations[${index}]`);
+            }
+            if (operation.endSentenceId < operation.startSentenceId)
+                return failure('noncontiguous_range', 'A range must be inclusive and contiguous.', `operations[${index}]`);
+            if (operation.text.length > MAX_REPLACEMENT_CHARACTERS)
+                return failure('invalid_replacement_text', `Replacement text must contain at most ${MAX_REPLACEMENT_CHARACTERS} characters.`, `operations[${index}].text`);
+        }
+        if (response.hygieneOperations !== undefined) {
+            if (!Array.isArray(response.hygieneOperations))
+                return failure('invalid_response_shape', 'Hygiene operations must be an array.', 'hygieneOperations');
+            for (const [index, operation] of response.hygieneOperations.entries()) {
+                if (!operation || !Number.isInteger(operation.start) || !Number.isInteger(operation.end) || typeof operation.text !== 'string' || operation.end < operation.start) {
+                    return failure('invalid_response_shape', 'Every hygiene operation requires integer start, end, and string text.', `hygieneOperations[${index}]`);
+                }
+            }
+        }
+        return response;
+    }
+    if (response.version !== '1')
+        return failure('invalid_response_version', 'Response version must be "1" or "2".', 'version');
     if (!Array.isArray(response.replacements))
         return failure('invalid_response_shape', 'Response replacements must be an array.', 'replacements');
     if (response.replacements.length > MAX_REPLACEMENTS)
@@ -74,18 +106,17 @@ function repairFencedJson(value) {
     const match = value.match(/^```json\s*\n([\s\S]*?)\n```\s*$/i);
     return match ? { value: match[1], adapterId: 'fenced_json_v1' } : { value };
 }
-export function prepareRewriteTask(draft, profile, copySpec, writingBrief) {
-    const analysis = rewritePrompt(draft, profile, [], writingBrief);
+export function prepareRewriteTask(draft, profile, copySpec, writingBrief, authorizedSentenceIds = []) {
+    const result = analyze(draft, profile, writingBrief);
+    const prompt = renderRewritePrompt(draft, profile, result, [], writingBrief);
     const mapped = sentences(draft);
-    const eligibleSentenceIds = new Set([
-        ...analysis.matchAll(/^- Sentence (\d+) \[/gm),
-    ].map((match) => Number(match[1])));
+    const eligibleSentenceIds = new Set([...deriveEditScope(result).eligibleSentenceIds, ...authorizedSentenceIds]);
     const taskBase = {
         version: '1',
         draft,
         sentences: mapped.map((sentence) => ({ id: sentence.index, text: sentence.text, eligible: eligibleSentenceIds.has(sentence.index) })),
         eligibleSentenceIds: [...eligibleSentenceIds].sort((left, right) => left - right),
-        prompt: analysis,
+        prompt,
         ...(copySpec ? { copySpec } : {}),
         ...(writingBrief ? { writingBrief } : {}),
     };
@@ -106,7 +137,22 @@ export function parseRewriteTask(value) {
     return task;
 }
 function rejected(task, raw, failures, adapterIds = []) {
-    return { status: 'repairable', failures, receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds } };
+    return { status: 'repairable', failures, receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds, replacementSentenceIds: [] } };
+}
+export function applyShip(task) {
+    return {
+        status: 'accepted',
+        candidate: task.draft,
+        failures: [],
+        receipt: {
+            version: '1',
+            taskFingerprint: task.fingerprint,
+            responseFingerprint: fingerprint({ version: '1', mode: 'SHIP', taskFingerprint: task.fingerprint }),
+            adapterIds: [],
+            replacementSentenceIds: [],
+            mode: 'SHIP',
+        },
+    };
 }
 export function applyRewriteResponse(task, raw) {
     const source = typeof raw === 'string' ? parseJson(raw) : raw;
@@ -119,6 +165,14 @@ export function applyRewriteResponse(task, raw) {
         return rejected(task, raw, [response], adapterIds);
     if (response.taskFingerprint !== task.fingerprint)
         return rejected(task, raw, [failure('task_fingerprint_mismatch', 'Response task fingerprint does not match this task.', 'taskFingerprint')], adapterIds);
+    if ('mode' in response && response.mode === 'SHIP') {
+        const shipped = applyShip(task);
+        return { ...shipped, receipt: { ...shipped.receipt, adapterIds, responseFingerprint: responseFingerprint(raw) } };
+    }
+    if (response.version === '2')
+        return applyRangeResponse(task, response, raw, adapterIds);
+    if (!('replacements' in response))
+        return rejected(task, raw, [failure('invalid_response_shape', 'Response replacements must be an array.', 'replacements')], adapterIds);
     const seen = new Set();
     const sentenceMap = new Map(task.sentences.map((sentence) => [sentence.id, sentence]));
     for (const [index, replacement] of response.replacements.entries()) {
@@ -139,16 +193,82 @@ export function applyRewriteResponse(task, raw) {
         if (replacement !== undefined)
             candidate = `${candidate.slice(0, sentence.start)}${replacement}${candidate.slice(sentence.end)}`;
     }
-    return { status: 'accepted', candidate, failures: [], receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds } };
+    return { status: 'accepted', candidate, failures: [], receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: responseFingerprint(raw), adapterIds, replacementSentenceIds: [...seen].sort((left, right) => left - right), mode: 'EDIT' } };
+}
+function applyRangeResponse(task, response, raw, adapterIds) {
+    const sentenceMap = new Map(task.sentences.map((sentence) => [sentence.id, sentence]));
+    let previousEnd = 0;
+    for (const [index, operation] of response.operations.entries()) {
+        if (index > 0 && operation.startSentenceId <= previousEnd)
+            return rejected(task, raw, [failure('overlapping_range', 'Operations must be ordered and non-overlapping.', `operations[${index}]`)], adapterIds);
+        if (index > 0 && operation.startSentenceId < response.operations[index - 1].startSentenceId) {
+            return rejected(task, raw, [failure('out_of_order_range', 'Operations must be in source order.', `operations[${index}]`)], adapterIds);
+        }
+        previousEnd = operation.endSentenceId;
+        for (let id = operation.startSentenceId; id <= operation.endSentenceId; id += 1) {
+            const sentence = sentenceMap.get(id);
+            if (!sentence)
+                return rejected(task, raw, [failure('unknown_sentence_id', 'Range sentenceId is not in this task.', `operations[${index}]`)], adapterIds);
+            if (!sentence.eligible)
+                return rejected(task, raw, [failure('partly_locked_range', 'A range may cover only eligible sentences.', `operations[${index}]`)], adapterIds);
+            if (id > operation.startSentenceId && !sentenceMap.has(id - 1))
+                return rejected(task, raw, [failure('noncontiguous_range', 'Ranges must be contiguous.', `operations[${index}]`)], adapterIds);
+        }
+    }
+    const eligibleHygiene = new Map(hygieneSourceFindings(task.draft).filter((finding) => finding.eligible).map((finding) => [`${finding.start}:${finding.end}`, finding]));
+    for (const [index, operation] of (response.hygieneOperations ?? []).entries()) {
+        if (!eligibleHygiene.has(`${operation.start}:${operation.end}`)) {
+            return rejected(task, raw, [failure('ineligible_hygiene_offset', 'Hygiene changes require an eligible source-offset finding.', `hygieneOperations[${index}]`)], adapterIds);
+        }
+    }
+    let candidate = task.draft;
+    for (const operation of [...(response.hygieneOperations ?? [])].sort((left, right) => right.start - left.start)) {
+        candidate = `${candidate.slice(0, operation.start)}${operation.text}${candidate.slice(operation.end)}`;
+    }
+    const mapped = sentences(candidate);
+    for (const operation of [...response.operations].reverse()) {
+        const start = mapped.find((sentence) => sentence.index === operation.startSentenceId);
+        const end = mapped.find((sentence) => sentence.index === operation.endSentenceId);
+        if (!start || !end)
+            return rejected(task, raw, [failure('unknown_sentence_id', 'Range sentenceId is not in this task.', 'operations')], adapterIds);
+        candidate = `${candidate.slice(0, start.start)}${operation.text}${candidate.slice(end.end)}`;
+    }
+    return {
+        status: 'accepted',
+        candidate,
+        failures: [],
+        receipt: {
+            version: '1',
+            taskFingerprint: task.fingerprint,
+            responseFingerprint: responseFingerprint(raw),
+            adapterIds,
+            operationRanges: response.operations.map((operation) => ({ startSentenceId: operation.startSentenceId, endSentenceId: operation.endSentenceId })),
+            mode: 'EDIT',
+        },
+    };
 }
 export function evaluateRewriteResponse(task, raw, profile) {
     const applied = applyRewriteResponse(task, raw);
     if (applied.status !== 'accepted' || !applied.candidate)
         return applied;
-    const verification = task.copySpec
-        ? verifyWithCopySpec(task.draft, applied.candidate, profile, task.copySpec, task.writingBrief)
-        : verify(task.draft, applied.candidate, profile, task.writingBrief);
+    const { verification, artifact: deterministicArtifact } = verifyDeterministically(task.draft, applied.candidate, profile, task.copySpec, task.writingBrief);
     if (!verification.passed)
         return { ...applied, status: 'needs_escalation', verification };
-    return { ...applied, status: 'needs_semantic_review', verification };
+    const lifecycleBinding = createRewriteLifecycleBinding(task, applied.receipt, deterministicArtifact);
+    return { ...applied, status: 'needs_semantic_review', verification, deterministicArtifact, lifecycleBinding };
+}
+export function createRewriteLifecycleBinding(task, receipt, deterministic) {
+    if (!deterministic.passed || receipt.taskFingerprint !== task.fingerprint)
+        throw new Error('Lifecycle binding requires a passed deterministic artifact for this rewrite task.');
+    return {
+        rewriteTaskFingerprint: task.fingerprint,
+        rewriteResponseFingerprint: receipt.responseFingerprint,
+        deterministicArtifactFingerprint: deterministic.artifactFingerprint,
+        sourceHash: deterministic.sourceHash,
+        candidateHash: deterministic.candidateHash,
+        profileId: deterministic.profileId,
+        profileRevisionDigest: deterministic.profileRevisionDigest,
+        rulesetVersion: deterministic.rulesetVersion,
+        schemaVersion: '1',
+    };
 }

package/dist/rewrite-task.test.js

@@ -1,8 +1,10 @@
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
 import test from 'node:test';
-import { applyRewriteResponse, parseRewriteTask, prepareRewriteTask } from './rewrite-task.js';
+import { applyRewriteResponse, createRewriteLifecycleBinding, evaluateRewriteResponse, parseRewriteTask, prepareRewriteTask } from './rewrite-task.js';
 import { parseWritingBrief } from './editorial-packs.js';
+import { canonicalJson } from './canonical-json.js';
+import { verifyDeterministically } from './pipeline.js';
 import { buildProfile } from './voice-dna.js';
 const profile = buildProfile([
     'I write clear notes. I keep the mechanism visible.',
@@ -19,10 +21,28 @@ test('applies only eligible numbered replacements and preserves all clean bytes'
     assert.equal(result.candidate, 'I use the answer. The launch is on 14 August.');
     assert.deepEqual(result.receipt.adapterIds, []);
 });
-test('makes only the sentence with a broad catalog match eligible', () => {
+test('does not make an advisory broad catalog match eligible', () => {
     const task = prepareRewriteTask('I write clear notes. This work is meaningful. I keep the mechanism visible.', profile);
-    assert.deepEqual(task.eligibleSentenceIds, [2]);
-    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, true, false]);
+    assert.deepEqual(task.eligibleSentenceIds, []);
+    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, false, false]);
+});
+test('grants edit scope only to blocking findings and keeps pending judgment separate', () => {
+    const advisory = prepareRewriteTask('Firstly, check the invoice.', profile);
+    assert.deepEqual(advisory.eligibleSentenceIds, []);
+    const neutralProfile = buildProfile(['I write plainly.', 'I name the mechanism.']);
+    const pending = prepareRewriteTask('We leverage the scheduler.', neutralProfile);
+    assert.deepEqual(pending.eligibleSentenceIds, []);
+    assert.match(pending.prompt, /pending judgment/i);
+    const blocking = prepareRewriteTask('The scheduler failed — twice. The owner checked it.', profile);
+    assert.deepEqual(blocking.eligibleSentenceIds, [1]);
+});
+test('keeps blocking VoiceDNA avoid findings eligible', () => {
+    const task = prepareRewriteTask('The plan uses leverage.', profile);
+    assert.deepEqual(task.eligibleSentenceIds, [1]);
+});
+test('preserves founder reframes that reconciled policy makes advisory', () => {
+    const task = prepareRewriteTask("This isn't positioning. This is proof.", profile);
+    assert.deepEqual(task.eligibleSentenceIds, []);
 });
 test('preserves a clean draft byte-for-byte when the rewrite response is empty', () => {
     const draft = 'I write clear notes.\n\nI keep the mechanism visible.\n';
@@ -32,24 +52,33 @@ test('preserves a clean draft byte-for-byte when the rewrite response is empty',
     assert.equal(result.status, 'accepted');
     assert.equal(result.candidate, draft);
 });
+test('rejects an attempted edit to a clean sentence without changing any source bytes', () => {
+    const draft = 'I leverage the answer.\n\nThe launch starts Tuesday.\n';
+    const task = prepareRewriteTask(draft, profile);
+    const result = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 2, text: 'The launch starts Wednesday.' }] });
+    assert.equal(result.status, 'repairable');
+    assert.equal(result.candidate, undefined);
+    assert.equal(result.failures[0]?.code, 'ineligible_sentence_id');
+    assert.equal(task.draft, draft);
+});
 test('carries WritingBrief context into a fingerprinted rewrite task', () => {
     const brief = parseWritingBrief({ version: '1', audience: 'founders', intent: 'start a discussion', format: 'social' });
     const task = prepareRewriteTask('A pattern I keep seeing in founder posts is vague advice.', profile, undefined, brief);
     assert.equal(task.writingBrief?.format, 'social');
-    assert.ok(task.eligibleSentenceIds.includes(1));
+    assert.deepEqual(task.eligibleSentenceIds, []);
 });
 test('rejects a fingerprint-valid rewrite task with malformed WritingBrief data', () => {
     const task = prepareRewriteTask('I leverage the answer.', profile);
     const { fingerprint: _fingerprint, ...taskBase } = task;
     const base = { ...taskBase, writingBrief: { version: '1', audience: 'operators', intent: 'write', format: 'general', prohibitedTerms: [42] } };
-    const malformed = { ...base, fingerprint: createHash('sha256').update(JSON.stringify(base)).digest('hex') };
+    const malformed = { ...base, fingerprint: createHash('sha256').update(canonicalJson(base)).digest('hex') };
     assert.throws(() => parseRewriteTask(malformed), /WritingBrief/);
 });
 test('rejects a fingerprint-valid rewrite task with a null WritingBrief', () => {
     const task = prepareRewriteTask('I leverage the answer.', profile);
     const { fingerprint: _fingerprint, ...taskBase } = task;
     const base = { ...taskBase, writingBrief: null };
-    const malformed = { ...base, fingerprint: createHash('sha256').update(JSON.stringify(base)).digest('hex') };
+    const malformed = { ...base, fingerprint: createHash('sha256').update(canonicalJson(base)).digest('hex') };
     assert.throws(() => parseRewriteTask(malformed), /WritingBrief/);
 });
 test('rejects a duplicate, unknown, or clean sentence replacement before it creates a candidate', () => {
@@ -85,6 +114,32 @@ test('keeps a valid response byte-for-byte unchanged by repair adapters', () =>
     assert.equal(result.status, 'accepted');
     assert.equal(result.receipt.responseFingerprint.length, 64);
     assert.deepEqual(result.receipt.adapterIds, []);
+    assert.deepEqual(result.receipt.replacementSentenceIds, [1]);
+});
+test('binds the task, response, deterministic artifact, text hashes, and profile revision', () => {
+    const draft = 'I write clear notes.';
+    const task = prepareRewriteTask(draft, profile);
+    const applied = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] });
+    assert.equal(applied.status, 'accepted');
+    const artifact = verifyDeterministically(draft, applied.candidate, profile).artifact;
+    const binding = createRewriteLifecycleBinding(task, applied.receipt, artifact);
+    assert.equal(binding.rewriteTaskFingerprint, task.fingerprint);
+    assert.equal(binding.rewriteResponseFingerprint, applied.receipt.responseFingerprint);
+    assert.equal(binding.deterministicArtifactFingerprint, artifact.artifactFingerprint);
+    assert.match(binding.sourceHash, /^[a-f0-9]{64}$/);
+});
+test('returns the deterministic artifact and lifecycle binding at the semantic gate', () => {
+    const task = prepareRewriteTask('I write clear notes.', profile);
+    const result = evaluateRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [] }, profile);
+    assert.equal(result.status, 'needs_semantic_review');
+    assert.equal(result.deterministicArtifact?.passed, true);
+    assert.equal(result.lifecycleBinding?.deterministicArtifactFingerprint, result.deterministicArtifact?.artifactFingerprint);
+});
+test('keeps object response fingerprints stable across property order', () => {
+    const task = prepareRewriteTask('I leverage the answer.', profile);
+    const first = applyRewriteResponse(task, { version: '1', taskFingerprint: task.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer.' }] });
+    const second = applyRewriteResponse(task, { replacements: [{ text: 'I use the answer.', sentenceId: 1 }], taskFingerprint: task.fingerprint, version: '1' });
+    assert.equal(first.receipt.responseFingerprint, second.receipt.responseFingerprint);
 });
 test('repairs only an exact outer JSON code fence after JSON parsing fails', () => {
     const task = prepareRewriteTask('I leverage the answer with useful detail and clear mechanism.', profile);

package/dist/rule-reconciliation.test.js

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { rules } from './ai-editor-rules.js';
+function rule(id) {
+    const match = rules.find((candidate) => candidate.id === id);
+    assert.ok(match, `missing rule ${id}`);
+    return match;
+}
+test('struct.not-x-y only detects an explicit two-beat contrast', () => {
+    const matcher = rule('struct.not-x-y').expression;
+    assert.equal(matcher.test('Not speed. Reliability.'), true);
+    assert.equal(matcher.test('This does not include the standard onboarding steps every team runs.'), false);
+});
+test('keeps the explicit this-isnt reframe matcher available to policy', () => {
+    const matcher = rule('struct.this-isnt-x-this-is-y').expression;
+    assert.equal(matcher.test("This isn't positioning. This is proof."), true);
+    assert.equal(matcher.test('This positioning claim has proof.'), false);
+});
+test('treats both long dash characters as red findings', () => {
+    const emDash = rule('punct.em-dash');
+    const enDash = rule('punct.en-dash');
+    assert.equal(emDash.severity, 'red');
+    assert.equal(enDash.severity, 'red');
+    assert.equal(emDash.expression.test('The job failed — retry it.'), true);
+    assert.equal(enDash.expression.test('Use pages 6–11.'), true);
+    assert.equal(emDash.expression.test('The job failed; retry it.'), false);
+    assert.equal(enDash.expression.test('Use pages 6-11.'), false);
+});
+test('detects clear performative-sincerity phrases as red', () => {
+    const matcher = rule('formula.performative-sincerity');
+    assert.equal(matcher.severity, 'red');
+    for (const text of ['To be honest, the launch failed.', 'In all honesty, the launch failed.']) {
+        assert.equal(matcher.expression.test(text), true, text);
+    }
+    assert.equal(matcher.expression.test('The honest report says the launch failed.'), false);
+});
+test('detects performative-sincerity adverbs as yellow', () => {
+    const matcher = rule('hedge.performative-sincerity-adverb');
+    assert.equal(matcher.severity, 'yellow');
+    for (const text of [
+        'Honestly, the launch failed.',
+        'Genuinely, the launch failed.',
+        'Truly, the launch failed.',
+        'Frankly, the launch failed.',
+        'Actually, the launch failed.',
+    ]) {
+        assert.equal(matcher.expression.test(text), true, text);
+    }
+    assert.equal(matcher.expression.test('The genuine invoice arrived.'), false);
+});