@holdyourvoice/hyv 3.3.2 → 3.3.4

package/Readme.md

@@ -14,7 +14,7 @@ Those programs keep separate findings, scores, and pass states. A strong result
 
 Everything in the CLI runs from local files: accounts, API calls, telemetry, payment collection, and runtime network requests stay out of the core path. The optional Claude extension adds a local stdio MCP adapter around that same engine; it is not a hosted service.
 
-> **Status:** [`@holdyourvoice/hyv`](https://www.npmjs.com/package/@holdyourvoice/hyv) **3.3.2** is the public founder-aware rewrite. It runs locally and makes no runtime network requests. The package includes Profile v3 policy, pre-edit SHIP/EDIT/REBUILD judgments, contiguous range edits, authorized rebuild, and a signed semantic lifecycle.
+> **Status:** [`@holdyourvoice/hyv`](https://www.npmjs.com/package/@holdyourvoice/hyv) **3.3.4** is the public founder-aware rewrite. It runs locally and makes no runtime network requests. The package includes Profile v3 policy, pre-edit SHIP/EDIT/REBUILD judgments, contiguous range edits, authorized rebuild, and a signed semantic lifecycle.
 
 ## Why it exists
 

package/dist/cli.js

@@ -17,7 +17,8 @@ import { finalizeLifecycle, inspectLifecycle, prepareLifecycle, recordApprovedLe
 import { buildProfile } from './voice-dna.js';
 import { loadApprovalContext } from './approval-context.js';
 import { formatFactLintReport, lintFacts } from './fact-linter.js';
-const usage = 'Commands: profile, analyze, hygiene, inspect-hidden-text, apply-hidden-text-policy, final-check, fact-lint, batch-analyze, rewrite-prompt, prepare-rewrite, apply-rewrite, prepare-judgment, reduce-judgment, prepare-rebuild, rebuild-writer-request, apply-rebuild, verify, verify-spec, lifecycle, learning, patterns, mcp';
+import { lintLogic } from './logic-linter.js';
+const usage = 'Commands: profile, analyze, hygiene, inspect-hidden-text, apply-hidden-text-policy, final-check, fact-lint, logic-lint, batch-analyze, rewrite-prompt, prepare-rewrite, apply-rewrite, prepare-judgment, reduce-judgment, prepare-rebuild, rebuild-writer-request, apply-rebuild, verify, verify-spec, lifecycle, learning, patterns, mcp';
 const MAX_JSON_BYTES = 1024 * 1024;
 function input(path) {
     return path === '-' ? readFileSync(0, 'utf8') : readFileSync(path, 'utf8');
@@ -371,6 +372,14 @@ export async function runCli(args) {
             json(report);
         return strict && report.findings.some((item) => item.severity === 'error') ? 2 : 0;
     }
+    if (command === 'logic-lint') {
+        const [draftPath, briefPath, ...extra] = rest;
+        if (!draftPath || extra.length)
+            throw new Error('Usage: hyv logic-lint <draft|-> [writing-brief.json]');
+        const report = lintLogic(input(draftPath), readBrief(briefPath));
+        json(report);
+        return report.passed ? 0 : 2;
+    }
     if (command === 'batch-analyze') {
         if (rest.length < 2)
             throw new Error('Usage: hyv batch-analyze draft-a.md draft-b.md [draft-c.md]');

package/dist/cli.test.js

@@ -181,7 +181,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', 'original', 'passed', 'preservationScore', 'regressions', 'version']);
+        assert.deepEqual(Object.keys(JSON.parse(verification.stdout)).sort(), ['candidate', 'finalOutput', 'logicLint', 'original', 'passed', 'preservationScore', 'regressions', 'version']);
         assert.equal(run(['unknown-command']).status, 1);
         assert.equal(run(['mcp', 'unexpected']).status, 1);
     }
@@ -189,6 +189,19 @@ test('uses exit code 2 for a failed candidate gate and 1 for misuse', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('runs the logic linter as a standalone final gate', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-logic-lint-'));
+    try {
+        const draft = join(directory, 'draft.md');
+        writeFileSync(draft, 'The release checklist names rollback ownership. Each owner signs before deployment. Espresso machines use a dual boiler for stable temperature control. The checklist catches missing rollback steps.');
+        const result = run(['logic-lint', draft]);
+        assert.equal(result.status, 2, result.stderr);
+        assert.equal(JSON.parse(result.stdout).findings[0].kind, 'topic_drift');
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('fails the CopySpec gate when a locked claim changes', () => {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-cli-'));
     try {

package/dist/logic-linter-corpus.test.js

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import { lintLogic } from './logic-linter.js';
+import { words } from './text.js';
+const domains = ['marketing', 'engineering', 'deep-tech'];
+function corpus(domain) {
+    return JSON.parse(readFileSync(new URL(`../test-fixtures/logic-linter/${domain}.json`, import.meta.url), 'utf8'));
+}
+test('keeps a 54-post long-form corpus cohesive across marketing, engineering, and deep tech', () => {
+    const posts = domains.flatMap(corpus);
+    assert.equal(posts.length, 54);
+    assert.equal(new Set(posts.map((post) => post.id)).size, 54);
+    for (const domain of domains)
+        assert.equal(corpus(domain).length, 18);
+    for (const post of posts) {
+        const wordCount = words(post.text).length;
+        assert.ok(wordCount >= 350 && wordCount <= 1_500, `${post.id} must contain 350–1,500 words; got ${wordCount}`);
+        const report = lintLogic(post.text);
+        assert.equal(report.passed, true, `${post.id}: ${JSON.stringify(report.findings)}`);
+    }
+});

package/dist/logic-linter.js

@@ -0,0 +1,101 @@
+import { sentences, words } from './text.js';
+const STOP_WORDS = new Set(['about', 'after', 'again', 'also', 'among', 'another', 'because', 'before', 'being', 'between', 'build', 'could', 'every', 'first', 'from', 'have', 'into', 'just', 'like', 'many', 'more', 'most', 'only', 'other', 'over', 'same', 'some', 'than', 'that', 'their', 'there', 'these', 'they', 'this', 'those', 'through', 'under', 'very', 'what', 'when', 'which', 'while', 'with', 'would', 'your']);
+const ANAPHORA = /\b(?:this|that|these|those|it|they|them|its|their|the result|the change|the work|that choice|this choice|this means)\b/i;
+const INFERENCE = /^(?:but|however|therefore|thus|so|instead|because|as a result|that means|this means|the result|in practice)\b/i;
+const NEGATION = /\b(?:not|never|no|cannot|can't|won't|isn't|aren't|wasn't|weren't|doesn't|don't|didn't)\b/i;
+function stem(word) {
+    if (word.length > 6 && word.endsWith('ies'))
+        return `${word.slice(0, -3)}y`;
+    if (word.length > 5 && word.endsWith('ing'))
+        return word.slice(0, -3);
+    if (word.length > 4 && word.endsWith('ed'))
+        return word.slice(0, -2);
+    if (word.length > 4 && word.endsWith('s'))
+        return word.slice(0, -1);
+    return word;
+}
+function anchors(text) {
+    return new Set(words(text.toLowerCase()).map(stem).filter((word) => word.length > 3 && !STOP_WORDS.has(word)));
+}
+function overlap(left, right) {
+    return [...left].some((item) => right.has(item));
+}
+function allArgumentAnchors(brief) {
+    if (!brief?.argumentMap)
+        return new Set();
+    const map = brief.argumentMap;
+    return anchors(`${map.observation} ${map.mechanism} ${map.consequence} ${map.readerValue}`);
+}
+function contradictionKey(text) {
+    const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, ' ').replace(/\s+/g, ' ').trim();
+    const match = normalized.match(/^((?:[\p{L}\p{N}'-]+\s+){0,4}[\p{L}\p{N}'-]+)\s+(?:is|are|was|were|will|can|should|does|do|did|has|have)\s+(.+)$/u);
+    if (!match)
+        return undefined;
+    const subject = match[1].split(' ').filter((word) => word.length > 2 && !STOP_WORDS.has(word)).map(stem).join(' ');
+    const predicate = match[2].replace(NEGATION, '').split(' ').filter((word) => word.length > 2 && !STOP_WORDS.has(word)).map(stem).join(' ');
+    return subject && predicate ? { key: `${subject}|${predicate}`, negated: NEGATION.test(normalized) } : undefined;
+}
+function finding(kind, severity, sentence, excerpt, reason, suggestion, relatedSentence) {
+    return { kind, severity, sentence, ...(relatedSentence ? { relatedSentence } : {}), excerpt, reason, suggestion };
+}
+export function lintLogic(draft, brief) {
+    const document = sentences(draft);
+    const findings = [];
+    const skippedChecks = [];
+    const sentenceAnchors = document.map((sentence) => anchors(sentence.text));
+    const frequencies = new Map();
+    for (const list of sentenceAnchors)
+        for (const anchor of list)
+            frequencies.set(anchor, (frequencies.get(anchor) ?? 0) + 1);
+    const dominant = new Set([...frequencies].filter(([, count]) => count >= 2).map(([anchor]) => anchor));
+    const briefAnchors = allArgumentAnchors(brief);
+    const priorClaims = new Map();
+    for (const sentence of document) {
+        const claim = contradictionKey(sentence.text);
+        if (!claim)
+            continue;
+        const previous = priorClaims.get(claim.key);
+        if (previous && previous.negated !== claim.negated) {
+            findings.push(finding('internal_contradiction', 'error', sentence.index, sentence.text, `This statement reverses the polarity of sentence ${previous.sentence}.`, 'Keep one position, or explain the changed condition explicitly.', previous.sentence));
+        }
+        else
+            priorClaims.set(claim.key, { sentence: sentence.index, negated: claim.negated });
+    }
+    if (document.length < 3)
+        skippedChecks.push('topic_drift_short_post');
+    else {
+        for (let index = 2; index < document.length - 1; index += 1) {
+            const current = document[index];
+            const currentAnchors = sentenceAnchors[index];
+            const previousAnchors = sentenceAnchors[index - 1];
+            const nextAnchors = sentenceAnchors[index + 1];
+            const connected = overlap(currentAnchors, previousAnchors) || overlap(currentAnchors, nextAnchors) || overlap(currentAnchors, dominant) || overlap(currentAnchors, briefAnchors) || ANAPHORA.test(current.text);
+            if (!connected && currentAnchors.size >= 5 && !current.text.trim().endsWith('?')) {
+                findings.push(finding('topic_drift', 'error', current.index, current.text, 'This sentence has no detectable topic anchor in the surrounding argument or brief.', 'Connect it to the current subject, or remove it from this post.'));
+            }
+            if (INFERENCE.test(current.text) && !overlap(currentAnchors, previousAnchors) && !ANAPHORA.test(current.text)) {
+                findings.push(finding('unanchored_inference', 'error', current.index, current.text, 'The transition claims an inference or contrast without a detectable subject bridge to the prior sentence.', 'Name the subject that carries across the transition.'));
+            }
+        }
+    }
+    if (brief?.argumentMap) {
+        const draftAnchors = new Set(sentenceAnchors.flatMap((set) => [...set]));
+        const missing = [...briefAnchors].filter((anchor) => !draftAnchors.has(anchor));
+        if (briefAnchors.size >= 3 && missing.length === briefAnchors.size) {
+            const first = document[0];
+            if (first)
+                findings.push(finding('argument_map_gap', 'needs_human_review', first.index, first.text, 'No terms from the brief argument map are visible in the draft.', 'Check that this draft answers the assigned argument.'));
+        }
+    }
+    const errors = findings.filter((item) => item.severity === 'error').length;
+    const needsHumanReview = findings.filter((item) => item.severity === 'needs_human_review').length;
+    return { version: '1', passed: errors === 0, summary: { checkedSentences: document.length, errors, needsHumanReview }, findings, skippedChecks, limitations: ['English-only lexical coherence check.', 'Does not establish factual truth, rhetorical quality, or publication approval.', 'A pass means no configured deterministic logic failure was found.'] };
+}
+export function formatLogicLintReport(report) {
+    const lines = [`logic lint: ${report.summary.checkedSentences} sentences, ${report.summary.errors} errors, ${report.summary.needsHumanReview} review findings`];
+    for (const item of report.findings)
+        lines.push(`${item.severity} ${item.kind} s${item.sentence}: ${item.reason}`);
+    if (report.skippedChecks.length)
+        lines.push(`skipped: ${report.skippedChecks.join(', ')}`);
+    return lines.join('\n');
+}

package/dist/logic-linter.test.js

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { lintLogic } from './logic-linter.js';
+test('accepts a post that develops one connected marketing argument', () => {
+    const report = lintLogic('Most marketing teams measure clicks before they measure qualified conversations. That choice rewards cheap attention. We changed the weekly review to start with qualified conversations, then used click data to explain movement. The review now tells the team which message created demand.');
+    assert.equal(report.passed, true);
+    assert.deepEqual(report.findings, []);
+});
+test('blocks an abrupt, unsupported topic jump', () => {
+    const report = lintLogic('The release checklist makes rollback ownership explicit. Each service owner signs the same checklist before deployment. The best espresso machines use a dual boiler for stable temperature control. The checklist now catches missing rollback steps before they become incidents.');
+    assert.equal(report.passed, false);
+    assert.equal(report.findings[0]?.kind, 'topic_drift');
+    assert.equal(report.findings[0]?.severity, 'error');
+});
+test('allows an explicit bridge into a consequence', () => {
+    const report = lintLogic('The compiler now records each cache key. This means the build dashboard can explain a cache miss without replaying the job. That explanation makes incident review faster.');
+    assert.equal(report.passed, true);
+});
+test('does not treat an isolated rhetorical question as a hard topic-drift finding', () => {
+    const report = lintLogic('The migration writes its recovery marker before it changes customer data. What happens if execution stops between two writes? The recovery marker lets the worker resume the migration safely.');
+    assert.equal(report.passed, true);
+});
+test('blocks directly contradictory claims', () => {
+    const report = lintLogic('The migration is ready for production. The migration is not ready for production.');
+    assert.equal(report.passed, false);
+    assert.equal(report.findings[0]?.kind, 'internal_contradiction');
+});
+test('uses the brief argument map as an additional topical anchor', () => {
+    const report = lintLogic('Operators still reconcile customer changes by hand. A small approval queue records the owner and reason for each change. The queue turns a vague audit request into a traceable review.', {
+        version: '1', audience: 'operators', intent: 'explain', format: 'social',
+        argumentMap: { observation: 'manual customer change reconciliation', mechanism: 'approval queue', consequence: 'traceable audit review', readerValue: 'faster operator review' },
+    });
+    assert.equal(report.passed, true);
+});
+test('does not make a drift verdict for a short post', () => {
+    const report = lintLogic('The release is ready. Espresso needs fresh beans.');
+    assert.equal(report.passed, true);
+    assert.deepEqual(report.skippedChecks, ['topic_drift_short_post']);
+});

package/dist/mcp-tools.js

@@ -3,6 +3,7 @@ import { parseCopySpec } from './copy-spec.js';
 import { analyzeBatch, parseWritingBrief } from './editorial-packs.js';
 import { clearLearning, composeLearning, inspectLearning, migrateLearningV2ToV3, ratifyLearningEvent, recordLearningInstruction, supersedeLearningEvent } from './learning.js';
 import { analyze, rewritePrompt, verify, verifyWithCopySpec } from './pipeline.js';
+import { lintLogic } from './logic-linter.js';
 import { parseProfile } from './profile.js';
 import { evaluateRewriteResponse, parseRewriteTask, prepareRewriteTask } from './rewrite-task.js';
 import { parseJudgmentEnvelope, preparePostCandidateJudgment, preparePreEditJudgment, reducePostCandidate, reducePreEdit } from './judgment-task.js';
@@ -98,6 +99,9 @@ export function verifyCopySpecForMcp(original, candidate, profileJson, copySpecJ
     const profile = profileFromJson(profileJson);
     return verifyWithCopySpec(original, candidate, profile, copySpecFromJson(copySpecJson), writingBriefFromJson(writingBriefJson));
 }
+export function logicLintForMcp(draft, writingBriefJson) {
+    return lintLogic(draft, writingBriefFromJson(writingBriefJson));
+}
 function parsed(json, label) {
     if (Buffer.byteLength(json, 'utf8') > 1024 * 1024)
         throw new Error(`${label} exceeds the byte limit.`);

package/dist/mcp-tools.test.js

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { analyzeBatchForMcp, analyzeForMcp, applyHiddenTextPolicyForMcp, applyRebuildForMcp, applyRewriteForMcp, buildProfileForMcp, clearLearningForMcp, finalOutputCheckForMcp, finalizeLifecycleForMcp, inspectHiddenTextForMcp, inspectHygieneForMcp, inspectLearningForMcp, inspectLifecycleForMcp, patternsForMcp, prepareJudgmentForMcp, prepareLifecycleForMcp, prepareRebuildForMcp, prepareRewriteForMcp, ratifyLearningForMcp, recordApprovedLearningForMcp, recordLearningForMcp, rebuildWriterRequestForMcp, reduceJudgmentForMcp, rewritePromptForMcp, submitSemanticVerdictForMcp, supersedeLearningForMcp, validateFinalApprovalForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
+import { analyzeBatchForMcp, analyzeForMcp, applyHiddenTextPolicyForMcp, applyRebuildForMcp, applyRewriteForMcp, buildProfileForMcp, clearLearningForMcp, finalOutputCheckForMcp, finalizeLifecycleForMcp, inspectHiddenTextForMcp, inspectHygieneForMcp, inspectLearningForMcp, inspectLifecycleForMcp, logicLintForMcp, patternsForMcp, prepareJudgmentForMcp, prepareLifecycleForMcp, prepareRebuildForMcp, prepareRewriteForMcp, ratifyLearningForMcp, recordApprovedLearningForMcp, recordLearningForMcp, rebuildWriterRequestForMcp, reduceJudgmentForMcp, rewritePromptForMcp, submitSemanticVerdictForMcp, supersedeLearningForMcp, validateFinalApprovalForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
 import { canonicalJson } from './canonical-json.js';
 const profile = buildProfileForMcp(['I write clearly. I keep the useful detail.', 'I make the call. Then I explain the trade-off.'], ['leverage']);
 const profileJson = JSON.stringify(profile);
@@ -23,6 +23,11 @@ test('inspects Unicode hygiene through MCP without a voice profile', () => {
     assert.equal(result.suspiciousCount, 2);
     assert.equal(result.fixableCount, 0);
 });
+test('exposes the deterministic logic gate through MCP helpers', () => {
+    const report = logicLintForMcp('The service records cache keys. Each build writes its cache key. Espresso machines use dual boilers for stable temperature control. The service uses cache keys during incident review.');
+    assert.equal(report.passed, false);
+    assert.equal(report.findings[0]?.kind, 'topic_drift');
+});
 test('applies only explicit hidden-text removals through MCP', () => {
     const policy = JSON.stringify({ version: '1', name: 'minimal-text-control-cleanup', approvedRemovals: ['ascii_control'], acknowledgement: 'Removes only listed non-semantic controls; all other findings remain review-only.' });
     const inspected = inspectHiddenTextForMcp('one\u0007two\uFEFFthree\u200D', policy);

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { analyzeBatchForMcp, analyzeForMcp, applyHiddenTextPolicyForMcp, applyRebuildForMcp, applyRewriteForMcp, buildProfileForMcp, clearLearningForMcp, finalOutputCheckForMcp, finalizeLifecycleForMcp, finalizeRejectionForMcp, inspectHiddenTextForMcp, inspectHygieneForMcp, inspectLearningForMcp, inspectLifecycleForMcp, migrateLearningForMcp, patternsForMcp, prepareJudgmentForMcp, prepareLifecycleForMcp, prepareRebuildForMcp, prepareRewriteForMcp, ratifyLearningForMcp, rebuildWriterRequestForMcp, recordApprovedLearningForMcp, recordLearningForMcp, reduceJudgmentForMcp, rewritePromptForMcp, submitSemanticVerdictForMcp, supersedeLearningForMcp, validateFinalApprovalForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
+import { analyzeBatchForMcp, analyzeForMcp, applyHiddenTextPolicyForMcp, applyRebuildForMcp, applyRewriteForMcp, buildProfileForMcp, clearLearningForMcp, finalOutputCheckForMcp, finalizeLifecycleForMcp, finalizeRejectionForMcp, inspectHiddenTextForMcp, inspectHygieneForMcp, inspectLearningForMcp, inspectLifecycleForMcp, logicLintForMcp, migrateLearningForMcp, patternsForMcp, prepareJudgmentForMcp, prepareLifecycleForMcp, prepareRebuildForMcp, prepareRewriteForMcp, ratifyLearningForMcp, rebuildWriterRequestForMcp, recordApprovedLearningForMcp, recordLearningForMcp, reduceJudgmentForMcp, rewritePromptForMcp, submitSemanticVerdictForMcp, supersedeLearningForMcp, validateFinalApprovalForMcp, verifyCopySpecForMcp, verifyForMcp } from './mcp-tools.js';
 import { HYV_VERSION } from './version.js';
 import { loadApprovalContext } from './approval-context.js';
 const writing = z.string().min(1).max(100_000);
@@ -78,6 +78,18 @@ server.registerTool('hyv_final_check', {
     inputSchema: { text: hygieneText },
     annotations: { readOnlyHint: true },
 }, async ({ text }) => json(finalOutputCheckForMcp(text)));
+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);
+    }
+});
 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() },

package/dist/mcp.test.js

@@ -64,7 +64,7 @@ test('serves local Claude tools over stdio', async () => {
     assert.equal(code, 0);
     const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
     const tools = responses.find((response) => response.id === 2)?.result?.tools;
-    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_hygiene', 'hyv_inspect_hidden_text', 'hyv_apply_hidden_text_policy', 'hyv_final_check', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_prepare_judgment', 'hyv_reduce_judgment', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns', 'hyv_learning_inspect', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear', 'hyv_lifecycle_prepare_semantic', 'hyv_lifecycle_submit_verdict', 'hyv_lifecycle_inspect', 'hyv_lifecycle_finalize']);
+    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_hygiene', 'hyv_inspect_hidden_text', 'hyv_apply_hidden_text_policy', 'hyv_final_check', 'hyv_logic_lint', 'hyv_rewrite_prompt', 'hyv_prepare_rewrite', 'hyv_apply_rewrite', 'hyv_prepare_judgment', 'hyv_reduce_judgment', 'hyv_verify', 'hyv_verify_copy_spec', 'hyv_batch_analyze', 'hyv_patterns', 'hyv_learning_inspect', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear', 'hyv_lifecycle_prepare_semantic', 'hyv_lifecycle_submit_verdict', 'hyv_lifecycle_inspect', 'hyv_lifecycle_finalize']);
     assert.ok(tools?.filter((tool) => !['hyv_verify', 'hyv_verify_copy_spec', 'hyv_apply_hidden_text_policy', 'hyv_learning_record', 'hyv_learning_ratify', 'hyv_learning_supersede', 'hyv_learning_migrate', 'hyv_learning_clear'].includes(tool.name)).every((tool) => tool.annotations?.readOnlyHint));
     assert.equal(tools?.find((tool) => tool.name === 'hyv_verify')?.annotations?.readOnlyHint, true);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_verify_copy_spec')?.annotations?.readOnlyHint, true);
@@ -75,6 +75,7 @@ test('serves local Claude tools over stdio', async () => {
     assert.equal('capability_json' in (tools?.find((tool) => tool.name === 'hyv_lifecycle_finalize')?.inputSchema?.properties ?? {}), false);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_inspect')?.annotations?.readOnlyHint, true);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_inspect_hidden_text')?.annotations?.readOnlyHint, true);
+    assert.equal(tools?.find((tool) => tool.name === 'hyv_logic_lint')?.annotations?.readOnlyHint, true);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_apply_hidden_text_policy')?.annotations?.readOnlyHint, false);
     assert.equal(tools?.find((tool) => tool.name === 'hyv_learning_clear')?.annotations?.readOnlyHint, false);
     assert.deepEqual(tools?.filter((tool) => tool.name.startsWith('hyv_learning_')).map((tool) => [tool.name, tool.annotations?.readOnlyHint, tool.annotations?.destructiveHint]), [
@@ -97,7 +98,7 @@ test('registers capability tools only with host redaction attestation', async ()
     assert.equal(stderr, '');
     const response = stdout.trim().split('\n').map((line) => JSON.parse(line)).find((item) => item.id === 2);
     const names = response.result.tools.map((tool) => tool.name);
-    assert.equal(names.length, 30);
+    assert.equal(names.length, 31);
     assert.ok(names.includes('hyv_lifecycle_validate_final_approval'));
     assert.ok(names.includes('hyv_learning_record_approved'));
     assert.ok(names.includes('hyv_prepare_rebuild'));

package/dist/pipeline.js

@@ -8,6 +8,7 @@ import { finalOutputCheck, inspectHygiene } from './hygiene.js';
 import { analyzeVoiceDna } from './voice-dna.js';
 import { legacySetPreservation } from './preservation.js';
 import { lintFacts } from './fact-linter.js';
+import { lintLogic } from './logic-linter.js';
 import { sentences } from './text.js';
 export function analyze(text, profile, brief) {
     const voiceDna = analyzeVoiceDna(text, profile);
@@ -112,6 +113,7 @@ function verifyRequiredFacts(candidate, brief) {
 export function verify(original, candidate, profile, brief) {
     const { baseline, checked, regressions, preservation } = compareCandidates(original, candidate, profile, brief);
     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);
     return {
@@ -121,8 +123,9 @@ export function verify(original, candidate, profile, brief) {
         preservationScore: preservation,
         regressions,
         finalOutput,
+        logicLint,
         ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && !regressions.some(isBlockingFinding) && preservation >= 70 && finalOutput.accepted && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
+        passed: checked.passed && !regressions.some(isBlockingFinding) && preservation >= 70 && finalOutput.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
     };
 }
 export function verifyWithCopySpec(original, candidate, profile, spec, brief) {
@@ -134,6 +137,7 @@ export function verifyRebuildWithCopySpec(original, candidate, profile, spec, br
     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 {
@@ -144,8 +148,9 @@ export function verifyRebuildWithCopySpec(original, candidate, profile, spec, br
         regressions,
         claims,
         finalOutput: finalCheck,
+        logicLint,
         ...(factLint ? { factLint } : {}), ...(requiredFacts ? { requiredFacts } : {}),
-        passed: checked.passed && !regressions.some(isBlockingFinding) && claims.passed && finalCheck.accepted && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
+        passed: checked.passed && !regressions.some(isBlockingFinding) && claims.passed && finalCheck.accepted && logicLint.passed && !factLint?.findings.some((finding) => finding.severity === 'error') && (requiredFacts?.passed ?? true),
     };
 }
 function digest(value) { return createHash('sha256').update(value).digest('hex'); }

package/dist/pipeline.test.js

@@ -94,6 +94,14 @@ test('verification applies the final-output gate by default', () => {
     assert.equal(result.finalOutput.accepted, false);
     assert.equal('output' in result.finalOutput, false);
 });
+test('verification blocks a candidate with document-level topic drift', () => {
+    const source = 'The checklist names rollback ownership. Each owner signs before deployment. The checklist catches missing rollback steps. The owner reviews the checklist after release.';
+    const candidate = 'The checklist names rollback ownership. Each owner signs before deployment. Espresso machines use a dual boiler for stable temperature control. The checklist catches missing rollback steps.';
+    const result = verify(source, candidate, profile);
+    assert.equal(result.logicLint.passed, false);
+    assert.equal(result.logicLint.findings[0]?.kind, 'topic_drift');
+    assert.equal(result.passed, false);
+});
 test('advisory and pending-judgment findings pass while blocking findings fail', () => {
     const advisory = analyze('Firstly, check the invoice.', profile);
     assert.equal(advisory.passed, true);

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

package/dist/version.js

@@ -1 +1 @@
-export const HYV_VERSION = '3.3.2';
+export const HYV_VERSION = '3.3.4';

package/package.json

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