dravoice 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dravoice",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Compile article voice profiles into reusable LLM writing context, evidence-first briefs, and deterministic draft review notes.",
   "type": "module",
   "bin": {

package/src/v2/analyzers/discourse.js

@@ -12,6 +12,7 @@ const TRANSITIONS = {
 export function analyzeDiscourse(documents) {
   const sentences = documents.flatMap((document) => document.sentences);
   const labels = sentences.map((sentence) => transitionLabel(sentence.text));
+  const nonPlainLabels = labels.filter((label) => label !== "plain");
   const transitionRates = {};
   for (const key of Object.keys(TRANSITIONS)) {
     transitionRates[key] = rate(labels.filter((label) => label === key).length, sentences.length, 2);
@@ -22,10 +23,12 @@ export function analyzeDiscourse(documents) {
     confidence: sentences.length >= 12 ? "medium" : "low",
     features: {
       transitionRates,
-      transitionSequence: labels.filter(Boolean).slice(0, 12),
+      transitionSequence: labels.slice(0, 12),
+      transitionBigrams: topItems(sequenceNgrams(labels, 2), 12),
+      transitionTrigrams: topItems(sequenceNgrams(labels, 3), 12),
       sentenceCallbacks: callbackRate(sentences),
     },
-    examples: topItems(labels.filter(Boolean), 5).map((item) => item.value),
+    examples: topItems(nonPlainLabels, 5).map((item) => item.value),
     warnings: sentences.length < 12 ? ["Discourse confidence is limited because the corpus has fewer than 12 sentences."] : [],
     revisionHandles: ["Compare how sentences turn, contrast, explain, and return to earlier ideas."],
   };
@@ -50,3 +53,11 @@ function callbackRate(sentences) {
   }
   return rate(callbacks, Math.max(1, sentences.length - 1), 2);
 }
+
+function sequenceNgrams(values, size) {
+  const result = [];
+  for (let index = 0; index <= values.length - size; index += 1) {
+    result.push(values.slice(index, index + size).join(" -> "));
+  }
+  return result;
+}

package/src/v2/analyzers/evidence.js

@@ -14,34 +14,69 @@ const EVIDENCE_PATTERNS = {
 const ABSTRACT_CLAIM_RE = /\b(always|never|everyone|everything|nothing|best|better|worse|important|obvious|clearly|should|must|need to|have to|all|none|every)\b/i;
 
 export function analyzeEvidence(documents) {
-  const sentences = documents.flatMap((document) => document.sentences);
-  const evidenceSentences = sentences.filter((sentence) => evidenceTypes(sentence.text).length > 0);
-  const claimSentences = sentences.filter((sentence) => ABSTRACT_CLAIM_RE.test(sentence.text));
-  const typeValues = evidenceSentences.flatMap((sentence) => evidenceTypes(sentence.text));
+  const documentResults = documents.map(documentEvidence);
+  const sentenceCount = documentResults.reduce((sum, item) => sum + item.sentenceCount, 0);
+  const evidenceSentenceCount = documentResults.reduce((sum, item) => sum + item.evidenceSentenceCount, 0);
+  const claimSentenceCount = documentResults.reduce((sum, item) => sum + item.claimSentenceCount, 0);
+  const supportedClaimCount = documentResults.reduce((sum, item) => sum + item.supportedClaimCount, 0);
+  const unsupportedClaimCount = documentResults.reduce((sum, item) => sum + item.unsupportedClaimCount, 0);
+  const typeValues = documentResults.flatMap((item) => item.typeValues);
 
   return {
     family: "evidence",
-    confidence: sentences.length >= 12 ? "medium" : "low",
+    confidence: sentenceCount >= 12 ? "medium" : "low",
     features: {
-      sentenceCount: sentences.length,
-      evidenceSentenceCount: evidenceSentences.length,
-      evidenceSentenceRate: rate(evidenceSentences.length, sentences.length, 2),
-      claimSentenceRate: rate(claimSentences.length, sentences.length, 2),
-      unsupportedClaimRate: rate(Math.max(0, claimSentences.length - evidenceSentences.length), sentences.length, 2),
+      sentenceCount,
+      evidenceSentenceCount,
+      evidenceSentenceRate: rate(evidenceSentenceCount, sentenceCount, 2),
+      claimSentenceCount,
+      claimSentenceRate: rate(claimSentenceCount, sentenceCount, 2),
+      supportedClaimRate: rate(supportedClaimCount, Math.max(1, claimSentenceCount), 2),
+      unsupportedClaimRate: rate(unsupportedClaimCount, Math.max(1, claimSentenceCount), 2),
       evidenceTypes: topItems(typeValues, 8),
     },
     examples: topItems(typeValues, 4).map((item) => `${item.value}: ${item.count}`),
-    warnings: sentences.length < 12 ? ["Evidence confidence is limited because the corpus has fewer than 12 sentences."] : [],
+    warnings: sentenceCount < 12 ? ["Evidence confidence is limited because the corpus has fewer than 12 sentences."] : [],
     revisionHandles: ["Compare how broad claims are supported by concrete scenes, numbers, quotes, citations, or examples."],
   };
 }
 
-export function evidenceTypes(text) {
-  return Object.entries(EVIDENCE_PATTERNS)
-    .filter(([, pattern]) => pattern.test(text))
-    .map(([type]) => type);
-}
-
-export function isAbstractClaim(text) {
-  return ABSTRACT_CLAIM_RE.test(text);
-}
+function documentEvidence(document) {
+  const sentences = document.sentences;
+  const sentenceEvidenceTypes = sentences.map((sentence) => evidenceTypes(sentence.text));
+  const evidenceSentences = sentences.filter((_, index) => sentenceEvidenceTypes[index].length > 0);
+  const claimIndexes = sentences
+    .map((sentence, index) => ({ sentence, index }))
+    .filter(({ sentence }) => ABSTRACT_CLAIM_RE.test(sentence.text))
+    .map(({ index }) => index);
+  const supportedClaimIndexes = claimIndexes.filter((index) => hasNearbyEvidence(sentenceEvidenceTypes, index));
+  return {
+    sentenceCount: sentences.length,
+    evidenceSentenceCount: evidenceSentences.length,
+    claimSentenceCount: claimIndexes.length,
+    supportedClaimCount: supportedClaimIndexes.length,
+    unsupportedClaimCount: claimIndexes.length - supportedClaimIndexes.length,
+    typeValues: evidenceSentences.flatMap((sentence) => evidenceTypes(sentence.text)),
+  };
+}
+
+function hasNearbyEvidence(sentenceEvidenceTypes, claimIndex) {
+  const start = Math.max(0, claimIndex - 2);
+  const end = Math.min(sentenceEvidenceTypes.length - 1, claimIndex + 2);
+  for (let index = start; index <= end; index += 1) {
+    if (sentenceEvidenceTypes[index].length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function evidenceTypes(text) {
+  return Object.entries(EVIDENCE_PATTERNS)
+    .filter(([, pattern]) => pattern.test(text))
+    .map(([type]) => type);
+}
+
+export function isAbstractClaim(text) {
+  return ABSTRACT_CLAIM_RE.test(text);
+}

package/src/v2/analyzers/lexical.js

@@ -3,6 +3,7 @@ import {
   characterNgrams,
   contentWords,
   distribution,
+  normalizeText,
   rate,
   tokenizeWords,
   topItems,
@@ -27,8 +28,13 @@ export function analyzeLexical(documents) {
       },
       wordLength: distribution(words.map((word) => word.length)),
       functionWords: topItems(words.filter((word) => functionWordSet.has(word)), 24),
+      functionWordBigrams: topItems(tokenNgrams(words.filter((word) => functionWordSet.has(word)), 2), 36),
       characterTrigrams: topItems(characterNgrams(text, 3), 24),
+      maskedCharacterFourgrams: topItems(maskedCharacterNgrams(text, 4), 48),
       repeatedMotifs: topItems(content, 16).filter((item) => item.count > 1),
+      sentenceInitialTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens[0], functionWordSet)), 16),
+      sentenceFinalTokens: topItems(sentences.map((sentence) => boundaryToken(sentence.tokens.at(-1), functionWordSet)), 16),
+      punctuationNgrams: topItems(punctuationNgrams(text, 3), 16),
       punctuation: {
         commaRate: rate(count(text, /,/g), sentences.length, 2),
         semicolonRate: rate(count(text, /;/g), sentences.length, 2),
@@ -43,6 +49,56 @@ export function analyzeLexical(documents) {
   };
 }
 
+function boundaryToken(word, functionWordSet) {
+  if (!word) {
+    return null;
+  }
+  if (functionWordSet.has(word)) {
+    return word;
+  }
+  if (/^\d+$/.test(word)) {
+    return "<number>";
+  }
+  return "<content>";
+}
+
+function tokenNgrams(tokens, size) {
+  const grams = [];
+  for (let index = 0; index <= tokens.length - size; index += 1) {
+    grams.push(tokens.slice(index, index + size).join(" "));
+  }
+  return grams;
+}
+
+function maskedCharacterNgrams(text, size) {
+  const functionWordSet = new Set(FUNCTION_WORDS);
+  const masked = normalizeText(text)
+    .replace(/\p{L}[\p{L}\p{N}'-]*|\p{N}+/gu, (word) => {
+      const normalized = word.toLowerCase().replace(/'s$/, "");
+      if (functionWordSet.has(normalized)) {
+        return normalized;
+      }
+      if (/^\p{N}+$/u.test(normalized)) {
+        return "@";
+      }
+      return "#";
+    })
+    .replace(/\s+/g, " ");
+  const grams = [];
+  for (let index = 0; index <= masked.length - size; index += 1) {
+    const gram = masked.slice(index, index + size);
+    if (gram.trim()) {
+      grams.push(gram);
+    }
+  }
+  return grams;
+}
+
+function punctuationNgrams(text, size) {
+  const marks = Array.from(String(text ?? "").matchAll(/[.,;:!?-]/g)).map((match) => match[0]);
+  return tokenNgrams(marks, size);
+}
+
 function confidenceFor(wordCount) {
   if (wordCount >= 2000) {
     return "high";

package/src/v2/analyzers/rhetorical-shape.js

@@ -6,10 +6,18 @@ export function analyzeRhetoricalShape(documents) {
   const documentMoves = documents.map((document) => document.sentences.map((sentence) => moveFor(sentence.text)));
   const sentenceMoves = documentMoves.flat();
   const openingMoves = documents.flatMap((document) => document.sentences.slice(0, 3).map((sentence) => moveFor(sentence.text)));
-  const sequences = [];
+  const bigrams = [];
+  const trigrams = [];
+  const openingMovePatterns = [];
   for (const moves of documentMoves) {
+    if (moves.length > 0) {
+      openingMovePatterns.push(moves.slice(0, 3).join(" -> "));
+    }
     for (let index = 0; index < moves.length - 1; index += 1) {
-      sequences.push(`${moves[index]} -> ${moves[index + 1]}`);
+      bigrams.push(`${moves[index]} -> ${moves[index + 1]}`);
+    }
+    for (let index = 0; index < moves.length - 2; index += 1) {
+      trigrams.push(`${moves[index]} -> ${moves[index + 1]} -> ${moves[index + 2]}`);
     }
   }
 
@@ -19,7 +27,10 @@ export function analyzeRhetoricalShape(documents) {
     features: {
       moveRates: topItems(sentenceMoves, 12),
       openingMoves: openingMoves.slice(0, 9),
-      commonSequences: topItems(sequences, 12),
+      openingMovePatterns: topItems(openingMovePatterns, 8),
+      moveBigrams: topItems(bigrams, 12),
+      moveTrigrams: topItems(trigrams, 12),
+      commonSequences: topItems(bigrams, 12),
     },
     examples: openingMoves.slice(0, 5),
     warnings: sentenceMoves.length < 12 ? ["Rhetorical-shape confidence is limited because the corpus has fewer than 12 sentences."] : [],

package/src/v2/inspect.js

@@ -46,7 +46,7 @@ function featureSummary(name, features) {
     return `sentenceWords.median=${features.sentenceWords.median}; paragraphWords.median=${features.paragraphWords.median}; listDensity=${features.listDensity}; quoteDensity=${features.quoteDensity}`;
   }
   if (name === "lexical") {
-    return `wordCount=${features.wordCount}; contentTypeTokenRatio=${features.vocabularyRichness.contentTypeTokenRatio}; wordLength.median=${features.wordLength.median}`;
+    return `wordCount=${features.wordCount}; contentTypeTokenRatio=${features.vocabularyRichness.contentTypeTokenRatio}; wordLength.median=${features.wordLength.median}; maskedCharacterFourgrams=${features.maskedCharacterFourgrams?.length ?? 0}; functionWordBigrams=${features.functionWordBigrams?.length ?? 0}`;
   }
   if (name === "register") {
     return `primary=${features.primary.value} (${features.primary.score}); alternates=${features.scores.slice(1, 4).map((score) => `${score.value}:${score.score}`).join(", ")}`;
@@ -55,10 +55,10 @@ function featureSummary(name, features) {
     return `transitionRates=${Object.entries(features.transitionRates).map(([key, value]) => `${key}:${value}`).join(", ")}; sentenceCallbacks=${features.sentenceCallbacks}`;
   }
   if (name === "rhetoricalShape") {
-    return `openingMoves=${features.openingMoves.slice(0, 5).join(" -> ") || "none"}; commonSequences=${features.commonSequences.slice(0, 3).map((item) => `${item.value}:${item.count}`).join(", ") || "none"}`;
+    return `openingMoves=${features.openingMoves.slice(0, 5).join(" -> ") || "none"}; moveTrigrams=${features.moveTrigrams?.slice(0, 2).map((item) => `${item.value}:${item.count}`).join(", ") || "none"}; commonSequences=${features.commonSequences.slice(0, 3).map((item) => `${item.value}:${item.count}`).join(", ") || "none"}`;
   }
   if (name === "evidence") {
-    return `evidenceSentenceRate=${features.evidenceSentenceRate}; claimSentenceRate=${features.claimSentenceRate}; unsupportedClaimRate=${features.unsupportedClaimRate}; evidenceTypes=${features.evidenceTypes.map((item) => `${item.value}:${item.count}`).join(", ") || "none"}`;
+    return `evidenceSentenceRate=${features.evidenceSentenceRate}; claimSentenceRate=${features.claimSentenceRate}; supportedClaimRate=${features.supportedClaimRate}; unsupportedClaimRate=${features.unsupportedClaimRate}; evidenceTypes=${features.evidenceTypes.map((item) => `${item.value}:${item.count}`).join(", ") || "none"}`;
   }
   if (name === "structure") {
     return `sectionWords.median=${features.sectionWords.median}; headingCount.median=${features.headingCount.median}; listDocumentRate=${features.listDocumentRate}; quoteDocumentRate=${features.quoteDocumentRate}`;

package/src/v2/profile.js

@@ -6,14 +6,15 @@ import { analyzeLexical } from "./analyzers/lexical.js";
 import { analyzeRegister } from "./analyzers/register.js";
 import { analyzeRhetoricalShape } from "./analyzers/rhetorical-shape.js";
 import { analyzeRhythm } from "./analyzers/rhythm.js";
-import { analyzeStructure } from "./analyzers/structure.js";
-import { loadDocuments } from "./document-model.js";
-import {
-  STYLOMETRIC_REFERENCES,
-  defaultStyleThresholds,
-  distanceByFamily,
-  percentile,
-} from "./stylometry.js";
+import { analyzeStructure } from "./analyzers/structure.js";
+import { loadDocuments } from "./document-model.js";
+import {
+  STYLOMETRIC_REFERENCES,
+  defaultStyleThresholds,
+  distanceByFamily,
+  percentile,
+  stabilityFromDistances,
+} from "./stylometry.js";
 
 export function learnVoicePackV2({ examplesDir, outDir }) {
   const documents = loadDocuments({ examplesDir });
@@ -36,11 +37,11 @@ export function loadVoicePackV2(voiceDir) {
   return profile;
 }
 
-export function buildVoiceProfileV2({ documents }) {
-  const source = sourceSummary(documents);
-  const families = analyzeFeatureFamilies(documents);
-
-  return {
+export function buildVoiceProfileV2({ documents }) {
+  const source = sourceSummary(documents);
+  const families = analyzeFeatureFamilies(documents);
+
+  return {
     schemaVersion: 2,
     generatedBy: "dravoice-v2",
     tool: { name: "Dravoice", cli: "drav" },
@@ -49,67 +50,68 @@ export function buildVoiceProfileV2({ documents }) {
     guidance: guidanceFor({ source, families }),
     calibration: {
       featureStability: Object.fromEntries(Object.entries(families).map(([name, family]) => [name, family.confidence])),
-      tolerances: {
-        rhythmMedianWords: toleranceFor(source.confidence.band, 5, 8, 12),
-        evidenceRate: toleranceFor(source.confidence.band, 0.12, 0.18, 0.25),
-      },
-      styleThresholds: styleThresholdsFor(documents, families),
-      minimumDraftSize: {
-        words: source.confidence.band === "weak" ? 25 : 35,
-        sentences: source.confidence.band === "weak" ? 3 : 4,
+      tolerances: {
+        rhythmMedianWords: toleranceFor(source.confidence.band, 5, 8, 12),
+        evidenceRate: toleranceFor(source.confidence.band, 0.12, 0.18, 0.25),
+      },
+      styleThresholds: styleThresholdsFor(documents, families),
+      minimumDraftSize: {
+        words: source.confidence.band === "weak" ? 25 : 35,
+        sentences: source.confidence.band === "weak" ? 3 : 4,
       },
     },
-  };
-}
-
-function analyzeFeatureFamilies(documents) {
-  return {
-    rhythm: analyzeRhythm(documents),
-    lexical: analyzeLexical(documents),
-    register: analyzeRegister(documents),
-    discourse: analyzeDiscourse(documents),
-    rhetoricalShape: analyzeRhetoricalShape(documents),
-    evidence: analyzeEvidence(documents),
-    structure: analyzeStructure(documents),
-  };
-}
-
-function styleThresholdsFor(documents, fallbackFamilies) {
-  const fallbackThresholds = defaultStyleThresholds();
-  const distancesByFamily = Object.fromEntries(Object.keys(fallbackFamilies).map((family) => [family, []]));
-
-  if (documents.length >= 2) {
-    for (let index = 0; index < documents.length; index += 1) {
-      const referenceDocuments = documents.filter((_, candidateIndex) => candidateIndex !== index);
-      const referenceFamilies = analyzeFeatureFamilies(referenceDocuments);
-      const heldoutFamilies = analyzeFeatureFamilies([documents[index]]);
-      for (const family of Object.keys(fallbackFamilies)) {
-        distancesByFamily[family].push(distanceByFamily(
-          family,
-          referenceFamilies[family].features,
-          heldoutFamilies[family].features,
-        ));
-      }
-    }
-  }
-
-  const families = {};
-  for (const family of Object.keys(fallbackFamilies)) {
-    const observations = distancesByFamily[family];
-    const observedThreshold = observations.length > 0 ? percentile(observations, 0.9) : 0;
-    const fallback = fallbackThresholds[family].threshold;
-    families[family] = {
-      threshold: Math.max(0.01, Math.min(0.95, observedThreshold || fallback)),
-      observations: observations.length,
-    };
-  }
-
-  return {
-    method: "leave-one-out-cosine-delta",
-    references: STYLOMETRIC_REFERENCES,
-    families,
-  };
-}
+  };
+}
+
+function analyzeFeatureFamilies(documents) {
+  return {
+    rhythm: analyzeRhythm(documents),
+    lexical: analyzeLexical(documents),
+    register: analyzeRegister(documents),
+    discourse: analyzeDiscourse(documents),
+    rhetoricalShape: analyzeRhetoricalShape(documents),
+    evidence: analyzeEvidence(documents),
+    structure: analyzeStructure(documents),
+  };
+}
+
+function styleThresholdsFor(documents, fallbackFamilies) {
+  const fallbackThresholds = defaultStyleThresholds();
+  const distancesByFamily = Object.fromEntries(Object.keys(fallbackFamilies).map((family) => [family, []]));
+
+  if (documents.length >= 2) {
+    for (let index = 0; index < documents.length; index += 1) {
+      const referenceDocuments = documents.filter((_, candidateIndex) => candidateIndex !== index);
+      const referenceFamilies = analyzeFeatureFamilies(referenceDocuments);
+      const heldoutFamilies = analyzeFeatureFamilies([documents[index]]);
+      for (const family of Object.keys(fallbackFamilies)) {
+        distancesByFamily[family].push(distanceByFamily(
+          family,
+          referenceFamilies[family].features,
+          heldoutFamilies[family].features,
+        ));
+      }
+    }
+  }
+
+  const families = {};
+  for (const family of Object.keys(fallbackFamilies)) {
+    const observations = distancesByFamily[family];
+    const observedThreshold = observations.length > 0 ? percentile(observations, 0.9) : 0;
+    const fallback = fallbackThresholds[family].threshold;
+    families[family] = {
+      threshold: Math.max(0.01, Math.min(0.95, observedThreshold || fallback)),
+      observations: observations.length,
+      stability: stabilityFromDistances(observations),
+    };
+  }
+
+  return {
+    method: "leave-one-out-cosine-delta",
+    references: STYLOMETRIC_REFERENCES,
+    families,
+  };
+}
 
 function writeVoicePackV2(outDir, profile) {
   fs.mkdirSync(outDir, { recursive: true });

package/src/v2/review.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { parseDocument } from "./document-model.js";
 import { buildVoiceProfileV2, loadVoicePackV2 } from "./profile.js";
-import { clampScore } from "./text-utils.js";
+import { familyDiagnosticsFor, styleDistanceFromDiagnostics } from "./stylometry.js";
 
 const REVIEW_MODES = {
   loose: {
@@ -48,11 +48,12 @@ export function reviewVoiceDraftV2({ file, voice, cwd = process.cwd(), mode = "b
     };
   }
 
-  const familyScores = scoreFamilies(sourceProfile, draftProfile);
-  const distance = Math.round(Object.values(familyScores).reduce((sum, score) => sum + (100 - score), 0) / Object.keys(familyScores).length);
+  const familyDiagnostics = familyDiagnosticsFor(sourceProfile, draftProfile);
+  const familyScores = Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.score]));
+  const distance = styleDistanceFromDiagnostics(familyDiagnostics);
   const findings = reviewFindings(sourceProfile, draftProfile, familyScores, reviewMode);
   const fit = {
-    band: fitBand(distance, findings),
+    band: fitBand(distance, findings, familyDiagnostics),
     distance,
   };
 
@@ -63,6 +64,9 @@ export function reviewVoiceDraftV2({ file, voice, cwd = process.cwd(), mode = "b
       mode: reviewMode,
       fit,
       familyScores,
+      familyDistances: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.distance])),
+      familyDrift: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.drift])),
+      thresholds: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.threshold])),
       corpusConfidence: sourceProfile.source.confidence,
     },
     findings,
@@ -101,57 +105,6 @@ export function renderVoiceReviewV2(result) {
   return lines.join("\n");
 }
 
-function scoreFamilies(source, draft) {
-  return {
-    rhythm: rhythmScore(source.families.rhythm.features, draft.families.rhythm.features),
-    lexical: lexicalScore(source.families.lexical.features, draft.families.lexical.features),
-    register: source.families.register.features.primary.value === draft.families.register.features.primary.value ? 90 : 58,
-    discourse: transitionScore(source.families.discourse.features.transitionRates, draft.families.discourse.features.transitionRates),
-    rhetoricalShape: sequenceScore(source.families.rhetoricalShape.features.openingMoves, draft.families.rhetoricalShape.features.openingMoves),
-    evidence: evidenceScore(source.families.evidence.features, draft.families.evidence.features),
-    structure: sequenceScore(source.families.structure.features.openingMoves, draft.families.structure.features.openingMoves),
-  };
-}
-
-function rhythmScore(source, draft) {
-  const sentenceDelta = Math.abs(source.sentenceWords.median - draft.sentenceWords.median);
-  const paragraphDelta = Math.abs(source.paragraphWords.median - draft.paragraphWords.median);
-  return clampScore(100 - sentenceDelta * 4 - paragraphDelta * 0.6);
-}
-
-function lexicalScore(source, draft) {
-  const ratioDelta = Math.abs(source.vocabularyRichness.contentTypeTokenRatio - draft.vocabularyRichness.contentTypeTokenRatio);
-  const wordLengthDelta = Math.abs(source.wordLength.median - draft.wordLength.median);
-  return clampScore(100 - ratioDelta * 100 - wordLengthDelta * 8);
-}
-
-function transitionScore(source, draft) {
-  const keys = Array.from(new Set([...Object.keys(source), ...Object.keys(draft)]));
-  const delta = keys.reduce((sum, key) => sum + Math.abs((source[key] ?? 0) - (draft[key] ?? 0)), 0);
-  return clampScore(100 - delta * 150);
-}
-
-function sequenceScore(source, draft) {
-  if (source.length === 0 || draft.length === 0) {
-    return 100;
-  }
-  let matches = 0;
-  for (let index = 0; index < Math.min(source.length, draft.length); index += 1) {
-    if (source[index] === draft[index]) {
-      matches += 1;
-    } else if (source.includes(draft[index]) || draft.includes(source[index])) {
-      matches += 0.5;
-    }
-  }
-  return clampScore(100 * matches / Math.min(source.length, draft.length));
-}
-
-function evidenceScore(source, draft) {
-  const rateDelta = Math.max(0, source.evidenceSentenceRate - draft.evidenceSentenceRate);
-  const unsupportedDelta = Math.max(0, draft.unsupportedClaimRate - source.unsupportedClaimRate);
-  return clampScore(100 - rateDelta * 180 - unsupportedDelta * 180);
-}
-
 function reviewFindings(source, draft, scores, mode) {
   const modeConfig = REVIEW_MODES[mode];
   if (source.source?.confidence?.band === "weak" || !modeConfig.findingThresholds) {
@@ -196,11 +149,12 @@ function normalizeReviewMode(mode) {
   return normalized;
 }
 
-function fitBand(distance, findings) {
-  if (findings.some((finding) => finding.priority === "review") || distance >= 35) {
+function fitBand(distance, findings, familyDiagnostics) {
+  const maxDrift = Math.max(0, ...Object.values(familyDiagnostics).map((item) => item.drift));
+  if (findings.some((finding) => finding.priority === "review") || distance >= 35 || maxDrift >= 1.25) {
     return "drift";
   }
-  if (findings.length > 0 || distance >= 20) {
+  if (findings.length > 0 || distance >= 20 || maxDrift > 0) {
     return "watch";
   }
   return "close";