@holdyourvoice/hyv 3.5.1 → 3.6.1

package/dist/cli.test.js

@@ -272,7 +272,7 @@ test('uses exit code 2 for a failed candidate gate and 1 for misuse', () => {
         assert.equal(run(['profile', profile, first, second, '--avoid=unlock']).status, 0);
         const verification = run(['verify', original, candidate, profile]);
         assert.equal(verification.status, 2);
-        assert.deepEqual(Object.keys(JSON.parse(verification.stdout)).sort(), ['candidate', 'finalOutput', 'logicLint', 'original', 'passed', 'preservationScore', 'regressions', 'version']);
+        assert.deepEqual(Object.keys(JSON.parse(verification.stdout)).sort(), ['candidate', 'finalOutput', 'logicLint', 'original', 'passed', 'preservationScore', 'regressions', 'strictFindings', 'version']);
         assert.equal(run(['unknown-command']).status, 1);
         assert.equal(run(['mcp', 'unexpected']).status, 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', {
@@ -74,8 +68,8 @@ server.registerTool('hyv_analyze', {
     annotations: { readOnlyHint: true },
 }, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => analyzeForMcp(draft, profile_json, writing_brief_json)));
 server.registerTool('hyv_strict_check', {
-    description: 'Run the opt-in local strict quality gate. It requires a calibrated 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() },
+    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, 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', {
@@ -128,7 +122,7 @@ server.registerTool('hyv_logic_lint', {
     annotations: { readOnlyHint: true },
 }, async ({ draft, writing_brief_json }) => guardedJson(() => logicLintForMcp(draft, writing_brief_json)));
 server.registerTool('hyv_rewrite_prompt', {
-    description: 'Create a constrained editing brief. Explicit local examples are redacted in memory and injected only as advisory cadence evidence. It does not rewrite the draft or call a model.',
+    description: 'Create a strict constrained editing brief. Every active AI Editor finding is a required repair; explicit local examples remain advisory cadence evidence. It does not rewrite the draft or call a model.',
     inputSchema: { draft: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional(), examples: writingExamples.optional() },
     annotations: { readOnlyHint: true },
 }, async ({ draft, profile_json, writing_brief_json, examples }) => guardedJson(() => rewritePromptForMcp(draft, profile_json, {}, writing_brief_json, examples)));
@@ -138,12 +132,12 @@ server.registerTool('hyv_find_writing_examples', {
     annotations: { readOnlyHint: true },
 }, async ({ query, examples }) => guardedJson(() => findWritingExamplesForMcp(query, examples)));
 server.registerTool('hyv_prepare_rewrite', {
-    description: 'Prepare a local, versioned rewrite task. The caller may forward it to a provider; doing so shares the draft and must be an explicit choice.',
+    description: 'Prepare a strict local, versioned rewrite task. Every active AI Editor finding is eligible for source-faithful repair; the caller may forward the task to a provider only by explicit choice.',
     inputSchema: { draft: writing, profile_json: profileJson, copy_spec_json: copySpecJson.optional(), writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
 }, async ({ draft, profile_json, copy_spec_json, writing_brief_json }) => guardedJson(() => prepareRewriteForMcp(draft, profile_json, copy_spec_json, writing_brief_json)));
 server.registerTool('hyv_apply_rewrite', {
-    description: 'Validate and apply a model response to a prepared task, then run the local gates. It never calls a provider or stores source or candidate text.',
+    description: 'Validate a model response to a prepared task, then reject any candidate with an unresolved active AI Editor finding. It never calls a provider or stores source or candidate text.',
     inputSchema: { task_json: z.string().min(1).max(250_000), response_json: z.string().min(1).max(100_000), profile_json: profileJson },
     annotations: { readOnlyHint: true },
 }, async ({ task_json, response_json, profile_json }) => guardedJson(() => applyRewriteForMcp(task_json, response_json, profile_json)));
@@ -164,12 +158,12 @@ server.registerTool('hyv_reduce_judgment', {
     annotations: { readOnlyHint: true },
 }, async ({ envelopes_json }) => guardedJson(() => reduceJudgmentForMcp(envelopes_json)));
 server.registerTool('hyv_verify', {
-    description: 'Verify a revised candidate against an original draft and portable profile without changing learning state.',
+    description: 'Verify a revised candidate against an original draft and portable profile. Every active AI Editor finding fails default verification; learning state remains unchanged.',
     inputSchema: { original: writing, candidate: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
 }, async ({ original, candidate, profile_json, writing_brief_json }) => guardedJson(() => verifyForMcp(original, candidate, profile_json, writing_brief_json)));
 server.registerTool('hyv_verify_copy_spec', {
-    description: 'Verify a candidate against the existing voice gates and a local CopySpec. Immutable claims remain verbatim unless atoms are supplied; then each declared atom must remain. Prohibited claims fail closed.',
+    description: 'Verify a candidate against strict default voice gates and a local CopySpec. Every active AI Editor finding fails verification; immutable claims remain verbatim unless atoms are supplied, and prohibited claims fail closed.',
     inputSchema: { original: writing, candidate: writing, profile_json: profileJson, copy_spec_json: copySpecJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
 }, async ({ original, candidate, profile_json, copy_spec_json, writing_brief_json }) => guardedJson(() => verifyCopySpecForMcp(original, candidate, profile_json, copy_spec_json, writing_brief_json)));
@@ -250,7 +244,7 @@ if (redactsSensitiveInputs) {
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
     }, async (args) => guardedJson(() => prepareRebuildForMcp(args.draft, args.profile_json, args.reduction_json, args.copy_spec_json, args.capability_json, loadApprovalContext(), args.writing_brief_json, args.recomposition_policy_json), 'Rebuild preparation failed.'));
     server.registerTool('hyv_apply_rebuild', {
-        description: 'Validate and evaluate a whole-document rebuild response against a prepared authorized rebuild task. Capability input requires host-guaranteed sensitive-input redaction. It never calls a provider.',
+        description: 'Validate a whole-document rebuild response against a prepared authorized rebuild task and reject unresolved active AI Editor findings. Capability input requires host-guaranteed sensitive-input redaction. It never calls a provider.',
         inputSchema: { task_json: lifecycleJson, response_json: z.string().min(1).max(100_000), profile_json: profileJson, capability_json: lifecycleJson },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
     }, async (args) => guardedJson(() => applyRebuildForMcp(args.task_json, args.response_json, args.profile_json, args.capability_json, loadApprovalContext()), 'Rebuild application failed.'));

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

@@ -29,10 +29,19 @@ function formatFindings(findings) {
 export function isBlockingFinding(finding) {
     return finding.engine === 'ai_editor' ? finding.appliedPolicy === 'blocking' : finding.severity === 'red';
 }
-export function deriveEditScope(result) {
-    const findings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
-    const blocking = findings.filter(isBlockingFinding);
-    const pendingJudgment = findings.filter((finding) => finding.appliedPolicy === 'judgment-required');
+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 analysisFindings(result).filter(isStrictFinding);
+}
+export function deriveEditScope(result, strict = false) {
+    const findings = analysisFindings(result);
+    const blocking = findings.filter(strict ? isStrictFinding : isBlockingFinding);
+    const pendingJudgment = strict ? [] : findings.filter((finding) => finding.appliedPolicy === 'judgment-required');
     return {
         eligibleSentenceIds: [...new Set(blocking.map((finding) => finding.sentence))].sort((left, right) => left - right),
         blocking,
@@ -40,17 +49,17 @@ export function deriveEditScope(result) {
     };
 }
 export function renderRewritePrompt(draft, profile, result, learning = [], brief, examples = []) {
-    const allFindings = [...result.voiceDna.findings, ...result.aiEditor.findings, ...(result.editorial?.findings ?? [])];
-    const scope = deriveEditScope(result);
+    const allFindings = analysisFindings(result);
+    const scope = deriveEditScope(result, true);
     const redFindings = scope.blocking;
-    const yellowFindings = allFindings.filter((finding) => !isBlockingFinding(finding) && finding.appliedPolicy !== 'judgment-required');
+    const yellowFindings = allFindings.filter((finding) => !isStrictFinding(finding) && finding.appliedPolicy !== 'judgment-required');
     const metrics = profile.metrics;
     return [
         '# Tier 0 — non-negotiable preservation',
         'Preserve facts, names, numbers, claims, and every unflagged sentence exactly. Do not add claims, examples, sections, hooks, or CTAs.',
         '',
-        '# Tier 1 — release blockers',
-        'Treat each blocker as a required repair. Replace the flagged sentence with a stronger, source-faithful sentence; do not merely swap one stock phrase for another.',
+        '# Tier 1 — strict repair requirements',
+        'Every active AI Editor finding is a required repair. Replace each flagged sentence with a stronger, source-faithful sentence; do not merely swap one stock phrase for another.',
         'Use only facts already present in the draft, CopySpec, WritingBrief, or supplied source context. Do not invent a source, metric, date, quotation, mechanism, example, CTA, or opinion.',
         `VoiceDNA: ${result.voiceDna.score}/100 (${result.voiceDna.passed ? 'pass' : 'fail'}).`,
         `AI Editor: ${result.aiEditor.score}/100 (${result.aiEditor.passed ? 'pass' : 'fail'}).`,
@@ -87,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;
@@ -114,48 +123,38 @@ 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;
     const requiredFacts = verifyRequiredFacts(candidate, brief);
+    const unresolvedStrictFindings = strictFindings(checked);
     return {
         version: '2',
         original: baseline,
         candidate: checked,
         preservationScore: preservation,
         regressions,
+        strictFindings: unresolvedStrictFindings,
+        ...(claims ? { claims } : {}),
         finalOutput,
         logicLint,
         ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && !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);
-    return {
-        version: '2',
-        original: baseline,
-        candidate: checked,
-        preservationScore: preservation,
-        regressions,
-        claims,
-        finalOutput: finalCheck,
-        logicLint,
-        ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && !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/pipeline.test.js

@@ -83,7 +83,7 @@ test('orders rewrite instructions by importance tier', () => {
 });
 test('gives strong, source-faithful repair feedback without authorizing a broader rewrite', () => {
     const prompt = rewritePrompt('The scheduler failed — twice. Experts say this changes everything. The launch is on 14 August.', profile);
-    assert.match(prompt, /Treat each blocker as a required repair/);
+    assert.match(prompt, /Every active AI Editor finding is a required repair/);
     assert.match(prompt, /Do not invent a source, metric, date, quotation, mechanism, example, CTA, or opinion/);
     assert.match(prompt, /otherwise remove the unsupported framing without widening the claim/);
     assert.match(prompt, /Before responding, check every Tier 1 finding against its replacement/);
@@ -119,9 +119,11 @@ test('advisory and pending-judgment findings pass while blocking findings fail',
     const blocking = analyze('The scheduler failed — twice.', profile);
     assert.equal(blocking.passed, false);
 });
-test('verify rejects only new policy-blocking regressions', () => {
+test('verify rejects unresolved active AI Editor findings under the default strict policy', () => {
     const neutralProfile = buildProfile(['I write plainly.', 'I name the mechanism.']);
-    assert.equal(verify('The scheduler failed twice.', 'The scheduler failed twice. We leverage logs.', neutralProfile).passed, true);
+    const unresolved = verify('The scheduler failed twice.', 'The scheduler failed twice. We leverage logs.', neutralProfile);
+    assert.equal(unresolved.passed, false);
+    assert.ok(unresolved.strictFindings.some((finding) => finding.id === 'ai.leverage'));
     assert.equal(verify('The scheduler failed twice.', 'The scheduler failed — twice.', profile).passed, false);
 });
 test('keeps verify pass/fail on the legacy metric while calibration reports both metrics', () => {

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.5.1');
+    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))
@@ -106,7 +90,7 @@ export function prepareRewriteTask(draft, profile, copySpec, writingBrief, autho
     const result = analyze(draft, profile, writingBrief);
     const prompt = renderRewritePrompt(draft, profile, result, [], writingBrief);
     const mapped = sentences(draft);
-    const eligibleSentenceIds = new Set([...deriveEditScope(result).eligibleSentenceIds, ...authorizedSentenceIds]);
+    const eligibleSentenceIds = new Set([...deriveEditScope(result, true).eligibleSentenceIds, ...authorizedSentenceIds]);
     const taskBase = {
         version: '1',
         draft,
@@ -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/rewrite-task.test.js

@@ -21,18 +21,19 @@ 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('does not make an advisory broad catalog match eligible', () => {
+test('makes every active AI Editor finding eligible under the default strict rewrite policy', () => {
     const task = prepareRewriteTask('I write clear notes. This work is meaningful. I keep the mechanism visible.', profile);
-    assert.deepEqual(task.eligibleSentenceIds, []);
-    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, false, false]);
+    assert.deepEqual(task.eligibleSentenceIds, [2]);
+    assert.deepEqual(task.sentences.map((sentence) => sentence.eligible), [false, true, false]);
+    assert.match(task.prompt, /Every active AI Editor finding is a required repair/);
 });
-test('grants edit scope only to blocking findings and keeps pending judgment separate', () => {
+test('makes advisory and judgment-required findings required repairs', () => {
     const advisory = prepareRewriteTask('Firstly, check the invoice.', profile);
-    assert.deepEqual(advisory.eligibleSentenceIds, []);
+    assert.deepEqual(advisory.eligibleSentenceIds, [1]);
     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);
+    assert.deepEqual(pending.eligibleSentenceIds, [1]);
+    assert.match(pending.prompt, /Every active AI Editor finding is a required repair/);
     const blocking = prepareRewriteTask('The scheduler failed — twice. The owner checked it.', profile);
     assert.deepEqual(blocking.eligibleSentenceIds, [1]);
 });
@@ -40,9 +41,9 @@ 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', () => {
+test('makes reconciled active founder reframes eligible under the default strict policy', () => {
     const task = prepareRewriteTask("This isn't positioning. This is proof.", profile);
-    assert.deepEqual(task.eligibleSentenceIds, []);
+    assert.deepEqual(task.eligibleSentenceIds, [1]);
 });
 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';