@holdyourvoice/hyv 3.6.0 → 3.6.1

package/dist/learning.js

@@ -170,6 +170,9 @@ function receipt(profile, event, status) {
     const publicMetadata = { mutationId: event.mutationId, eventId: event.eventId, profileId: identity(profile), profileRevision: revision(profile), status, timestamp: event.timestamp };
     return { version: '1', ...publicMetadata, digest: digest(publicMetadata) };
 }
+function requestDigest(event) {
+    return digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+}
 function eventBase(profile, kind, options) {
     const mutationId = options.mutationId ?? randomUUID();
     const base = {
@@ -177,7 +180,7 @@ function eventBase(profile, kind, options) {
         profileRevision: revision(profile), revisionDigest: revisionDigest(profile), authority: options.authority ?? 'team',
         provenance: options.provenance ?? 'local', weight: options.weight ?? 1, compatibility: options.compatibility ?? 'same-or-newer', kind,
     };
-    return { ...base, requestDigest: digest({ ...base, eventId: undefined, timestamp: undefined, requestDigest: undefined }) };
+    return { ...base, requestDigest: requestDigest(base) };
 }
 function mutate(profile, event, options, validate) {
     try {
@@ -225,7 +228,7 @@ export function recordVerifiedCandidate(profile, verification, candidate, option
     if (readEvents(profile, options).some((event) => event.kind === 'verified_candidate' && event.outcome === outcome))
         return 'nothing_to_learn';
     const event = { ...eventBase(profile, 'verified_candidate', { ...options, mutationId: options.mutationId ?? outcome }), resolved: resolved.slice(0, MAX_RESOLVED_FINDINGS), outcome };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+    event.requestDigest = requestDigest(event);
     const result = mutate(profile, event, options);
     return result.status === 'recorded' ? 'recorded' : result.status === 'already_recorded' ? 'nothing_to_learn' : 'write_failed';
 }
@@ -236,19 +239,23 @@ export function recordLearningInstruction(profile, instruction, options = {}) {
     if (normalized.length > MAX_INSTRUCTION_CHARACTERS)
         throw new Error(`Learning instructions must be ${MAX_INSTRUCTION_CHARACTERS} characters or fewer.`);
     const event = { ...eventBase(profile, 'instruction', options), instruction: normalized };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
+    event.requestDigest = requestDigest(event);
     return mutate(profile, event, options);
 }
 export function addLearningInstruction(profile, instruction, options = {}) { return recordLearningInstruction(profile, instruction, options).status === 'recorded'; }
+function recordControlEvent(profile, kind, targetEventId, options) {
+    const event = { ...eventBase(profile, kind, options), targetEventId };
+    event.requestDigest = requestDigest(event);
+    return mutate(profile, event, options, (events) => {
+        const target = events.find((item) => item.eventId === targetEventId);
+        return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined;
+    });
+}
 export function ratifyLearningEvent(profile, targetEventId, options = {}) {
-    const event = { ...eventBase(profile, 'ratification', options), targetEventId };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
-    return mutate(profile, event, options, (events) => { const target = events.find((item) => item.eventId === targetEventId); return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined; });
+    return recordControlEvent(profile, 'ratification', targetEventId, options);
 }
 export function supersedeLearningEvent(profile, targetEventId, options = {}) {
-    const event = { ...eventBase(profile, 'supersession', options), targetEventId };
-    event.requestDigest = digest({ ...event, eventId: undefined, timestamp: undefined, requestDigest: undefined });
-    return mutate(profile, event, options, (events) => { const target = events.find((item) => item.eventId === targetEventId); return !target ? 'not_found' : authorityRank[event.authority] < authorityRank[target.authority] ? 'unauthorized' : undefined; });
+    return recordControlEvent(profile, 'supersession', targetEventId, options);
 }
 export function migrateLearningV2ToV3(source, target, options = {}) {
     const sourceFingerprint = profileFingerprint(source);

package/dist/mcp-tools.js

@@ -21,14 +21,17 @@ import { scoreHeldoutProfile } from './profile-score.js';
 import { findWritingExamples } from './writing-examples.js';
 import { evaluateIsolatedBacktest } from './backtest.js';
 import { evaluateLocalComposite } from './local-eval.js';
-function profileFromJson(profileJson) {
+function parseDocument(text, parse, label) {
     try {
-        return parseProfile(JSON.parse(profileJson));
+        return parse(JSON.parse(text));
     }
     catch (error) {
-        throw new Error(error instanceof Error ? error.message : 'Profile is not valid JSON.');
+        throw new Error(error instanceof Error ? error.message : `${label} is not valid JSON.`);
     }
 }
+function profileFromJson(profileJson) {
+    return parseDocument(profileJson, parseProfile, 'Profile');
+}
 function profileV3FromJson(profileJson) {
     const profile = profileFromJson(profileJson);
     if (profile.version !== '3')
@@ -36,22 +39,10 @@ function profileV3FromJson(profileJson) {
     return profile;
 }
 function copySpecFromJson(copySpecJson) {
-    try {
-        return parseCopySpec(JSON.parse(copySpecJson));
-    }
-    catch (error) {
-        throw new Error(error instanceof Error ? error.message : 'CopySpec is not valid JSON.');
-    }
+    return parseDocument(copySpecJson, parseCopySpec, 'CopySpec');
 }
 function writingBriefFromJson(writingBriefJson) {
-    if (!writingBriefJson)
-        return undefined;
-    try {
-        return parseWritingBrief(JSON.parse(writingBriefJson));
-    }
-    catch (error) {
-        throw new Error(error instanceof Error ? error.message : 'WritingBrief is not valid JSON.');
-    }
+    return writingBriefJson ? parseDocument(writingBriefJson, parseWritingBrief, 'WritingBrief') : undefined;
 }
 export function buildProfileForMcp(samples, avoid = []) {
     return buildProfile(samples, avoid);

package/dist/mcp.js

@@ -12,7 +12,6 @@ const profileJson = z.string().min(1).max(50_000);
 const copySpecJson = z.string().min(1).max(250_000);
 const writingBriefJson = z.string().min(1).max(50_000);
 const samples = z.array(writing).min(2).max(20);
-const strictSamples = z.array(writing).min(2).max(20);
 const heldoutSamples = z.array(writing).min(3).max(20);
 const evalParagraphs = z.array(z.object({ paragraph_id: z.string().min(1).max(160), text: writing })).min(2).max(50);
 const writingExamples = z.array(z.object({ basename: z.string().min(1).max(160), text: writing })).min(1).max(64);
@@ -39,9 +38,6 @@ function json(value) {
 function failure(error) {
     return { content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }], isError: true };
 }
-function lifecycleResult(result) {
-    return json(result.ok ? result.artifact : { error: result.error });
-}
 function guardedJson(run, publicError) {
     try {
         return json(run());
@@ -51,12 +47,10 @@ function guardedJson(run, publicError) {
     }
 }
 function guardedLifecycle(run, publicError) {
-    try {
-        return lifecycleResult(run());
-    }
-    catch (error) {
-        return failure(publicError ? new Error(publicError) : error);
-    }
+    return guardedJson(() => {
+        const result = run();
+        return result.ok ? result.artifact : { error: result.error };
+    }, publicError);
 }
 const server = new McpServer({ name: 'hold-your-voice', version: HYV_VERSION });
 server.registerTool('hyv_build_profile', {
@@ -75,7 +69,7 @@ server.registerTool('hyv_analyze', {
 }, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => analyzeForMcp(draft, profile_json, writing_brief_json)));
 server.registerTool('hyv_strict_check', {
     description: 'Run the calibrated local strict-quality gate. It requires a Profile v3 and local writing samples; it returns strict-ready, needs-human-review, or blocked without changing text or learning state.',
-    inputSchema: { draft: writing, profile_json: profileJson, samples: strictSamples, writing_brief_json: writingBriefJson.optional() },
+    inputSchema: { draft: writing, profile_json: profileJson, samples, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
 }, async ({ draft, profile_json, samples: localSamples, writing_brief_json }) => guardedJson(() => strictCheckForMcp(draft, profile_json, localSamples, writing_brief_json)));
 server.registerTool('hyv_score', {

package/dist/mirror-refs.test.js

@@ -23,7 +23,7 @@ test('reconciles branch and tag creates, rewrites, and deletions', () => {
         git(root, 'clone', '--quiet', source, checkout);
         git(checkout, 'config', 'user.name', 'Mirror Test');
         git(checkout, 'config', 'user.email', 'mirror-test@example.invalid');
-        git(checkout, 'switch', '--quiet', '-c', 'main');
+        git(checkout, 'switch', '--quiet', '-c', 'fixture/main');
         writeFileSync(join(checkout, 'main.txt'), 'first\n');
         git(checkout, 'add', 'main.txt');
         git(checkout, 'commit', '--quiet', '-m', 'first');
@@ -34,20 +34,20 @@ test('reconciles branch and tag creates, rewrites, and deletions', () => {
         git(checkout, 'tag', 'v1.0.0');
         git(checkout, 'push', '--quiet', '--all', 'origin');
         git(checkout, 'push', '--quiet', '--tags', 'origin');
-        git(source, 'symbolic-ref', 'HEAD', 'refs/heads/main');
+        git(source, 'symbolic-ref', 'HEAD', 'refs/heads/fixture/main');
         git(checkout, 'remote', 'set-head', 'origin', '-a');
         git(checkout, 'remote', 'add', 'mirror', mirror);
         execFileSync(process.execPath, [mirrorScript], { cwd: checkout, stdio: 'pipe' });
         assert.deepEqual(refs(mirror), refs(source));
         assert.equal(refs(mirror).some((ref) => ref.endsWith('refs/heads/HEAD')), false);
-        git(checkout, 'switch', '--quiet', 'main');
+        git(checkout, 'switch', '--quiet', 'fixture/main');
         writeFileSync(join(checkout, 'main.txt'), 'rewritten\n');
         git(checkout, 'add', 'main.txt');
         git(checkout, 'commit', '--quiet', '--amend', '-m', 'rewritten main');
         git(checkout, 'branch', '-D', 'feature/test');
         git(checkout, 'tag', '-d', 'v1.0.0');
         git(checkout, 'tag', 'v2.0.0');
-        git(checkout, 'push', '--quiet', '--force', 'origin', 'main');
+        git(checkout, 'push', '--quiet', '--force', 'origin', 'fixture/main');
         git(checkout, 'push', '--quiet', 'origin', '--delete', 'feature/test');
         git(checkout, 'push', '--quiet', 'origin', ':refs/tags/v1.0.0');
         git(checkout, 'push', '--quiet', 'origin', 'v2.0.0');

package/dist/pipeline.js

@@ -32,11 +32,14 @@ export function isBlockingFinding(finding) {
 export function isStrictFinding(finding) {
     return finding.engine === 'ai_editor' || isBlockingFinding(finding);
 }
+function analysisFindings(result) {
+    return [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
+}
 export function strictFindings(result) {
-    return [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])].filter(isStrictFinding);
+    return analysisFindings(result).filter(isStrictFinding);
 }
 export function deriveEditScope(result, strict = false) {
-    const findings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
+    const findings = analysisFindings(result);
     const blocking = findings.filter(strict ? isStrictFinding : isBlockingFinding);
     const pendingJudgment = strict ? [] : findings.filter((finding) => finding.appliedPolicy === 'judgment-required');
     return {
@@ -46,7 +49,7 @@ export function deriveEditScope(result, strict = false) {
     };
 }
 export function renderRewritePrompt(draft, profile, result, learning = [], brief, examples = []) {
-    const allFindings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
+    const allFindings = analysisFindings(result);
     const scope = deriveEditScope(result, true);
     const redFindings = scope.blocking;
     const yellowFindings = allFindings.filter((finding) => !isStrictFinding(finding) && finding.appliedPolicy !== 'judgment-required');
@@ -93,8 +96,8 @@ export function rewritePrompt(draft, profile, learning = [], brief, examples = [
 function compareCandidates(original, candidate, profile, brief) {
     const baseline = analyze(original, profile, brief);
     const checked = analyze(candidate, profile, brief);
-    const baselineFindings = [...baseline.voiceDna.findings, ...baseline.aiEditor.findings, ...(baseline.editorial?.findings ?? [])];
-    const checkedFindings = [...checked.voiceDna.findings, ...checked.aiEditor.findings, ...(checked.editorial?.findings ?? [])];
+    const baselineFindings = analysisFindings(baseline);
+    const checkedFindings = analysisFindings(checked);
     const known = new Set(baselineFindings.map((finding) => `${finding.engine}:${finding.id}:${finding.sentence}`));
     const regressions = checkedFindings.filter((finding) => !known.has(`${finding.engine}:${finding.id}:${finding.sentence}`));
     const preservation = legacySetPreservation(original, candidate).score;
@@ -120,8 +123,9 @@ function verifyRequiredFacts(candidate, brief) {
         return result;
     return { ...result, passed: false, failures: [...result.failures, ...reversed.map((fact) => ({ id: fact.id, code: 'missing_immutable_claim', message: `Required fact ${fact.id} is negated or denied.`, evidence: 'WritingBrief required fact.' }))] };
 }
-export function verify(original, candidate, profile, brief) {
+function verifyCandidate(original, candidate, profile, brief, rebuild) {
     const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
+    const claims = rebuild ? verifyClaims(candidate, rebuild.copySpec) : undefined;
     const finalOutput = finalOutputCheck(candidate);
     const logicLint = lintLogic(candidate, brief);
     const factLint = brief?.factSources?.length ? lintFacts({ sources: brief.factSources, draft: candidate, metadata: brief.factMetadata }) : undefined;
@@ -134,38 +138,23 @@ export function verify(original, candidate, profile, brief) {
         preservationScore: preservation,
         regressions,
         strictFindings: unresolvedStrictFindings,
+        ...(claims ? { claims } : {}),
         finalOutput,
         logicLint,
         ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding) && preservation >= 70 && finalOutput.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
+        passed: checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding) && (claims ? claims.passed : preservation >= 70) && finalOutput.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
     };
 }
+export function verify(original, candidate, profile, brief) {
+    return verifyCandidate(original, candidate, profile, brief);
+}
 export function verifyWithCopySpec(original, candidate, profile, spec, brief) {
     const verification = verify(original, candidate, profile, brief);
     const claims = verifyClaims(candidate, spec);
     return { ...verification, claims, passed: verification.passed && claims.passed };
 }
 export function verifyRebuildWithCopySpec(original, candidate, profile, spec, brief) {
-    const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
-    const claims = verifyClaims(candidate, spec);
-    const finalCheck = finalOutputCheck(candidate);
-    const logicLint = lintLogic(candidate, brief);
-    const factLint = brief?.factSources?.length ? lintFacts({ sources: brief.factSources, draft: candidate, metadata: brief.factMetadata }) : undefined;
-    const requiredFacts = verifyRequiredFacts(candidate, brief);
-    const unresolvedStrictFindings = strictFindings(checked);
-    return {
-        version: '2',
-        original: baseline,
-        candidate: checked,
-        preservationScore: preservation,
-        regressions,
-        strictFindings: unresolvedStrictFindings,
-        claims,
-        finalOutput: finalCheck,
-        logicLint,
-        ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && unresolvedStrictFindings.length === 0 && !regressions.some(isBlockingFinding) && claims.passed && finalCheck.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
-    };
+    return verifyCandidate(original, candidate, profile, brief, { copySpec: spec });
 }
 function projectDeterministicVerificationArtifact(source, candidate, profile, verification, copySpec, writingBrief, verificationKind = 'claims' in verification ? 'copy_spec' : 'standard') {
     const identity = profileIdentity(profile);

package/dist/rebuild-task.js

@@ -10,26 +10,13 @@ import { HYV_VERSION } from './version.js';
 import { buildRecompositionBrief, measureLexicalResidual, parseRecompositionPolicy } from './recomposition.js';
 import { provenanceStatusForRebuild, writerRequestForRebuild } from './provenance-status.js';
 import { fingerprint, profileIdentity, sha256 as digest } from './internal.js';
-const MAX_RESPONSE_BYTES = 100_000;
+import { failure, parseResponseJson, projectLifecycleBinding } from './rewrite-response.js';
 const MAX_CANDIDATE_CHARACTERS = 100_000;
-function failure(code, message, path) {
-    return { code, message, ...(path ? { path } : {}) };
-}
 function isFailure(value) {
     return typeof value === 'object' && value !== null && 'code' in value && 'message' in value;
 }
-function parseJson(value) {
-    if (Buffer.byteLength(value) > MAX_RESPONSE_BYTES)
-        return failure('response_too_large', `Response exceeds ${MAX_RESPONSE_BYTES} bytes.`);
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return failure('invalid_json', 'Response must be valid JSON.');
-    }
-}
 function parseRebuildResponse(value) {
-    const raw = typeof value === 'string' ? parseJson(value) : value;
+    const raw = typeof value === 'string' ? parseResponseJson(value) : value;
     if (isFailure(raw))
         return raw;
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -159,7 +146,7 @@ function rejected(task, raw, failures) {
     };
 }
 export function applyRebuildResponse(task, raw) {
-    const response = parseRebuildResponse(typeof raw === 'string' ? parseJson(raw) : raw);
+    const response = parseRebuildResponse(typeof raw === 'string' ? parseResponseJson(raw) : raw);
     if (isFailure(response))
         return rejected(task, raw, [response]);
     if (response.taskFingerprint !== task.fingerprint) {
@@ -227,15 +214,5 @@ export function createRebuildLifecycleBinding(task, receipt, deterministic) {
     if (!deterministic.passed || receipt.taskFingerprint !== task.fingerprint || receipt.mode !== 'REBUILD' || deterministic.verificationKind !== 'rebuild') {
         throw new Error('Lifecycle binding requires a passed rebuild artifact for this rebuild 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',
-    };
+    return projectLifecycleBinding(task.fingerprint, receipt, deterministic);
 }

package/dist/rebuild-task.test.js

@@ -174,7 +174,7 @@ test('CLI and MCP rebuild helpers share fingerprints', () => {
         version: '1', audience: 'operators', intent: 'explain', format: 'outreach',
     });
     assert.match(briefTask.prompt, /# WritingBrief/);
-    assert.equal(HYV_VERSION, '3.6.0');
+    assert.equal(HYV_VERSION, '3.6.1');
 });
 test('apply rejects forged tasks, missing capability, and substituted profiles', () => {
     const reduction = rebuildRecommendation();

package/dist/rewrite-response.js

@@ -0,0 +1,27 @@
+const MAX_RESPONSE_BYTES = 100_000;
+export function failure(code, message, path) {
+    return { code, message, ...(path ? { path } : {}) };
+}
+export function parseResponseJson(value) {
+    if (Buffer.byteLength(value) > MAX_RESPONSE_BYTES)
+        return failure('response_too_large', `Response exceeds ${MAX_RESPONSE_BYTES} bytes.`);
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return failure('invalid_json', 'Response must be valid JSON.');
+    }
+}
+export function projectLifecycleBinding(taskFingerprint, receipt, deterministic) {
+    return {
+        rewriteTaskFingerprint: taskFingerprint,
+        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.js

@@ -3,30 +3,14 @@ import { finalOutputCheck, hygieneSourceFindings } from './hygiene.js';
 import { analyze, deriveEditScope, renderRewritePrompt, verifyDeterministically } from './pipeline.js';
 import { sentences } from './text.js';
 import { fingerprint } from './internal.js';
-const MAX_RESPONSE_BYTES = 100_000;
+import { failure, parseResponseJson, projectLifecycleBinding } from './rewrite-response.js';
 const MAX_REPLACEMENTS = 100;
 const MAX_REPLACEMENT_CHARACTERS = 10_000;
-function failure(code, message, path) {
-    return { code, message, ...(path ? { path } : {}) };
-}
-function responseFingerprint(response) {
-    return fingerprint(response);
-}
-function parseJson(value) {
-    if (Buffer.byteLength(value) > MAX_RESPONSE_BYTES)
-        return failure('response_too_large', `Response exceeds ${MAX_RESPONSE_BYTES} bytes.`);
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return failure('invalid_json', 'Response must be valid JSON.');
-    }
-}
 function isFailure(value) {
     return typeof value === 'object' && value !== null && 'code' in value;
 }
 function parseResponse(value) {
-    const raw = typeof value === 'string' ? parseJson(value) : value;
+    const raw = typeof value === 'string' ? parseResponseJson(value) : value;
     if (isFailure(raw))
         return raw;
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -133,7 +117,7 @@ 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, replacementSentenceIds: [] } };
+    return { status: 'repairable', failures, receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: fingerprint(raw), adapterIds, replacementSentenceIds: [] } };
 }
 export function applyShip(task) {
     return {
@@ -151,7 +135,7 @@ export function applyShip(task) {
     };
 }
 export function applyRewriteResponse(task, raw) {
-    const source = typeof raw === 'string' ? parseJson(raw) : raw;
+    const source = typeof raw === 'string' ? parseResponseJson(raw) : raw;
     const parsed = isFailure(source) ? source : parseResponse(source);
     const fenced = isFailure(parsed) && parsed.code === 'invalid_json' ? repairFencedJson(raw) : { value: source };
     const repaired = isFailure(parsed) && parsed.code === 'invalid_response_shape' ? repairStringifiedReplacements(source) : fenced;
@@ -163,7 +147,7 @@ export function applyRewriteResponse(task, raw) {
         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) } };
+        return { ...shipped, receipt: { ...shipped.receipt, adapterIds, responseFingerprint: fingerprint(raw) } };
     }
     if (response.version === '2')
         return applyRangeResponse(task, response, raw, adapterIds);
@@ -189,7 +173,7 @@ 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, replacementSentenceIds: [...seen].sort((left, right) => left - right), mode: 'EDIT' } };
+    return { status: 'accepted', candidate, failures: [], receipt: { version: '1', taskFingerprint: task.fingerprint, responseFingerprint: fingerprint(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]));
@@ -236,7 +220,7 @@ function applyRangeResponse(task, response, raw, adapterIds) {
         receipt: {
             version: '1',
             taskFingerprint: task.fingerprint,
-            responseFingerprint: responseFingerprint(raw),
+            responseFingerprint: fingerprint(raw),
             adapterIds,
             operationRanges: response.operations.map((operation) => ({ startSentenceId: operation.startSentenceId, endSentenceId: operation.endSentenceId })),
             mode: 'EDIT',
@@ -262,15 +246,5 @@ export function evaluateRewriteResponse(task, raw, profile) {
 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',
-    };
+    return projectLifecycleBinding(task.fingerprint, receipt, deterministic);
 }

package/dist/version.js

@@ -1 +1 @@
-export const HYV_VERSION = '3.6.0';
+export const HYV_VERSION = '3.6.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "A local-first dual-engine writing gate that protects voice and catches generic AI patterns.",
   "type": "module",
   "bin": {