dravoice 0.1.3 → 0.2.0

package/src/v2/benchmark.js

@@ -81,6 +81,40 @@ export function prepareVoiceBenchmark({ examplesDir, topic, outDir, seed = 1, cw
   return benchmark;
 }
 
+export function prepareVoiceBenchmarkRuns({ examplesDir, topic, outDir, seed = 1, runs = 3, cwd = process.cwd() }) {
+  const runCount = normalizeRunCount(runs);
+  const normalizedSeed = normalizeSeed(seed);
+  const root = path.resolve(resolvePath(cwd, outDir));
+  const preparedRuns = [];
+  for (let index = 0; index < runCount; index += 1) {
+    const runSeed = (normalizedSeed + index) >>> 0;
+    const runName = `run-${String(index + 1).padStart(3, "0")}`;
+    const benchmark = prepareVoiceBenchmark({
+      examplesDir,
+      topic,
+      outDir: path.join(root, runName),
+      seed: runSeed,
+      cwd,
+    });
+    preparedRuns.push({
+      index: index + 1,
+      name: runName,
+      seed: runSeed,
+      path: runName,
+      corpusFileCount: benchmark.corpus.fileCount,
+    });
+  }
+  const manifest = {
+    schemaVersion: BENCHMARK_SCHEMA_VERSION,
+    generatedBy: `${GENERATED_BY}-runs`,
+    topic,
+    runs: preparedRuns,
+    minimumRunsRecommended: Math.max(3, runCount),
+  };
+  writeUtf8FileSafely(path.join(root, "benchmark-runs.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
 export function scoreVoiceBenchmark({ runDir, judgePath, judgeFile, judge, cwd = process.cwd() }) {
   const root = path.resolve(resolvePath(cwd, runDir));
   const resolvedJudgePath = judgePath ?? judgeFile ?? judge;
@@ -145,6 +179,15 @@ export function renderBenchmarkReport(scores) {
     lines.push(`Deterministic provisional leader: ${scores.deterministicWinner.draft} (${scores.deterministicWinner.label})`);
   }
   lines.push("Single benchmark run is directional, not proof; compare repeated runs and family diagnostics before deciding.");
+  if (scores.comparison) {
+    lines.push("");
+    lines.push(`Deterministic comparison: ${scores.comparison.deterministicLeader} leads by ${scores.comparison.deterministicMargin} point(s).`);
+    lines.push(`Repeated runs recommended: ${scores.comparison.repeatedRunsRecommended ? "yes" : "no"}.`);
+  }
+  if (scores.repeatSummary) {
+    lines.push(`Minimum repeat runs recommended: ${scores.repeatSummary.minimumRunsRecommended}.`);
+    lines.push(`Suggested next seeds: ${scores.repeatSummary.nextSeeds.join(", ")}.`);
+  }
 
   for (const key of ["baseline", "voiceAssisted"]) {
     const draft = scores.drafts[key];
@@ -217,12 +260,52 @@ function benchmarkScores({ benchmark, baselineReview, voiceReview, judge, judgeP
       baseline,
       voiceAssisted,
     },
+    comparison: benchmarkComparison({ baseline, voiceAssisted }),
+    repeatSummary: repeatSummaryFor(benchmark.seed),
     deterministicWinner,
     winner,
     exitCode: 0,
   };
 }
 
+function repeatSummaryFor(seed) {
+  const normalized = normalizeSeed(seed);
+  return {
+    minimumRunsRecommended: 3,
+    nextSeeds: [1, 2, 3].map((offset) => (normalized + offset) >>> 0),
+    reason: "Compare multiple topics, blind mappings, and draft pairs before treating benchmark results as product evidence.",
+  };
+}
+
+function normalizeRunCount(runs) {
+  const value = String(runs);
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`Invalid runs value: ${runs}`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 50) {
+    throw new Error("Benchmark runs must be an integer between 1 and 50.");
+  }
+  return parsed;
+}
+
+function benchmarkComparison({ baseline, voiceAssisted }) {
+  const margin = roundHalfUp(Math.abs(
+    voiceAssisted.deterministic.voiceFit - baseline.deterministic.voiceFit,
+  ), 2);
+  const deterministicLeader = voiceAssisted.deterministic.voiceFit === baseline.deterministic.voiceFit
+    ? "tie"
+    : voiceAssisted.deterministic.voiceFit > baseline.deterministic.voiceFit
+      ? "voice-assisted"
+      : "baseline";
+  return {
+    deterministicLeader,
+    deterministicMargin: margin,
+    repeatedRunsRecommended: true,
+    caution: "Single benchmark runs are directional; repeat with more topics and draft pairs before making product claims.",
+  };
+}
+
 function draftScore({ key, name, label, review, judge }) {
   const deterministic = deterministicScore(review);
   const judgeDraft = judge ? normalizeJudgeDraft(judge.drafts?.[label], label) : null;

package/src/v2/brief.js

@@ -27,7 +27,7 @@ export function voiceArticleBriefV2({ voice, topic, evidence, cwd = process.cwd(
     workingThesis: `Draft a grounded article about ${topic}. Let the supplied evidence set the size of each claim before broadening the lesson.`,
     evidence: evidenceResult,
     missingEvidence: missingEvidenceFor({ topic, evidenceAnchors: evidenceResult.anchors }),
-    outline: outlineFor(profile),
+    outline: outlineFor(profile, topic),
     voiceCautions: [
       ...profile.guidance.avoid,
       "Mark unsupported claims as [specific evidence needed] instead of inventing proof.",
@@ -116,19 +116,53 @@ function missingEvidenceFor({ topic, evidenceAnchors }) {
   return items;
 }
 
-function outlineFor(profile) {
-  const opening = profile.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ");
-  const sentenceMedian = profile.families.rhythm.features.sentenceWords.median;
+function outlineFor(profile, topic = "") {
+  const rhythm = profile.families.rhythm.features.sentenceWords;
+  const seed = topicSeed(topic);
+
+  const openingPatterns = (profile.families.rhetoricalShape.features.openingMovePatterns || [])
+    .map((item) => item.value)
+    .filter(Boolean);
+  const opening = pickSeeded(openingPatterns, seed);
+
+  const sectionShapes = (profile.families.structure.features.sectionOrderPatterns || [])
+    .map((item) => item.value)
+    .filter(Boolean);
+  const sectionShape = pickSeeded(sectionShapes, seed + 1);
+  const headingCount = profile.families.structure.features.headingCount || {};
+
+  const rhythmRange = rhythm.count > 0
+    ? `${rhythm.p25}-${rhythm.p75} words (median ${rhythm.median}, variation ~${rhythm.stdev})`
+    : "a varied range of sentence lengths";
+
   return [
     opening
-      ? `Start from a concrete artifact or observation, keeping the opening shape compatible with: ${opening}.`
-      : "Start from a concrete artifact or observation before making the larger claim.",
+      ? `Start from a concrete artifact or observation; for this piece try the opening shape "${opening}", but do not reuse one opening across articles.`
+      : "Start from a concrete artifact or observation before making the larger claim, varying the opening across pieces.",
     "Name the pressure, question, or practical stakes that make the evidence matter.",
-    `Develop the article in the learned register with sentence pacing near the ${sentenceMedian}-word median where it fits.`,
+    sectionShape
+      ? `Shape the body using a section pattern from the corpus such as "${sectionShape}" (heading count usually ${headingCount.min ?? 0}-${headingCount.max ?? 0}); pick what fits this topic rather than a fixed skeleton.`
+      : "Shape the body to fit this topic; vary sectioning across pieces instead of reusing one skeleton.",
+    `Develop the article in the learned register, mixing short and long sentences across ${rhythmRange} rather than holding a constant cadence.`,
     "Close by returning to the evidence and leaving the reader with a practical handle, not a generic conclusion.",
   ];
 }
 
+function topicSeed(topic) {
+  let hash = 0;
+  for (const char of String(topic ?? "")) {
+    hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
+  }
+  return hash;
+}
+
+function pickSeeded(values, seed) {
+  if (!values.length) {
+    return "";
+  }
+  return values[seed % values.length];
+}
+
 function resolvePath(cwd, value) {
   return path.isAbsolute(value) ? value : path.join(cwd, value);
 }

package/src/v2/doctor.js

@@ -0,0 +1,308 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  DEFAULT_MAX_FILE_BYTES,
+  DEFAULT_MAX_FILES,
+  DEFAULT_MAX_TOTAL_BYTES,
+  VOICE_EXTENSIONS,
+  VOICE_SKIP_DIRS,
+  parseDocument,
+} from "./document-model.js";
+import { buildVoiceProfileV2 } from "./profile.js";
+
+export function diagnoseVoiceCorpusV2({ examplesDir, cwd = process.cwd() }) {
+  const requestedExamples = examplesDir ?? "./articles";
+  const resolvedExamples = resolvePath(cwd, requestedExamples);
+  const displayedExamples = path.isAbsolute(requestedExamples)
+    ? displayPath(resolvedExamples, cwd)
+    : displayPathForCommand(requestedExamples);
+  const baseResult = {
+    schemaVersion: 2,
+    generatedBy: "dravoice-v2-doctor",
+    examples: displayedExamples,
+    status: "needs-work",
+    exitCode: 1,
+    summary: emptySummary(),
+    files: [],
+    unsupportedFiles: [],
+    recommendations: [],
+  };
+
+  if (!fs.existsSync(resolvedExamples)) {
+    return {
+      ...baseResult,
+      recommendations: [
+        "Examples directory is missing.",
+        "Run mkdir -p articles, then copy at least 3 representative .md, .mdx, or .txt pieces into it.",
+        `If your writing lives elsewhere, run drav doctor --examples ${displayPathForCommand(requestedExamples) === "./articles" ? "~/path/to/writing" : displayPathForCommand(requestedExamples)}.`,
+      ],
+    };
+  }
+
+  if (!fs.statSync(resolvedExamples).isDirectory()) {
+    return {
+      ...baseResult,
+      recommendations: [
+        "Examples path is not a directory.",
+        "Point --examples at a folder containing representative .md, .mdx, or .txt pieces.",
+      ],
+    };
+  }
+
+  const discovered = discoverCorpusFiles(resolvedExamples);
+  const validDocuments = [];
+  const files = [];
+  let totalBytes = 0;
+
+  discovered.supportedFiles.forEach((filePath, index) => {
+    const relative = displayPath(filePath, resolvedExamples);
+    const extension = path.extname(filePath).toLowerCase();
+    const record = { path: relative, extension, wordCount: 0, sentenceCount: 0 };
+
+    try {
+      if (index >= DEFAULT_MAX_FILES) {
+        throw new Error(`Corpus contains more than ${DEFAULT_MAX_FILES} voice file(s) allowed.`);
+      }
+      const stats = fs.statSync(filePath);
+      if (stats.size > DEFAULT_MAX_FILE_BYTES) {
+        throw new Error(`Voice file ${relative} exceeds the ${DEFAULT_MAX_FILE_BYTES} byte limit.`);
+      }
+      totalBytes += stats.size;
+      if (totalBytes > DEFAULT_MAX_TOTAL_BYTES) {
+        throw new Error(`Voice corpus exceeds the ${DEFAULT_MAX_TOTAL_BYTES} byte total limit.`);
+      }
+      const contents = fs.readFileSync(filePath, "utf8");
+      if (contents.includes("\0")) {
+        throw new Error(`Voice file ${relative} looks like binary-looking text and cannot be analyzed.`);
+      }
+      const document = parseDocument({ filePath, rootDir: resolvedExamples, contents });
+      record.wordCount = document.wordCount;
+      record.sentenceCount = document.sentences.length;
+      validDocuments.push(document);
+    } catch (error) {
+      record.issue = error.message;
+    }
+
+    files.push(record);
+  });
+
+  const summary = summaryFor(validDocuments);
+  const unsupportedFiles = discovered.unsupportedFiles.map((filePath) => ({
+    path: displayPath(filePath, resolvedExamples),
+    extension: path.extname(filePath).toLowerCase() || null,
+  }));
+  const status = statusFor({ summary, files, supportedCount: discovered.supportedFiles.length });
+
+  return {
+    ...baseResult,
+    status,
+    exitCode: status === "ready" ? 0 : 1,
+    summary,
+    files,
+    unsupportedFiles,
+    recommendations: recommendationsFor({
+      status,
+      summary,
+      files,
+      unsupportedFiles,
+      examples: baseResult.examples,
+    }),
+  };
+}
+
+export function renderCorpusDoctorV2(result) {
+  const lines = [
+    "# Corpus Doctor",
+    "",
+    `Examples: ${result.examples}`,
+    `Status: ${result.status}`,
+    `Documents: ${result.summary.documentCount}`,
+    `Words: ${result.summary.wordCount}`,
+    `Sentences: ${result.summary.sentenceCount}`,
+    `Confidence: ${result.summary.confidence.band} - ${result.summary.confidence.message}`,
+    `Supported files: ${result.files.length}`,
+    `Unsupported files: ${result.unsupportedFiles.length}`,
+    "",
+  ];
+
+  const issueFiles = result.files.filter((file) => file.issue);
+  if (issueFiles.length > 0) {
+    lines.push("File issues:");
+    issueFiles.slice(0, 8).forEach((file) => {
+      lines.push(`- ${file.path}: ${file.issue}`);
+    });
+    if (issueFiles.length > 8) {
+      lines.push(`- ...and ${issueFiles.length - 8} more`);
+    }
+    lines.push("");
+  }
+
+  if (result.unsupportedFiles.length > 0) {
+    lines.push("Unsupported files:");
+    result.unsupportedFiles.slice(0, 8).forEach((file) => {
+      lines.push(`- ${file.path}`);
+    });
+    if (result.unsupportedFiles.length > 8) {
+      lines.push(`- ...and ${result.unsupportedFiles.length - 8} more`);
+    }
+    lines.push("");
+  }
+
+  if (result.summary.quality?.warnings?.length) {
+    lines.push("Corpus quality warnings:");
+    result.summary.quality.warnings.forEach((warning) => {
+      lines.push(`- ${warning}`);
+    });
+    lines.push("");
+  }
+
+  lines.push("Recommendations:");
+  result.recommendations.forEach((item) => {
+    lines.push(`- ${item}`);
+  });
+  lines.push("");
+  lines.push(`Next: ${nextStepFor(result)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+function discoverCorpusFiles(rootDir) {
+  const supportedFiles = [];
+  const unsupportedFiles = [];
+  const stack = [rootDir];
+
+  while (stack.length) {
+    const current = stack.pop();
+    const entries = fs.readdirSync(current, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    const directories = [];
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!VOICE_SKIP_DIRS.has(entry.name)) {
+          directories.push(fullPath);
+        }
+      } else if (entry.isFile()) {
+        if (VOICE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+          supportedFiles.push(fullPath);
+        } else {
+          unsupportedFiles.push(fullPath);
+        }
+      }
+    }
+    stack.push(...directories.reverse());
+  }
+
+  return {
+    supportedFiles: supportedFiles.sort((left, right) => left.localeCompare(right)),
+    unsupportedFiles: unsupportedFiles.sort((left, right) => left.localeCompare(right)),
+  };
+}
+
+function summaryFor(documents) {
+  if (documents.length === 0) {
+    return emptySummary();
+  }
+  const source = buildVoiceProfileV2({ documents }).source;
+  return {
+    documentCount: source.documentCount,
+    wordCount: source.wordCount,
+    sentenceCount: source.sentenceCount,
+    confidence: source.confidence,
+    quality: source.quality,
+  };
+}
+
+function emptySummary() {
+  return {
+    documentCount: 0,
+    wordCount: 0,
+    sentenceCount: 0,
+    confidence: {
+      band: "weak",
+      message: "No usable source documents were found.",
+    },
+    quality: {
+      lengthSpread: { minWords: 0, maxWords: 0, minSentences: 0, maxSentences: 0 },
+      duplicateGroups: 0,
+      warnings: [],
+    },
+  };
+}
+
+function statusFor({ summary, files, supportedCount }) {
+  const issueCount = files.filter((file) => file.issue).length;
+  if (supportedCount === 0 || summary.documentCount === 0) {
+    return "needs-work";
+  }
+  if (issueCount > 0) {
+    return "needs-work";
+  }
+  if (summary.documentCount >= 3 && summary.sentenceCount >= 10) {
+    return "ready";
+  }
+  return "weak";
+}
+
+function recommendationsFor({ status, summary, files, unsupportedFiles, examples }) {
+  const recommendations = [];
+  const issueCount = files.filter((file) => file.issue).length;
+
+  if (status === "ready") {
+    recommendations.push("Corpus is ready for cautious profile learning.");
+    if (summary.quality?.warnings?.length) {
+      recommendations.push("Review corpus quality warnings before trusting strict calibration.");
+    }
+    recommendations.push(`Run drav init --examples ${examples}.`);
+    return recommendations;
+  }
+
+  if (files.length === 0) {
+    recommendations.push("Convert or copy your writing into Markdown, MDX, or plain text.");
+  }
+
+  if (summary.documentCount < 3) {
+    const remaining = 3 - summary.documentCount;
+    recommendations.push(`Add at least ${remaining} more representative long-form piece(s).`);
+  }
+
+  if (summary.sentenceCount < 10) {
+    recommendations.push("Use longer source pieces; Dravoice needs at least 10 total sentences for a ready corpus.");
+  }
+
+  if (issueCount > 0) {
+    recommendations.push("Fix or remove supported files with issues, then rerun drav doctor.");
+  }
+
+  if (unsupportedFiles.length > 0) {
+    recommendations.push("Supported extensions: .md, .mdx, .txt.");
+  }
+
+  if (recommendations.length === 0) {
+    recommendations.push("Add more representative long-form writing, then rerun drav doctor.");
+  }
+
+  return recommendations;
+}
+
+function nextStepFor(result) {
+  if (result.status === "ready") {
+    return `drav init --examples ${result.examples}`;
+  }
+  return "add more writing, then run drav doctor";
+}
+
+function resolvePath(cwd, value) {
+  return path.isAbsolute(value) ? value : path.join(cwd, value);
+}
+
+function displayPath(filePath, rootDir) {
+  const relative = path.relative(rootDir, filePath);
+  if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return relative.split(path.sep).join("/");
+  }
+  return filePath.split(path.sep).join("/");
+}
+
+function displayPathForCommand(value) {
+  return String(value).replace(/[\\/]+/g, "/");
+}

package/src/v2/document-model.js

@@ -3,9 +3,10 @@ import path from "node:path";
 import { normalizeText, splitSentences, tokenizeWords } from "./text-utils.js";
 
 export const VOICE_EXTENSIONS = new Set([".md", ".mdx", ".txt"]);
-const DEFAULT_MAX_FILES = 500;
-const DEFAULT_MAX_FILE_BYTES = 1024 * 1024;
-const DEFAULT_MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+export const VOICE_SKIP_DIRS = new Set([".git", "node_modules", "dist", "build", "__pycache__", "prompts", "voice-pack", "dravoice-voice"]);
+export const DEFAULT_MAX_FILES = 500;
+export const DEFAULT_MAX_FILE_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_TOTAL_BYTES = 20 * 1024 * 1024;
 
 export function loadDocuments({
   examplesDir,
@@ -56,6 +57,8 @@ export function parseDocument({ filePath, rootDir = process.cwd(), contents }) {
   let inFrontmatter = lines[0]?.trim() === "---";
   let inHtmlComment = false;
   let jsxBlockTag = null;
+  let mdxScaffoldDepth = 0;
+  let mdxExpressionDepth = 0;
 
   const flushParagraph = () => {
     if (currentParagraph?.lines.length) {
@@ -85,6 +88,16 @@ export function parseDocument({ filePath, rootDir = process.cwd(), contents }) {
       return;
     }
 
+    if (mdxScaffoldDepth > 0) {
+      mdxScaffoldDepth = Math.max(0, mdxScaffoldDepth + syntaxDepthDelta(trimmed));
+      return;
+    }
+
+    if (mdxExpressionDepth > 0) {
+      mdxExpressionDepth = Math.max(0, mdxExpressionDepth + curlyDepthDelta(trimmed));
+      return;
+    }
+
     if (inHtmlComment) {
       if (trimmed.includes("-->")) {
         inHtmlComment = false;
@@ -114,7 +127,19 @@ export function parseDocument({ filePath, rootDir = process.cwd(), contents }) {
       return;
     }
 
-    if (!trimmed || isMdxScaffold(trimmed) || isTableLine(trimmed) || isJsxLike(trimmed)) {
+    if (isMdxScaffold(trimmed)) {
+      flushParagraph();
+      mdxScaffoldDepth = Math.max(0, syntaxDepthDelta(trimmed));
+      return;
+    }
+
+    if (mdxExpressionStart(trimmed)) {
+      flushParagraph();
+      mdxExpressionDepth = Math.max(0, curlyDepthDelta(trimmed));
+      return;
+    }
+
+    if (!trimmed || isTableLine(trimmed) || isJsxLike(trimmed)) {
       if (!trimmed) {
         flushParagraph();
       }
@@ -166,6 +191,7 @@ export function parseDocument({ filePath, rootDir = process.cwd(), contents }) {
     sentences,
     wordCount: sentences.reduce((sum, sentence) => sum + sentence.tokens.length, 0),
     text: paragraphs.map((paragraph) => paragraph.text).join("\n\n"),
+    raw: String(contents ?? ""),
   };
 }
 
@@ -277,6 +303,53 @@ function isMdxScaffold(trimmed) {
   return /^(?:import|export)\s/.test(trimmed);
 }
 
+function mdxExpressionStart(trimmed) {
+  return trimmed.startsWith("{") && /[A-Za-z_$][\w$]*\s*[.(]/.test(trimmed);
+}
+
+function syntaxDepthDelta(text) {
+  return curlyDepthDelta(text) + bracketDepthDelta(text) + parenDepthDelta(text);
+}
+
+function curlyDepthDelta(text) {
+  return depthDelta(text, "{", "}");
+}
+
+function bracketDepthDelta(text) {
+  return depthDelta(text, "[", "]");
+}
+
+function parenDepthDelta(text) {
+  return depthDelta(text, "(", ")");
+}
+
+function depthDelta(text, open, close) {
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const previous = text[index - 1];
+    if (char === "'" && !inDouble && previous !== "\\") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (char === "\"" && !inSingle && previous !== "\\") {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (inSingle || inDouble) {
+      continue;
+    }
+    if (char === open) {
+      depth += 1;
+    } else if (char === close) {
+      depth -= 1;
+    }
+  }
+  return depth;
+}
+
 function isTableLine(trimmed) {
   return /^\|.*\|$/.test(trimmed);
 }
@@ -291,7 +364,6 @@ function walkVoiceFiles(rootDir, { maxFiles, excludePaths }) {
     return result;
   }
   const stack = [rootDir];
-  const skipDirs = new Set([".git", "node_modules", "dist", "build", "__pycache__", "prompts", "voice-pack", "dravoice-voice"]);
   while (stack.length) {
     const current = stack.pop();
     if (isExcludedPath(current, excludePaths)) {
@@ -305,7 +377,7 @@ function walkVoiceFiles(rootDir, { maxFiles, excludePaths }) {
         continue;
       }
       if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
+        if (!VOICE_SKIP_DIRS.has(entry.name)) {
           directories.push(fullPath);
         }
       } else if (entry.isFile() && VOICE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {

package/src/v2/inspect.js

@@ -49,7 +49,7 @@ function featureSummary(name, features) {
     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(", ")}`;
+    return `primary=${features.primary.value} (${features.primary.score}); mixedRegister=${features.mixedRegister ? "yes" : "no"}; markerSets=${features.markerSets?.length ?? 0}; alternates=${features.scores.slice(1, 4).map((score) => `${score.value}:${score.score}`).join(", ")}`;
   }
   if (name === "discourse") {
     return `transitionRates=${Object.entries(features.transitionRates).map(([key, value]) => `${key}:${value}`).join(", ")}; sentenceCallbacks=${features.sentenceCallbacks}`;
@@ -61,7 +61,7 @@ function featureSummary(name, features) {
     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}`;
+    return `sectionWords.median=${features.sectionWords.median}; headingCount.median=${features.headingCount.median}; maxHeadingDepth.median=${features.maxHeadingDepth?.median ?? 0}; sectionOrderPatterns=${features.sectionOrderPatterns?.length ?? 0}; listDocumentRate=${features.listDocumentRate}; quoteDocumentRate=${features.quoteDocumentRate}`;
   }
   return JSON.stringify(features);
 }