dravoice 0.1.0

package/src/v2/brief.js

@@ -0,0 +1,146 @@
+import fs from "node:fs";
+import path from "node:path";
+import { evidenceTypes } from "./analyzers/evidence.js";
+import { parseDocument } from "./document-model.js";
+import { loadVoicePackV2 } from "./profile.js";
+
+export function voiceArticleBriefV2({ voice, topic, evidence, cwd = process.cwd() }) {
+  const profile = typeof voice === "string" ? loadVoicePackV2(resolvePath(cwd, voice)) : voice;
+  const evidenceResult = evidence ? evidenceAnchorsFromFile({ evidence, cwd }) : {
+    source: null,
+    anchors: [],
+  };
+
+  return {
+    schemaVersion: 2,
+    generatedBy: "dravoice-v2-brief",
+    topic,
+    voice: {
+      corpusConfidence: profile.source.confidence,
+      sourceFileCount: profile.source.documentCount,
+      sourceWordCount: profile.source.wordCount,
+      primaryRegister: profile.families.register.features.primary.value,
+      evidenceSentenceRate: profile.families.evidence.features.evidenceSentenceRate,
+      featureFamilies: Object.keys(profile.families),
+      draftingRules: profile.guidance.draftingRules.slice(0, 5),
+    },
+    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),
+    voiceCautions: [
+      ...profile.guidance.avoid,
+      "Mark unsupported claims as [specific evidence needed] instead of inventing proof.",
+    ].slice(0, 5),
+  };
+}
+
+export function renderVoiceBriefV2(brief) {
+  const lines = [
+    `# Article Brief: ${brief.topic}`,
+    "",
+    "## Voice Source",
+    "",
+    `- Corpus confidence: ${capitalize(brief.voice.corpusConfidence.band)} - ${brief.voice.corpusConfidence.message}`,
+    `- Source files: ${brief.voice.sourceFileCount}`,
+    `- Primary register: ${brief.voice.primaryRegister}`,
+    `- Evidence sentence rate: ${brief.voice.evidenceSentenceRate}`,
+    "",
+    "## Working Thesis",
+    "",
+    `- ${brief.workingThesis}`,
+    "",
+    "## Evidence Anchors",
+    "",
+  ];
+
+  if (brief.evidence.anchors.length) {
+    for (const item of brief.evidence.anchors) {
+      const typeList = item.types.length ? ` (${item.types.join(", ")})` : "";
+      lines.push(`- ${brief.evidence.source}:${item.line}${typeList} - ${item.text}`);
+    }
+  } else {
+    lines.push("- [specific evidence needed] Add notes, dates, quotes, examples, or source links before drafting broad claims.");
+  }
+
+  lines.push("", "## Missing Evidence", "");
+  lines.push(...brief.missingEvidence.map((item) => `- ${item}`));
+
+  lines.push("", "## Outline", "");
+  lines.push(...brief.outline.map((item, index) => `${index + 1}. ${item}`));
+
+  lines.push("", "## Voice Cautions", "");
+  lines.push(...brief.voiceCautions.map((item) => `- ${item}`));
+
+  lines.push(
+    "",
+    "## Drafting Prompt",
+    "",
+    `Write the article about ${brief.topic} using the evidence anchors above. Keep claims close to concrete support, follow the voice cautions, and write [specific evidence needed] anywhere the brief does not supply enough ground.`,
+    "",
+  );
+
+  return lines.join("\n");
+}
+
+function evidenceAnchorsFromFile({ evidence, cwd }) {
+  const evidencePath = resolvePath(cwd, evidence);
+  const contents = fs.readFileSync(evidencePath, "utf8");
+  const document = parseDocument({
+    filePath: evidencePath,
+    rootDir: cwd,
+    contents,
+  });
+
+  return {
+    source: displayPath(evidencePath, cwd),
+    anchors: document.sentences
+      .map((sentence) => ({
+        line: sentence.line,
+        text: sentence.text,
+        types: evidenceTypes(sentence.text),
+      }))
+      .filter((sentence) => sentence.types.length > 0)
+      .slice(0, 8),
+  };
+}
+
+function missingEvidenceFor({ topic, evidenceAnchors }) {
+  const items = [
+    `Add [specific evidence needed] for the central claim about ${topic}.`,
+    "Add [specific evidence needed] for any number, date, quote, source, or example the article depends on.",
+  ];
+  if (evidenceAnchors.length === 0) {
+    items.unshift("No evidence anchors were detected; collect concrete notes before asking for a full draft.");
+  }
+  return items;
+}
+
+function outlineFor(profile) {
+  const opening = profile.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ");
+  const sentenceMedian = profile.families.rhythm.features.sentenceWords.median;
+  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.",
+    "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.`,
+    "Close by returning to the evidence and leaving the reader with a practical handle, not a generic conclusion.",
+  ];
+}
+
+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 capitalize(value) {
+  return String(value ?? "").charAt(0).toUpperCase() + String(value ?? "").slice(1);
+}

package/src/v2/document-model.js

@@ -0,0 +1,260 @@
+import fs from "node:fs";
+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 function loadDocuments({
+  examplesDir,
+  maxFiles = DEFAULT_MAX_FILES,
+  maxFileBytes = DEFAULT_MAX_FILE_BYTES,
+  maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES,
+}) {
+  const root = path.resolve(examplesDir);
+  const files = walkVoiceFiles(root);
+  if (files.length === 0) {
+    throw new Error(`No Markdown, MDX, or text examples found at ${examplesDir}`);
+  }
+  if (files.length > maxFiles) {
+    throw new Error(`Corpus contains ${files.length} voice files, more than ${maxFiles} voice file(s) allowed.`);
+  }
+
+  let totalBytes = 0;
+  return files.map((filePath) => {
+    const stats = fs.statSync(filePath);
+    if (stats.size > maxFileBytes) {
+      throw new Error(`Voice file ${displayPath(filePath, root)} exceeds the ${maxFileBytes} byte limit.`);
+    }
+    totalBytes += stats.size;
+    if (totalBytes > maxTotalBytes) {
+      throw new Error(`Voice corpus exceeds the ${maxTotalBytes} byte total limit.`);
+    }
+    const contents = fs.readFileSync(filePath, "utf8");
+    if (looksBinary(contents)) {
+      throw new Error(`Voice file ${displayPath(filePath, root)} looks like binary-looking text and cannot be analyzed.`);
+    }
+    return parseDocument({
+      filePath,
+      rootDir: root,
+      contents,
+    });
+  });
+}
+
+export function parseDocument({ filePath, rootDir = process.cwd(), contents }) {
+  const relative = displayPath(filePath, rootDir);
+  const lines = String(contents ?? "").split(/\r?\n/);
+  const headings = [];
+  const blocks = [];
+  let currentHeading = null;
+  let currentParagraph = null;
+  let inFence = false;
+  let inFrontmatter = lines[0]?.trim() === "---";
+  let inHtmlComment = false;
+
+  const flushParagraph = () => {
+    if (currentParagraph?.lines.length) {
+      blocks.push(currentParagraph);
+    }
+    currentParagraph = null;
+  };
+
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1;
+    const trimmed = line.trim();
+
+    if (inHtmlComment) {
+      if (trimmed.includes("-->")) {
+        inHtmlComment = false;
+      }
+      return;
+    }
+
+    if (inFrontmatter) {
+      if (index > 0 && trimmed === "---") {
+        inFrontmatter = false;
+      }
+      return;
+    }
+
+    if (/^(```|~~~)/.test(trimmed)) {
+      flushParagraph();
+      inFence = !inFence;
+      return;
+    }
+
+    if (trimmed.startsWith("<!--")) {
+      flushParagraph();
+      if (!trimmed.includes("-->")) {
+        inHtmlComment = true;
+      }
+      return;
+    }
+
+    if (inFence || !trimmed || isMdxScaffold(trimmed) || isTableLine(trimmed) || isJsxLike(trimmed)) {
+      if (!trimmed) {
+        flushParagraph();
+      }
+      return;
+    }
+
+    const headingMatch = /^(#{1,6})\s+(.+)$/.exec(trimmed);
+    if (headingMatch) {
+      flushParagraph();
+      currentHeading = {
+        id: `h${headings.length + 1}`,
+        depth: headingMatch[1].length,
+        text: stripMarkdown(headingMatch[2]).trim(),
+        line: lineNumber,
+      };
+      headings.push(currentHeading);
+      return;
+    }
+
+    const blockType = blockTypeFor(trimmed);
+    const text = stripMarkdown(trimmed.replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, "").replace(/^>\s+/, ""));
+    if (blockType === "paragraph") {
+      if (!currentParagraph) {
+        currentParagraph = makeBlock({ type: "paragraph", line: lineNumber, heading: currentHeading });
+      }
+      currentParagraph.lines.push(text);
+      return;
+    }
+
+    flushParagraph();
+    blocks.push({
+      ...makeBlock({ type: blockType, line: lineNumber, heading: currentHeading }),
+      lines: [text],
+    });
+  });
+  flushParagraph();
+
+  const paragraphs = blocks.map(blockToParagraph).filter((paragraph) => paragraph.text);
+  const sentences = paragraphs.flatMap(paragraphToSentences);
+  return {
+    file: relative,
+    path: filePath,
+    headings,
+    sections: buildSections(headings, blocks),
+    blocks,
+    paragraphs,
+    sentences,
+    wordCount: sentences.reduce((sum, sentence) => sum + sentence.tokens.length, 0),
+    text: paragraphs.map((paragraph) => paragraph.text).join("\n\n"),
+  };
+}
+
+function makeBlock({ type, line, heading }) {
+  return {
+    type,
+    line,
+    heading: heading?.text ?? null,
+    headingId: heading?.id ?? null,
+    headingDepth: heading?.depth ?? 0,
+    lines: [],
+  };
+}
+
+function blockTypeFor(trimmed) {
+  if (/^>\s+/.test(trimmed)) {
+    return "quote";
+  }
+  if (/^[-*]\s+/.test(trimmed)) {
+    return "list";
+  }
+  if (/^\d+[.)]\s+/.test(trimmed)) {
+    return "list";
+  }
+  return "paragraph";
+}
+
+function buildSections(headings, blocks) {
+  if (headings.length === 0) {
+    return [{ heading: null, blocks }];
+  }
+  return headings.map((heading, index) => {
+    const nextBoundary = headings.slice(index + 1).find((candidate) => candidate.depth <= heading.depth);
+    return {
+      heading,
+      blocks: blocks.filter((block) =>
+        block.line > heading.line &&
+        (!nextBoundary || block.line < nextBoundary.line)
+      ),
+    };
+  });
+}
+
+function blockToParagraph(block) {
+  return {
+    type: block.type,
+    line: block.line,
+    heading: block.heading,
+    headingId: block.headingId,
+    text: block.lines.join(" ").replace(/\s+/g, " ").trim(),
+  };
+}
+
+function paragraphToSentences(paragraph) {
+  return splitSentences(paragraph.text).map((text, offset) => ({
+    text,
+    normalized: normalizeText(text),
+    line: paragraph.line + offset,
+    blockType: paragraph.type,
+    heading: paragraph.heading,
+    headingId: paragraph.headingId,
+    tokens: tokenizeWords(text),
+  }));
+}
+
+function stripMarkdown(text) {
+  return text
+    .replace(/\*\*/g, "")
+    .replace(/__+/g, "")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+}
+
+function isJsxLike(trimmed) {
+  return /^<\/?[A-Za-z][^>]*>/.test(trimmed) || /^<[A-Za-z][^>]*\/>$/.test(trimmed);
+}
+
+function isMdxScaffold(trimmed) {
+  return /^(?:import|export)\s/.test(trimmed);
+}
+
+function isTableLine(trimmed) {
+  return /^\|.*\|$/.test(trimmed);
+}
+
+function looksBinary(contents) {
+  return String(contents ?? "").includes("\0");
+}
+
+function walkVoiceFiles(rootDir) {
+  const result = [];
+  if (!fs.existsSync(rootDir)) {
+    return result;
+  }
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const fullPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      if (![".git", "node_modules", "dist", "build", "__pycache__", "prompts", "voice-pack", "dravoice-voice"].includes(entry.name)) {
+        result.push(...walkVoiceFiles(fullPath));
+      }
+    } else if (VOICE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+      result.push(fullPath);
+    }
+  }
+  return result;
+}
+
+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("/");
+}

package/src/v2/inspect.js

@@ -0,0 +1,67 @@
+export function renderInspectV2(profile) {
+  const lines = [
+    "Dravoice V2 Profile",
+    "",
+    `Source: ${profile.source.documentCount} document(s), ${profile.source.wordCount} words, ${profile.source.sentenceCount} sentences`,
+    `Corpus confidence: ${capitalize(profile.source.confidence.band)} - ${profile.source.confidence.message}`,
+    "",
+    "Feature families:",
+  ];
+
+  for (const [name, family] of Object.entries(profile.families)) {
+    lines.push(`- ${name}: ${family.confidence}`);
+    if (family.warnings.length) {
+      for (const warning of family.warnings) {
+        lines.push(`  warning: ${warning}`);
+      }
+    }
+  }
+
+  lines.push("", "Feature details:");
+  for (const [name, family] of Object.entries(profile.families)) {
+    lines.push(`- ${name}: ${featureSummary(name, family.features)}`);
+    if (family.revisionHandles?.length) {
+      lines.push("  Revision handles:");
+      for (const handle of family.revisionHandles) {
+        lines.push(`  - ${handle}`);
+      }
+    }
+  }
+
+  lines.push("", "Guidance:");
+  for (const rule of profile.guidance.draftingRules) {
+    lines.push(`- ${rule}`);
+  }
+
+  lines.push("");
+  return `${lines.join("\n")}`;
+}
+
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function featureSummary(name, features) {
+  if (name === "rhythm") {
+    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}`;
+  }
+  if (name === "register") {
+    return `primary=${features.primary.value} (${features.primary.score}); 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}`;
+  }
+  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"}`;
+  }
+  if (name === "evidence") {
+    return `evidenceSentenceRate=${features.evidenceSentenceRate}; claimSentenceRate=${features.claimSentenceRate}; 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 JSON.stringify(features);
+}

package/src/v2/profile.js

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+import { analyzeDiscourse } from "./analyzers/discourse.js";
+import { analyzeEvidence } from "./analyzers/evidence.js";
+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";
+
+export function learnVoicePackV2({ examplesDir, outDir }) {
+  const documents = loadDocuments({ examplesDir });
+  const profile = buildVoiceProfileV2({ documents });
+  if (outDir) {
+    writeVoicePackV2(outDir, profile);
+  }
+  return profile;
+}
+
+export function loadVoicePackV2(voiceDir) {
+  const profilePath = path.join(voiceDir, "profile.json");
+  if (!fs.existsSync(profilePath)) {
+    throw new Error(`No Dravoice V2 profile found at ${voiceDir}`);
+  }
+  const profile = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+  if (profile.schemaVersion !== 2) {
+    throw new Error(`Expected a Dravoice V2 profile at ${voiceDir}; found schemaVersion ${profile.schemaVersion ?? "unknown"}.`);
+  }
+  return profile;
+}
+
+export function buildVoiceProfileV2({ documents }) {
+  const source = sourceSummary(documents);
+  const families = {
+    rhythm: analyzeRhythm(documents),
+    lexical: analyzeLexical(documents),
+    register: analyzeRegister(documents),
+    discourse: analyzeDiscourse(documents),
+    rhetoricalShape: analyzeRhetoricalShape(documents),
+    evidence: analyzeEvidence(documents),
+    structure: analyzeStructure(documents),
+  };
+
+  return {
+    schemaVersion: 2,
+    generatedBy: "dravoice-v2",
+    tool: { name: "Dravoice", cli: "drav" },
+    source,
+    families,
+    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),
+      },
+      minimumDraftSize: {
+        words: source.confidence.band === "weak" ? 25 : 35,
+        sentences: source.confidence.band === "weak" ? 3 : 4,
+      },
+    },
+  };
+}
+
+function writeVoicePackV2(outDir, profile) {
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(path.join(outDir, "profile.json"), `${JSON.stringify(profile, null, 2)}\n`, "utf8");
+  fs.writeFileSync(
+    path.join(outDir, ".dravoice.yml"),
+    [
+      "schemaVersion: 2",
+      "generatedBy: dravoice-v2",
+      `confidence: ${profile.source.confidence.band}`,
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+}
+
+function sourceSummary(documents) {
+  const wordCount = documents.reduce((sum, document) => sum + document.wordCount, 0);
+  const sentenceCount = documents.reduce((sum, document) => sum + document.sentences.length, 0);
+  const confidence = confidenceFor(documents.length, sentenceCount, wordCount);
+  return {
+    files: documents.map((document, index) => ({
+      id: `source-${index + 1}`,
+      extension: path.extname(document.path || document.file).toLowerCase() || ".txt",
+      wordCount: document.wordCount,
+      sentenceCount: document.sentences.length,
+    })),
+    documentCount: documents.length,
+    wordCount,
+    sentenceCount,
+    genres: [],
+    confidence,
+  };
+}
+
+function confidenceFor(documentCount, sentenceCount, wordCount) {
+  if (documentCount >= 10 && sentenceCount >= 80 && wordCount >= 5000) {
+    return { band: "deep", message: "Enough material for stricter family-level review." };
+  }
+  if (documentCount >= 5 && sentenceCount >= 30) {
+    return { band: "strong", message: "Enough examples for stable family-level review." };
+  }
+  if (documentCount >= 3 && sentenceCount >= 10) {
+    return { band: "usable", message: "Enough text for prompt guidance and cautious review." };
+  }
+  return { band: "weak", message: "Limited corpus; use findings as weak signals." };
+}
+
+function guidanceFor({ source, families }) {
+  const primaryRegister = families.register.features.primary.value;
+  const evidenceRate = families.evidence.features.evidenceSentenceRate;
+  const sentenceMedian = families.rhythm.features.sentenceWords.median;
+  const opening = families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ");
+
+  const draftingRules = [
+    `Keep sentence pacing near the learned median of ${sentenceMedian} words when it fits the draft.`,
+    `Use ${primaryRegister} register as the default genre signal unless the piece intentionally changes genre.`,
+    evidenceRate > 0.35
+      ? "Anchor broad claims with concrete scenes, numbers, quotes, citations, or specific examples."
+      : "Do not force evidence density higher than the source corpus supports.",
+    opening
+      ? `Prefer opening moves compatible with: ${opening}.`
+      : "Start from the article's real subject rather than generic positioning.",
+  ];
+
+  return {
+    summary: [
+      `Local Dravoice V2 profile from ${source.documentCount} document(s), ${source.wordCount} words, confidence ${source.confidence.band}.`,
+      `Primary register signal: ${primaryRegister}.`,
+    ],
+    draftingRules,
+    avoid: [
+      "Do not treat topic vocabulary as proof of voice fit.",
+      "Do not claim a draft is or is not the writer's true voice.",
+      "Do not invent concrete evidence to satisfy a style finding.",
+    ],
+    examples: [],
+  };
+}
+
+function toleranceFor(band, deep, strong, weak) {
+  if (band === "deep") {
+    return deep;
+  }
+  if (band === "strong") {
+    return strong;
+  }
+  return weak;
+}

package/src/v2/prompt.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadVoicePackV2 } from "./profile.js";
+
+export function voicePromptPackV2({ voice, format = "agents", outPath }) {
+  const profile = typeof voice === "string" ? loadVoicePackV2(voice) : voice;
+  if (format !== "agents" && format !== "claude" && format !== "system") {
+    throw new Error(`Unsupported prompt format: ${format}`);
+  }
+  const rendered = renderPrompt(profile, format);
+  if (outPath) {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, rendered, "utf8");
+  }
+  return rendered;
+}
+
+function renderPrompt(profile, format) {
+  const header = {
+    agents: "# Dravoice V2 Writing Guidance",
+    claude: "# CLAUDE.md guidance for Dravoice V2",
+    system: "System writing guidance: Dravoice V2",
+  }[format];
+  const preface = {
+    agents: "Use this as local, inspectable drafting guidance from the writer's own corpus. It is not an AI detector or a license to imitate a third party.",
+    claude: "Use these project-local voice notes when drafting or reviewing prose for this repository. Treat them as guidance, not identity proof.",
+    system: "Follow these local voice constraints when writing prose. Do not expose private source text or claim authorship identity from them.",
+  }[format];
+  const lines = [
+    header,
+    "",
+    preface,
+    "",
+    "## Summary",
+    "",
+    ...profile.guidance.summary.map((item) => `- ${item}`),
+    "",
+    "## Feature Families",
+    "",
+  ];
+
+  for (const [name, family] of Object.entries(profile.families)) {
+    lines.push(`- ${name}: ${family.confidence} confidence; ${family.revisionHandles[0]}`);
+  }
+
+  lines.push("", "## Drafting Rules", "");
+  for (const rule of profile.guidance.draftingRules) {
+    lines.push(`- ${rule}`);
+  }
+
+  lines.push("", "## Avoid", "");
+  for (const item of profile.guidance.avoid) {
+    lines.push(`- ${item}`);
+  }
+
+  if (profile.guidance.examples.length) {
+    lines.push("", "## Source-Backed Examples", "");
+    for (const example of profile.guidance.examples) {
+      lines.push(`- ${example}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}