@holdyourvoice/hyv 3.3.1 → 3.3.2

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.1** 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.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.
 
 ## Why it exists
 
@@ -29,7 +29,7 @@ Hold Your Voice keeps the work visible:
 | Did the rewrite introduce a new blocker or replace too much? | Verification | Regressions, preservation score, and a release decision. |
 | Should this draft ship, take a bounded edit, or rebuild? | Judgment | A SHIP, EDIT, or REBUILD recommendation bound to the draft and profile. |
 
-Its scope is a local writing gate. Authorship detection, fact checking, plagiarism review, and hosted generation each need their own tools. Hold Your Voice gives a writer or chosen model a narrow editing brief, then asks the same two engines to inspect the result.
+Its scope is a local writing gate. It includes a source-consistency fact linter, not a truth engine: it checks a final draft against the evidence you provide. Authorship detection, plagiarism review, and hosted generation each need their own tools.
 
 ## Start here
 
@@ -94,9 +94,9 @@ producer | hyv final-check -
 hyv final-check final-response.md
 ```
 
-Clean text is written to stdout byte-for-byte. A leading U+FEFF byte-order mark is removed before output. When other hidden Unicode remains, stdout stays empty, the report goes to stderr, and the command exits `2`. Put this command immediately before display, copy, export, posting, or an API response. The producer and the presence of a VoiceDNA profile do not change the policy.
+Clean text is written to stdout byte-for-byte. The gate removes only non-semantic ASCII controls and byte-order marks. When any other hidden Unicode remains, stdout stays empty, the report goes to stderr, and the command exits `2`. Put this command immediately before display, copy, export, posting, or an API response. The producer and the presence of a VoiceDNA profile do not change the policy.
 
-This is an integration boundary, not a background interceptor. A GUI, agent host, or external tool must pass its exact final text to `hyv final-check -` or the read-only `hyv_final_check` MCP tool and deliver only accepted output. Run it after the last rewrite, formatter, template expansion, or manual edit; checking an earlier draft does not cover later changes.
+This is an integration boundary, not a background interceptor. HYV applies the same gate by default during rewrite and rebuild verification; unresolved output is withheld from their CLI and MCP evaluation result. A GUI, agent host, or external tool must still pass any later changed text to `hyv final-check -` or the read-only `hyv_final_check` MCP tool and deliver only accepted output. Run it after the last rewrite, formatter, template expansion, or manual edit; checking an earlier draft does not cover later changes.
 
 ### Inspect and clean hidden Unicode
 
@@ -113,7 +113,16 @@ hyv hygiene draft.md --fix
 hyv hygiene draft.md --fix --output=review-copy.md
 ```
 
-The fix receipt lists every changed UTF-16 offset and code point. The conservative cleaner removes only a leading U+FEFF byte-order mark. It reports other zero-width characters, unusual spaces, bidirectional controls, and tag characters without changing them because they can carry legitimate language, typography, or emoji behavior. Existing output files are never overwritten.
+The fix receipt lists every changed UTF-16 offset and code point. The conservative cleaner removes ASCII controls and byte-order marks. It reports other zero-width characters, unusual spaces, bidirectional controls, and tag characters without changing them because they can carry legitimate language, typography, or emoji behavior. Existing output files are never overwritten.
+
+For a deliberately narrow, policy-backed cleanup of non-semantic ASCII controls and mid-document byte-order marks, inspect first and write a separate result:
+
+```bash
+hyv inspect-hidden-text draft.md policy.json
+hyv apply-hidden-text-policy draft.md policy.json draft.sanitized.md
+```
+
+The receipt carries the input/output hashes, exact changes, remaining review findings, and an idempotence result. It does not label Unicode findings as watermarks or claim that any provider watermark was removed.
 
 ### Add contextual editorial guidance
 
@@ -196,7 +205,36 @@ Use `verify-spec` when a draft has claims that must remain verbatim unless they
 hyv verify-spec original.md candidate.md profile.json copy-spec.json
 ```
 
-The check is deterministic. Without `atoms`, an immutable claim remains a verbatim sentence check. With `atoms`, every declared phrase must remain somewhere in the candidate, allowing independent facts to be split or reordered. Atoms are lexical-presence checks, not factual validation: put the whole relationship in one atom when it must stay true (for example, `Kimi K2.6 uses INT4 weights` rather than `INT4`). It covers declared claims and prohibited text; arbitrary unsupported assertions need a separate factual evaluator.
+The check is deterministic. Without `atoms`, an immutable claim remains a verbatim sentence check. With `atoms`, every declared phrase must remain somewhere in the candidate, allowing independent facts to be split or reordered. Atoms are lexical-presence checks, not factual validation.
+
+### Check factual consistency with supplied sources
+
+`fact-lint` compares a final draft with local evidence. It extracts claims with sentence and UTF-16 offsets, checks dates, names, quotes, capabilities, causal/comparative escalation, and draft contradictions, then returns JSON with exact local evidence.
+
+```bash
+hyv fact-lint final.md --source=release:release-notes.md --source=research:research.md
+hyv fact-lint final.md --source=release:release-notes.md --human
+hyv fact-lint final.md --source=release:release-notes.md --strict
+```
+
+The default is report-only and exits `0`; `--strict` exits `2` for error findings. Known conflicts such as a CSV-to-PDF change are errors. A new or unclear capability, or weak evidence such as “exists” versus “grows”, becomes `needs_human_review`. No source text leaves the process by default. The linter checks consistency with supplied evidence; it does not prove the sources are true. See the [fact linter guide](docs/wiki/Fact-Linter.md).
+
+When a `WritingBrief` includes `factSources`, HYV runs the same local fact lint automatically during `verify`, `verify-spec`, rewrite evaluation, and their MCP equivalents. Error findings block verification. Source-free flows remain unchanged.
+
+Use `requiredFacts` for facts that must appear in the final draft. Each required fact must be supported by its source text or declared atoms in `factSources`; HYV fails verification if it is missing, negated, or denied. It does not assume every fact from every source belongs in every output.
+
+```json
+{
+  "version": "1",
+  "audience": "founders",
+  "intent": "write a post",
+  "format": "social",
+  "factSources": [{ "id": "bio", "text": "Shashank is a LinkedIn Top Voice." }],
+  "requiredFacts": [{ "id": "linkedin-top-voice", "text": "Shashank is a LinkedIn Top Voice." }]
+}
+```
+
+HYV does not infer trusted evidence from ordinary prompt prose. Pass source material through `factSources`, then mark only the inclusion-critical statements in `requiredFacts`. Run source-backed `verify` after the last substantive edit. `final-check` is a hygiene gate; it does not re-run evidence checks. Use source material that you are allowed to include in a rewrite task; task handoff is controlled by the calling host.
 
 ### Local voice memory
 
@@ -226,7 +264,10 @@ flowchart LR
   T --> G[Verify candidate]
   C --> G
   D --> G
-  G --> R[Pass or inspect regressions]
+  F[Optional factSources + requiredFacts] --> L[Local fact lint]
+  L --> G
+  G --> R[Errors block; review findings stay visible]
+  R --> H[final-check: hygiene before output]
 ```
 
 The tool never applies changes to your draft. You decide which findings are valid, apply replacement sentences or an authorized rebuild deliberately, and run the final check.
@@ -240,12 +281,14 @@ The tool never applies changes to your draft. You decide which findings are vali
 3. **EDIT** applies eligible sentence replacements or contiguous range edits through `prepare-rewrite` / `apply-rewrite`. Clean and unflagged text stays in place. Overlapping, out-of-order, or partly locked ranges fail before a candidate is built.
 4. **REBUILD** prepares a whole-document candidate only after a matching REBUILD recommendation, a CopySpec, and a signed `hyv.rebuild-authorization` capability. `prepare-rebuild` / `apply-rebuild` re-check that capability and the bound profile. Claim, polarity, hygiene, and semantic gates stay in force. Edit and rebuild responses are mutually incompatible.
 
+For a meaning-first recomposition, pass an explicit lexical-residual policy to `prepare-rebuild`. HYV gives the external writer structured facts and constraints rather than automatically including the source draft in its prompt, then measures shared wording after the candidate returns. A passed residual report means only that the candidate meets the configured overlap policy. It does not detect, remove, or prove the absence of a provider watermark, and it does not establish authorship.
+
 ```bash
 hyv prepare-judgment pre-edit argument draft.md profile.json task.json
 hyv reduce-judgment envelope-a.json envelope-b.json envelope-c.json
 hyv prepare-rewrite draft.md profile.json task.json
 hyv apply-rewrite task.json response.json profile.json
-hyv prepare-rebuild draft.md profile.json reduction.json copy-spec.json task.json --capability-file capability.json
+hyv prepare-rebuild draft.md profile.json reduction.json copy-spec.json task.json --recomposition-policy policy.json --capability-file capability.json
 hyv apply-rebuild task.json response.json profile.json --capability-file capability.json
 ```
 
@@ -327,7 +370,7 @@ The preservation score is a guardrail based on retained original words longer th
 | `hyv apply-rewrite <task.json> <response.json> <profile.json>` | Task, response, and profile | Candidate evaluation JSON | A host needs to apply and recheck eligible sentence replacements. |
 | `hyv prepare-judgment <pre-edit\|post-candidate> <kind> <draft> <profile.json> <task.json> [candidate.md]` | Draft, profile, and optional candidate | Versioned judgment task | Findings need a SHIP, EDIT, or REBUILD recommendation. |
 | `hyv reduce-judgment <envelope.json> <envelope.json> [envelope.json...]` | Signed judgment envelopes | Recommendation JSON | Multiple judgment envelopes must reduce to one decision. |
-| `hyv prepare-rebuild <draft> <profile.json> <reduction.json> <copy-spec.json> <task.json>` | Draft, recommendation, CopySpec, and capability | Versioned rebuild task | An upstream REBUILD recommendation needs a whole-document candidate. |
+| `hyv prepare-rebuild <draft> <profile.json> <reduction.json> <copy-spec.json> <task.json> [--recomposition-policy policy.json]` | Draft, recommendation, CopySpec, capability, and optional policy | Versioned rebuild task | An upstream REBUILD recommendation needs a whole-document candidate; an optional policy makes it meaning-first and adds lexical-residual evidence. |
 | `hyv apply-rebuild <task.json> <response.json> <profile.json>` | Task, response, profile, and capability | Candidate evaluation JSON | A host needs to apply and recheck an authorized rebuild. |
 | `hyv verify <original> <candidate> <profile.json>` | Original, candidate, profile | Verification JSON and exit code | You need the candidate gate. |
 | `hyv verify-spec <original> <candidate> <profile.json> <copy-spec.json>` | Original, candidate, profile, CopySpec | Verification JSON with hard claim gate | A brief contains locked facts or prohibited claims. |
@@ -356,6 +399,7 @@ The standalone CLI supports normal-policy semantic review. High-assurance review
 | `src/rewrite-task.ts` | Prepares and evaluates fingerprint-bound sentence-replacement and range-edit tasks. |
 | `src/judgment-task.ts` | Reduces pre-edit SHIP/EDIT/REBUILD recommendations and post-candidate clearance. |
 | `src/rebuild-task.ts` | Prepares whole-document rebuild after a matching recommendation, CopySpec, and signed capability. |
+| `src/recomposition.ts` | Builds meaning-first rebuild briefs and measures declared lexical-residual evidence. |
 | `src/semantic-review.ts` | Defines and reduces semantic and human-review lifecycle artifacts. |
 | `src/approval-capability.ts` | Verifies canonical signed approval capabilities. |
 | `src/approval-context.ts` | Loads permission-checked trust roots and evaluator authorization. |

package/dist/cli.js

@@ -6,16 +6,18 @@ import { parseCopySpec } from './copy-spec.js';
 import { analyzeBatch, parseWritingBrief } from './editorial-packs.js';
 import { clearLearning, composeLearning, inspectLearning, migrateLearningV2ToV3, profileFingerprint, ratifyLearningEvent, recordLearningInstruction, supersedeLearningEvent } from './learning.js';
 import { cleanHygiene, finalOutputCheck, inspectHygiene } from './hygiene.js';
+import { applyHiddenTextPolicy, inspectHiddenText, parseHiddenTextPolicy } from './hidden-text.js';
 import { analyze, rewritePrompt, verify, verifyWithCopySpec } from './pipeline.js';
 import { parseProfile } from './profile.js';
 import { evaluateRewriteResponse, parseRewriteTask, prepareRewriteTask } from './rewrite-task.js';
 import { parseJudgmentEnvelope, preparePostCandidateJudgment, preparePreEditJudgment, reducePostCandidate, reducePreEdit } from './judgment-task.js';
-import { evaluateRebuildResponse, parseRebuildTask, prepareRebuildTask } from './rebuild-task.js';
+import { evaluateRebuildResponse, parseRebuildTask, prepareRebuildTask, writerRequestForRebuild } from './rebuild-task.js';
 import { canonicalJson, parseCanonicalJson } from './canonical-json.js';
 import { finalizeLifecycle, inspectLifecycle, prepareLifecycle, recordApprovedLearning, submitSemanticVerdict, validateFinalApproval } from './lifecycle-adapter.js';
 import { buildProfile } from './voice-dna.js';
 import { loadApprovalContext } from './approval-context.js';
-const usage = 'Commands: profile, analyze, hygiene, final-check, batch-analyze, rewrite-prompt, prepare-rewrite, apply-rewrite, prepare-judgment, reduce-judgment, prepare-rebuild, apply-rebuild, verify, verify-spec, lifecycle, learning, patterns, mcp';
+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';
 const MAX_JSON_BYTES = 1024 * 1024;
 function input(path) {
     return path === '-' ? readFileSync(0, 'utf8') : readFileSync(path, 'utf8');
@@ -106,6 +108,23 @@ function capabilityArguments(args) {
         throw new Error('JSON input exceeds the byte limit.');
     return { values, capability: parseCanonicalJson(Buffer.from(raw, 'utf8')) };
 }
+function rebuildArguments(args) {
+    const values = [];
+    let policyPath;
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== '--recomposition-policy') {
+            values.push(args[index]);
+            continue;
+        }
+        const path = args[index + 1];
+        if (policyPath || !path || path === '-' || path.startsWith('--'))
+            throw new Error('Choose one recomposition policy file.');
+        policyPath = path;
+        index += 1;
+    }
+    const capability = capabilityArguments(values);
+    return { ...capability, ...(policyPath ? { recompositionPolicy: readJson(policyPath) } : {}) };
+}
 function readProfile(path) {
     return parseProfile(JSON.parse(input(path)));
 }
@@ -280,6 +299,24 @@ export async function runCli(args) {
         json({ ...result.report, changed: result.changed, changes: result.changes, outputPath });
         return 0;
     }
+    if (command === 'inspect-hidden-text') {
+        const [path, policyPath, ...extra] = rest;
+        if (!path || extra.length)
+            throw new Error('Usage: hyv inspect-hidden-text draft.md [policy.json]');
+        json(inspectHiddenText(input(path), policyPath ? parseHiddenTextPolicy(readJson(policyPath)) : undefined));
+        return 0;
+    }
+    if (command === 'apply-hidden-text-policy') {
+        const [path, policyPath, output, ...extra] = rest;
+        if (!path || !policyPath || !output || extra.length)
+            throw new Error('Usage: hyv apply-hidden-text-policy draft.md policy.json output.md');
+        if (path === '-' || resolve(path) === resolve(output))
+            throw new Error('Hidden-text output must differ from the input path.');
+        const result = applyHiddenTextPolicy(input(path), parseHiddenTextPolicy(readJson(policyPath)));
+        writeNewFileAtomically(output, result.output);
+        json({ ...result, outputPath: output });
+        return 0;
+    }
     if (command === 'final-check') {
         const [path, ...options] = rest;
         if (!path || options.length)
@@ -294,6 +331,46 @@ export async function runCli(args) {
         process.stdout.write(result.output);
         return 0;
     }
+    if (command === 'fact-lint') {
+        const [draftPath, ...options] = rest;
+        const sources = [];
+        let metadata;
+        let strict = false;
+        let human = false;
+        if (!draftPath)
+            throw new Error('Usage: hyv fact-lint <draft|-> --source=id:path [--source=id:path] [--metadata=metadata.json] [--strict] [--human]');
+        for (const option of options) {
+            if (option === '--strict') {
+                strict = true;
+                continue;
+            }
+            if (option === '--human') {
+                human = true;
+                continue;
+            }
+            if (option.startsWith('--source=')) {
+                const value = option.slice('--source='.length);
+                const separator = value.indexOf(':');
+                const id = value.slice(0, separator).trim();
+                const path = value.slice(separator + 1);
+                if (separator < 1 || !id || !path)
+                    throw new Error('Sources must use --source=id:path.');
+                sources.push({ id, text: input(path) });
+                continue;
+            }
+            if (option.startsWith('--metadata=')) {
+                metadata = JSON.parse(input(option.slice('--metadata='.length)));
+                continue;
+            }
+            throw new Error('Usage: hyv fact-lint <draft|-> --source=id:path [--source=id:path] [--metadata=metadata.json] [--strict] [--human]');
+        }
+        const report = lintFacts({ sources, draft: input(draftPath), metadata });
+        if (human)
+            console.log(formatFactLintReport(report));
+        else
+            json(report);
+        return strict && report.findings.some((item) => item.severity === 'error') ? 2 : 0;
+    }
     if (command === 'batch-analyze') {
         if (rest.length < 2)
             throw new Error('Usage: hyv batch-analyze draft-a.md draft-b.md [draft-c.md]');
@@ -349,15 +426,15 @@ export async function runCli(args) {
         return 0;
     }
     if (command === 'prepare-rebuild') {
-        const { values, capability } = capabilityArguments(rest);
+        const { values, capability, recompositionPolicy } = rebuildArguments(rest);
         const [draft, profilePath, reductionPath, specPath, output, briefPath] = values;
         if (!draft || !profilePath || !reductionPath || !specPath || !output || !capability) {
-            throw new Error('Usage: hyv prepare-rebuild draft.md profile.json reduction.json copy-spec.json task.json [writing-brief.json] (--capability-stdin|--capability-file path)');
+            throw new Error('Usage: hyv prepare-rebuild draft.md profile.json reduction.json copy-spec.json task.json [writing-brief.json] [--recomposition-policy policy.json] (--capability-stdin|--capability-file path)');
         }
         const context = loadApprovalContext();
-        const task = prepareRebuildTask(input(draft), readProfile(profilePath), readJson(reductionPath), parseCopySpec(JSON.parse(input(specPath))), capability, context.trustStore, context.now, briefPath ? parseWritingBrief(JSON.parse(input(briefPath))) : undefined);
+        const task = prepareRebuildTask(input(draft), readProfile(profilePath), readJson(reductionPath), parseCopySpec(JSON.parse(input(specPath))), capability, context.trustStore, context.now, briefPath ? parseWritingBrief(JSON.parse(input(briefPath))) : undefined, recompositionPolicy);
         writeFileSync(output, `${JSON.stringify(task, null, 2)}\n`);
-        json({ version: task.version, fingerprint: task.fingerprint, recommendationFingerprint: task.recommendationFingerprint, authorizationFingerprint: task.authorizationFingerprint });
+        json({ version: task.version, fingerprint: task.fingerprint, recommendationFingerprint: task.recommendationFingerprint, authorizationFingerprint: task.authorizationFingerprint, ...(task.recompositionPolicy ? { recompositionPolicy: task.recompositionPolicy } : {}) });
         return 0;
     }
     if (command === 'apply-rebuild') {
@@ -370,6 +447,15 @@ export async function runCli(args) {
         json(result);
         return result.status === 'accepted' ? 0 : 2;
     }
+    if (command === 'rebuild-writer-request') {
+        const [taskPath, output, ...extra] = rest;
+        if (!taskPath || !output || extra.length)
+            throw new Error('Usage: hyv rebuild-writer-request task.json writer-request.json');
+        const request = writerRequestForRebuild(parseRebuildTask(JSON.parse(input(taskPath))));
+        writeFileSync(output, `${JSON.stringify(request, null, 2)}\n`);
+        json({ version: request.version, taskFingerprint: request.taskFingerprint, copySpecFingerprint: request.copySpecFingerprint, ...(request.recompositionPolicyFingerprint ? { recompositionPolicyFingerprint: request.recompositionPolicyFingerprint } : {}) });
+        return 0;
+    }
     if (command === 'verify') {
         const [original, candidate, profilePath, briefPath] = rest;
         if (!original || !candidate || !profilePath)

package/dist/cli.test.js

@@ -128,6 +128,30 @@ test('inspects stdin and refuses to clean it without a preservable input file',
     assert.equal(refused.status, 1);
     assert.match(refused.stderr, /requires a file path/);
 });
+test('applies the explicit hidden-text policy through CLI without touching review-only Unicode', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-cli-hidden-text-'));
+    try {
+        const draft = join(directory, 'draft.md');
+        const policy = join(directory, 'hidden-text-policy.json');
+        const output = join(directory, 'draft.sanitized.md');
+        const original = 'before\u0007middle\uFEFFafter\u200D';
+        writeFileSync(draft, original);
+        writeFileSync(policy, JSON.stringify({ version: '1', name: 'minimal-text-control-cleanup', approvedRemovals: ['ascii_control', 'mid_document_bom'], acknowledgement: 'Removes only listed non-semantic controls; all other findings remain review-only.' }));
+        const inspected = run(['inspect-hidden-text', draft, policy]);
+        assert.equal(inspected.status, 0, inspected.stderr);
+        assert.deepEqual(JSON.parse(inspected.stdout).proposedChanges.map((change) => change.codepoint), ['U+0007', 'U+FEFF']);
+        const applied = run(['apply-hidden-text-policy', draft, policy, output]);
+        assert.equal(applied.status, 0, applied.stderr);
+        const receipt = JSON.parse(applied.stdout);
+        assert.equal(receipt.idempotent, true);
+        assert.equal(readFileSync(draft, 'utf8'), original);
+        assert.equal(readFileSync(output, 'utf8'), 'beforemiddleafter\u200D');
+        assert.equal(receipt.remaining[0].codepoint, 'U+200D');
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('gates final output from any producer without a voice profile', () => {
     const clean = run(['final-check', '-'], process.env, 'exact output\n');
     assert.equal(clean.status, 0, clean.stderr);
@@ -157,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', 'original', 'passed', 'preservationScore', 'regressions', 'version']);
+        assert.deepEqual(Object.keys(JSON.parse(verification.stdout)).sort(), ['candidate', 'finalOutput', 'original', 'passed', 'preservationScore', 'regressions', 'version']);
         assert.equal(run(['unknown-command']).status, 1);
         assert.equal(run(['mcp', 'unexpected']).status, 1);
     }
@@ -188,6 +212,25 @@ test('fails the CopySpec gate when a locked claim changes', () => {
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test('reports fact consistency as JSON or compact text and only fails strict mode on errors', () => {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-fact-lint-'));
+    try {
+        const source = join(directory, 'source.md');
+        const draft = join(directory, 'draft.md');
+        writeFileSync(source, 'Atlas launched on 14 August 2026 and exports CSV reports.');
+        writeFileSync(draft, 'Atlas launched on 15 August 2026 and exports CSV reports.');
+        const report = run(['fact-lint', draft, `--source=release:${source}`]);
+        assert.equal(report.status, 0, report.stderr);
+        assert.equal(JSON.parse(report.stdout).findings[0].kind, 'date_drift');
+        assert.equal(run(['fact-lint', draft, `--source=release:${source}`, '--strict']).status, 2);
+        const compact = run(['fact-lint', draft, `--source=release:${source}`, '--human']);
+        assert.equal(compact.status, 0, compact.stderr);
+        assert.match(compact.stdout, /date_drift/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
 test('prepares and applies the same constrained rewrite task without a provider call', () => {
     const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-cli-'));
     try {
@@ -437,14 +480,17 @@ test('prepares and applies an authorized rebuild through CLI', () => {
         const profile = join(directory, 'profile.json');
         const draft = join(directory, 'draft.md');
         const spec = join(directory, 'copy-spec.json');
+        const policy = join(directory, 'recomposition-policy.json');
         const reduction = join(directory, 'reduction.json');
         const task = join(directory, 'rebuild-task.json');
         const response = join(directory, 'response.json');
         const capability = join(directory, 'capability.json');
+        const writerRequest = join(directory, 'writer-request.json');
         writeFileSync(first, 'I write plainly. I name the work.');
         writeFileSync(second, 'I keep the mechanism clear. I avoid filler.');
         writeFileSync(draft, 'I leverage the answer. The launch is on 14 August.');
         writeFileSync(spec, JSON.stringify({ version: '1', audience: 'operators', intent: 'explain', channel: 'email', claims: [{ id: 'launch-date', text: 'The launch is on 14 August.', evidence: 'Release calendar, 7 August.' }] }));
+        writeFileSync(policy, JSON.stringify({ version: '1', mode: 'meaning-first', lexicalResidual: { ngramSize: 5, maxSharedNgramFraction: 0, maxLongestSharedRunTokens: 4 }, acknowledgement: 'Measures shared wording only; does not detect or prove removal of a watermark.' }));
         assert.equal(run(['profile', profile, first, second, '--avoid=leverage']).status, 0);
         const envelopes = ['triage', 'argument', 'form'].map((kind) => {
             const taskPath = join(directory, `${kind}.json`);
@@ -476,8 +522,13 @@ test('prepares and applies an authorized rebuild through CLI', () => {
         const payload = Buffer.from(canonicalJson(claims));
         writeFileSync(capability, canonicalJson({ payload: payload.toString('base64url'), signature: sign(null, payload, privateKey).toString('base64url') }));
         chmodSync(capability, 0o600);
-        const prepared = run(['prepare-rebuild', draft, profile, reduction, spec, task, '--capability-file', capability], env);
+        const prepared = run(['prepare-rebuild', draft, profile, reduction, spec, task, '--recomposition-policy', policy, '--capability-file', capability], env);
         assert.equal(prepared.status, 0, prepared.stderr);
+        assert.match(JSON.parse(prepared.stdout).recompositionPolicy.acknowledgement, /not detect/);
+        assert.doesNotMatch(JSON.parse(readFileSync(task, 'utf8')).prompt, /I leverage the answer/);
+        const writer = run(['rebuild-writer-request', task, writerRequest]);
+        assert.equal(writer.status, 0, writer.stderr);
+        assert.doesNotMatch(readFileSync(writerRequest, 'utf8'), /I leverage the answer|capability|profile/i);
         writeFileSync(response, JSON.stringify({
             version: '1', mode: 'REBUILD', taskFingerprint: JSON.parse(readFileSync(task, 'utf8')).fingerprint,
             candidate: 'Ship planning now treats one calendar fact as fixed. The launch is on 14 August. Every other sentence in this note is new operational language for the release desk.',
@@ -485,6 +536,7 @@ test('prepares and applies an authorized rebuild through CLI', () => {
         const applied = run(['apply-rebuild', task, response, profile, '--capability-file', capability], env);
         assert.equal(applied.status, 2, applied.stderr);
         assert.equal(JSON.parse(applied.stdout).status, 'needs_semantic_review');
+        assert.equal(JSON.parse(applied.stdout).receipt.lexicalResidual.passed, true);
         assert.equal(run(['apply-rebuild', task, response, profile], env).status, 1);
     }
     finally {

package/dist/editorial-packs.js

@@ -7,6 +7,36 @@ function isText(value, limit) {
 function isTerms(value) {
     return Array.isArray(value) && value.length <= 100 && value.every((term) => isText(term, 200));
 }
+function isFactSources(value) {
+    return Array.isArray(value) && value.length > 0 && value.length <= 20 && value.every((source) => !!source && typeof source === 'object' && isText(source.id, 100) && isText(source.text, 40_000)) && value.reduce((total, source) => total + source.id.length + source.text.length, 0) <= 40_000;
+}
+function isFactMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const metadata = value;
+    return (metadata.allowedAssumptions === undefined || isTerms(metadata.allowedAssumptions)) && (metadata.approvedHypotheses === undefined || isTerms(metadata.approvedHypotheses));
+}
+function isRequiredFacts(value) {
+    return Array.isArray(value) && value.length > 0 && value.length <= 50 && value.every((fact) => !!fact && typeof fact === 'object' && isText(fact.id, 100) && /^[A-Za-z0-9._-]+$/.test(fact.id) && isText(fact.text, 2_000) && (fact.atoms === undefined || isTerms(fact.atoms)));
+}
+function isDenied(text) {
+    return /\b(?:not|false|untrue|incorrect)\b/i.test(text);
+}
+function isFollowUpDenial(text) {
+    return /^(?:that|this) (?:statement|claim|fact|assertion|point) (?:is|was) (?:not|false|untrue|incorrect)\b/i.test(text.trim());
+}
+function hasAffirmedSourceText(source, text) {
+    const expected = text.toLowerCase();
+    const sourceSentences = sentences(source);
+    return sourceSentences.some((sentence, index) => sentence.text.toLowerCase().includes(expected) && !isDenied(sentence.text) && !isFollowUpDenial(sourceSentences[index + 1]?.text ?? ''));
+}
+function requiredFactsAreSourced(brief) {
+    if (!brief.requiredFacts?.length)
+        return true;
+    if (!brief.factSources?.length)
+        return false;
+    return brief.requiredFacts.every((fact) => brief.factSources?.some((source) => hasAffirmedSourceText(source.text, fact.text) || (fact.atoms?.length && fact.atoms.every((atom) => hasAffirmedSourceText(source.text, atom)))));
+}
 function isArgumentMap(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
@@ -23,7 +53,11 @@ export function parseWritingBrief(value) {
         || (brief.prohibitedTerms !== undefined && !isTerms(brief.prohibitedTerms))
         || (brief.title !== undefined && !isText(brief.title, 500))
         || (brief.evidenceStatus !== undefined && !evidenceStatuses.includes(brief.evidenceStatus))
-        || (brief.argumentMap !== undefined && !isArgumentMap(brief.argumentMap))) {
+        || (brief.argumentMap !== undefined && !isArgumentMap(brief.argumentMap))
+        || (brief.factSources !== undefined && !isFactSources(brief.factSources))
+        || (brief.factMetadata !== undefined && !isFactMetadata(brief.factMetadata))
+        || (brief.requiredFacts !== undefined && !isRequiredFacts(brief.requiredFacts))
+        || !requiredFactsAreSourced(brief)) {
         throw new Error('WritingBrief needs version "1", audience, intent, a known format, and optional bounded context fields.');
     }
     return brief;