@holdyourvoice/hyv 3.1.0 → 3.2.0

package/Readme.md

@@ -8,7 +8,7 @@ Hold Your Voice is an MIT-licensed, local-first writing gate for people who want
 It checks a draft through two separate programs:
 
 - **VoiceDNA** compares the draft with 13 observable elements from your own local writing samples.
-- **AI Editor** flags a small, versioned set of editorial patterns that can make writing generic, formulaic, or inflated.
+- **AI Editor** flags a reviewed, versioned set of editorial patterns that can make writing generic, formulaic, or inflated.
 
 Those programs keep separate findings, scores, and pass states. A strong result from one never cancels a failure in the other. The tool creates a tiered editing brief, then checks the candidate again before you accept it.
 
@@ -77,11 +77,81 @@ The result is JSON with independent reports:
 {
   "voiceDna": { "score": 93, "passed": true, "findings": [] },
   "aiEditor": { "score": 88, "passed": true, "findings": [] },
+  "hygiene": { "suspiciousCount": 0, "fixableCount": 0, "hits": [] },
   "passed": true
 }
 ```
 
-Read both reports. The outer `passed` field means each engine passed. Scores remain independent.
+Read both scored reports and the separate hygiene inspection. The outer `passed` field means each engine passed. Unicode hygiene never changes either score or the release decision.
+
+### Gate every final text output
+
+`final-check` is a profile-free last-mile boundary for text from any model, tool, agent, API, template, CLI, or GUI:
+
+```bash
+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.
+
+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.
+
+### Inspect and clean hidden Unicode
+
+Use the profile-free hygiene command to inspect zero-width characters, bidirectional controls, Unicode tag characters, and unusual spaces:
+
+```bash
+hyv hygiene draft.md
+```
+
+Add `--fix` to create `draft.cleaned.md` while keeping `draft.md` unchanged:
+
+```bash
+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.
+
+### Add contextual editorial guidance
+
+Use an optional local WritingBrief when the same writer needs different guidance for a social post, deck, outreach note, blog, audit, or website. A brief activates only the relevant advisory format checks and can block explicitly prohibited local terms. It never changes your VoiceDNA profile or the default two-engine analysis.
+
+```json
+{
+  "version": "1",
+  "audience": "technical founders",
+  "intent": "start a useful discussion",
+  "format": "social",
+  "readerKnowsAuthor": false,
+  "vocabulary": ["deployment", "incident"],
+  "prohibitedTerms": ["internal contract value"],
+  "evidenceStatus": "attributed",
+  "argumentMap": {
+    "observation": "A worker fails during a live request.",
+    "mechanism": "Its in-memory state is lost.",
+    "consequence": "The request restarts instead of resuming.",
+    "readerValue": "Avoid the cost of a cold restart."
+  }
+}
+```
+
+```bash
+hyv analyze draft.md profile.json writing-brief.json
+hyv rewrite-prompt draft.md profile.json writing-brief.json > rewrite-brief.md
+hyv verify original.md candidate.md profile.json writing-brief.json
+```
+
+Format checks, an `unverified` evidence state, and a missing configured reader-value cue are yellow review cues. `argumentMap` is a soft editorial contract surfaced to the rewrite prompt; it does not become a universal formula. Explicit `prohibitedTerms` are red release blockers. Keep client-specific briefs outside public repositories unless you have the right to publish them.
+
+### Inspect a batch
+
+Use batch analysis to catch exact repeated opening or closing sentences across two or more drafts. It is advisory and keeps all drafts local.
+
+```bash
+hyv batch-analyze posts/one.md posts/two.md posts/three.md
+```
 
 ### Create an editing brief
 
@@ -99,6 +169,34 @@ npx @holdyourvoice/hyv verify draft.md candidate.md profile.json
 
 `verify` returns the original and candidate reports, identifies newly introduced findings, calculates a coarse preservation score, and exits with status `2` when the candidate fails the dual gate. A passing verification automatically records only the resolved finding IDs for that profile in local learning state. It exits with `1` for a usage or runtime error. Treat status `2` as a release signal in scripts or CI.
 
+### Lock factual claims with a CopySpec
+
+Use `verify-spec` when a draft has claims that must remain verbatim unless they declare atomic facts. A local CopySpec records each immutable claim alongside its evidence, then blocks a candidate if its required text or atoms are absent, or if it is joined by a prohibited claim.
+
+```json
+{
+  "version": "1",
+  "audience": "operators",
+  "intent": "explain a launch date",
+  "channel": "email",
+  "claims": [
+    {
+      "id": "launch-date",
+      "text": "The launch is on 14 August.",
+      "atoms": ["The launch is on 14 August."],
+      "evidence": "Release calendar, checked 7 August."
+    }
+  ],
+  "prohibitedClaims": ["The launch is guaranteed to double revenue."]
+}
+```
+
+```bash
+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.
+
 ### Local voice memory
 
 Learning is on by default. After a successful `verify`, Hold Your Voice records resolved rule IDs under `~/.hyv/learning/`, scoped to a fingerprint of the portable profile. It stores no draft or candidate text. The next `rewrite-prompt` uses a bounded list of those verified repairs.
@@ -170,15 +268,19 @@ Read the full [VoiceDNA reference](docs/VOICE-DNA.md) and [Wiki guide](https://g
 
 ## AI Editor: inspectable rules
 
-AI Editor uses a local, deterministic ruleset. Each rule has a stable ID, severity, reason, and repair direction. Run this command to see the rules that actually execute in your checkout:
+AI Editor uses a local, deterministic ruleset. The current `2.9.24-static.2` ruleset restores the reviewed 143-rule static catalog from the published `@holdyourvoice/hyv@2.9.24` `signals.ts` artifact and retains two detectors introduced in 3.1, for 145 rules total. Most rules inspect sentences; selected inherited rules inspect one physical line to preserve multi-sentence and line-start behavior. Each rule has a stable ID, severity, reason, repair direction, reconstructable expression, and explicit scope. Intentional inherited overlaps remain visible as separate findings.
+
+Run this command to see the rules and ruleset version that actually execute in the published CLI:
 
 ```bash
 npx @holdyourvoice/hyv patterns
 ```
 
+From a built source checkout, run `node dist/cli.js patterns` instead.
+
 Red findings are release blockers. Yellow findings are a request to inspect a sentence in context. A match never proves who wrote the text, and a clean scan never proves the text is good.
 
-The repository also includes a public [220-pattern editorial catalog](docs/patterns/AI-WRITING-PATTERNS-1-220.md). That catalog is broader than the executable ruleset on purpose. A catalog entry becomes executable only after the project has defined its counterexamples, reviewed public provenance, written tests, and decided the rule is narrow enough to help without creating noise.
+The repository also includes a public [220-pattern editorial catalog](docs/patterns/AI-WRITING-PATTERNS-1-220.md). It is broader editorial guidance, not a claim that all 220 entries execute. A catalog entry becomes executable only after the project has defined its counterexamples, reviewed public provenance, written tests, and decided the rule is narrow enough to help without creating noise. Neither the executable rules nor the editorial catalog can prove authorship.
 
 ## Verification contract
 
@@ -197,8 +299,11 @@ The preservation score is a guardrail based on retained original words longer th
 | --- | --- | --- | --- |
 | `hyv profile <profile.json> <sample...>` | Two or more text files | Profile JSON | You need a new local reference. |
 | `hyv analyze <draft> <profile.json>` | Draft and profile | Analysis JSON | You need both reports before editing. |
+| `hyv hygiene <draft> [--fix] [--output=path]` | Draft | Hygiene report or cleaned copy plus receipt | You need to inspect or conservatively clean hidden Unicode. |
+| `hyv final-check <path\|->` | Any final text | Exact accepted text on stdout or a withheld-output report on stderr | Text is about to cross a user-facing boundary. |
 | `hyv rewrite-prompt <draft> <profile.json>` | Draft and profile | Markdown editing brief | You need a constrained request for an editor or model. |
 | `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. |
 | `hyv learning <show\|add\|clear> <profile.json>` | Profile and optional instruction | Local learning JSON | You need to inspect or manage profile-scoped learning. |
 | `hyv patterns` | None | Ruleset JSON | You need the exact enabled rules. |
 
@@ -210,8 +315,10 @@ Every file argument can be `-` when the command accepts text input from standard
 | --- | --- |
 | `src/contracts.ts` | Profiles, findings, reports, analysis, and verification data shapes. |
 | `src/text.ts` | Sentence, paragraph, word, and basic statistics helpers. |
+| `src/hygiene.ts` | Profile-free hidden Unicode inspection and conservative cleaning. |
 | `src/voice-dna.ts` | Builds profiles and runs VoiceDNA checks. |
 | `src/ai-editor.ts` | Owns the versioned deterministic editorial rules. |
+| `src/editorial-packs.ts` | Parses WritingBrief context and runs format and batch checks. |
 | `src/learning.ts` | Stores text-free, profile-scoped verified repairs and composes bounded local preferences. |
 | `src/pipeline.ts` | Combines pass states, makes briefs, and verifies candidates. |
 | `src/cli.ts` | Local file and standard-input command adapter. |

package/dist/ai-editor-rules.js

@@ -0,0 +1,148 @@
+/** Reviewed static sentence-compatible rules shipped in @holdyourvoice/hyv@2.9.24. */
+export const rules = [
+    { id: "ai.delve", severity: "red", expression: /\bdelve\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use a specific verb: dig, explore, look at" },
+    { id: "ai.leverage", severity: "red", expression: /\bleverage\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: use, apply, build on" },
+    { id: "ai.tapestry", severity: "red", expression: /\btapestry\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "be specific about what you mean" },
+    { id: "ai.holistic", severity: "red", expression: /\bholistic\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the actual approach" },
+    { id: "ai.robust", severity: "yellow", expression: /\brobust\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say what actually makes it strong" },
+    { id: "ai.pivotal", severity: "yellow", expression: /\bpivotal\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say why it matters specifically" },
+    { id: "ai.foster", severity: "yellow", expression: /\bfoster\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: build, grow, encourage, support" },
+    { id: "ai.harness", severity: "yellow", expression: /\bharness\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: use, apply, work with" },
+    { id: "ai.illuminate", severity: "yellow", expression: /\billuminate\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: show, explain, highlight" },
+    { id: "ai.ever-evolving", severity: "red", expression: /\b(?:ever[\s-]evolving|ever[\s-]changing)\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "cut this \u2014 it says nothing" },
+    { id: "ai.fast-paced", severity: "red", expression: /\bfast[\s-]paced\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "cut this \u2014 every industry says this" },
+    { id: "ai.game-changer", severity: "red", expression: /\bgame[\s-]changer\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "explain what actually changed" },
+    { id: "ai.paradigm", severity: "red", expression: /\bparadigm\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the actual shift" },
+    { id: "ai.synergy", severity: "red", expression: /\bsynergy\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what works together and why" },
+    { id: "ai.ecosystem", severity: "yellow", expression: /\becosystem\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific tools/partners/platforms" },
+    { id: "ai.seamless", severity: "yellow", expression: /\bseamless\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe how it actually works" },
+    { id: "ai.actionable", severity: "yellow", expression: /\bactionable\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just give the action, don't label it" },
+    { id: "ai.granular", severity: "yellow", expression: /\bgranular\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say: specific, detailed, or name the level" },
+    { id: "ai.impactful", severity: "yellow", expression: /\bimpactful\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the actual impact" },
+    { id: "ai.transform", severity: "yellow", expression: /\btransform\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what specifically changed" },
+    { id: "ai.empower", severity: "yellow", expression: /\bempower\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what people can actually do" },
+    { id: "ai.unlock", severity: "yellow", expression: /\bunlock\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what they get access to" },
+    { id: "ai.nuanced", severity: "yellow", expression: /\bnuanced\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "explain the specific complexity" },
+    { id: "ai.multifaceted", severity: "red", expression: /\bmultifaceted\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific aspects" },
+    { id: "ai.comprehensive", severity: "yellow", expression: /\bcomprehensive\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say what it covers specifically" },
+    { id: "ai.innovative", severity: "yellow", expression: /\binnovative\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what's actually new" },
+    { id: "ai.cut[t]?ing-edge", severity: "red", expression: /\bcut(?:t)?ing[\s-]edge\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific technology" },
+    { id: "ai.state-of-the-art", severity: "red", expression: /\bstate[\s-]of[\s-]the[\s-]art\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what makes it current" },
+    { id: "ai.best-practices", severity: "yellow", expression: /\bbest[\s-]practices?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific practice" },
+    { id: "ai.world-class", severity: "red", expression: /\bworld[\s-]class\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "prove it with specifics" },
+    { id: "ai.second-to-none", severity: "red", expression: /\bsecond[\s-]to[\s-]none\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "drop the superlative, show the work" },
+    { id: "ai.utilize", severity: "red", expression: /\butilize[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'use "use" instead' },
+    { id: "ai.landscape", severity: "red", expression: /\blandscape\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific market/field/area" },
+    { id: "ai.realm", severity: "red", expression: /\brealm\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific domain" },
+    { id: "ai.straightforward", severity: "yellow", expression: /\bstraightforward\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just explain it directly" },
+    { id: "ai.seamlessly", severity: "yellow", expression: /\bseamlessly\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe how it actually works" },
+    { id: "ai.transformative", severity: "yellow", expression: /\btransformative\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what specifically changed" },
+    { id: "ai.meaningful", severity: "yellow", expression: /\bmeaningful\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "be specific about what makes it meaningful" },
+    { id: "ai.profound", severity: "yellow", expression: /\bprofound\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the actual depth/impact" },
+    { id: "ai.intricate", severity: "yellow", expression: /\bintricate\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say what specifically is complex" },
+    { id: "ai.cornerstone", severity: "red", expression: /\bcornerstone\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific foundation" },
+    { id: "ai.navigate", severity: "yellow", expression: /\bnavigate\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the specific action" },
+    { id: "ai.endeavor", severity: "yellow", expression: /\bendeavor\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: effort, project, attempt" },
+    { id: "ai.encapsulate", severity: "yellow", expression: /\bencapsulate[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: capture, contain, describe" },
+    { id: "ai.facilitate", severity: "yellow", expression: /\bfacilitate[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: help, enable, support" },
+    { id: "ai.bolster", severity: "yellow", expression: /\bbolster[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: strengthen, support, boost" },
+    { id: "ai.streamline", severity: "yellow", expression: /\bstreamline[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what specifically was simplified" },
+    { id: "ai.differentiate", severity: "yellow", expression: /\bdifferentiate[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what specifically is different" },
+    { id: "ai.myriad", severity: "yellow", expression: /\bmyriad\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific number or items" },
+    { id: "ai.elevate", severity: "yellow", expression: /\belevate[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what specifically improved" },
+    { id: "ai.revolutionize", severity: "red", expression: /\brevolutionize[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the specific change" },
+    { id: "ai.supercharge", severity: "red", expression: /\bsupercharge[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe what it actually does" },
+    { id: "ai.ensure", severity: "yellow", expression: /\bensure\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: make sure, confirm, verify" },
+    { id: "ai.crucial", severity: "yellow", expression: /\bcrucial\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "explain why it matters specifically" },
+    { id: "ai.vital", severity: "yellow", expression: /\bvital\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "describe the specific importance" },
+    { id: "ai.cultivate", severity: "yellow", expression: /\bcultivate[sd]?\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "use: build, grow, develop" },
+    { id: "ai.plethora", severity: "yellow", expression: /\bplethora\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "name the specific quantity or items" },
+    { id: "ai.embark", severity: "red", expression: /\bembark\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just start. no embarking needed." },
+    { id: "formula.firstly", severity: "yellow", expression: /\bfirstly\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'just start \u2014 "firstly" is filler' },
+    { id: "formula.secondly", severity: "yellow", expression: /\bsecondly\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'just continue \u2014 "secondly" is filler' },
+    { id: "formula.lastly", severity: "yellow", expression: /\blastly\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'just end \u2014 "lastly" is filler' },
+    { id: "formula.moreover", severity: "yellow", expression: /\bmoreover\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just add the point" },
+    { id: "formula.furthermore", severity: "yellow", expression: /\bfurthermore\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just add the point" },
+    { id: "formula.in-conclusion", severity: "red", expression: /\bin conclusion\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just end. readers know it's the end." },
+    { id: "formula.in-summary", severity: "red", expression: /\bin summary\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just summarize. the label is redundant." },
+    { id: "formula.it-is-important", severity: "yellow", expression: /\bit is important to note\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just note it. skip the preamble." },
+    { id: "formula.at-the-end", severity: "yellow", expression: /\bat the end of the day\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "cut this \u2014 it means nothing" },
+    { id: "formula.needless-to-say", severity: "yellow", expression: /\bneedless to say\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "if it's needless, don't say it" },
+    { id: "formula.it-goes-without", severity: "yellow", expression: /\bit goes without saying\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "then don't say it" },
+    { id: "formula.in-today", severity: "red", expression: /\bin today'?s\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "start with your actual point instead" },
+    { id: "formula.lets-dive", severity: "red", expression: /\blet'?s (?:dive|jump|dig|delve)\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just start. no diving needed." },
+    { id: "formula.without-further", severity: "red", expression: /\bwithout further ado\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "cut this \u2014 just get to it" },
+    { id: "formula.its-worth-noting", severity: "yellow", expression: /\bit'?s worth noting\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just note it directly" },
+    { id: "formula.moving-forward", severity: "yellow", expression: /\bmoving forward\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just say what happens next" },
+    { id: "formula.to-put-in-perspective", severity: "yellow", expression: /\bto put this in perspective\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just give the perspective directly" },
+    { id: "formula.what-makes-interesting", severity: "yellow", expression: /\bwhat makes this particularly interesting\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just say the interesting thing" },
+    { id: "formula.implications", severity: "yellow", expression: /\bthe implications here are\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "state the implications directly" },
+    { id: "formula.in-other-words", severity: "red", expression: /\bin other words\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "say it once, well" },
+    { id: "formula.here-the-thing", severity: "yellow", expression: /\bhere'?s the thing\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just say the thing" },
+    { id: "formula.lets-be-clear", severity: "yellow", expression: /\blet'?s be clear\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just be clear. the announcement is filler." },
+    { id: "formula.the-bottom-line", severity: "yellow", expression: /\bthe bottom line\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just state the conclusion" },
+    { id: "formula.picture-this", severity: "yellow", expression: /\bpicture this\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just describe the scene" },
+    { id: "formula.think-of-it", severity: "yellow", expression: /\bthink of it this way\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just explain it directly" },
+    { id: "formula.when-it-comes-to", severity: "yellow", expression: /\bwhen it comes to\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just address the topic directly" },
+    { id: "formula.the-reality-is", severity: "yellow", expression: /\bthe reality is\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "just state the reality" },
+    { id: "hedge.some-might", severity: "yellow", expression: /\bsome might say\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "commit to the claim or drop it" },
+    { id: "hedge.arguably", severity: "yellow", expression: /\barguably\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "commit. say it or don't." },
+    { id: "hedge.worth-noting", severity: "yellow", expression: /\bit'?s worth noting\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "just note it directly" },
+    { id: "hedge.to-some-extent", severity: "yellow", expression: /\bto some extent\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "be specific about the extent" },
+    { id: "hedge.perhaps", severity: "yellow", expression: /\bperhaps\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "commit or cut" },
+    { id: "hedge.maybe", severity: "yellow", expression: /\bmaybe\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "commit or cut" },
+    { id: "hedge.possibly", severity: "yellow", expression: /\bpossibly\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "commit or cut" },
+    { id: "hedge.it-seems", severity: "yellow", expression: /\bit seems\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "state it directly" },
+    { id: "hedge.i-think", severity: "yellow", expression: /\bi think\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: 'just say it. the "i think" is implied.' },
+    { id: "hedge.in-my-opinion", severity: "yellow", expression: /\bin my opinion\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "just state it. it's your article." },
+    { id: "struct.antithesis", severity: "yellow", expression: /\bnot (?:just|only) .{3,50}, but .{3,50}/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "this antithesis pattern is an AI tell \u2014 restructure" },
+    { id: "struct.not-just-but-also", severity: "yellow", expression: /\bnot\s+just\b.{3,80}\bbut\s+(?:also\s+)?/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "say what it IS, not what it isn't" },
+    { id: "struct.more-than-just", severity: "yellow", expression: /\bmore\s+than\s+just\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "say what it IS, not what it isn't" },
+    { id: "struct.in-order-to", severity: "yellow", expression: /\bin order to\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: 'just use "to"' },
+    { id: "struct.due-to-the-fact", severity: "yellow", expression: /\bdue to the fact that\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: 'use "because"' },
+    { id: "struct.for-the-purpose", severity: "yellow", expression: /\bfor the purpose of\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: 'use "to"' },
+    { id: "struct.which-is-another", severity: "red", expression: /\bwhich is another way of saying\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "just say the thing directly" },
+    { id: "struct.in-other-words", severity: "red", expression: /\bin other words\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "just say it once, well" },
+    { id: "struct.rhetorical-truth", severity: "yellow", expression: /\b(?:the\s+)?(?:uncomfortable|hard|harsh|brutal|ugly|unsexy|real|honest)\s+(?:truth|reality)\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "state the fact directly, skip the framing" },
+    { id: "struct.truth-is", severity: "yellow", expression: /\bthe\s+truth\s+is\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "just say the truth. the framing is filler." },
+    { id: "struct.lesson-setup", severity: "yellow", expression: /\b(?:here'?s\s+)?what\s+.{3,80}\s+(?:taught|teaches)\s+(?:me|us|you|everyone)\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "just share the lesson" },
+    { id: "struct.negation-cascade", severity: "yellow", expression: /\b(?:no|not)\s+\w[^.!?\n]{0,80}[.!?][ \t]*\n?[ \t]*(?:no|not)\s+\w[^.!?\n]{0,80}[.!?][ \t]*\n?[ \t]*(?:no|not)\s+\w/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "three negations in a row reads like AI performance", scope: "line" },
+    { id: "struct.inline-triplet", severity: "yellow", expression: /\bit'?s\s+\w[^,.!?;\n]{0,30},\s*it'?s\s+\w[^,.!?;\n]{0,30}[,.]?\s*(?:and\s+)?it'?s\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: `the "it's X, it's Y, it's Z" pattern is an AI tell` },
+    { id: "struct.moment-becomes", severity: "red", expression: /\b(?:the\s+)?moment\b.{3,80}\bbecomes?\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: '"the moment X becomes Y" is polished founder cadence \u2014 restructure' },
+    { id: "struct.same-better", severity: "red", expression: /\bsame\s+[^.!?\n]{1,35}[.!?]\s*(?:better|nicer|cleaner|calmer|safer)\s+[^.!?\n]{1,35}[.!?]?/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: '"same X. better Y." is screenshot-ready founder cadence', scope: "line" },
+    { id: "struct.this-is-why", severity: "yellow", expression: /\bthis\s+is\s+(?:also\s+)?(?:why|how|where|what\b)/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "signpost claims are AI tells \u2014 just make the point" },
+    { id: "struct.heres-where", severity: "yellow", expression: /\b(?:here'?s|here\s+is)\s+(?:where|why|what|the\s+part|the\s+(?:harder|real|actual|main|bigger)\s+problem)\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "just make the point without the signpost" },
+    { id: "struct.generic-buyer", severity: "red", expression: /\bpeople\s+don'?t\s+just\s+buy\b|\bpeople\s+buy\s+the\s+feeling\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "generic buyer psychology is AI filler" },
+    { id: "struct.this-isnt-x-this-is-y", severity: "red", expression: /\bthis isn'?t .{2,40}\.?\s*(?:this is|it'?s) .{2,40}/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "FATAL: delete the negation, just state the positive claim", scope: "line" },
+    { id: "struct.not-x-y", severity: "red", expression: /\bnot .{2,30}\.?\s*.{2,30}\b/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: 'the "Not X. Y." pattern is an AI tell \u2014 just state Y', scope: "line" },
+    { id: "struct.forget-x", severity: "red", expression: /\bforget .{2,40}\.?\s*(?:this is|it'?s|you need)/i, reason: "A formulaic structure can make the sentence feel manufactured.", suggestion: "don't negate \u2014 just state what you mean", scope: "line" },
+    { id: "punct.em-dash", severity: "yellow", expression: /—/, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "em dashes are an AI tell \u2014 use a period, comma, or parentheses" },
+    { id: "bait.let-that-sink", severity: "red", expression: /\blet that sink in\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "cut the sink. make your point and move on." },
+    { id: "bait.read-that-again", severity: "red", expression: /\bread that again\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "if it needs repeating, repeat it yourself" },
+    { id: "bait.full-stop", severity: "red", expression: /\bfull stop\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "the period already does this job" },
+    { id: "bait.this-changes-everything", severity: "red", expression: /\bthis changes everything\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "prove it with specifics" },
+    { id: "bait.paying-attention", severity: "red", expression: /\bare you paying attention\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "don't patronize the reader" },
+    { id: "bait.not-ready", severity: "red", expression: /\byou'?re not ready for this\b/i, reason: "The phrase asks for attention instead of earning it.", suggestion: "just deliver the content" },
+    { id: "cringe.future-proof", severity: "red", expression: /\bfuture[\s-]proof\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "explain what specifically makes it durable" },
+    { id: "cringe.10x", severity: "red", expression: /\b10x\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "use the actual numbers" },
+    { id: "cringe.ai-revolution", severity: "red", expression: /\bthe ai revolution\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "describe the specific change" },
+    { id: "cringe.age-of-ai", severity: "red", expression: /\bin the age of ai\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "just talk about what's happening now" },
+    { id: "cringe.happy-to-help", severity: "red", expression: /\bi'?d be happy to help\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "just help. don't announce it." },
+    { id: "cringe.of-course", severity: "yellow", expression: /^of course!?\s/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "just answer. skip the enthusiasm.", scope: "line" },
+    { id: "cringe.great-question", severity: "red", expression: /\bgreat question!?\b/i, reason: "The phrase makes a broad promotional claim without evidence.", suggestion: "just answer the question" },
+    { id: "insider.nobody-talking", severity: "red", expression: /\bhere'?s the part nobody'?s? talking about\b/i, reason: "The framing claims privileged insight instead of stating the point.", suggestion: "just say the thing. the framing is noise." },
+    { id: "insider.nobody-tells", severity: "red", expression: /\bwhat nobody tells you\b/i, reason: "The framing claims privileged insight instead of stating the point.", suggestion: "just tell them." },
+    { id: "insider.most-people", severity: "yellow", expression: /\bmost people don'?t realize\b/i, reason: "The framing claims privileged insight instead of stating the point.", suggestion: "just explain it. skip the setup." },
+    { id: "insider.nobody-realizes", severity: "red", expression: /\bnobody (?:realizes|talks about|mentions)\b/i, reason: "The framing claims privileged insight instead of stating the point.", suggestion: "if nobody talks about it, just talk about it" },
+    { id: "ogilvy.bandwidth", severity: "yellow", expression: /\bbandwidth\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'Ogilvy: say "time" or "capacity"' },
+    { id: "ogilvy.circle-back", severity: "red", expression: /\bcircle back\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'Ogilvy: say "follow up" or "talk later"' },
+    { id: "ogilvy.low-hanging", severity: "red", expression: /\blow-hanging fruit\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "Ogilvy: name the specific easy win" },
+    { id: "ogilvy.move-the-needle", severity: "red", expression: /\bmove the needle\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: "Ogilvy: describe the actual impact" },
+    { id: "ogilvy.touch-base", severity: "red", expression: /\btouch base\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'Ogilvy: say "talk" or "meet"' },
+    { id: "ogilvy.take-it-offline", severity: "red", expression: /\btake it offline\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'Ogilvy: say "discuss later"' },
+    { id: "ogilvy.deep-dive", severity: "yellow", expression: /\bdeep dive\b/i, reason: "A stock phrase can flatten the writer's meaning.", suggestion: 'Ogilvy: say "look closely at" or "examine"' },
+    { id: "ogilvy.preamble-i-want-to", severity: "yellow", expression: /^\s*i want to (?:share|talk about|discuss|mention)\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "Ogilvy: just say it. skip the preamble.", scope: "line" },
+    { id: "ogilvy.preamble-just-wanted", severity: "yellow", expression: /^\s*(?:i just wanted|i wanted to)\b/i, reason: "A hedge or preamble weakens the direct claim.", suggestion: "Ogilvy: just say it.", scope: "line" },
+    { 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." },
+];

package/dist/ai-editor.js

@@ -1,9 +1,62 @@
+import { rules } from './ai-editor-rules.js';
 import { sentences } from './text.js';
-export const RULESET_VERSION = '2026.08.04.1';
-export const rules = [
-    ['ai.delve', 'red', /\bdelve\b/i, 'Generic AI verb.', 'Use a concrete verb.'], ['ai.leverage', 'red', /\bleverage\b/i, 'Business-jargon default.', 'Say what is being used.'], ['ai.tapestry', 'red', /\btapestry\b/i, 'Abstract metaphor without content.', 'Name the thing.'], ['ai.holistic', 'red', /\bholistic\b/i, 'Vague qualifier.', 'Describe the actual approach.'], ['ai.robust', 'yellow', /\brobust\b/i, 'Claims strength without evidence.', 'State what makes it strong.'], ['ai.landscape', 'yellow', /\blandscape\b/i, 'Generic context word.', 'Name the field.'], ['ai.game-changer', 'red', /\bgame[ -]changer\b/i, 'Promotional cliche.', 'Explain what changed.'], ['ai.formulaic-connector', 'yellow', /\b(firstly|secondly|moreover|furthermore|in conclusion)\b/i, 'Formulaic connector.', 'State the next point directly.'], ['ai.hedging', 'yellow', /\b(arguably|perhaps|it is worth noting|some might say)\b/i, 'Hedge hides the claim.', 'Make or remove the claim.'], ['ai.signpost', 'yellow', /\b(this is why|this is how|here.?s why)\b/i, 'Meta-signpost.', 'Lead with the observation.'], ['ai.not-just', 'red', /\bnot just\b.{0,80}\bbut\b/i, 'Binary persuasion template.', 'State the point plainly.'], ['ai.truth-setup', 'yellow', /\b(the hard|the brutal|the uncomfortable) truth\b/i, 'Manufactured revelation.', 'Name the fact.'], ['ai.em-dash', 'yellow', /—/, 'Dramatic em-dash use.', 'Use a sentence break when needed.'], ['ai.question-hook', 'yellow', /^(have you|do you|what if|why do|how do)\b/i, 'Question opener instead of a concrete start.', 'Open from an observation.'], ['ai.abstract-cluster', 'yellow', /\b(alignment|authenticity|clarity|strategy|value)\b.*\b(alignment|authenticity|clarity|strategy|value)\b/i, 'Abstract nouns pile up.', 'Use concrete nouns and actions.']
-].map(([id, severity, expression, reason, suggestion]) => ({ id: id, severity: severity, expression: expression, reason: reason, suggestion: suggestion }));
-export function analyzeAiEditor(text) { const findings = []; for (const s of sentences(text))
-    for (const r of rules)
-        if (r.expression.test(s.text))
-            findings.push({ engine: 'ai_editor', id: r.id, severity: r.severity, sentence: s.index, excerpt: s.text, reason: r.reason, suggestion: r.suggestion }); const reds = findings.filter(f => f.severity === 'red').length, score = Math.max(0, 100 - reds * 18 - (findings.length - reds) * 6); return { engine: 'ai_editor', version: RULESET_VERSION, score, passed: reds === 0, findings }; }
+export { rules } from './ai-editor-rules.js';
+export const RULESET_VERSION = '2.9.24-static.2';
+const sentenceRules = rules.filter((rule) => rule.scope !== 'line');
+const lineRules = rules.filter((rule) => rule.scope === 'line');
+const ruleOrder = new Map(rules.map((rule, index) => [rule.id, index]));
+export function serializedRules() {
+    return rules.map((rule) => ({
+        id: rule.id,
+        severity: rule.severity,
+        reason: rule.reason,
+        suggestion: rule.suggestion,
+        expression: { source: rule.expression.source, flags: rule.expression.flags },
+        scope: rule.scope ?? 'sentence',
+    }));
+}
+export function analyzeAiEditor(text) {
+    const findings = [];
+    const mapped = sentences(text);
+    for (const sentence of mapped) {
+        for (const rule of sentenceRules) {
+            if (rule.expression.test(sentence.text)) {
+                findings.push({
+                    engine: 'ai_editor',
+                    id: rule.id,
+                    severity: rule.severity,
+                    sentence: sentence.index,
+                    excerpt: sentence.text,
+                    reason: rule.reason,
+                    suggestion: rule.suggestion,
+                });
+            }
+        }
+    }
+    let lineStart = 0;
+    for (const line of text.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);
+            if (!sentence)
+                continue;
+            findings.push({
+                engine: 'ai_editor',
+                id: rule.id,
+                severity: rule.severity,
+                sentence: sentence.index,
+                excerpt: sentence.text,
+                reason: rule.reason,
+                suggestion: rule.suggestion,
+            });
+        }
+        lineStart += line.length + 1;
+    }
+    findings.sort((left, right) => left.sentence - right.sentence || (ruleOrder.get(left.id) ?? 0) - (ruleOrder.get(right.id) ?? 0));
+    const reds = findings.reduce((count, finding) => count + Number(finding.severity === 'red'), 0);
+    const score = Math.max(0, 100 - reds * 18 - (findings.length - reds) * 6);
+    return { engine: 'ai_editor', version: RULESET_VERSION, score, passed: reds === 0, findings };
+}

package/dist/ai-editor.test.js

@@ -1,15 +1,18 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { analyzeAiEditor, rules } from './ai-editor.js';
+import { analyzeAiEditor, rules, serializedRules } from './ai-editor.js';
 test('publishes executable rules with stable IDs and repair directions', () => {
-    assert.ok(rules.length > 0);
+    assert.equal(rules.length, 145);
+    assert.equal(new Set(rules.map((rule) => rule.id)).size, rules.length);
     for (const rule of rules) {
-        assert.match(rule.id, /^ai\./);
+        assert.match(rule.id, /^(ai|formula|hedge|struct|punct|bait|cringe|insider|ogilvy)\./);
         assert.ok(rule.reason.length > 0);
         assert.ok(rule.suggestion.length > 0);
+        assert.equal(rule.expression.global, false, rule.id);
+        assert.equal(rule.expression.sticky, false, rule.id);
     }
 });
-test('detects every executable rule against its exact sentence', () => {
+test('detects representative rules from every inherited rule family', () => {
     const examples = [
         ['ai.delve', 'we will delve into it.'],
         ['ai.leverage', 'we leverage the existing logs.'],
@@ -18,21 +21,23 @@ test('detects every executable rule against its exact sentence', () => {
         ['ai.robust', 'robust evidence supports the claim.'],
         ['ai.landscape', 'the market landscape changed.'],
         ['ai.game-changer', 'this is a game-changer.'],
-        ['ai.formulaic-connector', 'Firstly, check the invoice.'],
-        ['ai.hedging', 'Perhaps the invoice is late.'],
-        ['ai.signpost', 'This is why the invoice matters.'],
-        ['ai.not-just', 'this is not just fast but reliable.'],
-        ['ai.truth-setup', 'the hard truth is in the logs.'],
-        ['ai.em-dash', 'the logs failed — retry later.'],
-        ['ai.question-hook', 'Have you checked the logs?'],
-        ['ai.abstract-cluster', 'alignment and clarity are missing.'],
+        ['formula.firstly', 'Firstly, check the invoice.'],
+        ['hedge.perhaps', 'Perhaps the invoice is late.'],
+        ['struct.this-is-why', 'This is why the invoice matters.'],
+        ['struct.not-just-but-also', 'this is not just fast but reliable.'],
+        ['struct.rhetorical-truth', 'the hard truth is in the logs.'],
+        ['punct.em-dash', 'the logs failed — retry later.'],
+        ['bait.let-that-sink', 'Let that sink in.'],
+        ['cringe.10x', 'The change delivered a 10x result.'],
+        ['insider.nobody-tells', 'What nobody tells you is in the report.'],
+        ['ogilvy.bandwidth', 'We lack the bandwidth this week.'],
     ];
     for (const [id, example] of examples) {
         const report = analyzeAiEditor(example);
-        assert.deepEqual(report.findings.map((finding) => [finding.id, finding.sentence]), [[id, 1]], id);
+        assert.ok(report.findings.some((finding) => finding.id === id && finding.sentence === 1), id);
     }
 });
-test('keeps a counterexample for every executable rule', () => {
+test('keeps counterexamples for representative inherited rules', () => {
     const counterexamples = [
         ['ai.delve', 'we inspect the logs.'],
         ['ai.leverage', 'we use the existing logs.'],
@@ -41,14 +46,16 @@ test('keeps a counterexample for every executable rule', () => {
         ['ai.robust', 'the evidence includes three dated reports.'],
         ['ai.landscape', 'the market changed after the price cut.'],
         ['ai.game-changer', 'the release removed a manual step.'],
-        ['ai.formulaic-connector', 'next, check the invoice.'],
-        ['ai.hedging', 'the invoice is late.'],
-        ['ai.signpost', 'the invoice matters because it is overdue.'],
-        ['ai.not-just', 'the service is fast and reliable.'],
-        ['ai.truth-setup', 'the logs show the service failed.'],
-        ['ai.em-dash', 'the logs failed; retry later.'],
-        ['ai.question-hook', 'the reviewer asked, have you checked the logs?'],
-        ['ai.abstract-cluster', 'the editor checked the contract and sent the invoice.'],
+        ['formula.firstly', 'next, check the invoice.'],
+        ['hedge.perhaps', 'the invoice is late.'],
+        ['struct.this-is-why', 'the invoice matters because it is overdue.'],
+        ['struct.not-just-but-also', 'the service is fast and reliable.'],
+        ['struct.rhetorical-truth', 'the logs show the service failed.'],
+        ['punct.em-dash', 'the logs failed; retry later.'],
+        ['bait.let-that-sink', 'The invoice is overdue.'],
+        ['cringe.10x', 'The result rose from 2 to 20.'],
+        ['insider.nobody-tells', 'The report explains the missing step.'],
+        ['ogilvy.bandwidth', 'We lack time this week.'],
     ];
     for (const [id, example] of counterexamples) {
         assert.equal(analyzeAiEditor(example).findings.some((finding) => finding.id === id), false, id);
@@ -59,3 +66,57 @@ test('keeps yellow findings as review cues rather than release blockers', () =>
     assert.ok(report.findings.every((finding) => finding.severity === 'yellow'));
     assert.equal(report.passed, true);
 });
+test('restores the benchmark signals from the 2.9.24 executable catalog', () => {
+    const report = analyzeAiEditor("This work is meaningful. Here's the part nobody is talking about. The change delivered a 10x result.");
+    assert.deepEqual(report.findings.map((finding) => [finding.id, finding.sentence]), [
+        ['ai.meaningful', 1],
+        ['struct.heres-where', 2],
+        ['cringe.10x', 3],
+    ]);
+});
+test('returns the same findings across repeated sentence and line analysis', () => {
+    for (const text of ['We leverage logs. We leverage traces.', 'No demos. No decks. No distractions. Same team. Better results.']) {
+        assert.deepEqual(analyzeAiEditor(text), analyzeAiEditor(text));
+    }
+});
+test('reports the same rule in multiple sentences', () => {
+    const report = analyzeAiEditor('We leverage logs. We leverage traces.');
+    assert.deepEqual(report.findings.filter((finding) => finding.id === 'ai.leverage').map((finding) => finding.sentence), [1, 2]);
+});
+test('executes inherited cross-sentence rules and maps them to the first sentence', () => {
+    const report = analyzeAiEditor('No demos. No decks. No distractions. Same team. Better results.');
+    assert.deepEqual(report.findings
+        .filter((finding) => finding.id === 'struct.negation-cascade' || finding.id === 'struct.same-better')
+        .map((finding) => [finding.id, finding.sentence]), [
+        ['struct.negation-cascade', 1],
+        ['struct.same-better', 4],
+    ]);
+});
+test('preserves inherited physical-line matching and line-start anchors', () => {
+    const sameLine = analyzeAiEditor("This isn't positioning. This is proof. Forget vanity metrics. You need retention.");
+    assert.ok(sameLine.findings.some((finding) => finding.id === 'struct.this-isnt-x-this-is-y'));
+    assert.ok(sameLine.findings.some((finding) => finding.id === 'struct.forget-x'));
+    assert.equal(analyzeAiEditor("This isn't positioning.\nThis is proof.").findings.some((finding) => finding.id === 'struct.this-isnt-x-this-is-y'), false);
+    assert.equal(analyzeAiEditor('The logs failed. Of course we can retry.').findings.some((finding) => finding.id === 'cringe.of-course'), false);
+    assert.ok(analyzeAiEditor('The logs failed.\nOf course we can retry.').findings.some((finding) => finding.id === 'cringe.of-course'));
+});
+test('retains the current question-hook and abstract-cluster detectors', () => {
+    assert.ok(analyzeAiEditor('Have you checked the invoice?').findings.some((finding) => finding.id === 'ai.question-hook'));
+    assert.ok(analyzeAiEditor('Clarity and strategy are missing.').findings.some((finding) => finding.id === 'ai.abstract-cluster'));
+});
+test('serializes reconstructable regular expressions and explicit scopes', () => {
+    const catalog = serializedRules();
+    assert.equal(catalog.length, 145);
+    assert.ok(catalog.every((rule) => rule.scope === 'sentence' || rule.scope === 'line'));
+    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);
+});
+test('keeps intentional inherited overlaps visible and scores each finding', () => {
+    const report = analyzeAiEditor('In other words, use logs.');
+    assert.deepEqual(report.findings.map((finding) => finding.id), ['formula.in-other-words', 'struct.in-other-words']);
+    assert.equal(report.score, 64);
+});
+test('returns zero AI findings for clean input', () => {
+    assert.deepEqual(analyzeAiEditor('The launch starts Tuesday. The owner signed the release checklist.').findings, []);
+});