@maestroagora/agora 1.8.0 → 1.10.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "maestro-agora",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "displayName": "Maestro: Agora",
   "description": "Use /agora for persuasive writing, technical explanation, case studies, investment analysis, spoken or written copy, and explicit publication artifact audits.",
   "author": {

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "maestro-agora",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Maestro: Agora writes clear persuasion, technical explanations, case studies, and investment communication, then audits local publication artifacts when requested.",
   "author": {
     "name": "Mark Laursen",
@@ -38,7 +38,7 @@
     "composerIcon": "./assets/icon.png",
     "defaultPrompt": [
       "/agora sell Write the strongest hero from this brief and destination.",
-      "/agora science Explain this technical subject with the certainty and framing I specify.",
+      "/agora technical Explain this system for the technical reader I specify.",
       "/agora case study Turn this project material into the case study I describe.",
       "/agora invest Build this fundraising asset from my thesis, claims, urgency, and plan.",
       "/agora publication audit Inspect this local file for hidden Unicode, metadata, and provenance."

package/README.md

@@ -24,10 +24,12 @@ Use it for landing pages, heroes, ads, product copy, sales outreach, investor co
 |---|---|
 | Persuasion | Argument, consequence, reason to believe, CTA, channel fit, and rhetorical force |
 | Heroes and short sales copy | Awareness, claim saturation, traffic source, promise grammar, destination fidelity, and the complete first-screen composition |
-| `SCIENCE` | Scientific certainty, causal language, statistics, mechanisms, uncertainty, analogies, visuals, sources, and limits |
+| `SCIENCE` | Research findings, methods, statistics, uncertainty, scientific explanation, sources, and limits |
+| `TECHNICAL` | Documented system behavior, architecture, APIs, implementation detail, and technical evaluation |
 | `CASE_STUDY` | Real projects, fictional mocks, and concept portfolios shaped around the story and status you choose |
 | `INVEST` | Fundraising, diligence, and capital-allocation communication shaped around your thesis, claims, urgency, and next decision |
-| `VOICE` | A measured voice profile built from the corpus you choose |
+| `VOICE` | A measured persistent profile or a task-only sketch from samples supplied with one task |
+| Human-voice editing | One exact canonical standard for output bans, structural cleanup, meaning preservation, genre fit, and detector limits |
 | Written GEO/AEO | Clear entities, self-contained passages, source transparency, and relevant publication checks |
 
 Agora returns one ready-to-use result by default. Alternatives, internal routes, and rationale stay out of the final copy unless requested.
@@ -111,7 +113,7 @@ Choose a primary mode when you want to override inference:
 Add modifiers when the subject or asset needs them:
 
 ```text
-/agora sell science Write a technical product hero with this certainty and framing.
+/agora sell technical Write a product section for engineers with this documented behavior.
 /agora inform science Explain this study for a general audience.
 /agora sell case study Write a customer success case from this approved project record.
 /agora inform science case study Explain this engineering implementation and its measured limits.
@@ -122,6 +124,23 @@ Add modifiers when the subject or asset needs them:
 
 In Codex, `$agora` and the skills picker can also select the installed skill. Other hosts may expose skills through a picker or mention syntax. Asking the agent to use the Agora skill remains portable.
 
+## Human-voice editing standard
+
+Agora ships the attached source unchanged as `human-voice-editing-reference.md`. It is the single canonical authority for banned vocabulary, connectives, templates, significance tails, punctuation, prompt leakage, structural tells, author samples, meaning preservation, genre fit, detector limits, and privacy cautions.
+
+The standard removes generated stock vocabulary, connective phrases, templates, significance tails, prompt leakage, repeated structural patterns, raw channel residue, fake human texture, and detector-driven corruption. It preserves the current user's facts, required wording, technical terms, genre, and intended meaning. Measured voice profiles document author habits but do not automatically exempt banned vocabulary.
+
+Plain professional writing is the default. AI, software, data, security, engineering, and infrastructure products stay in plain language for ordinary readers. A specialized register activates only when the deliverable needs scientific findings, technical detail, legal wording, or formal review.
+
+Run the deterministic style review on a file:
+
+```sh
+npx -y -p @maestroagora/agora@latest agora-style-audit ./draft.md
+npx -y -p @maestroagora/agora@latest agora-style-audit ./draft.md --register technical --json
+```
+
+Hard findings cover banned typography, canonical vocabulary and templates, prompt leakage, and significance tails. Review warnings cover plain-register control words, long or joined sentences, repeated openings and paragraph shapes, noun and preposition stacks, false reframes, question fragments, corporate helper phrases, and legalistic leakage. The tool does not rewrite text, validate facts, infer authorship, or promise detector evasion.
+
 ## Publication privacy and provenance
 
 Agora writes copy. It does not create SVG, PNG, JPEG, PDF, DOCX, or PPTX files by itself. Other document, presentation, PDF, site, design, or image tools may place Agora copy into those artifacts.
@@ -149,7 +168,7 @@ Model-level text watermarks are statistical generation signals, not hidden chara
 
 ## Routing model
 
-Agora chooses a primary mode first, then the publication surface, then any domain or asset modifiers. `VOICE` enters afterward and preserves your required language and content choices.
+Agora resolves the audience, genre, writing register, and voice before it plans the argument. It then chooses a primary mode, publication surface, and any domain or asset modifiers. Voice shapes expression from the first sentence while preserving required facts and wording.
 
 ### Primary modes
 
@@ -167,11 +186,14 @@ Agora chooses a primary mode first, then the publication surface, then any domai
 
 | Modifier | Function |
 |---|---|
-| `SCIENCE` | Adds empirical or technical explanation and optional claim-review tools |
+| `SCIENCE` | Adds research findings, methods, statistics, uncertainty, and optional scientific review |
+| `TECHNICAL` | Adds documented system behavior, architecture, APIs, implementation detail, and technical evaluation |
 | `CASE_STUDY` | Adds case-study structure, result framing, and optional attribution or permission review |
-| `VOICE` | Applies a measured voice profile from the corpus you select |
+| `VOICE` | Applies a measured persistent profile or a task-only sketch |
 
-The modifiers can compose. A technical fundraising case may use `INVEST + SCIENCE + CASE_STUDY`. A founder-voiced scientific product video may use `SELL + SCIENCE + VOICE + HYBRID`.
+The modifiers can compose. A technical fundraising case may use `INVEST + TECHNICAL + CASE_STUDY`. A founder-voiced scientific product video may use `SELL + SCIENCE + VOICE + HYBRID`.
+
+Subject matter alone does not activate `SCIENCE` or `TECHNICAL`. A nontechnical homepage for an AI or security product remains `SELL + PLAIN`.
 
 ### Surfaces
 
@@ -221,12 +243,12 @@ Promise grammar matters. `See X`, `Learn how to X`, `We help you X`, `Do X more
 
 ## Scientific and technical communication
 
-`SCIENCE` supports three internal routes:
+Specialized explanation supports three internal routes:
 
 | Route | Subject |
 |---|---|
 | `EMPIRICAL` | Studies, experiments, observations, measurements, and findings |
-| `TECHNICAL` | Systems, interfaces, architecture, mechanisms, dependencies, and failure behavior |
+| `TECHNICAL` | Systems, interfaces, architecture, APIs, implementation, dependencies, and failure behavior |
 | `MIXED` | Measured findings plus technical mechanism |
 
 When you request scientific claim review, Agora can classify material as observation, established fact or consensus, model, interpretation, implication, recommendation, hypothesis, speculation, or unknown. Without that request, it follows the certainty and framing in your brief.
@@ -285,7 +307,7 @@ Legal, securities, offering, solicitation, eligibility, and disclosure review is
 
 ## Measured voice profiles
 
-`VOICE` modifies another mode rather than replacing it. Profiles are measured from the corpus you select, not improvised from adjectives.
+`VOICE` modifies another mode rather than replacing it. Persistent profiles are measured from the corpus you select, not improvised from adjectives.
 
 Build and inspect a profile with the shipped engine:
 
@@ -304,6 +326,10 @@ A profile records sentence and paragraph distributions, function words, punctuat
 
 Profiles live at `~/.agora/voices/`, outside the replaceable skill directory. A default profile can apply across modes. Use `--no-voice`, `neutral`, or `--voice <name>` per request. Your required wording overrides habitual profile tendencies.
 
+Task-only voice sketches are separate. When you supply authentic samples with one task, Agora can use three to ten same-genre samples without the 5,000-word persistent-profile floor. One or two samples support only cautious local observations. The sketch records visible habits, stays inside the task, is never certified or stored as a profile, and never claims authorship or statistical identity. Agora does not copy distinctive phrases, facts, examples, metaphors, slogans, or anecdotes from the samples. With no samples, it uses plain professional writing and preserves credible choices from your draft.
+
+Sentence and paragraph measurements remain available in `voice check`. They are diagnostics, not generation quotas. Agora does not force a 25-word sentence, alternate sentence lengths, or write toward a target distribution.
+
 Agora builds or applies the profile you request. You are responsible for corpus rights, identity use, attribution, endorsements, disclosure, and publication.
 
 ## User control and responsibility
@@ -342,6 +368,11 @@ skills/agora/
 |-- scripts/
 |   `-- publication-audit.mjs
 `-- references/
+    |-- agora-writing-runtime.md
+    |-- agora-marketing-runtime.md
+    |-- agora-conversion-runtime.md
+    |-- agora-case-study-runtime.md
+    |-- human-voice-editing-reference.md
     |-- agora-case-studies.md
     |-- agora-conversion.md
     |-- agora-craft.md
@@ -352,9 +383,12 @@ skills/agora/
     `-- agora-voice.md
 ```
 
-`SKILL.md` contains routing and the concise operating contract. Ordinary work loads only the reference sections it needs.
+`SKILL.md` contains routing. Ordinary work loads the compact writing and job runtimes first. Deep research stays available for explicit research, source review, scientific, technical, legal, audit, diligence, and maintainer work.
 
-- `agora-marketing.md` is the canonical doctrine for user authority, argument, channels, optional claim review, GEO/AEO, AI-writing-tell controls, examples, research grades, and conflict handling.
+- `human-voice-editing-reference.md` is the exact canonical human-voice editing authority.
+- `agora-writing-runtime.md` is the small plain-language writing contract loaded for every writing task.
+- `agora-marketing-runtime.md`, `agora-conversion-runtime.md`, and `agora-case-study-runtime.md` keep ordinary drafting out of the research register.
+- `agora-marketing.md` preserves deep doctrine, source material, research grades, and maintainer guidance.
 - `agora-craft.md` adds headlines, heroes, awareness and sophistication, emotion, and prose rhythm.
 - `agora-science.md` adds empirical and technical explanation plus optional scientific claim review.
 - `agora-case-studies.md` adds case structure, results, and optional attribution, permission, and confidentiality review.
@@ -370,13 +404,13 @@ Research informed Agora, but research custody is separate from distribution.
 
 The public repository and npm package must not contain raw or corrected transcripts, caption files, supplied PDFs or office documents, audio, video, private source identities, model-output scratch, research working files, local paths, or assigned secrets.
 
-`npm run check` runs validation, deterministic tests, the exact package allowlist, and release hygiene. `npm run release:check` is the proportional mandatory release gate and runs those same checks. `npm pack` and `npm publish` invoke it through `prepack` and `prepublishOnly`.
+`npm run check` runs validation, deterministic tests, the exact package allowlist, and release hygiene. `npm run release:check` adds the current frozen blind-evaluation evidence gate. `npm pack` and `npm publish` invoke it through `prepack` and `prepublishOnly`.
 
-Behavioral evaluation is optional research, not a pack or publish blocker. `npm run eval:release` preserves the version-specific v1.7 evidence audit and must be run from a matching v1.7 checkout. Existing evaluation artifacts remain frozen for reproducibility; new blind or confirmatory generations are not required for later releases.
+`evals/releases/current.json` is the explicit release contract. Its version must match `package.json`, the frozen manifest, schemas, release gates, adjudications, records, custody hashes, and external artifact manifests. Missing or stale human-writing evidence blocks a publishable release. Live generation does not run inside unit tests.
 
 The versioned directories under `evals/blind/` are public pairwise-release artifacts, not permanently secret holdouts. `v1.2.0`, `v1.4.0`, `v1.5.0`, and `v1.7.0` are frozen by exact tree hashes in `evals/releases/locks.json`; validation fails on additions, deletions, or edits.
 
-`evals/prospective/conversion-context-v1.0.0/` remains the development source for conversion-context cases. Earlier fixture sets are preserved under `evals/regression/` for regression analysis and historical reproducibility. `evals/blind/v1.7.0/` contains 25 independently authored conversion scenarios with versioned judging and reduction tooling.
+`evals/prospective/human-writing-v1.0.0/` is the development source for the human-writing partition. The frozen current manifest lives under `evals/blind/` after prospective generation and blind pairwise review. Earlier fixture sets remain frozen for regression analysis and historical reproducibility.
 
 Deterministic tests verify instruction structure, routing contracts, static invariants, and evaluation-record shape. Versioned blind-evaluation tooling remains available for repeatable development analysis without turning model preference into a universal conversion claim.
 
@@ -390,12 +424,14 @@ npm pack --dry-run --json
 npx -y @maestroagora/agora --dry-run
 ```
 
-The mandatory release gate checks skill structure, routing contracts, user-authority boundaries, modifiers, typography, metadata, reference links, full-tree installer parity, exact npm contents, frozen evaluation-tree locks, public-tree hygiene, and deterministic tests. It does not require model generation or blind adjudication.
+The mandatory release gate checks skill structure, routing contracts, factual and user-authority boundaries, typography, metadata, reference links, installer parity, exact npm contents, frozen evaluation-tree locks, public-tree hygiene, deterministic tests, and checked current blind evidence. Generation and judging happen before evidence is frozen, not during routine tests.
 
 ## Change record
 
 | Version | What changed |
 |---|---|
+| 1.10.0 | Makes plain professional writing the default, separates compact runtime rules from maintainer research, ships the exact canonical human-voice source, adds task-only voice sketches and a deterministic style audit, routes technical language by job and audience, removes forced rhythm targets, and binds release checks to current human-writing evidence. |
+| 1.9.0 | Makes first-read clarity automatic. Agora now drafts for factual completeness, rewrites for literal clarity, preserves qualifiers across short passages, names concrete actors and observable results, and rejects vague referents, hidden metaphors, noun stacks, and revisions that only rename ambiguity. Adds rendered label-clearance guidance for technical diagrams. |
 | 1.8.0 | Adds opt-in publication privacy and provenance review plus a packaged read-only audit CLI. Reports configured hidden Unicode, document and image metadata, Office review material, and C2PA carrier or validation signals without changing source files. Redacts sensitive values and paths by default, preserves unknown coverage, and makes no watermark-removal or authorship claim. |
 | 1.7.0 | Adds a progressively loaded conversion-context reference with bounded conversion priors, downstream outcome matching, self-serve and enterprise route design, pricing decision contracts, proof placement, and contradiction handling. Tightens closed-world fact preservation and limits written GEO/AEO requirements to indexable public work. |
 | 1.6.0 | Expands user control across every writing mode. User-selected claims, fiction, urgency, attribution, profile use, and publication choices now control the draft. Claim, evidence, permission, disclosure, confidentiality, diligence, and compliance review are opt-in. Adds a user-responsibility disclaimer and an accurate privacy notice. |

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@maestroagora/agora",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Install Maestro: Agora for persuasive writing, technical explanation, case studies, investment communication, and publication artifact review.",
   "type": "module",
   "bin": {
     "agora": "scripts/install.mjs",
     "agora-publication-audit": "skills/agora/scripts/publication-audit.mjs",
+    "agora-style-audit": "scripts/style-audit.mjs",
     "agora-voice": "scripts/voice-measure.mjs"
   },
   "files": [
@@ -21,6 +22,9 @@
     "assets/icon.png",
     "assets/maestro-agora-banner.png",
     "scripts/install.mjs",
+    "scripts/style-audit-core.mjs",
+    "scripts/style-audit.mjs",
+    "scripts/task-voice-sketch.mjs",
     "scripts/voice-measure.mjs",
     "scripts/voice",
     "skills/agora"
@@ -32,8 +36,8 @@
     "prepack": "npm run release:check",
     "prepublishOnly": "npm run release:check",
     "eval:release": "node scripts/release-evidence-check.mjs",
-    "release:check": "npm run check",
-    "test": "node --test tests/behavior-contract.test.mjs tests/hero-contract.test.mjs tests/conversion-context-contract.test.mjs tests/science-contract.test.mjs tests/case-study-contract.test.mjs tests/invest-contract.test.mjs tests/publication-audit.test.mjs tests/blind-summary.test.mjs tests/blind-judge-prompt.test.mjs tests/blind-judge-materialize.test.mjs tests/blind-judgment-ingest.test.mjs tests/adjudication-reducer.test.mjs tests/eval-provenance-check.test.mjs tests/release-evidence-check.test.mjs tests/release-hygiene.test.mjs tests/install.test.mjs tests/voice-measure.test.mjs",
+    "release:check": "npm run check && npm run eval:release",
+    "test": "node --test tests/behavior-contract.test.mjs tests/human-writing-contract.test.mjs tests/style-audit.test.mjs tests/task-voice-sketch.test.mjs tests/release-contract.test.mjs tests/hero-contract.test.mjs tests/conversion-context-contract.test.mjs tests/science-contract.test.mjs tests/case-study-contract.test.mjs tests/invest-contract.test.mjs tests/publication-audit.test.mjs tests/blind-summary.test.mjs tests/blind-judge-prompt.test.mjs tests/blind-judge-materialize.test.mjs tests/blind-judgment-ingest.test.mjs tests/adjudication-reducer.test.mjs tests/eval-provenance-check.test.mjs tests/release-evidence-check.test.mjs tests/release-hygiene.test.mjs tests/install.test.mjs tests/voice-measure.test.mjs",
     "validate": "node scripts/validate.mjs"
   },
   "engines": {

package/scripts/install.mjs

@@ -252,6 +252,11 @@ async function verifySource() {
     "references/agora-craft.md",
     "references/agora-invest.md",
     "references/agora-marketing.md",
+    "references/agora-case-study-runtime.md",
+    "references/agora-conversion-runtime.md",
+    "references/agora-marketing-runtime.md",
+    "references/agora-writing-runtime.md",
+    "references/human-voice-editing-reference.md",
     "references/agora-publication.md",
     "references/agora-science.md",
     "references/agora-voice.md",

package/scripts/style-audit-core.mjs

@@ -0,0 +1,267 @@
+import { readFile } from "node:fs/promises";
+
+import { GENERIC_AI_VOCABULARY } from "./voice/lexicon.mjs";
+import { segmentParagraphs, segmentSentences, tokenize } from "./voice/pipeline.mjs";
+
+export const REGISTERS = new Set(["plain", "technical", "scientific", "legal", "audit"]);
+
+export const CANONICAL_CONNECTIVES = [
+  "moreover",
+  "furthermore",
+  "additionally",
+  "in addition",
+  "notably",
+  "importantly",
+  "indeed",
+  "in essence",
+  "in summary",
+  "in conclusion",
+  "ultimately",
+  "that said",
+  "on the other hand",
+  "on one hand",
+];
+
+export const CANONICAL_TEMPLATE_PATTERNS = [
+  ["important-note", /\bit(?:'s| is) important to note that\b/giu],
+  ["worth-noting", /\bit(?:'s| is) worth (?:noting|mentioning) that\b/giu],
+  ["fast-paced-world", /\bin today(?:'s|s) fast-paced world\b/giu],
+  ["ever-evolving-landscape", /\bin the ever-evolving landscape of\b/giu],
+  ["realm", /\bin the realm of\b/giu],
+  ["testament", /\ba testament to\b/giu],
+  ["stands-as", /\bstands as a\b/giu],
+  ["serves-as", /\bserves as a\b/giu],
+  ["pivotal-role", /\bplays a (?:crucial|pivotal|vital) role in\b/giu],
+  ["not-only", /\bnot only\b[^.!?\n]{0,180}\bbut also\b/giu],
+  ["whether-you", /\bwhether you(?:'re| are)\b[^.!?\n]{0,120}\bor\b/giu],
+  ["from-to", /\bfrom\b[^,!?.\n]{1,80}\bto\b[^,!?.\n]{1,80},[^.!?\n]{0,120}\bhas\b/giu],
+  ["at-core", /\bat its core\b/giu],
+  ["when-it-comes", /\bwhen it comes to\b/giu],
+  ["navigating-complexities", /\bnavigating the complexities of\b/giu],
+  ["unlocking-potential", /\bunlocking the potential of\b/giu],
+  ["harnessing-power", /\bharnessing the power of\b/giu],
+  ["paving-way", /\bpaving the way for\b/giu],
+  ["setting-stage", /\bsetting the stage for\b/giu],
+  ["bringing-forefront", /\bbringing\b[^.!?\n]{1,100}\bto the forefront\b/giu],
+];
+
+export const CANONICAL_SIGNIFICANCE_TAILS = [
+  "emphasizing the significance of",
+  "reflecting the continued relevance of",
+  "underscoring the importance of",
+  "highlighting its role in",
+  "demonstrating its impact on",
+  "marking a turning point in",
+  "cementing its place as",
+  "solidifying its reputation for",
+  "showcasing its commitment to",
+];
+
+export const CANONICAL_PROMPT_LEAKAGE = [
+  /\bcertainly!\b/giu,
+  /\bof course!\b/giu,
+  /\babsolutely!\b/giu,
+  /\bgreat question!\b/giu,
+  /\bhere is your (?:article|blog post|essay) on\b/giu,
+  /\bas an ai language model\b/giu,
+  /\bup to my last training update\b/giu,
+  /\bi hope this helps!\b/giu,
+  /\blet me know if you(?:'d| would) like\b/giu,
+  /\bcertainly! here(?:'s| is) a\b/giu,
+  /\bsure, i can help with that\b/giu,
+];
+
+export const CONTROL_ROOM_TERMS = [
+  "evidence", "evidentiary", "proof", "verified", "verification", "claim",
+  "substantiation", "provenance", "methodology", "framework", "mechanism",
+  "criterion", "criteria", "qualification", "qualifier", "causal", "entailment",
+  "proposition", "decision surface", "route", "artifact", "register", "hierarchy",
+  "gate", "audit", "ledger", "boundary", "scope", "operational",
+];
+
+export const FALSE_REFRAMES = [
+  /\bthis is not just\b[^.!?\n]{1,120}[.!?]\s*it is\b/giu,
+  /\bthis is not\b[^.!?\n]{1,120}[.!?]\s*it is\b/giu,
+  /\b\w[\w -]{0,80} is more than \w/giu,
+  /\bthe real issue is not\b[^.!?\n]{1,140}[.!?]\s*it is\b/giu,
+  /\bthe question is not whether\b[^.!?\n]{1,160}\bbut how\b/giu,
+];
+
+export const QUESTION_FRAGMENT_THEATER = /\b(?:the result|the answer|the problem|the difference|the bottom line)\?/giu;
+export const CONVERSATIONAL_THEATER = /\b(?:here is the thing|let us be honest|think about it|imagine this|picture this|you know the feeling|the bottom line is)\b/giu;
+export const CORPORATE_HELPERS = /\b(?:provides the ability to|is designed to enable|helps to facilitate|allows users to|offers a way to|serves to|works to|aims to|seeks to|has the potential to)\b/giu;
+export const LEGALISTIC_LEAKAGE = /\b(?:with respect to|in relation to|insofar as|pursuant to|herein|therein|whereby|for the avoidance of doubt|where applicable|subject to the foregoing|constitutes|shall)\b/giu;
+export const EMPTY_ANALYTICAL_ENDINGS = /\bthis (?:demonstrates that|indicates the importance of|provides a strong foundation for|creates a clear pathway to|supports the broader objective of|aligns with|reinforces|reflects)\b/giu;
+
+const HARD = "hard";
+const WARNING = "warning";
+const EXACT_START = "<!-- agora-style-audit: exact-start -->";
+const EXACT_END = "<!-- agora-style-audit: exact-end -->";
+
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+const lineAndColumn = (text, index) => {
+  const before = text.slice(0, index);
+  const lines = before.split("\n");
+  return { line: lines.length, column: lines.at(-1).length + 1 };
+};
+
+const finding = (text, match, severity, category, rule, message) => ({
+  severity,
+  category,
+  rule,
+  message,
+  excerpt: match[0],
+  ...lineAndColumn(text, match.index),
+});
+
+const maskRange = (characters, start, end) => {
+  for (let index = Math.max(0, start); index < Math.min(characters.length, end); index += 1) {
+    if (characters[index] !== "\n") characters[index] = " ";
+  }
+};
+
+export function maskExactText(text, exactTextRanges = []) {
+  const characters = [...text];
+  const patterns = [
+    /```[\s\S]*?```/g,
+    /~~~[\s\S]*?~~~/g,
+    /`[^`\n]+`/g,
+    /^\s*>.*$/gm,
+    new RegExp(`${escapeRegExp(EXACT_START)}[\\s\\S]*?${escapeRegExp(EXACT_END)}`, "g"),
+  ];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) maskRange(characters, match.index, match.index + match[0].length);
+  }
+  for (const rangeValue of exactTextRanges) maskRange(characters, rangeValue.start, rangeValue.end);
+  return characters.join("");
+}
+
+const scanRegex = (text, masked, regex, severity, category, rule, message, findings) => {
+  regex.lastIndex = 0;
+  for (const match of masked.matchAll(regex)) findings.push(finding(text, match, severity, category, rule, message));
+};
+
+const sentenceEntries = (text) => {
+  const entries = [];
+  let searchFrom = 0;
+  for (const paragraph of segmentParagraphs(text)) {
+    for (const sentence of segmentSentences(paragraph)) {
+      const index = text.indexOf(sentence, searchFrom);
+      entries.push({ sentence, index: index < 0 ? searchFrom : index, tokens: tokenize(sentence) });
+      if (index >= 0) searchFrom = index + sentence.length;
+    }
+  }
+  return entries;
+};
+
+const sentenceWarnings = (text, masked, findings) => {
+  const entries = sentenceEntries(masked);
+  const joinWords = new Set(["and", "but", "or", "because", "although", "while", "whereas", "which", "that", "whereby", "if", "when", "since"]);
+  const prepositions = new Set(["of", "for", "with", "in", "through"]);
+  const nounSuffix = /(?:tion|sion|ment|ness|ity|ance|ence|al|ure|ism|ship)$/u;
+  for (const entry of entries) {
+    const match = { 0: entry.sentence, index: entry.index };
+    if (entry.tokens.length > 28) findings.push(finding(text, match, WARNING, "sentence", "sentence-over-28-words", `Ordinary sentence has ${entry.tokens.length} words; review whether a split preserves meaning.`));
+    const joins = entry.tokens.filter((token) => joinWords.has(token)).length;
+    if (joins >= 3) findings.push(finding(text, match, WARNING, "sentence", "three-or-more-joined-clauses", `Sentence contains ${joins} clause-join proxies.`));
+    const prepCount = entry.tokens.filter((token) => prepositions.has(token)).length;
+    if (prepCount >= 5) findings.push(finding(text, match, WARNING, "sentence", "preposition-stack", `Sentence contains ${prepCount} common prepositions.`));
+    let nounRun = 0;
+    let longest = 0;
+    for (const token of entry.tokens) {
+      nounRun = nounSuffix.test(token) ? nounRun + 1 : 0;
+      longest = Math.max(longest, nounRun);
+    }
+    if (longest >= 3) findings.push(finding(text, match, WARNING, "sentence", "noun-stack", "Sentence contains a possible abstract noun stack."));
+  }
+
+  for (let index = 2; index < entries.length; index += 1) {
+    const openings = entries.slice(index - 2, index + 1).map((entry) => entry.tokens.slice(0, 2).join(" "));
+    if (openings[0] && openings.every((opening) => opening === openings[0])) {
+      const entry = entries[index - 2];
+      findings.push(finding(text, { 0: openings[0], index: entry.index }, WARNING, "structure", "repeated-openings", "Three consecutive sentences share the same two-word opening."));
+    }
+  }
+};
+
+const paragraphWarnings = (text, masked, findings) => {
+  const paragraphs = segmentParagraphs(masked).map((paragraph) => ({
+    paragraph,
+    words: tokenize(paragraph).length,
+    sentences: segmentSentences(paragraph).length,
+  }));
+  for (let index = 2; index < paragraphs.length; index += 1) {
+    const group = paragraphs.slice(index - 2, index + 1);
+    const sameSentenceCount = group.every((entry) => entry.sentences === group[0].sentences);
+    const smallest = Math.min(...group.map((entry) => entry.words));
+    const largest = Math.max(...group.map((entry) => entry.words));
+    if (sameSentenceCount && smallest > 0 && largest / smallest <= 1.15) {
+      const start = text.indexOf(group[0].paragraph);
+      findings.push(finding(text, { 0: group[0].paragraph.slice(0, 80), index: Math.max(0, start) }, WARNING, "structure", "repeated-paragraph-shape", "Three consecutive paragraphs have nearly identical shapes."));
+    }
+  }
+};
+
+export function auditText(text, { register = "plain", exactTextRanges = [] } = {}) {
+  if (!REGISTERS.has(register)) throw new Error(`unknown register: ${register}`);
+  const masked = maskExactText(text, exactTextRanges);
+  const findings = [];
+
+  scanRegex(text, masked, /\u2014/gu, HARD, "punctuation", "u+2014", "Unicode U+2014 is forbidden outside exact text.", findings);
+  scanRegex(text, masked, /[\u2018\u2019\u201c\u201d]/gu, HARD, "punctuation", "smart-quote", "Generated smart quotes are forbidden outside exact text.", findings);
+
+  for (const word of GENERIC_AI_VOCABULARY) {
+    scanRegex(text, masked, new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu"), HARD, "canonical", `banned-vocabulary:${word}`, "Canonical banned vocabulary requires an explicit exact-text exception.", findings);
+  }
+  for (const phrase of CANONICAL_CONNECTIVES) {
+    scanRegex(text, masked, new RegExp(`\\b${escapeRegExp(phrase)}\\b`, "giu"), HARD, "canonical", `banned-connective:${phrase}`, "Canonical banned connective requires an explicit formal-genre or exact-text exception.", findings);
+  }
+  for (const [id, pattern] of CANONICAL_TEMPLATE_PATTERNS) {
+    scanRegex(text, masked, pattern, HARD, "canonical", `banned-template:${id}`, "Canonical stock template is forbidden.", findings);
+  }
+  for (const phrase of CANONICAL_SIGNIFICANCE_TAILS) {
+    scanRegex(text, masked, new RegExp(`,?\\s*${escapeRegExp(phrase)}\\b`, "giu"), HARD, "canonical", `significance-tail:${phrase}`, "Canonical significance tail is forbidden.", findings);
+  }
+  for (const [index, pattern] of CANONICAL_PROMPT_LEAKAGE.entries()) {
+    scanRegex(text, masked, pattern, HARD, "canonical", `prompt-leakage:${index + 1}`, "Prompt or task meta-commentary is forbidden.", findings);
+  }
+
+  if (register === "plain") {
+    for (const term of CONTROL_ROOM_TERMS) {
+      scanRegex(text, masked, new RegExp(`\\b${escapeRegExp(term)}\\b`, "giu"), WARNING, "register", `control-room:${term}`, "Review whether the reader needs this internal control term.", findings);
+    }
+  }
+
+  for (const [index, pattern] of FALSE_REFRAMES.entries()) scanRegex(text, masked, pattern, WARNING, "structure", `false-reframe:${index + 1}`, "Review generic false-reframe construction.", findings);
+  scanRegex(text, masked, QUESTION_FRAGMENT_THEATER, WARNING, "structure", "question-fragment-theater", "Review generic question-fragment theater.", findings);
+  scanRegex(text, masked, CONVERSATIONAL_THEATER, WARNING, "structure", "conversational-theater", "Review conversational theater against the active voice.", findings);
+  scanRegex(text, masked, CORPORATE_HELPERS, WARNING, "wording", "corporate-helper", "Replace a corporate helper phrase with a direct verb when meaning permits.", findings);
+  if (register !== "legal" && register !== "audit") scanRegex(text, masked, LEGALISTIC_LEAKAGE, WARNING, "register", "legalistic-leakage", "Review legalistic wording outside a legal or audit register.", findings);
+  scanRegex(text, masked, EMPTY_ANALYTICAL_ENDINGS, WARNING, "structure", "empty-analytical-ending", "Replace an empty analytical ending with the fact or needed inference.", findings);
+
+  sentenceWarnings(text, masked, findings);
+  paragraphWarnings(text, masked, findings);
+
+  findings.sort((left, right) => left.line - right.line || left.column - right.column || left.rule.localeCompare(right.rule));
+  const hardFailures = findings.filter((item) => item.severity === HARD);
+  const warnings = findings.filter((item) => item.severity === WARNING);
+  return {
+    schema_version: 1,
+    register,
+    pass: hardFailures.length === 0,
+    hard_failure_count: hardFailures.length,
+    warning_count: warnings.length,
+    findings,
+    limits: {
+      authorship: "not assessed",
+      detector_evasion: "not promised",
+      factual_validation: "outside this lexical and structural tool",
+      rewriting: "not performed",
+    },
+  };
+}
+
+export async function auditFile(path, options = {}) {
+  return auditText(await readFile(path, "utf8"), options);
+}

package/scripts/style-audit.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+
+import { auditFile, REGISTERS } from "./style-audit-core.mjs";
+
+export function parseArgs(argv) {
+  const options = { file: null, register: "plain", json: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === "--json") options.json = true;
+    else if (value === "--register") options.register = argv[++index];
+    else if (value.startsWith("--register=")) options.register = value.slice("--register=".length);
+    else if (value.startsWith("-")) throw new Error(`unknown option: ${value}`);
+    else if (options.file) throw new Error("supply exactly one file");
+    else options.file = value;
+  }
+  if (!options.file) throw new Error("missing file");
+  if (!REGISTERS.has(options.register)) throw new Error(`unknown register: ${options.register}`);
+  return options;
+}
+
+export function renderHuman(path, report) {
+  const status = report.pass ? "PASS" : "FAIL";
+  const lines = [
+    `${status} ${path}`,
+    `Register: ${report.register}`,
+    `Hard failures: ${report.hard_failure_count}`,
+    `Review warnings: ${report.warning_count}`,
+  ];
+  for (const item of report.findings) {
+    lines.push(`${item.severity.toUpperCase()} ${item.line}:${item.column} ${item.rule}: ${item.message}`);
+  }
+  lines.push("This audit does not rewrite text, validate facts, infer authorship, or promise detector evasion.");
+  return `${lines.join("\n")}\n`;
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  const path = resolve(options.file);
+  const report = await auditFile(path, { register: options.register });
+  process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : renderHuman(options.file, report));
+  if (!report.pass) process.exitCode = 1;
+  return report;
+}
+
+if (import.meta.url === new URL(`file://${resolve(process.argv[1]).replaceAll("\\", "/")}`).href) {
+  try {
+    await main();
+  } catch (error) {
+    process.stderr.write(`agora-style-audit: ${error.message}\n`);
+    process.exitCode = 2;
+  }
+}