@maestroagora/agora 1.9.0 → 1.10.0

package/scripts/task-voice-sketch.mjs

@@ -0,0 +1,110 @@
+import { measure } from "./voice/features.mjs";
+import { buildOverlapIndex, phraseOverlap } from "./voice/check.mjs";
+import { segmentParagraphs, segmentSentences, tokenize } from "./voice/pipeline.mjs";
+
+export const TASK_VOICE_SKETCH = "TASK_VOICE_SKETCH";
+export const TASK_SAMPLE_FULL_FLOOR = 3;
+export const TASK_SAMPLE_MAXIMUM = 10;
+
+const median = (values) => {
+  if (!values.length) return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+
+const range = (values) => values.length
+  ? { minimum: Math.min(...values), median: median(values), maximum: Math.max(...values) }
+  : { minimum: null, median: null, maximum: null };
+
+const normalizeSamples = (samples) => samples.map((sample, index) => {
+  if (typeof sample === "string") return { id: `sample-${index + 1}`, text: sample, genre: null };
+  if (!sample || typeof sample.text !== "string") throw new Error(`sample ${index + 1} must contain text`);
+  return {
+    id: sample.id || `sample-${index + 1}`,
+    text: sample.text,
+    genre: sample.genre || null,
+  };
+});
+
+const selectSamples = (samples, genre) => {
+  if (!genre) return { selected: samples, sameGenre: false };
+  const sameGenre = samples.filter((sample) => sample.genre === genre);
+  return sameGenre.length ? { selected: sameGenre, sameGenre: true } : { selected: samples, sameGenre: false };
+};
+
+export function buildTaskVoiceSketch(inputSamples, { genre = null } = {}) {
+  if (!Array.isArray(inputSamples)) throw new Error("samples must be an array");
+  if (inputSamples.length > TASK_SAMPLE_MAXIMUM) {
+    throw new Error(`task voice sketches accept at most ${TASK_SAMPLE_MAXIMUM} samples`);
+  }
+  if (inputSamples.length === 0) {
+    return {
+      kind: TASK_VOICE_SKETCH,
+      certified: false,
+      persistence: "task-only",
+      sample_count: 0,
+      confidence: "fallback",
+      genre,
+      same_genre_samples: false,
+      observations: ["No samples supplied. Preserve credible choices in the draft and use plain professional writing."],
+      measurements: null,
+      limitations: ["No author-sample fit can be assessed."],
+    };
+  }
+
+  const normalized = normalizeSamples(inputSamples);
+  const { selected, sameGenre } = selectSamples(normalized, genre);
+  const text = selected.map((sample) => sample.text).join("\n\n");
+  const paragraphs = segmentParagraphs(text);
+  const sentences = paragraphs.flatMap((paragraph) => segmentSentences(paragraph));
+  const sentenceWords = sentences.map((sentence) => tokenize(sentence).length);
+  const paragraphWords = paragraphs.map((paragraph) => tokenize(paragraph).length);
+  const measured = measure(text);
+  const lowConfidence = selected.length < TASK_SAMPLE_FULL_FLOOR;
+
+  return {
+    kind: TASK_VOICE_SKETCH,
+    certified: false,
+    persistence: "task-only",
+    stores_source_text: false,
+    sample_count: selected.length,
+    supplied_sample_count: normalized.length,
+    confidence: lowConfidence ? "low: cautious local observations only" : "task-local: recurring habits may guide this task",
+    genre,
+    same_genre_samples: sameGenre,
+    observations: [
+      `Sentence length in the selected samples ranges from ${range(sentenceWords).minimum} to ${range(sentenceWords).maximum} words, with a median of ${range(sentenceWords).median}.`,
+      `Paragraph length ranges from ${range(paragraphWords).minimum} to ${range(paragraphWords).maximum} words, with a median of ${range(paragraphWords).median}.`,
+      `First-person singular rate is ${measured.person_and_stance.person.first_singular ?? "unavailable"} per 1000 tokens; second-person rate is ${measured.person_and_stance.person.second ?? "unavailable"}.`,
+      `The contraction rate is ${measured.contractions.rate_percent ?? "unavailable at this sample size"}.`,
+    ],
+    measurements: {
+      tokens: measured.counts.tokens,
+      sentences: measured.counts.sentences,
+      paragraphs: measured.counts.paragraphs,
+      sentence_words: range(sentenceWords),
+      paragraph_words: range(paragraphWords),
+      punctuation_per_1000: measured.punctuation_per_1000,
+      person_per_1000: measured.person_and_stance.person,
+      contraction_rate_percent: measured.contractions.rate_percent,
+    },
+    limitations: [
+      "This sketch does not establish identity, authorship, statistical matching, personality, or approval.",
+      lowConfidence
+        ? "One or two samples support only obvious local observations."
+        : "Three to ten samples support task-local guidance, not a persistent certified profile.",
+      "Measurements describe the samples and never set generation quotas.",
+      "Source facts, examples, metaphors, slogans, anecdotes, and distinctive phrases must not transfer.",
+    ],
+  };
+}
+
+export function buildTaskSampleOverlapIndex(inputSamples) {
+  const samples = normalizeSamples(inputSamples);
+  return buildOverlapIndex(samples.map((sample) => ({ source: sample.id, tokens: tokenize(sample.text) })));
+}
+
+export function checkTaskSampleOverlap(draftText, index) {
+  return phraseOverlap(draftText, index);
+}

package/scripts/voice/lexicon.mjs

@@ -141,19 +141,21 @@ export const CONTRACTION_PAIRS = [
   { contracted: ["let's"], expanded: [["let", "us"]] },
 ];
 
-// The generic AI-vocabulary list the tell gate bans. A profile's owned list can
-// suppress the ban for a measured word, and only for the words it measured.
-// Sourced from the vocabulary section of the canonical reference.
+// The priority anti-AI vocabulary list. A profile's owned list records measured
+// author habit but does not suppress this ban automatically. It supplies only
+// candidate evidence for the narrow review described by the skill reference.
 export const GENERIC_AI_VOCABULARY = [
-  "bespoke", "bolster", "breathtaking", "comprehensive", "craft", "curated",
-  "cutting-edge", "delve", "elevate", "embark", "empower", "enhance",
-  "ecosystem", "essential", "facilitate", "forefront", "forge", "foster",
-  "game-changer", "groundbreaking", "harness", "holistic", "innovative",
-  "intricate", "invaluable", "journey", "landscape", "leverage", "meticulous",
-  "multifaceted", "navigate", "nuanced", "paramount", "pivotal", "powerhouse",
-  "profound", "realm", "revolutionary", "robust", "seamless", "showcase",
-  "spearhead", "state-of-the-art", "streamline", "tapestry", "testament",
-  "trailblazer", "transformative", "underscore", "unleash", "unlock",
+  "backbone", "bespoke", "best-in-class", "bolster", "breathtaking",
+  "comprehensive", "cornerstone", "craft", "crucial", "curated", "cutting-edge",
+  "delve", "drive", "ecosystem", "elevate", "empower", "enhance", "essential",
+  "facilitate", "forefront", "forge", "foster", "frontier", "game-changer",
+  "groundbreaking", "harness", "holistic", "indispensable", "intricate",
+  "invaluable", "journey", "landscape", "leverage", "lifeblood", "meticulous",
+  "multifaceted", "navigate", "notable", "noteworthy", "nuanced", "optimize",
+  "paramount", "pivotal", "powerhouse", "profound", "realm", "remarkable",
+  "revolutionary", "rich", "robust", "seamless", "showcase", "significant",
+  "spearhead", "state-of-the-art", "streamline", "stunning", "tapestry",
+  "testament", "trailblazer", "transformative", "underscore", "unleash", "unlock",
   "unparalleled", "unprecedented", "vibrant", "vital", "world-class",
 ];
 

package/scripts/voice/profile.mjs

@@ -79,8 +79,8 @@ export function ownedVocabulary(documents, certified) {
 
   return {
     withheld: false,
-    // The allowlist is the intersection with the generic ban list. Only a word
-    // the tell gate would otherwise strip needs an exception written down.
+    // Keep the public field name for profile-schema compatibility. The entries
+    // are candidate exceptions that require a separate load-bearing review.
     allowlist: qualifying.filter((entry) => AI_VOCABULARY.has(entry.token)),
     distinctive: qualifying
       .filter((entry) => !AI_VOCABULARY.has(entry.token) && !ALL_FUNCTION_WORDS.has(entry.token))
@@ -386,7 +386,7 @@ function notCaptured(measured, gates, corpus) {
   );
   if (curly > 0) {
     lines.push(
-      `- The corpus contains ${curly} curly quote characters. The curly-quote ban is not vocabulary, so the owned-vocabulary exception does not reach it and final copy uses straight quotes.`,
+      `- The corpus contains ${curly} curly quote characters. The priority anti-AI standard treats typography separately from vocabulary, so final copy uses straight quotes.`,
     );
   }
 
@@ -444,16 +444,16 @@ export function renderProfile({ name, measured, gates, corpus, pipeline, now })
   const excerpts = selectExcerpts(corpus.documents, measured);
 
   const vocabulary = [
-    "**Owned.** Words measured as recurring across independent documents in this corpus. The list is an allowlist against the generic AI-vocabulary ban and reaches those words only. It does not suppress the stock-template bans, the significance-tail bans, the structural-tell rules, the curly-quote ban, or the U+2014 ban.",
+    "**Owned.** Words measured as recurring across independent documents in this corpus. Entries that also appear on the priority anti-AI vocabulary list are candidate exceptions, not an automatic allowlist. Retain one only when it is load-bearing, exact, technically required, part of a verified proper name or immutable text, or explicitly required by the current user or house style. Nothing here suppresses the stock-template bans, significance-tail bans, structural-tell rules, curly-quote ban, or U+2014 ban.",
     "",
   ];
   if (owned.withheld) {
     vocabulary.push(
-      "No allowlist is issued. The corpus is below the certification floor, and a word cannot be shown to recur across genres in a corpus that has one. An allowlist assembled from a thin corpus is a licence built on noise.",
+      "No candidate exception list is issued. The corpus is below the certification floor, and a word cannot be shown to recur across genres in a corpus that has one. A preference claim assembled from a thin corpus is built on noise.",
     );
   } else if (owned.allowlist.length === 0) {
     vocabulary.push(
-      "No word on the generic AI-vocabulary ban list met the measurement bar in this corpus, so no exception is issued. The generic ban applies in full.",
+      "No word on the priority anti-AI vocabulary list met the measurement bar in this corpus. The vocabulary ban applies in full.",
     );
   } else {
     vocabulary.push(