@holdyourvoice/hyv 3.4.4 → 3.5.0

package/Readme.md

@@ -81,6 +81,8 @@ npm install --global @holdyourvoice/hyv
 
 For a one-off command, replace `hyv` with `npx @holdyourvoice/hyv`.
 
+For Humanizer's complementary editor skill, install it separately with `npx skills add blader/humanizer`. It is not a HYV dependency: HYV's local AI Editor keeps its own versioned rules and final-output gate.
+
 ## basic workflow
 
 1. Build a local profile from your samples.
@@ -124,7 +126,12 @@ producer | hyv final-check -
 | Command | Purpose |
 | --- | --- |
 | `hyv profile <profile.json> <sample...>` | Build a local profile from two or more samples. |
+| `hyv profile v3 <profile.json> --id=writer.channel --channel=email <sample...>` | Build a signed channel-specific Profile v3; optional tone is advisory metadata. |
+| `hyv profile compose --ratio 70:30 <profile...>` | Locally compose two or more Profile v3 metrics without creating writing. |
+| `hyv score <draft> <profile-v3.json> <heldout...>` | Measure the draft against a separate held-out local writing range; may abstain. |
+| `hyv ingest <source> <export> --owner=owner --output=/absolute/dir` | Create redacted, owner-authorized Gmail or Telegram samples and a text-free receipt. |
 | `hyv analyze <draft> <profile.json>` | Run VoiceDNA, AI Editor, and hygiene checks. |
+| `hyv strict-check <draft> <profile-v3.json> <sample...>` | Run the opt-in strict local quality gate. It requires a calibrated V3 profile built from five or more samples, five non-duplicate samples with a consistent visible format and 1,500 words total, and returns `strict-ready`, `needs-human-review`, or `blocked`. |
 | `hyv hygiene <draft> [--fix]` | Inspect hidden Unicode or write a conservative cleaned copy. |
 | `hyv inspect-hidden-text <draft> [policy.json]` | Inspect hidden text with an optional policy. |
 | `hyv apply-hidden-text-policy <draft> <policy.json> <output>` | Apply approved hidden-text removals. |

package/dist/agents/load.test.js

@@ -136,7 +136,7 @@ test('rejects unknown contract fields and invalid OpenAI interface metadata', ()
 });
 test('published packages declare command execution and required writes', () => {
     const packages = loadAll();
-    const writers = new Set(['hyv-profile', 'hyv-hygiene', 'hyv-apply-hidden-text-policy', 'hyv-prepare-rewrite', 'hyv-prepare-judgment', 'hyv-prepare-rebuild', 'hyv-rebuild-writer-request', 'hyv-lifecycle', 'hyv-learning']);
+    const writers = new Set(['hyv-profile', 'hyv-ingest', 'hyv-hygiene', 'hyv-apply-hidden-text-policy', 'hyv-prepare-rewrite', 'hyv-prepare-judgment', 'hyv-prepare-rebuild', 'hyv-rebuild-writer-request', 'hyv-lifecycle', 'hyv-learning']);
     for (const [id, pkg] of packages) {
         assert.ok(pkg.descriptor.permissions.includes('execute_commands'), `${id} must require command execution`);
         assert.equal(pkg.descriptor.permissions.includes('write_repository'), writers.has(id), `${id} write permission mismatch`);

package/dist/ai-editor-rules.js

@@ -148,4 +148,38 @@ export const rules = [
     { id: "hedge.performative-sincerity-adverb", severity: "yellow", expression: /\b(?:honestly|genuinely|truly|frankly|actually)\b/i, reason: "The adverb performs sincerity instead of adding evidence.", suggestion: "cut the adverb or replace it with the evidence" },
     { id: "ai.question-hook", severity: "yellow", expression: /^(?:have you|do you|what if|why do|how do)\b/i, reason: "A question opener delays the concrete observation.", suggestion: "Open from an observation." },
     { id: "ai.abstract-cluster", severity: "yellow", expression: /\b(?:alignment|authenticity|clarity|strategy|value)\b.*\b(?:alignment|authenticity|clarity|strategy|value)\b/i, reason: "Abstract nouns pile up without a mechanism.", suggestion: "Use concrete nouns and actions." },
+    { id: "ai.inflated-significance", severity: "yellow", expression: /\b(?:marks?|marking)\s+(?:a\s+)?(?:pivotal|defining|landmark)\s+(?:moment|chapter|milestone)\b/i, reason: "The sentence announces historical importance without showing it.", suggestion: "Name the specific change, date, or consequence." },
+    { id: "ai.notability-name-drop", severity: "yellow", expression: /\b(?:renowned|legendary|iconic)\s+(?:[A-Z][a-z]+\s+){1,3}(?:writer|scientist|scholar|artist|thinker)\b/, reason: "Prestige framing can stand in for the relevant work.", suggestion: "Name the work or contribution that matters here." },
+    { id: "ai.shallow-participle-analysis", severity: "yellow", expression: /\b(?:highlighting|underscoring|reflecting)\s+(?:its|their|the)\s+(?:importance|significance|impact)\b/i, reason: "The participle announces analysis without supplying it.", suggestion: "State the specific implication or evidence." },
+    { id: "ai.promotional-scene-setting", severity: "yellow", expression: /\b(?:in\s+)?(?:today['’]?s|the)\s+(?:rapidly\s+)?(?:changing|dynamic)\s+(?:business|digital|technology|market)\s+landscape\b/i, reason: "Generic scene-setting delays the actual subject.", suggestion: "Open with the concrete change or condition." },
+    { id: "ai.vague-attribution", severity: "yellow", expression: /\b(?:experts|critics|observers|many)\s+(?:say|note|believe|argue)\b/i, reason: "The source of the claim is too vague to evaluate.", suggestion: "Name the source, evidence, or make the claim directly." },
+    { id: "ai.challenges-outlook", severity: "yellow", expression: /\b(?:despite|while)\s+(?:these|the)\s+(?:challenges|obstacles).{0,80}\b(?:future|outlook)\b/i, reason: "A stock challenges-and-outlook turn can replace a concrete conclusion.", suggestion: "Name the remaining constraint and the next supported step." },
+    { id: "ai.copula-avoidance", severity: "yellow", expression: /\b(?:serving|representing|offering)\s+as\s+(?:a|an)\s+(?:testament|reminder|symbol)\b/i, reason: "The construction avoids a direct claim.", suggestion: "Use a direct subject, verb, and supported claim." },
+    { id: "ai.false-range", severity: "yellow", expression: /\bfrom\s+(?:the\s+)?(?:big\s+bang|ancient\s+times)\s+to\s+(?:dark\s+matter|the\s+modern\s+era)\b/i, reason: "A sweeping range can simulate scope without connecting the endpoints.", suggestion: "Name the specific connected topics instead." },
+    { id: "ai.actorless-claim", severity: "yellow", expression: /\bit\s+is\s+(?:important|clear|worth\s+noting)\s+that\b/i, reason: "The claim has no accountable actor or evidence.", suggestion: "Name who knows this and why, or state the fact directly." },
+    { id: "ai.chatbot-offer", severity: "yellow", expression: /\b(?:let me know if you(?:'d| would) like|i(?:'m| am) happy to help with anything else)\b/i, reason: "A generic assistant offer adds no useful next step.", suggestion: "Offer one concrete next action only when it is relevant." },
+    { id: "ai.knowledge-limit-disclaimer", severity: "yellow", expression: /\b(?:as an ai|my knowledge (?:cutoff|is limited)|i do not have access to)\b/i, reason: "A model disclaimer does not advance the reader's task.", suggestion: "State the verified limit or omit the boilerplate." },
+    { id: "ai.agreement-preamble", severity: "yellow", expression: /^\s*(?:absolutely|certainly|indeed)[,!]?\s+/i, reason: "An agreement preamble delays the answer.", suggestion: "Start with the answer or evidence.", scope: "line" },
+    { id: "ai.qualifier-stack", severity: "yellow", expression: /\b(?:very|really|quite|highly)\s+(?:important|significant|valuable|effective)\b/i, reason: "Stacked qualifiers ask for emphasis instead of supplying evidence.", suggestion: "Replace the qualifier with the measurable consequence." },
+    { id: "ai.generic-positive-ending", severity: "yellow", expression: /\b(?:the future is bright|the possibilities are endless|only time will tell)\b/i, reason: "A generic ending avoids a specific conclusion.", suggestion: "End on the concrete decision, constraint, or next step." },
+    { id: "ai.at-its-core", severity: "yellow", expression: /\bat\s+(?:its|the)\s+core\b/i, reason: "The phrase announces depth instead of making the underlying claim.", suggestion: "State the underlying claim directly." },
+    { id: "ai.section-announcement", severity: "yellow", expression: /\b(?:let'?s|let us)\s+(?:now\s+)?(?:explore|look at|turn to)\b/i, reason: "The sentence announces the next point instead of making it.", suggestion: "Start with the point itself." },
+    { id: "ai.historical-implementation-aside", severity: "yellow", expression: /\b(?:once|formerly)\s+known\s+as\b.{0,80}\b(?:now|today)\b/i, reason: "A historical aside can add trivia without advancing the argument.", suggestion: "Keep it only when the name change explains the current claim." },
+    { id: "ai.unraised-objection", severity: "yellow", expression: /\b(?:some\s+might\s+argue|one\s+could\s+argue)\b/i, reason: "The sentence raises an unnamed objection that the reader did not make.", suggestion: "Address a real, specific objection with evidence or remove it." },
+    { id: "ai.fake-alternative", severity: "yellow", expression: /\b(?:whether\s+you\s+choose|regardless\s+of\s+whether)\b/i, reason: "The sentence presents a false choice instead of the actual decision.", suggestion: "Name the real options and the trade-off." },
+    { id: "format.bold-bullet-label", severity: "yellow", expression: /^\s*(?:[-*+]|\d+[.)])\s+\*{1,2}[^*\n]{1,80}:\*{1,2}\s*/u, reason: "A bold label can turn a list into template-like mini-headings.", suggestion: "Use a plain list item unless the label carries real navigation value.", scope: "line" },
+    { id: "format.title-case-heading", severity: "yellow", expression: /^#{1,6}\s+(?:[A-Z][a-z]+\s+){2,}[A-Z][a-z]+\s*$/u, reason: "A title-case heading can create generic template texture.", suggestion: "Use sentence case or a more specific heading.", scope: "line" },
+    { id: "format.emoji-heading", severity: "yellow", expression: /^#{1,6}\s+\p{Extended_Pictographic}/u, reason: "An emoji heading can add template-like decoration without meaning.", suggestion: "Use a precise text heading.", scope: "line" },
+    { id: "format.curly-quotes", severity: "yellow", expression: /[“”]/u, reason: "Decorative curly quotation marks can be a house style rather than evidence of a writing problem.", suggestion: "Keep the house style only when the selected profile demonstrates it; otherwise use the document’s existing quote style." },
+    { id: "format.hyphenated-modifier-stack", severity: "yellow", expression: /\b(?:\p{L}+-){2,}\p{L}+\b/u, reason: "A stack of hyphenated modifiers can make prose sound manufactured.", suggestion: "Use a direct noun phrase or split the claim.", },
+    { id: "ai.forced-triplet", severity: "yellow", expression: /\b(?:[\p{L}-]+\s*,\s*){2}(?:and\s+)?[\p{L}-]+\b/u, reason: "A neat three-item construction can read like generated cadence when it carries no real taxonomy.", suggestion: "Keep the list only when the three items are necessary and distinct." },
+    { id: "ai.repeated-sentence-opening", severity: "yellow", expression: /\b\p{L}+/u, reason: "Three consecutive sentences opening the same way can create mechanical cadence.", suggestion: "Vary the openings or combine the sentences when the repetition adds no emphasis.", scope: "document" },
+    { id: "format.bold-density", severity: "yellow", expression: /\*\*[^*\n]+\*\*/u, reason: "Repeated bold fragments can make prose read like a template instead of a document.", suggestion: "Keep bold only for real navigation or remove decorative emphasis.", scope: "document" },
+    { id: "format.repeated-heading-body", severity: "yellow", expression: /^#{1,6}\s+(.+)$/mu, reason: "Repeating a heading verbatim in its body can add generated padding.", suggestion: "Start the body with the evidence or explanation instead of restating the heading.", scope: "document" },
+    { id: "ai.clipped-fragment-run", severity: "yellow", expression: /\b\p{L}+/u, reason: "A run of clipped fragments can manufacture punchy rhythm without adding information.", suggestion: "Join the fragments into a complete sentence or keep only the one that carries the point.", scope: "document" },
+    { id: "ai.formulaic-aphorism", severity: "yellow", expression: /\b(?:less is more|quality over quantity|the devil is in the details|actions speak louder than words)\b/i, reason: "A stock saying can stand in for the actual observation.", suggestion: "State the concrete lesson from this situation." },
+    { id: "ai.fake-candid-opener", severity: "yellow", expression: /^\s*i(?:'m| am) (?:going to )?(?:be )?(?:honest|real)\b/i, reason: "A performed candid opening can add authority without evidence.", suggestion: "Open with the concrete observation or claim." },
+    { id: "ai.metric-theater", severity: "yellow", expression: /\b(?:\d{1,2}:\d{2}\s*(?:a\.?(?:m)?\.?|p\.?(?:m)?\.?)|\d+(?:\.\d+)?x\s*(?:roi|return|growth|lift))\b/i, reason: "Hyper-specific numbers can simulate evidence when no source accompanies them.", suggestion: "Cite the measurement and source, or use only the detail the claim needs." },
+    { id: "ai.jargon-stack", severity: "yellow", expression: /\b(?:synergy|leverage|alignment|ecosystem|framework|paradigm|stakeholder|scalable|holistic)\b/i, reason: "Several business abstractions in one sentence can hide the mechanism.", suggestion: "Replace the stack with the people, action, system, and result.", scope: "document" },
+    { id: "ai.sentence-length-cluster", severity: "yellow", expression: /\b\p{L}+/u, reason: "A long run of similarly sized medium sentences can sound mechanically paced.", suggestion: "Vary length where it improves the natural rhythm of the argument.", scope: "document" },
 ];

package/dist/ai-editor.js

@@ -1,9 +1,10 @@
 import { rules } from './ai-editor-rules.js';
 import { sentences } from './text.js';
 export { rules } from './ai-editor-rules.js';
-export const RULESET_VERSION = '3.2.0-reconciled.1';
-const sentenceRules = rules.filter((rule) => rule.scope !== 'line');
+export const RULESET_VERSION = '3.5.0-local.3';
+const sentenceRules = rules.filter((rule) => rule.scope === undefined || rule.scope === 'sentence');
 const lineRules = rules.filter((rule) => rule.scope === 'line');
+const documentRules = rules.filter((rule) => rule.scope === 'document');
 const ruleOrder = new Map(rules.map((rule, index) => [rule.id, index]));
 const ruleIds = new Set(rules.map((rule) => rule.id));
 const policyStates = new Set(['blocking', 'advisory', 'judgment-required', 'disabled']);
@@ -33,9 +34,65 @@ function policiesFor(profile) {
                 throw new Error(`Profile rulePolicy contains invalid state for rule ID: ${id}`);
         }
     }
-    return new Map(rules.map((rule) => [rule.id, profile?.version === '3' && profile.rulePolicy[rule.id]
-            ? profile.rulePolicy[rule.id]
-            : defaultPolicy(rule.id, rule.severity)]));
+    return new Map(rules.map((rule) => {
+        const explicit = profile?.version === '3' ? profile.rulePolicy[rule.id] : undefined;
+        if (explicit)
+            return [rule.id, explicit];
+        if (profile?.version === '3' && profile.ruleAllowances?.[rule.id])
+            return [rule.id, 'disabled'];
+        return [rule.id, defaultPolicy(rule.id, rule.severity)];
+    }));
+}
+function maskRange(characters, start, end) {
+    for (let index = start; index < end; index += 1)
+        if (characters[index] !== '\n')
+            characters[index] = ' ';
+}
+/** Masks Markdown regions that are not author prose while preserving offsets. */
+export function maskNonProse(text) {
+    // String offsets elsewhere in HYV are UTF-16 code-unit offsets, so this
+    // buffer must use the same indexing even when prose contains emoji.
+    const characters = text.split('');
+    const lines = text.split('\n');
+    let offset = 0;
+    let fence;
+    let frontmatter = lines[0]?.trim() === '---';
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex];
+        const fenceMarker = line.match(/^\s*(\x60{3,}|~{3,})/u)?.[1];
+        if (frontmatter) {
+            maskRange(characters, offset, offset + line.length);
+            if (lineIndex > 0 && /^(?:---|\.\.\.)\s*$/u.test(line))
+                frontmatter = false;
+            offset += line.length + 1;
+            continue;
+        }
+        if (fence) {
+            maskRange(characters, offset, offset + line.length);
+            if (fenceMarker && fenceMarker[0] === fence[0] && fenceMarker.length >= fence.length)
+                fence = undefined;
+            offset += line.length + 1;
+            continue;
+        }
+        if (fenceMarker) {
+            maskRange(characters, offset, offset + line.length);
+            fence = fenceMarker;
+            offset += line.length + 1;
+            continue;
+        }
+        for (const match of line.matchAll(/\x60[^\x60\n]*\x60|\]\((?:\\.|[^)\n])*\)/gu)) {
+            const start = offset + match.index;
+            const value = match[0];
+            if (value.startsWith(']('))
+                maskRange(characters, start + 1, start + value.length);
+            else
+                maskRange(characters, start, start + value.length);
+        }
+        for (const match of line.matchAll(/\bhttps?:\/\/[^\s<>)]+/gu))
+            maskRange(characters, offset + match.index, offset + match.index + match[0].length);
+        offset += line.length + 1;
+    }
+    return characters.join('');
 }
 export function serializedRules() {
     return rules.map((rule) => ({
@@ -47,12 +104,63 @@ export function serializedRules() {
         scope: rule.scope ?? 'sentence',
     }));
 }
+function documentFinding(rule, sentence) {
+    return { engine: 'ai_editor', id: rule.id, severity: rule.severity, sentence: sentence.index, excerpt: sentence.text, reason: rule.reason, suggestion: rule.suggestion };
+}
+function documentMatches(rule, prose, mapped) {
+    const at = (index) => mapped[index] ? [documentFinding(rule, mapped[index])] : [];
+    if (rule.id === 'ai.repeated-sentence-opening') {
+        for (let index = 0; index + 2 < mapped.length; index += 1) {
+            const opening = mapped[index].text.match(/^\s*(\p{L}+)/u)?.[1]?.toLocaleLowerCase();
+            if (opening && [1, 2].every((offset) => mapped[index + offset].text.match(/^\s*(\p{L}+)/u)?.[1]?.toLocaleLowerCase() === opening))
+                return at(index);
+        }
+        return [];
+    }
+    if (rule.id === 'format.bold-density') {
+        const line = prose.split('\n').findIndex((value) => (value.match(/\*\*[^*\n]+\*\*/gu) ?? []).length >= 2);
+        if (line >= 0)
+            return at(mapped.findIndex((sentence) => sentence.start >= prose.split('\n').slice(0, line).join('\n').length));
+        const total = (prose.match(/\*\*[^*\n]+\*\*/gu) ?? []).length;
+        return total >= 4 ? at(0) : [];
+    }
+    if (rule.id === 'format.repeated-heading-body') {
+        for (const heading of prose.matchAll(/^#{1,6}\s+(.+)$/gmu)) {
+            const title = heading[1].trim().replace(/[.*_`]/g, '');
+            if (title.length >= 4 && prose.indexOf(title, heading.index + heading[0].length) >= 0)
+                return at(mapped.findIndex((sentence) => sentence.start >= heading.index));
+        }
+        return [];
+    }
+    if (rule.id === 'ai.clipped-fragment-run') {
+        for (let index = 0; index + 2 < mapped.length; index += 1)
+            if ([0, 1, 2].every((offset) => (mapped[index + offset].text.match(/\p{L}+/gu) ?? []).length <= 4))
+                return at(index);
+        return [];
+    }
+    if (rule.id === 'ai.jargon-stack') {
+        const jargon = /\b(?:synergy|leverage|alignment|ecosystem|framework|paradigm|stakeholder|scalable|holistic)\b/giu;
+        const index = mapped.findIndex((sentence) => (sentence.text.match(jargon) ?? []).length >= 3);
+        return index >= 0 ? at(index) : [];
+    }
+    if (rule.id === 'ai.sentence-length-cluster') {
+        for (let index = 0; index + 3 < mapped.length; index += 1)
+            if ([0, 1, 2, 3].every((offset) => {
+                const count = (mapped[index + offset].text.match(/\p{L}+/gu) ?? []).length;
+                return count >= 15 && count <= 20;
+            }))
+                return at(index);
+        return [];
+    }
+    return [];
+}
 export function analyzeAiEditor(text, profile) {
     const matched = [];
-    const mapped = sentences(text);
+    const prose = maskNonProse(text);
+    const mapped = sentences(prose).map((sentence) => ({ ...sentence, text: text.slice(sentence.start, sentence.end) }));
     for (const sentence of mapped) {
         for (const rule of sentenceRules) {
-            if (rule.expression.test(sentence.text)) {
+            if (rule.expression.test(prose.slice(sentence.start, sentence.end))) {
                 matched.push({
                     engine: 'ai_editor',
                     id: rule.id,
@@ -66,13 +174,14 @@ export function analyzeAiEditor(text, profile) {
         }
     }
     let lineStart = 0;
-    for (const line of text.split('\n')) {
+    for (const line of prose.split('\n')) {
         for (const rule of lineRules) {
             const result = rule.expression.exec(line);
             if (!result)
                 continue;
             const matchStart = lineStart + result.index;
-            const sentence = mapped.find((candidate) => candidate.start <= matchStart && matchStart < candidate.end);
+            const sentence = mapped.find((candidate) => candidate.start <= matchStart && matchStart < candidate.end)
+                ?? mapped.find((candidate) => candidate.start >= lineStart && candidate.start < lineStart + line.length);
             if (!sentence)
                 continue;
             matched.push({
@@ -87,6 +196,8 @@ export function analyzeAiEditor(text, profile) {
         }
         lineStart += line.length + 1;
     }
+    for (const rule of documentRules)
+        matched.push(...documentMatches(rule, prose, mapped));
     matched.sort((left, right) => left.sentence - right.sentence || (ruleOrder.get(left.id) ?? 0) - (ruleOrder.get(right.id) ?? 0));
     const policies = policiesFor(profile);
     const findings = matched.flatMap((finding) => {

package/dist/ai-editor.test.js

@@ -1,15 +1,17 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { analyzeAiEditor, RULESET_VERSION, rules, serializedRules } from './ai-editor.js';
+import { analyzeAiEditor, maskNonProse, RULESET_VERSION, rules, serializedRules } from './ai-editor.js';
 import { createHash } from 'node:crypto';
+import { AI_SHADOW_FAIL_SET_V1 } from './ai-shadow-fixtures.js';
+import { generateAiShadowFailSetV1 } from './ai-shadow-generator.js';
 test('publishes executable rules with stable IDs and repair directions', () => {
-    assert.equal(RULESET_VERSION, '3.2.0-reconciled.1');
-    assert.equal(rules.length, 148);
-    assert.equal(createHash('sha256').update(JSON.stringify(rules.map((rule) => rule.id))).digest('hex'), '8d3cdde1922686076cb3baa79c55db95f37c9088d246f47c24405417fe58f979');
-    assert.equal(createHash('sha256').update(JSON.stringify(serializedRules())).digest('hex'), 'a758d7cd8e53e42d1a3ada81aff3e61f2994555d286f8915a9fc52767f145094');
+    assert.equal(RULESET_VERSION, '3.5.0-local.3');
+    assert.equal(rules.length, 182);
+    assert.equal(createHash('sha256').update(JSON.stringify(rules.map((rule) => rule.id))).digest('hex'), '172563cd3f55b363c895bb97c37f636dd718253799c369f329bb943dad416f16');
+    assert.equal(createHash('sha256').update(JSON.stringify(serializedRules())).digest('hex'), '542534f1223d65e7ae7d4c3da8ba22bd31b4ddae2dfe399f7672ca9e6a9cee6b');
     assert.equal(new Set(rules.map((rule) => rule.id)).size, rules.length);
     for (const rule of rules) {
-        assert.match(rule.id, /^(ai|formula|hedge|struct|punct|bait|cringe|insider|ogilvy)\./);
+        assert.match(rule.id, /^(ai|formula|hedge|struct|punct|bait|cringe|insider|ogilvy|format)\./);
         assert.ok(rule.reason.length > 0);
         assert.ok(rule.suggestion.length > 0);
         assert.equal(rule.expression.global, false, rule.id);
@@ -43,6 +45,39 @@ test('applies all four v3 policy states after matching and preserves catalog ord
 test('fails closed when a v3 policy names a rule outside the catalog', () => {
     assert.throws(() => analyzeAiEditor('Plain text.', profileWithPolicies({ 'ai.missing': 'blocking' })), /unknown rule ID/);
 });
+test('allows a sample-derived punctuation exception only when no explicit policy exists', () => {
+    const profile = profileWithPolicies({});
+    profile.ruleAllowances = { 'punct.em-dash': { sampleCount: 2, evidenceDigest: 'a'.repeat(64) } };
+    assert.equal(analyzeAiEditor('The scheduler failed — retry later.', profile).findings.some((finding) => finding.id === 'punct.em-dash'), false);
+    profile.rulePolicy['punct.em-dash'] = 'blocking';
+    assert.equal(analyzeAiEditor('The scheduler failed — retry later.', profile).findings.find((finding) => finding.id === 'punct.em-dash')?.appliedPolicy, 'blocking');
+});
+test('keeps non-prose regions out of AI Editor while scanning adjacent prose', () => {
+    const tick = String.fromCharCode(96);
+    const fence = tick.repeat(3);
+    const draft = [
+        '---',
+        'title: We leverage the launch',
+        '---',
+        'We leverage the launch.',
+        fence + 'ts',
+        'const message = "We leverage logs";',
+        fence,
+        'Use ' + tick + 'we leverage logs' + tick + ' only as an example.',
+        '[A link](https://example.com/we-leverage) stays useful.',
+    ].join('\n');
+    const report = analyzeAiEditor(draft);
+    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => finding.sentence), [1]);
+    assert.equal(maskNonProse(draft).includes('https://example.com/we-leverage'), false);
+});
+test('preserves protected-region offsets after a supplementary Unicode character', () => {
+    const tick = String.fromCharCode(96);
+    const draft = '🚀 We leverage the launch. Use ' + tick + 'we leverage logs' + tick + ' as an example.';
+    const report = analyzeAiEditor(draft);
+    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => [finding.sentence, finding.excerpt]), [
+        [1, '🚀 We leverage the launch.'],
+    ]);
+});
 test('uses reconciled defaults for v2 profiles and suppresses inherited duplicate emissions', () => {
     const report = analyzeAiEditor("It's worth noting: in other words, I think the same plan. Better results.");
     assert.equal(report.findings.some((finding) => finding.id === 'hedge.worth-noting'), false);
@@ -92,6 +127,62 @@ test('detects representative rules from every inherited rule family', () => {
         assert.ok(report.findings.some((finding) => finding.id === id && finding.sentence === 1), id);
     }
 });
+test('covers the narrow 3.5 pattern additions with an editorial example for each rule', () => {
+    const examples = [
+        ['ai.inflated-significance', 'This marks a pivotal moment for the project.'],
+        ['ai.notability-name-drop', 'The renowned Ada Lovelace writer changed the field.'],
+        ['ai.shallow-participle-analysis', 'The result matters, highlighting its importance.'],
+        ['ai.promotional-scene-setting', 'In today’s changing technology landscape, the work starts.'],
+        ['ai.vague-attribution', 'Experts say the change will help.'],
+        ['ai.challenges-outlook', 'Despite these challenges, the future remains open.'],
+        ['ai.copula-avoidance', 'The launch is serving as a testament to patience.'],
+        ['ai.false-range', 'The course runs from the Big Bang to dark matter.'],
+        ['ai.actorless-claim', 'It is important that we check the source.'],
+        ['ai.chatbot-offer', 'Let me know if you would like another draft.'],
+        ['ai.knowledge-limit-disclaimer', 'As an AI, I cannot verify that.'],
+        ['ai.agreement-preamble', 'Absolutely, the invoice is overdue.'],
+        ['ai.qualifier-stack', 'This is very important for the launch.'],
+        ['ai.generic-positive-ending', 'The possibilities are endless.'],
+        ['ai.at-its-core', 'At its core, the work is a queue.'],
+        ['ai.section-announcement', 'Let us now explore the next step.'],
+        ['ai.historical-implementation-aside', 'The tool was once known as Alpha and now has a new name.'],
+        ['ai.unraised-objection', 'Some might argue that the queue is unnecessary.'],
+        ['ai.fake-alternative', 'Whether you choose email or chat, start today.'],
+        ['format.bold-bullet-label', '- **Decision:** Ship Tuesday.'],
+        ['format.title-case-heading', '# Generic Title Case Heading'],
+        ['format.emoji-heading', '# 🚀 Launch plan'],
+        ['format.curly-quotes', 'The operator wrote “ship Tuesday” in the release note.'],
+        ['format.hyphenated-modifier-stack', 'Use a high-trust-low-friction process.'],
+    ];
+    for (const [id, example] of examples)
+        assert.ok(analyzeAiEditor(example).findings.some((finding) => finding.id === id), id);
+});
+test('keeps bounded Humanizer and Ghostwriter document cues advisory', () => {
+    const examples = [
+        ['ai.forced-triplet', 'The template promises speed, scale, and alignment.'],
+        ['ai.repeated-sentence-opening', 'We checked the logs. We checked the queue. We checked the retry.'],
+        ['format.bold-density', '**Plan** stays visible. **Owner** checks it. **Proof** ships. **Next** is Tuesday.'],
+        ['format.repeated-heading-body', '# Release plan\n\nRelease plan explains the verified rollback.'],
+        ['ai.clipped-fragment-run', 'No demos. No decks. No distractions. The owner checked the logs.'],
+        ['ai.formulaic-aphorism', 'Quality over quantity is the whole lesson.'],
+        ['ai.fake-candid-opener', "I'm going to be honest: the queue failed."],
+        ['ai.metric-theater', 'At 3:47 AM, the slide promised a 23.6x ROI.'],
+        ['ai.jargon-stack', 'The scalable ecosystem needs alignment, leverage, and a holistic framework.'],
+        ['ai.sentence-length-cluster', 'The release owner carefully checks each visible rollback instruction before the scheduled production deployment window opens this morning. The release operator carefully records each visible rollback instruction before the scheduled production deployment window opens this morning. The release reviewer carefully reviews each visible rollback instruction before the scheduled production deployment window opens this morning. The release manager carefully confirms each visible rollback instruction before the scheduled production deployment window opens this morning.'],
+    ];
+    for (const [id, example] of examples) {
+        const finding = analyzeAiEditor(example).findings.find((item) => item.id === id);
+        assert.ok(finding, id);
+        assert.equal(finding.appliedPolicy, 'advisory', id);
+    }
+    assert.equal(analyzeAiEditor('Three source IDs appear in the manifest.').findings.some((finding) => finding.id === 'ai.forced-triplet'), false);
+    assert.equal(analyzeAiEditor('Owners checked the queue. Operators checked the log. Reviewers checked the proof.').findings.some((finding) => finding.id === 'ai.repeated-sentence-opening'), false);
+});
+test('keeps the frozen synthetic AI-shadow fail set generated in CI and executable without runtime generation', () => {
+    assert.deepEqual(generateAiShadowFailSetV1(), AI_SHADOW_FAIL_SET_V1);
+    for (const fixture of AI_SHADOW_FAIL_SET_V1)
+        assert.ok(analyzeAiEditor(fixture.text).findings.some((finding) => finding.id === fixture.rule), fixture.id);
+});
 test('keeps counterexamples for representative inherited rules', () => {
     const counterexamples = [
         ['ai.delve', 'we inspect the logs.'],
@@ -158,8 +249,8 @@ test('retains the current question-hook and abstract-cluster detectors', () => {
 });
 test('serializes reconstructable regular expressions and explicit scopes', () => {
     const catalog = serializedRules();
-    assert.equal(catalog.length, 148);
-    assert.ok(catalog.every((rule) => rule.scope === 'sentence' || rule.scope === 'line'));
+    assert.equal(catalog.length, 182);
+    assert.ok(catalog.every((rule) => rule.scope === 'sentence' || rule.scope === 'line' || rule.scope === 'document'));
     const meaningful = catalog.find((rule) => rule.id === 'ai.meaningful');
     assert.ok(meaningful);
     assert.equal(new RegExp(meaningful.expression.source, meaningful.expression.flags).test('Meaningful work.'), true);

package/dist/ai-shadow-fixtures.js

@@ -0,0 +1,7 @@
+/** Frozen, invented AI-tell fixtures. Runtime never generates or fetches them. */
+export const AI_SHADOW_FAIL_SET_V1 = [
+    { id: 'metric-theater', text: 'At 3:47 AM, the slide promised a 23.6x ROI.', rule: 'ai.metric-theater' },
+    { id: 'jargon-stack', text: 'The scalable ecosystem needs alignment, leverage, and a holistic framework.', rule: 'ai.jargon-stack' },
+    { id: 'forced-triplet', text: 'The template promises speed, scale, and alignment.', rule: 'ai.forced-triplet' },
+    { id: 'clipped-run', text: 'No demos. No decks. No distractions. The owner checked the logs.', rule: 'ai.clipped-fragment-run' },
+];

package/dist/ai-shadow-generator.js

@@ -0,0 +1,17 @@
+function injectTell(seed, tell) {
+    switch (tell) {
+        case 'metric-theater': return { id: tell, text: `At 3:47 AM, ${seed} promised a 23.6x ROI.`, rule: 'ai.metric-theater' };
+        case 'jargon-stack': return { id: tell, text: `The scalable ${seed} needs alignment, leverage, and a holistic framework.`, rule: 'ai.jargon-stack' };
+        case 'forced-triplet': return { id: tell, text: `The ${seed} promises speed, scale, and alignment.`, rule: 'ai.forced-triplet' };
+        case 'clipped-run': return { id: tell, text: `No demos. No decks. No distractions. The ${seed} checked the logs.`, rule: 'ai.clipped-fragment-run' };
+    }
+}
+/** Generates the reviewed synthetic fail-set candidate bytes deterministically. */
+export function generateAiShadowFailSetV1() {
+    return [
+        injectTell('the slide', 'metric-theater'),
+        injectTell('ecosystem', 'jargon-stack'),
+        injectTell('template', 'forced-triplet'),
+        injectTell('owner', 'clipped-run'),
+    ];
+}

package/dist/backtest.js

@@ -0,0 +1,16 @@
+import { analyze } from './pipeline.js';
+import { comparePreservation } from './preservation.js';
+import { scoreHeldoutProfile } from './profile-score.js';
+import { sha256 } from './internal.js';
+function textFreeAiEditor(report) {
+    return { ...report, findings: report.findings.map(({ excerpt: _excerpt, ...finding }) => finding) };
+}
+/** Scores a caller-supplied candidate without generating from or returning the held-out target. */
+export function evaluateIsolatedBacktest(context, target, candidate, profile, heldoutSamples) {
+    return {
+        version: '1', contextDigest: sha256(context), targetDigest: sha256(target), candidateDigest: sha256(candidate),
+        preservation: comparePreservation(target, candidate).legacySet,
+        aiEditor: textFreeAiEditor(analyze(candidate, profile).aiEditor),
+        heldout: scoreHeldoutProfile(candidate, profile, heldoutSamples),
+    };
+}

package/dist/backtest.test.js

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { evaluateIsolatedBacktest } from './backtest.js';
+import { buildProfile } from './voice-dna.js';
+test('keeps an isolated backtest generation-free and text-free in its report', () => {
+    const samples = [
+        'I name the constraint first and explain the mechanism with direct words for the person doing the work. The owner checks each source before the release moves into the production queue.',
+        'The owner checks the source before the release moves into the production queue and records the evidence for later review. I keep the next step clear for the person handling the release.',
+        'I keep evidence visible and choose one next step for the person doing the work before the deployment window opens. The operator records the trade-off and names the owner for the rollback.',
+    ];
+    const target = 'The owner checks the source before the release and records the rollback evidence for the operator doing the production work.';
+    const candidate = 'The owner checks the source before the release and uses leverage for the operator doing the production work while the team records each rollback decision in the release log.';
+    const report = evaluateIsolatedBacktest('Reply to the rollout question with the owner and check.', target, candidate, buildProfile(samples), samples);
+    assert.equal(report.version, '1');
+    assert.ok(report.preservation.score < 100);
+    assert.equal(report.heldout.selfSimilarity?.ceiling, 100);
+    assert.equal(JSON.stringify(report).includes(target), false);
+    assert.equal(JSON.stringify(report).includes(candidate), false);
+    assert.equal(JSON.stringify(report).includes('uses leverage for the operator'), false);
+});