@holdyourvoice/hyv 3.4.0 → 3.4.2

package/dist/fact-linter.js

@@ -67,6 +67,110 @@ export function extractFactClaims(draft) {
     }
     return output;
 }
+function capabilityFinding(claim, relevant, evidenceItems) {
+    const claimCapabilities = capabilityObjects(claim.text);
+    if (!claimCapabilities.length || !relevant.length)
+        return undefined;
+    const sourceCapabilities = relevant.flatMap(({ text }) => capabilityObjects(text));
+    const supported = claimCapabilities.every((capability) => sourceCapabilities.some((sourceCapability) => capability.every((token) => sourceCapability.includes(token))));
+    if (supported && relevant.some(({ text }) => negated(text) !== negated(claim.text))) {
+        return finding(claim, 'capability_drift', 'error', 'The draft reverses the source capability.', evidenceItems, 'high', 'Match the source capability polarity or cite contrary evidence.');
+    }
+    if (supported)
+        return undefined;
+    const formatMismatch = claimCapabilities.some((capability) => {
+        const claimFormats = capability.filter((token) => CAPABILITY_FORMATS.has(token));
+        return claimFormats.length > 0 && sourceCapabilities.some((sourceCapability) => {
+            const sourceFormats = sourceCapability.filter((token) => CAPABILITY_FORMATS.has(token));
+            return sourceFormats.length > 0 && claimFormats.some((format) => !sourceFormats.includes(format));
+        });
+    });
+    if (formatMismatch) {
+        return finding(claim, 'capability_drift', 'error', 'The product capability differs from the supplied source.', evidenceItems, 'high', 'Match the source capability or cite contrary evidence.');
+    }
+    return finding(claim, 'missing_evidence', 'needs_human_review', 'The product capability is not established by the relevant source wording.', evidenceItems, 'medium', 'Confirm the capability with a reviewer or add evidence.');
+}
+function findingsForClaim(claim, input, sourceLines, semanticAdapter) {
+    const relevant = findRelevant(claim.text, sourceLines);
+    const same = sourceLines.find(({ text }) => hasOverlap(claim.text, text));
+    const evidenceItems = relevant.length ? relevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : fallbackEvidence(sourceLines);
+    const quote = claim.text.match(QUOTE)?.[1];
+    const sourceHasAttribution = input.sources.some((source) => /\b(said|according to|reported)\b/i.test(source.text));
+    if (quote && sourceHasAttribution && !input.sources.some((source) => source.text.includes(quote))) {
+        const quoteRelevant = sourceLines.filter(({ text }) => /\b(said|according to|reported)\b/i.test(text));
+        const quoteEvidence = quoteRelevant.length ? quoteRelevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : input.sources.slice(0, 1).map((source) => evidence(source, source.text));
+        return [finding(claim, 'quote_drift', 'error', 'The quoted wording differs from the supplied source.', quoteEvidence, 'high', 'Use the source wording or label the text as a paraphrase.')];
+    }
+    const claimDates = dates(claim.text);
+    const sourceDates = relevant.flatMap(({ text }) => dates(text));
+    const claimNumbers = numbers(claim.text);
+    const sourceNumbers = relevant.flatMap(({ text }) => numbers(text));
+    if (!claimDates.length && !claim.kinds.includes('attribution_quote') && claimNumbers.length && sourceNumbers.length && claimNumbers.some((number) => !sourceNumbers.some((sourceNumber) => normal(sourceNumber) === normal(number)))) {
+        return [finding(claim, 'number_drift', 'error', 'A number or unit differs from relevant source evidence.', evidenceItems, 'high', 'Correct the number or unit, or cite a newer source.')];
+    }
+    if (claimDates.length && sourceDates.length && claimDates.some((date) => !sourceDates.includes(date))) {
+        return [finding(claim, 'date_drift', 'error', 'The draft date differs from relevant source evidence.', evidenceItems, 'high', 'Correct the date or cite a newer source.')];
+    }
+    const claimEntities = entities(claim.text);
+    const sourceEntities = relevant.flatMap(({ text }) => entities(text));
+    if (claimEntities.length && sourceEntities.length && claimEntities.some((entity) => !sourceEntities.some((sourceEntity) => normal(sourceEntity) === normal(entity)))) {
+        return [finding(claim, 'entity_drift', 'error', 'A named entity differs from relevant source evidence.', evidenceItems, 'high', 'Correct the name or cite the source that supports it.')];
+    }
+    const capability = capabilityFinding(claim, relevant, evidenceItems);
+    if (capability)
+        return [capability];
+    if (capabilityObjects(claim.text).length && relevant.length)
+        return [];
+    const overreach = [];
+    if (claim.kinds.includes('causal') && relevant.length && !relevant.some(({ text }) => /\b(caused?|because|led to|resulted in)\b/i.test(text))) {
+        overreach.push(finding(claim, 'causal_overreach', 'warning', 'The sources describe an outcome but do not establish causation.', evidenceItems, 'medium', 'Use an association claim or add causal evidence.'));
+    }
+    if (claim.kinds.includes('comparative') && relevant.length && !relevant.some(({ text }) => /\b(better|more|less|than|best|largest|fastest)\b/i.test(text))) {
+        overreach.push(finding(claim, 'comparative_overreach', 'warning', 'The sources do not establish the comparison.', evidenceItems, 'medium', 'Narrow the comparison or add comparative evidence.'));
+    }
+    if (overreach.length)
+        return overreach;
+    if (claimDates.some((date) => sourceDates.includes(date)) || same)
+        return [];
+    if (!relevant.length && claim.kinds.includes('fact') && tokens(claim.text).length <= 4) {
+        return [finding(claim, 'missing_evidence', 'needs_human_review', 'No close source evidence was found; the wording is too sparse for a reliable deterministic verdict.', evidenceItems, 'low', 'Confirm with a reviewer or provide a source.')];
+    }
+    if (!relevant.length || (claim.kinds.includes('number') && !relevant.some(({ text }) => /\b\d+(?:\.\d+)?%?\b/.test(text)))) {
+        return [finding(claim, 'unsupported_claim', 'error', 'No supplied source supports this checkable claim.', evidenceItems, 'medium', 'Add a source, remove the claim, or mark it as an approved hypothesis.')];
+    }
+    const semantic = semanticAdapter?.compare({ claim: claim.text, sources: input.sources });
+    if (semantic === 'supported')
+        return [];
+    if (semantic === 'contradicted') {
+        return [finding(claim, 'semantic_contradiction', 'error', 'The configured semantic adapter found contradictory source evidence.', evidenceItems, 'medium', 'Review the cited sources and correct or qualify the claim.')];
+    }
+    return [finding(claim, 'missing_evidence', 'needs_human_review', 'Relevant source material exists, but deterministic matching could not establish support.', evidenceItems, 'low', 'Review the source context or enable an approved semantic adapter.')];
+}
+function draftContradictions(claims, sourceLines) {
+    const normalized = claims.map((claim) => ({ claim, text: normal(claim.text) }));
+    const findings = [];
+    for (let index = 0; index < normalized.length; index += 1) {
+        for (let other = index + 1; other < normalized.length; other += 1) {
+            const left = normalized[index];
+            const right = normalized[other];
+            const leftCore = normal(left.text.replace(/\bnot\b/g, ''));
+            const rightCore = normal(right.text.replace(/\bnot\b/g, ''));
+            if (leftCore === rightCore && /\bnot\b/.test(left.text) !== /\bnot\b/.test(right.text)) {
+                findings.push(finding(right.claim, 'draft_contradiction', 'error', 'This draft claim contradicts an earlier draft claim.', fallbackEvidence(sourceLines), 'high', 'Resolve the two claims before publishing.'));
+            }
+        }
+    }
+    return findings;
+}
+function summarizeFindings(claims, findings) {
+    const claimKey = (item) => `${item.draftLocation.start}:${item.draftLocation.end}`;
+    const unsupported = new Set(findings.filter((item) => item.kind === 'unsupported_claim').map(claimKey)).size;
+    const contradicted = new Set(findings.filter((item) => ['draft_contradiction', 'number_drift', 'date_drift', 'entity_drift', 'quote_drift', 'capability_drift', 'semantic_contradiction'].includes(item.kind)).map(claimKey)).size;
+    const humanReview = new Set(findings.filter((item) => item.severity === 'needs_human_review' || item.severity === 'warning').map(claimKey)).size;
+    const checked = claims.filter((claim) => !claim.kinds.includes('opinion')).length;
+    const affected = new Set(findings.map(claimKey)).size;
+    return { checked, supported: Math.max(0, checked - affected), unsupported, contradicted, humanReview };
+}
 export function lintFacts(input) {
     if (!input.sources.length)
         throw new Error('Fact lint requires at least one source document.');
@@ -81,105 +185,10 @@ export function lintFacts(input) {
     for (const claim of claims) {
         if (claim.kinds.includes('opinion') || allowed.has(normal(claim.text)) || (claim.kinds.includes('hypothesis') && approved.has(normal(claim.text))))
             continue;
-        const relevant = findRelevant(claim.text, sourceLines);
-        const same = sourceLines.find(({ text }) => hasOverlap(claim.text, text));
-        const evidenceItems = relevant.length ? relevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : fallbackEvidence(sourceLines);
-        const quote = claim.text.match(QUOTE)?.[1];
-        const quoteRelevant = sourceLines.filter(({ text }) => /\b(said|according to|reported)\b/i.test(text));
-        if (quote && input.sources.some((source) => /\b(said|according to|reported)\b/i.test(source.text)) && !input.sources.some((source) => source.text.includes(quote))) {
-            const quoteEvidence = quoteRelevant.length ? quoteRelevant.slice(0, 2).map(({ source, text }) => evidence(source, text)) : input.sources.slice(0, 1).map((source) => evidence(source, source.text));
-            findings.push(finding(claim, 'quote_drift', 'error', 'The quoted wording differs from the supplied source.', quoteEvidence, 'high', 'Use the source wording or label the text as a paraphrase.'));
-            continue;
-        }
-        const claimDates = dates(claim.text);
-        const sourceDates = relevant.flatMap(({ text }) => dates(text));
-        const claimNumbers = numbers(claim.text);
-        const sourceNumbers = relevant.flatMap(({ text }) => numbers(text));
-        if (!claimDates.length && !claim.kinds.includes('attribution_quote') && claimNumbers.length && sourceNumbers.length && claimNumbers.some((number) => !sourceNumbers.some((sourceNumber) => normal(sourceNumber) === normal(number)))) {
-            findings.push(finding(claim, 'number_drift', 'error', 'A number or unit differs from relevant source evidence.', evidenceItems, 'high', 'Correct the number or unit, or cite a newer source.'));
-            continue;
-        }
-        if (claimDates.length && sourceDates.length && claimDates.some((date) => !sourceDates.includes(date))) {
-            findings.push(finding(claim, 'date_drift', 'error', 'The draft date differs from relevant source evidence.', evidenceItems, 'high', 'Correct the date or cite a newer source.'));
-            continue;
-        }
-        const claimEntities = entities(claim.text);
-        const sourceEntities = relevant.flatMap(({ text }) => entities(text));
-        if (claimEntities.length && sourceEntities.length && claimEntities.some((entity) => !sourceEntities.some((sourceEntity) => normal(sourceEntity) === normal(entity)))) {
-            findings.push(finding(claim, 'entity_drift', 'error', 'A named entity differs from relevant source evidence.', evidenceItems, 'high', 'Correct the name or cite the source that supports it.'));
-            continue;
-        }
-        const claimCapabilities = capabilityObjects(claim.text);
-        if (claimCapabilities.length && relevant.length) {
-            const sourceCapabilities = relevant.flatMap(({ text }) => capabilityObjects(text));
-            const supportedCapability = claimCapabilities.every((capability) => sourceCapabilities.some((sourceCapability) => capability.every((token) => sourceCapability.includes(token))));
-            if (supportedCapability && relevant.some(({ text }) => negated(text) !== negated(claim.text))) {
-                findings.push(finding(claim, 'capability_drift', 'error', 'The draft reverses the source capability.', evidenceItems, 'high', 'Match the source capability polarity or cite contrary evidence.'));
-                continue;
-            }
-            if (supportedCapability)
-                continue;
-            const knownFormatMismatch = claimCapabilities.some((capability) => {
-                const claimFormats = capability.filter((token) => CAPABILITY_FORMATS.has(token));
-                return claimFormats.length > 0 && sourceCapabilities.some((sourceCapability) => {
-                    const sourceFormats = sourceCapability.filter((token) => CAPABILITY_FORMATS.has(token));
-                    return sourceFormats.length > 0 && claimFormats.some((format) => !sourceFormats.includes(format));
-                });
-            });
-            if (knownFormatMismatch) {
-                findings.push(finding(claim, 'capability_drift', 'error', 'The product capability differs from the supplied source.', evidenceItems, 'high', 'Match the source capability or cite contrary evidence.'));
-                continue;
-            }
-            findings.push(finding(claim, 'missing_evidence', 'needs_human_review', 'The product capability is not established by the relevant source wording.', evidenceItems, 'medium', 'Confirm the capability with a reviewer or add evidence.'));
-            continue;
-        }
-        const causalOverreach = claim.kinds.includes('causal') && relevant.length && !relevant.some(({ text }) => /\b(caused?|because|led to|resulted in)\b/i.test(text));
-        const comparativeOverreach = claim.kinds.includes('comparative') && relevant.length && !relevant.some(({ text }) => /\b(better|more|less|than|best|largest|fastest)\b/i.test(text));
-        if (causalOverreach)
-            findings.push(finding(claim, 'causal_overreach', 'warning', 'The sources describe an outcome but do not establish causation.', evidenceItems, 'medium', 'Use an association claim or add causal evidence.'));
-        if (comparativeOverreach)
-            findings.push(finding(claim, 'comparative_overreach', 'warning', 'The sources do not establish the comparison.', evidenceItems, 'medium', 'Narrow the comparison or add comparative evidence.'));
-        if (causalOverreach || comparativeOverreach)
-            continue;
-        if (claimDates.length && claimDates.some((date) => sourceDates.includes(date)))
-            continue;
-        if (same)
-            continue;
-        if (!relevant.length && claim.kinds.includes('fact') && tokens(claim.text).length <= 4) {
-            findings.push(finding(claim, 'missing_evidence', 'needs_human_review', 'No close source evidence was found; the wording is too sparse for a reliable deterministic verdict.', evidenceItems, 'low', 'Confirm with a reviewer or provide a source.'));
-            continue;
-        }
-        if ((!relevant.length || (claim.kinds.includes('number') && !relevant.some(({ text }) => /\b\d+(?:\.\d+)?%?\b/.test(text))))) {
-            findings.push(finding(claim, 'unsupported_claim', 'error', 'No supplied source supports this checkable claim.', evidenceItems, 'medium', 'Add a source, remove the claim, or mark it as an approved hypothesis.'));
-            continue;
-        }
-        const semantic = semanticAdapter?.compare({ claim: claim.text, sources: input.sources });
-        if (semantic === 'supported')
-            continue;
-        if (semantic === 'contradicted') {
-            findings.push(finding(claim, 'semantic_contradiction', 'error', 'The configured semantic adapter found contradictory source evidence.', evidenceItems, 'medium', 'Review the cited sources and correct or qualify the claim.'));
-            continue;
-        }
-        findings.push(finding(claim, 'missing_evidence', 'needs_human_review', 'Relevant source material exists, but deterministic matching could not establish support.', evidenceItems, 'low', 'Review the source context or enable an approved semantic adapter.'));
+        findings.push(...findingsForClaim(claim, input, sourceLines, semanticAdapter));
     }
-    const normalizedClaims = claims.map((claim) => ({ claim, text: normal(claim.text) }));
-    for (let index = 0; index < normalizedClaims.length; index += 1)
-        for (let other = index + 1; other < normalizedClaims.length; other += 1) {
-            const left = normalizedClaims[index];
-            const right = normalizedClaims[other];
-            const leftCore = normal(left.text.replace(/\bnot\b/g, ''));
-            const rightCore = normal(right.text.replace(/\bnot\b/g, ''));
-            if (leftCore === rightCore && /\bnot\b/.test(left.text) !== /\bnot\b/.test(right.text)) {
-                findings.push(finding(right.claim, 'draft_contradiction', 'error', 'This draft claim contradicts an earlier draft claim.', fallbackEvidence(sourceLines), 'high', 'Resolve the two claims before publishing.'));
-            }
-        }
-    const claimKey = (item) => `${item.draftLocation.start}:${item.draftLocation.end}`;
-    const unsupported = new Set(findings.filter((item) => item.kind === 'unsupported_claim').map(claimKey)).size;
-    const contradicted = new Set(findings.filter((item) => ['draft_contradiction', 'number_drift', 'date_drift', 'entity_drift', 'quote_drift', 'capability_drift', 'semantic_contradiction'].includes(item.kind)).map(claimKey)).size;
-    const humanReview = new Set(findings.filter((item) => item.severity === 'needs_human_review' || item.severity === 'warning').map(claimKey)).size;
-    const checked = claims.filter((claim) => !claim.kinds.includes('opinion')).length;
-    const affected = new Set(findings.map(claimKey)).size;
-    return { version: '1', summary: { checked, supported: Math.max(0, checked - affected), unsupported, contradicted, humanReview }, claims, findings, skippedChecks: semanticAdapter ? [] : ['semantic_matching'] };
+    findings.push(...draftContradictions(claims, sourceLines));
+    return { version: '1', summary: summarizeFindings(claims, findings), claims, findings, skippedChecks: semanticAdapter ? [] : ['semantic_matching'] };
 }
 export function formatFactLintReport(report) {
     const lines = [`fact lint: ${report.summary.checked} checked, ${report.summary.supported} supported, ${report.findings.length} findings`];

package/dist/mcp.js

@@ -35,31 +35,33 @@ function failure(error) {
 function lifecycleResult(result) {
     return json(result.ok ? result.artifact : { error: result.error });
 }
+function guardedJson(run, publicError) {
+    try {
+        return json(run());
+    }
+    catch (error) {
+        return failure(publicError ? new Error(publicError) : error);
+    }
+}
+function guardedLifecycle(run, publicError) {
+    try {
+        return lifecycleResult(run());
+    }
+    catch (error) {
+        return failure(publicError ? new Error(publicError) : error);
+    }
+}
 const server = new McpServer({ name: 'hold-your-voice', version: HYV_VERSION });
 server.registerTool('hyv_build_profile', {
     description: 'Build a portable VoiceDNA profile from at least two writing samples. The samples stay in memory and are not saved.',
     inputSchema: { samples, avoid },
     annotations: { readOnlyHint: true },
-}, async ({ samples: writingSamples, avoid: phrases }) => {
-    try {
-        return json(buildProfileForMcp(writingSamples, phrases));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ samples: writingSamples, avoid: phrases }) => guardedJson(() => buildProfileForMcp(writingSamples, phrases)));
 server.registerTool('hyv_analyze', {
     description: 'Run separate VoiceDNA and AI Editor checks plus a non-scoring Unicode hygiene inspection against a draft using a portable profile JSON string.',
     inputSchema: { draft: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, profile_json, writing_brief_json }) => {
-    try {
-        return json(analyzeForMcp(draft, profile_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => analyzeForMcp(draft, profile_json, writing_brief_json)));
 server.registerTool('hyv_hygiene', {
     description: 'Inspect text for zero-width characters, bidirectional controls, Unicode tag characters, and unusual spaces without changing it or requiring a voice profile.',
     inputSchema: { draft: hygieneText },
@@ -82,50 +84,22 @@ server.registerTool('hyv_logic_lint', {
     description: 'Run the deterministic document-coherence gate. It detects configured topic drift, unanchored inference, and direct internal contradictions; it does not verify facts or approve publication.',
     inputSchema: { draft: writing, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, writing_brief_json }) => {
-    try {
-        return json(logicLintForMcp(draft, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, writing_brief_json }) => guardedJson(() => logicLintForMcp(draft, writing_brief_json)));
 server.registerTool('hyv_rewrite_prompt', {
     description: 'Create a constrained editing brief. It does not rewrite the draft or call a model.',
     inputSchema: { draft: writing, profile_json: profileJson, writing_brief_json: writingBriefJson.optional() },
     annotations: { readOnlyHint: true },
-}, async ({ draft, profile_json, writing_brief_json }) => {
-    try {
-        return json(rewritePromptForMcp(draft, profile_json, {}, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ draft, profile_json, writing_brief_json }) => guardedJson(() => rewritePromptForMcp(draft, profile_json, {}, writing_brief_json)));
 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.',
     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 }) => {
-    try {
-        return json(prepareRewriteForMcp(draft, profile_json, copy_spec_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, 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.',
     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 }) => {
-    try {
-        return json(applyRewriteForMcp(task_json, response_json, profile_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ task_json, response_json, profile_json }) => guardedJson(() => applyRewriteForMcp(task_json, response_json, profile_json)));
 server.registerTool('hyv_prepare_judgment', {
     description: 'Prepare a versioned pre-edit or post-candidate judgment task. It does not call a model.',
     inputSchema: {
@@ -136,62 +110,27 @@ server.registerTool('hyv_prepare_judgment', {
         candidate: writing.optional(),
     },
     annotations: { readOnlyHint: true },
-}, async ({ stage, kind, draft, profile_json, candidate }) => {
-    try {
-        return json(prepareJudgmentForMcp(stage, kind, draft, profile_json, candidate));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ stage, kind, draft, profile_json, candidate }) => guardedJson(() => prepareJudgmentForMcp(stage, kind, draft, profile_json, candidate)));
 server.registerTool('hyv_reduce_judgment', {
     description: 'Reduce bound judgment envelopes into SHIP, EDIT, REBUILD, CLEAR, or ESCALATE. It does not call a model.',
     inputSchema: { envelopes_json: z.string().min(1).max(250_000) },
     annotations: { readOnlyHint: true },
-}, async ({ envelopes_json }) => {
-    try {
-        return json(reduceJudgmentForMcp(envelopes_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, 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.',
     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 }) => {
-    try {
-        return json(verifyForMcp(original, candidate, profile_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, 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.',
     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 }) => {
-    try {
-        return json(verifyCopySpecForMcp(original, candidate, profile_json, copy_spec_json, writing_brief_json));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ original, candidate, profile_json, copy_spec_json, writing_brief_json }) => guardedJson(() => verifyCopySpecForMcp(original, candidate, profile_json, copy_spec_json, writing_brief_json)));
 server.registerTool('hyv_batch_analyze', {
     description: 'Inspect two to one hundred drafts for repeated opening and closing sentences. It returns advisory batch findings and does not store the drafts.',
     inputSchema: { drafts: z.array(writing).min(2).max(100) },
     annotations: { readOnlyHint: true },
-}, async ({ drafts }) => {
-    try {
-        return json(analyzeBatchForMcp(drafts));
-    }
-    catch (error) {
-        return failure(error);
-    }
-});
+}, async ({ drafts }) => guardedJson(() => analyzeBatchForMcp(drafts)));
 server.registerTool('hyv_patterns', {
     description: 'List the exact AI Editor rules that run in this extension.',
     inputSchema: {},
@@ -200,116 +139,56 @@ server.registerTool('hyv_patterns', {
 server.registerTool('hyv_learning_inspect', {
     description: 'Inspect profile-scoped learning receipts without returning stored instruction or draft text.',
     inputSchema: { profile_json: profileJson }, annotations: { readOnlyHint: true },
-}, async ({ profile_json }) => { try {
-    return json(inspectLearningForMcp(profile_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ profile_json }) => guardedJson(() => inspectLearningForMcp(profile_json)));
 server.registerTool('hyv_learning_record', {
     description: 'Record an explicit profile-scoped learning instruction with authority and provenance metadata.',
     inputSchema: { profile_json: profileJson, instruction: z.string().min(1).max(240), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(recordLearningForMcp(args.profile_json, args.instruction, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => recordLearningForMcp(args.profile_json, args.instruction, learningArgs(args))));
 server.registerTool('hyv_learning_ratify', {
     description: 'Ratify a learning event for a Profile v3 revision.',
     inputSchema: { profile_json: profileJson, event_id: z.string().min(1).max(200), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(ratifyLearningForMcp(args.profile_json, args.event_id, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => ratifyLearningForMcp(args.profile_json, args.event_id, learningArgs(args))));
 server.registerTool('hyv_learning_supersede', {
     description: 'Supersede a learning event for a Profile v3 revision.',
     inputSchema: { profile_json: profileJson, event_id: z.string().min(1).max(200), ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-}, async (args) => { try {
-    return json(supersedeLearningForMcp(args.profile_json, args.event_id, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => supersedeLearningForMcp(args.profile_json, args.event_id, learningArgs(args))));
 server.registerTool('hyv_learning_migrate', {
     description: 'Migrate Profile v2 learning into a Profile v3 identity.',
     inputSchema: { source_profile_json: profileJson, target_profile_json: profileJson, ...learningOptions }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(migrateLearningForMcp(args.source_profile_json, args.target_profile_json, learningArgs(args)));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => migrateLearningForMcp(args.source_profile_json, args.target_profile_json, learningArgs(args))));
 server.registerTool('hyv_learning_clear', {
     description: 'Delete all local learning state for a profile.',
     inputSchema: { profile_json: profileJson }, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-}, async ({ profile_json }) => { try {
-    return json(clearLearningForMcp(profile_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ profile_json }) => guardedJson(() => clearLearningForMcp(profile_json)));
 server.registerTool('hyv_lifecycle_prepare_semantic', {
     description: 'Prepare a normal semantic-review task and its initial immutable lifecycle artifact.',
     inputSchema: { deterministic_json: lifecycleJson, binding_json: lifecycleJson, receipt_json: lifecycleJson, policy: z.literal('normal'), allowed_violations: z.array(semanticViolation).max(5) },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return json(prepareLifecycleForMcp(args.deterministic_json, args.binding_json, args.receipt_json, args.policy, args.allowed_violations));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedJson(() => prepareLifecycleForMcp(args.deterministic_json, args.binding_json, args.receipt_json, args.policy, args.allowed_violations)));
 server.registerTool('hyv_lifecycle_submit_verdict', {
     description: 'Submit one normal-policy semantic verdict using the server-installed evaluator authorization context.',
     inputSchema: { artifact_json: lifecycleJson, task_json: lifecycleJson, evaluator_id: evaluatorId, verdict_json: lifecycleJson },
     annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async (args) => { try {
-    return lifecycleResult(submitSemanticVerdictForMcp(args.artifact_json, args.task_json, args.evaluator_id, args.verdict_json, loadApprovalContext()));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async (args) => guardedLifecycle(() => submitSemanticVerdictForMcp(args.artifact_json, args.task_json, args.evaluator_id, args.verdict_json, loadApprovalContext())));
 server.registerTool('hyv_lifecycle_inspect', {
     description: 'Validate and inspect an immutable lifecycle artifact without exposing bound source or candidate hashes.',
     inputSchema: { artifact_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-}, async ({ artifact_json }) => { try {
-    return json(inspectLifecycleForMcp(artifact_json));
-}
-catch (error) {
-    return failure(error);
-} });
+}, async ({ artifact_json }) => guardedJson(() => inspectLifecycleForMcp(artifact_json)));
 if (redactsSensitiveInputs) {
     server.registerTool('hyv_lifecycle_finalize', {
         description: 'Finalize an authorized human approval or rejection. Capability input requires host-guaranteed sensitive-input redaction.',
         inputSchema: { artifact_json: lifecycleJson, decision_json: lifecycleJson, capability_json: lifecycleJson.optional() },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return lifecycleResult(finalizeLifecycleForMcp(args.artifact_json, args.decision_json, loadApprovalContext(), args.capability_json));
-    }
-    catch {
-        return failure(new Error('Lifecycle finalization failed.'));
-    } });
+    }, async (args) => guardedLifecycle(() => finalizeLifecycleForMcp(args.artifact_json, args.decision_json, loadApprovalContext(), args.capability_json), 'Lifecycle finalization failed.'));
     server.registerTool('hyv_lifecycle_validate_final_approval', {
         description: 'Validate a final-approval capability against the server-installed trust context.',
         inputSchema: { artifact_json: lifecycleJson, capability_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return json(validateFinalApprovalForMcp(args.artifact_json, args.capability_json, loadApprovalContext()));
-    }
-    catch {
-        return failure(new Error('Capability validation failed.'));
-    } });
+    }, async (args) => guardedJson(() => validateFinalApprovalForMcp(args.artifact_json, args.capability_json, loadApprovalContext()), 'Capability validation failed.'));
     server.registerTool('hyv_learning_record_approved', {
         description: 'Record one approval-revalidated, deterministic, text-free learning event.',
         inputSchema: { ready_json: lifecycleJson, approved_json: lifecycleJson, original: approvedLearningText, candidate: approvedLearningText, profile_json: profileJson, decision_json: lifecycleJson, capability_json: lifecycleJson, copy_spec_json: copySpecJson.optional(), writing_brief_json: writingBriefJson.optional() },
         annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
-    }, async (args) => { try {
-        return json({ status: recordApprovedLearningForMcp({ readyJson: args.ready_json, approvedJson: args.approved_json, source: args.original, candidate: args.candidate, profileJson: args.profile_json, decisionJson: args.decision_json, capabilityJson: args.capability_json, context: loadApprovalContext(), copySpecJson: args.copy_spec_json, writingBriefJson: args.writing_brief_json }) });
-    }
-    catch {
-        return failure(new Error('Approved learning was not authorized.'));
-    } });
+    }, async (args) => guardedJson(() => ({ status: recordApprovedLearningForMcp({ readyJson: args.ready_json, approvedJson: args.approved_json, source: args.original, candidate: args.candidate, profileJson: args.profile_json, decisionJson: args.decision_json, capabilityJson: args.capability_json, context: loadApprovalContext(), copySpecJson: args.copy_spec_json, writingBriefJson: args.writing_brief_json }) }), 'Approved learning was not authorized.'));
     server.registerTool('hyv_prepare_rebuild', {
         description: 'Prepare a rebuild task only after an upstream REBUILD recommendation, CopySpec, and signed rebuild-authorization capability. Capability input requires host-guaranteed sensitive-input redaction.',
         inputSchema: {
@@ -322,49 +201,21 @@ if (redactsSensitiveInputs) {
             recomposition_policy_json: lifecycleJson.optional(),
         },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => {
-        try {
-            return json(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));
-        }
-        catch {
-            return failure(new Error('Rebuild preparation failed.'));
-        }
-    });
+    }, 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.',
         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) => {
-        try {
-            return json(applyRebuildForMcp(args.task_json, args.response_json, args.profile_json, args.capability_json, loadApprovalContext()));
-        }
-        catch {
-            return failure(new Error('Rebuild application failed.'));
-        }
-    });
+    }, async (args) => guardedJson(() => applyRebuildForMcp(args.task_json, args.response_json, args.profile_json, args.capability_json, loadApprovalContext()), 'Rebuild application failed.'));
     server.registerTool('hyv_rebuild_writer_request', {
         description: 'Create the writer-only payload for a prepared rebuild. It excludes source draft, capability, profile body, and validation evidence.',
         inputSchema: { task_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async ({ task_json }) => {
-        try {
-            return json(rebuildWriterRequestForMcp(task_json));
-        }
-        catch {
-            return failure(new Error('Writer request could not be prepared.'));
-        }
-    });
+    }, async ({ task_json }) => guardedJson(() => rebuildWriterRequestForMcp(task_json), 'Writer request could not be prepared.'));
 }
 else {
     server.registerTool('hyv_lifecycle_finalize', {
         description: 'Record an authorized human rejection. Approval is unavailable because this host does not guarantee sensitive-input redaction.',
         inputSchema: { artifact_json: lifecycleJson, decision_json: lifecycleJson }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    }, async (args) => {
-        try {
-            return lifecycleResult(finalizeRejectionForMcp(args.artifact_json, args.decision_json, loadApprovalContext()));
-        }
-        catch {
-            return failure(new Error('Only rejection is available without sensitive-input redaction.'));
-        }
-    });
+    }, async (args) => guardedLifecycle(() => finalizeRejectionForMcp(args.artifact_json, args.decision_json, loadApprovalContext()), 'Only rejection is available without sensitive-input redaction.'));
 }
 await server.connect(new StdioServerTransport());

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.4.0');
+    assert.equal(HYV_VERSION, '3.4.2');
 });
 test('apply rejects forged tasks, missing capability, and substituted profiles', () => {
     const reduction = rebuildRecommendation();