@holdyourvoice/hyv 3.1.1 → 3.3.0

package/dist/rebuild-task.test.js

@@ -0,0 +1,179 @@
+import assert from 'node:assert/strict';
+import { createHash, generateKeyPairSync, sign } from 'node:crypto';
+import test from 'node:test';
+import { canonicalJson, canonicalJsonBytes } from './canonical-json.js';
+import { applyRewriteResponse, prepareRewriteTask } from './rewrite-task.js';
+import { applyRebuildResponse, evaluateRebuildResponse, parseRebuildTask, prepareRebuildTask } from './rebuild-task.js';
+import { bindJudgmentEnvelope, preparePreEditJudgment, reducePreEdit } from './judgment-task.js';
+import { verifyDeterministically, verifyRebuildWithCopySpec } from './pipeline.js';
+import { prepareLifecycle, recordApprovedLearning } from './lifecycle-adapter.js';
+import { buildProfile } from './voice-dna.js';
+import { HYV_VERSION } from './version.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']);
+const draft = 'I leverage the answer. The launch is on 14 August.';
+const rebuilt = 'Ship planning now treats one calendar fact as fixed. The launch is on 14 August. Every other sentence in this note is new operational language for the release desk.';
+const copySpec = {
+    version: '1',
+    audience: 'operators',
+    intent: 'explain',
+    channel: 'email',
+    claims: [{ id: 'launch-date', text: 'The launch is on 14 August.', evidence: 'Release calendar, 7 August.' }],
+};
+const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+const trustStore = {
+    version: '1',
+    audience: '@holdyourvoice/hyv',
+    maxCapabilityLifetimeSeconds: 300,
+    keys: [{ issuer: 'host.example', keyId: 'key-1', publicKeySpki: publicKey.export({ format: 'der', type: 'spki' }).toString('base64url'), status: 'active' }],
+};
+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,
+    };
+}
+function rebuildRecommendation(text = draft) {
+    const triage = preparePreEditJudgment(text, profile, 'triage');
+    const argument = preparePreEditJudgment(text, profile, 'argument');
+    const form = preparePreEditJudgment(text, profile, 'form');
+    return reducePreEdit([
+        bindJudgmentEnvelope(triage, envelope(triage, 'SHIP')),
+        bindJudgmentEnvelope(argument, envelope(argument, 'REBUILD')),
+        bindJudgmentEnvelope(form, envelope(form, 'SHIP')),
+    ]);
+}
+function capability(reduction, overrides = {}, source = draft) {
+    const sourceHash = createHash('sha256').update(source).digest('hex');
+    const identity = `legacy-v2:${createHash('sha256').update(canonicalJson(profile)).digest('hex')}`;
+    const claims = {
+        version: '1',
+        purpose: 'hyv.rebuild-authorization',
+        issuer: 'host.example',
+        audience: '@holdyourvoice/hyv',
+        subjectArtifactFingerprint: reduction.recommendationFingerprint,
+        sourceHash,
+        candidateHash: sourceHash,
+        profileId: identity,
+        profileRevisionDigest: identity,
+        keyId: 'key-1',
+        issuedAt: 100,
+        notBefore: 100,
+        expiresAt: 200,
+        nonce: 'nonce-rebuild',
+        ...overrides,
+    };
+    const payload = canonicalJsonBytes(claims);
+    return { payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') };
+}
+function evaluate(task, raw, reduction, boundProfile = profile) {
+    return evaluateRebuildResponse(task, raw, boundProfile, capability(reduction), trustStore, 150);
+}
+test('pre-edit reductions carry a stable recommendation fingerprint', () => {
+    const left = rebuildRecommendation();
+    const right = rebuildRecommendation();
+    assert.equal(left.decision, 'REBUILD');
+    assert.match(left.recommendationFingerprint, /^[a-f0-9]{64}$/);
+    assert.equal(left.recommendationFingerprint, right.recommendationFingerprint);
+});
+test('a caller cannot self-select rebuild or submit a forged authorization', () => {
+    const reduction = rebuildRecommendation();
+    const edit = { ...reduction, decision: 'EDIT' };
+    assert.throws(() => prepareRebuildTask(draft, profile, edit, copySpec, capability(reduction), trustStore, 150), /upstream REBUILD recommendation/);
+    assert.throws(() => prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction, { purpose: 'hyv.final-approval' }), trustStore, 150), /Rebuild authorization is invalid/);
+    assert.throws(() => prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction, { nonce: 'stale' }), { ...trustStore, keys: [{ ...trustStore.keys[0], status: 'revoked' }] }, 150), /Rebuild authorization is invalid/);
+    assert.throws(() => prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction, { sourceHash: '8'.repeat(64) }), trustStore, 150), /Rebuild authorization is invalid/);
+    assert.throws(() => prepareRebuildTask(draft, profile, { ...reduction, recommendationFingerprint: 'a'.repeat(64) }, copySpec, capability(reduction), trustStore, 150), /upstream REBUILD recommendation/);
+});
+test('missing CopySpec blocks rebuild before a candidate is evaluated', () => {
+    const reduction = rebuildRecommendation();
+    assert.throws(() => prepareRebuildTask(draft, profile, reduction, { ...copySpec, claims: [] }, capability(reduction), trustStore, 150), /CopySpec/);
+});
+test('edit and rebuild responses are mutually incompatible', () => {
+    const reduction = rebuildRecommendation();
+    const rebuildTask = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction), trustStore, 150);
+    const editTask = prepareRewriteTask(draft, profile);
+    const rebuildOnEdit = applyRewriteResponse(editTask, { version: '1', mode: 'REBUILD', taskFingerprint: editTask.fingerprint, candidate: rebuilt });
+    assert.equal(rebuildOnEdit.status, 'repairable');
+    assert.equal(rebuildOnEdit.failures[0]?.code, 'rebuild_response_on_edit_task');
+    const replacementsOnRebuild = applyRebuildResponse(rebuildTask, { version: '1', taskFingerprint: rebuildTask.fingerprint, replacements: [{ sentenceId: 1, text: 'I use the answer.' }] });
+    assert.equal(replacementsOnRebuild.status, 'repairable');
+    assert.equal(replacementsOnRebuild.failures[0]?.code, 'edit_response_on_rebuild_task');
+    const unsigned = applyRebuildResponse(rebuildTask, { version: '1', mode: 'REBUILD', taskFingerprint: rebuildTask.fingerprint, candidate: rebuilt });
+    assert.equal(unsigned.status, 'accepted');
+    assert.equal(unsigned.receipt.authorizationFingerprint, undefined);
+    assert.equal(unsigned.receipt.preservationBypass, undefined);
+});
+test('authorized rebuild allows low lexical survival while claims and hygiene still block', () => {
+    const reduction = rebuildRecommendation();
+    const task = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction), trustStore, 150);
+    const passed = evaluate(task, { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: rebuilt }, reduction);
+    assert.equal(passed.status, 'needs_semantic_review');
+    assert.ok((passed.verification?.preservationScore ?? 100) < 70);
+    assert.equal(passed.receipt.mode, 'REBUILD');
+    assert.equal(passed.receipt.preservationBypass, true);
+    assert.ok(Array.isArray(passed.receipt.replacementSentenceIds));
+    assert.ok((passed.receipt.replacementSentenceIds?.length ?? 0) > 0);
+    assert.equal(passed.deterministicArtifact?.verificationKind, 'rebuild');
+    assert.equal(prepareLifecycle(passed.deterministicArtifact, passed.lifecycleBinding, passed.receipt, 'normal', ['action_change']).artifact.status, 'needs_semantic_review');
+    assert.equal(verifyRebuildWithCopySpec(draft, rebuilt, profile, copySpec).passed, true);
+    const missingClaim = evaluate(task, { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: 'Operators should delay the launch indefinitely.' }, reduction);
+    assert.equal(missingClaim.status, 'needs_escalation');
+    const hygiene = evaluate(task, { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: `${rebuilt}\u200B` }, reduction);
+    assert.equal(hygiene.status, 'needs_escalation');
+});
+test('rebuild disagreement cannot record accepted learning', () => {
+    const reduction = rebuildRecommendation();
+    const task = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction), trustStore, 150);
+    const failed = evaluate(task, { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: 'Operators should delay the launch indefinitely.' }, reduction);
+    assert.equal(failed.status, 'needs_escalation');
+    const evaluated = evaluate(task, { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: rebuilt }, reduction);
+    assert.equal(evaluated.status, 'needs_semantic_review');
+    const standard = verifyDeterministically(draft, rebuilt, profile, copySpec);
+    assert.notEqual(standard.artifact.artifactFingerprint, evaluated.deterministicArtifact?.artifactFingerprint);
+    assert.throws(() => recordApprovedLearning({
+        ready: { version: '1', status: 'ready_for_human_review', artifactFingerprint: '1'.repeat(64), transitionFingerprint: '2'.repeat(64), binding: evaluated.lifecycleBinding, semanticPolicy: 'normal', semanticTaskFingerprint: '3'.repeat(64), semanticEvidenceScopeFingerprint: '4'.repeat(64), verdictFingerprints: [] },
+        approved: { version: '1', status: 'approved', artifactFingerprint: '5'.repeat(64), transitionFingerprint: '6'.repeat(64), binding: evaluated.lifecycleBinding, semanticPolicy: 'normal', semanticTaskFingerprint: '3'.repeat(64), semanticEvidenceScopeFingerprint: '4'.repeat(64), verdictFingerprints: [] },
+        decision: { evaluatorId: 'human.1', decision: 'approve' },
+        capability: capability(reduction),
+        source: draft,
+        candidate: rebuilt,
+        profile,
+        context: { now: 150, trustStore, authorizedSemanticEvaluatorIds: { normal: [], highAssurance: [] }, authorizedHumanFinalizerIds: ['human.1'] },
+        copySpec,
+    }), /Invalid lifecycle artifact|Approved learning is not authorized|does not match deterministic verification/);
+});
+test('CLI and MCP rebuild helpers share fingerprints', () => {
+    const reduction = rebuildRecommendation();
+    const task = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction), trustStore, 150);
+    const parsed = parseRebuildTask(JSON.parse(JSON.stringify(task)));
+    assert.equal(parsed.fingerprint, task.fingerprint);
+    assert.equal(parsed.authorizationFingerprint, task.authorizationFingerprint);
+    assert.match(task.prompt, /whole-document candidate/);
+    const briefTask = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction, { nonce: 'nonce-brief' }), trustStore, 150, {
+        version: '1', audience: 'operators', intent: 'explain', format: 'outreach',
+    });
+    assert.match(briefTask.prompt, /# WritingBrief/);
+    assert.equal(HYV_VERSION, '3.3.0');
+});
+test('apply rejects forged tasks, missing capability, and substituted profiles', () => {
+    const reduction = rebuildRecommendation();
+    const task = prepareRebuildTask(draft, profile, reduction, copySpec, capability(reduction), trustStore, 150);
+    const response = { version: '1', mode: 'REBUILD', taskFingerprint: task.fingerprint, candidate: rebuilt };
+    const { fingerprint: _ignored, ...base } = task;
+    const forgedBase = { ...base, authorizationFingerprint: 'a'.repeat(64) };
+    const forged = { ...forgedBase, fingerprint: createHash('sha256').update(canonicalJson(forgedBase)).digest('hex') };
+    assert.equal(parseRebuildTask(forged).fingerprint, forged.fingerprint);
+    assert.throws(() => evaluateRebuildResponse(forged, { ...response, taskFingerprint: forged.fingerprint }, profile, capability(reduction), trustStore, 150), /Rebuild authorization is invalid/);
+    assert.throws(() => evaluateRebuildResponse(task, response, profile, {}, trustStore, 150), /Rebuild authorization is invalid/);
+    const other = buildProfile(['I speak in a different register altogether.', 'I keep every sentence longer than the first profile would.'], ['mechanism']);
+    assert.throws(() => evaluate(task, response, reduction, other), /Rebuild profile binding does not match this task/);
+});

package/dist/release-audit.test.js

@@ -5,17 +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'] }),
+        '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);
@@ -25,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 {
@@ -39,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 {
@@ -51,3 +100,96 @@ test('requires the Claude extension version to match npm', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('requires every Claude package surface to match npm', () => {
+    const directory = fixture({
+        'README.md': '# public',
+        'claude-plugin/.claude-plugin/plugin.json': JSON.stringify({ version: '0.9.0' }),
+        '.claude-plugin/marketplace.json': JSON.stringify({ plugins: [{ name: 'other', version: '1.0.0' }, { name: 'hold-your-voice', version: '0.9.0' }] }),
+        'claude-plugin/.mcp.json': JSON.stringify({ mcpServers: { 'hold-your-voice': { args: ['--package=@holdyourvoice/hyv@0.9.0'] } } }),
+    });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /Claude plugin version must match package\.json/);
+        assert.match(result.stderr, /Claude marketplace version must match package\.json/);
+        assert.match(result.stderr, /Claude plugin package pin must match package\.json/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test('requires the MCP runtime version to match npm', () => {
+    const directory = fixture({ 'README.md': '# public', 'src/version.ts': "export const HYV_VERSION = '0.9.0';" });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /MCP runtime version must match package\.json/);
+    }
+    finally {
+        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',
+    };
 }