@poltergeist-ai/cli 0.0.0 → 0.1.5

package/dist/cli.js

@@ -233,31 +233,31 @@ var LANG_MAP = {
 var JS_TS = ["typescript", "javascript"];
 var TS_ONLY = ["typescript"];
 var PATTERN_RULES = [
-  // Imports
-  { category: "import_style", choice: "named_import", pattern: /^import\s+\{/, languages: JS_TS },
-  { category: "import_style", choice: "default_import", pattern: /^import\s+[A-Za-z_$][^\s{]*\s+from/, languages: JS_TS },
-  { category: "import_style", choice: "path_alias", pattern: /from\s+['"][@~]\//, languages: JS_TS },
-  { category: "import_style", choice: "relative_import", pattern: /from\s+['"]\.\.?\//, languages: JS_TS },
-  // Exports
-  { category: "export_style", choice: "named_export", pattern: /^export\s+(?:const|function|class|type|interface|enum)\s/, languages: JS_TS },
-  { category: "export_style", choice: "default_export", pattern: /^export\s+default\b/, languages: JS_TS },
-  { category: "export_style", choice: "re_export", pattern: /^export\s+\{[^}]*\}\s+from/, languages: JS_TS },
-  // Functions
+  // Imports — typically project-level config (path aliases, import style)
+  { category: "import_style", choice: "named_import", pattern: /^import\s+\{/, languages: JS_TS, lintEnforceable: true },
+  { category: "import_style", choice: "default_import", pattern: /^import\s+[A-Za-z_$][^\s{]*\s+from/, languages: JS_TS, lintEnforceable: true },
+  { category: "import_style", choice: "path_alias", pattern: /from\s+['"][@~]\//, languages: JS_TS, lintEnforceable: true },
+  { category: "import_style", choice: "relative_import", pattern: /from\s+['"]\.\.?\//, languages: JS_TS, lintEnforceable: true },
+  // Exports — often enforced by barrel-file lint rules
+  { category: "export_style", choice: "named_export", pattern: /^export\s+(?:const|function|class|type|interface|enum)\s/, languages: JS_TS, lintEnforceable: true },
+  { category: "export_style", choice: "default_export", pattern: /^export\s+default\b/, languages: JS_TS, lintEnforceable: true },
+  { category: "export_style", choice: "re_export", pattern: /^export\s+\{[^}]*\}\s+from/, languages: JS_TS, lintEnforceable: true },
+  // Functions — genuine opinion, not typically lint-enforced
   { category: "function_style", choice: "arrow_function", pattern: /(?:const|let)\s+\w+\s*=\s*(?:async\s+)?\(/, languages: JS_TS },
   { category: "function_style", choice: "function_declaration", pattern: /^(?:export\s+)?(?:async\s+)?function\s+\w/, languages: JS_TS },
-  // Async
+  // Async — genuine architectural choice
   { category: "async_style", choice: "async_await", pattern: /\bawait\s/, languages: [...JS_TS, "python"] },
   { category: "async_style", choice: "then_chain", pattern: /\.then\s*\(/, languages: JS_TS },
-  // Control flow
+  // Control flow — genuine opinion about code structure
   { category: "control_flow", choice: "early_return", pattern: /^\s+if\s*\(.*\)\s*return\b/, languages: JS_TS },
   { category: "control_flow", choice: "guard_clause", pattern: /^\s+if\s*\(!/, languages: JS_TS },
-  // Strings
-  { category: "string_style", choice: "template_literal", pattern: /`[^`]*\$\{/, languages: JS_TS },
-  // Modern operators
+  // Strings — often lint-enforced (prefer-template)
+  { category: "string_style", choice: "template_literal", pattern: /`[^`]*\$\{/, languages: JS_TS, lintEnforceable: true },
+  // Modern operators — genuine preference
   { category: "modern_operators", choice: "optional_chaining", pattern: /\?\.\w/, languages: JS_TS },
   { category: "modern_operators", choice: "nullish_coalescing", pattern: /\?\?/, languages: JS_TS },
   { category: "modern_operators", choice: "destructuring", pattern: /(?:const|let|var)\s+[\[{]/, languages: JS_TS },
-  // TypeScript types
+  // TypeScript types — genuine opinion about modelling
   { category: "type_definition", choice: "interface", pattern: /^(?:export\s+)?interface\s+\w/, languages: TS_ONLY },
   { category: "type_definition", choice: "type_alias", pattern: /^(?:export\s+)?type\s+\w+\s*=/, languages: TS_ONLY },
   { category: "enum_vs_union", choice: "enum", pattern: /^(?:export\s+)?(?:const\s+)?enum\s+\w/, languages: TS_ONLY },
@@ -265,15 +265,15 @@ var PATTERN_RULES = [
   { category: "type_features", choice: "as_const", pattern: /\bas\s+const\b/, languages: TS_ONLY },
   { category: "type_features", choice: "generic_usage", pattern: /<[A-Z]\w*(?:,\s*[A-Z]\w*)*>/, languages: TS_ONLY },
   { category: "type_features", choice: "explicit_return_type", pattern: /\)\s*:\s*(?:Promise<|void|string|number|boolean|\w+\[\])/, languages: TS_ONLY },
-  // Error handling
+  // Error handling — genuine architectural choice
   { category: "error_handling", choice: "try_catch", pattern: /^\s*(?:try\s*\{|\}\s*catch\s*\()/ },
   { category: "error_handling", choice: "custom_error", pattern: /class\s+\w+Error\s+extends/ },
-  // Testing
+  // Testing — genuine opinion about test structure
   { category: "test_structure", choice: "describe_it", pattern: /\b(?:describe|it)\s*\(/, languages: JS_TS },
   { category: "test_structure", choice: "test_fn", pattern: /\btest\s*\(/, languages: JS_TS },
   { category: "test_assertion", choice: "expect", pattern: /\bexpect\s*\(/, languages: JS_TS },
   { category: "test_assertion", choice: "assert", pattern: /\bassert\.\w/, languages: [...JS_TS, "python"] },
-  // Architecture
+  // Architecture — strong personal opinion territory
   { category: "composition_style", choice: "inheritance", pattern: /class\s+\w+\s+extends\s/, languages: JS_TS },
   { category: "composition_style", choice: "composition", pattern: /\buse[A-Z]\w+\s*\(/, languages: JS_TS },
   { category: "architecture", choice: "factory_function", pattern: /(?:create|make|build)[A-Z]\w+\s*\(/, languages: JS_TS },
@@ -282,7 +282,7 @@ var PATTERN_RULES = [
   { category: "python_style", choice: "type_hints", pattern: /def\s+\w+\(.*:\s*\w+/, languages: ["python"] },
   { category: "python_style", choice: "list_comprehension", pattern: /\[.*\bfor\b.*\bin\b.*\]/, languages: ["python"] },
   { category: "python_style", choice: "dataclass", pattern: /@dataclass/, languages: ["python"] },
-  { category: "python_style", choice: "f_string", pattern: /f['"].*\{/, languages: ["python"] }
+  { category: "python_style", choice: "f_string", pattern: /f['"].*\{/, languages: ["python"], lintEnforceable: true }
 ];
 var CATEGORY_LABELS = {
   import_style: "Import Style",
@@ -385,17 +385,31 @@ function extractCodeStyleFromDiff(diffOutput) {
 }
 function summariseCodeStyle(signals) {
   const observations = [];
+  const categoryLintStatus = /* @__PURE__ */ new Map();
+  for (const rule of PATTERN_RULES) {
+    const current = categoryLintStatus.get(rule.category);
+    if (current === void 0) {
+      categoryLintStatus.set(rule.category, rule.lintEnforceable === true);
+    } else {
+      categoryLintStatus.set(
+        rule.category,
+        current && rule.lintEnforceable === true
+      );
+    }
+  }
   for (const [category, choices] of Object.entries(signals.counters)) {
     const entries = Object.entries(choices).sort((a, b) => b[1] - a[1]);
     const total = entries.reduce((sum, [, c]) => sum + c, 0);
     if (total < 3) continue;
     const [topChoice, topCount] = entries[0];
+    const isLintEnforceable = categoryLintStatus.get(category) ?? false;
     if (entries.length === 1) {
       if (topCount >= 5) {
         observations.push({
           category: CATEGORY_LABELS[category] ?? category,
           observation: `Frequently uses ${CHOICE_LABELS[topChoice] ?? topChoice} (${topCount} occurrences)`,
-          confidence: topCount >= 15 ? "strong" : "moderate"
+          confidence: topCount >= 15 ? "strong" : "moderate",
+          lintEnforceable: isLintEnforceable
         });
       }
       continue;
@@ -409,7 +423,8 @@ function summariseCodeStyle(signals) {
     observations.push({
       category: CATEGORY_LABELS[category] ?? category,
       observation: `Prefers ${topLabel} over ${runnerLabel} (${pct}% of ${total})`,
-      confidence
+      confidence,
+      lintEnforceable: isLintEnforceable
     });
   }
   observations.sort((a, b) => {
@@ -427,6 +442,347 @@ function summariseCodeStyle(signals) {
 import { readFileSync } from "fs";
 
 // src/extractors/review-common.ts
+var THEME_DEFS = [
+  {
+    theme: "decomposition",
+    label: "Decomposition / single responsibility",
+    patterns: [
+      /\bextract\b.*\b(?:into|to|out)\b/,
+      /\bsplit\b.*\b(?:into|up|out)\b/,
+      /\bseparate\b/,
+      /\bsingle.?responsib/,
+      /\bdoing\s+(?:too\s+)?(?:much|many|multiple)\b/,
+      /\btoo\s+(?:big|large|long|complex)\b/,
+      /\bbreak\b.*\b(?:into|up|out|down)\b/,
+      /\bpull\b.*\bout\b/
+    ]
+  },
+  {
+    theme: "naming",
+    label: "Naming clarity",
+    patterns: [
+      /\brename\b/,
+      /\bnaming\b/,
+      /\bname\b.*\b(?:unclear|confusing|misleading|vague|generic|better)\b/,
+      /\bwhat\s+does\s+\w+\s+mean\b/,
+      /\bmore\s+descriptive\b/
+    ]
+  },
+  {
+    theme: "error_handling",
+    label: "Error handling / edge cases",
+    patterns: [
+      /\berror\s+handl/,
+      /\bwhat\s+(?:if|happens\s+(?:if|when))\b/,
+      /\bedge\s+case/,
+      /\bfail(?:s|ure|ing)?\b.*\b(?:silent|graceful|handle|catch)\b/,
+      /\bunhandled\b/,
+      /\bmissing\b.*\b(?:error|catch|check|validation)\b/,
+      /\bcatch\b.*\b(?:this|here|error)\b/
+    ]
+  },
+  {
+    theme: "testing",
+    label: "Testing / test coverage",
+    patterns: [
+      /\badd\b.*\btests?\b/,
+      /\btest\s+(?:for|this|that|coverage|case|missing)\b/,
+      /\buntested\b/,
+      /\bspec\b.*\b(?:for|missing|add)\b/,
+      /\bcoverage\b/,
+      /\bassert(?:ion)?\b.*\b(?:missing|add|should)\b/
+    ]
+  },
+  {
+    theme: "performance",
+    label: "Performance awareness",
+    patterns: [
+      /\bperformance\b/,
+      /\bslow\b/,
+      /\boptimiz/,
+      /\bcache\b/,
+      /\bmemory\b/,
+      /\bcomplexity\b/,
+      /\bn\s*\+\s*1\b/,
+      /\bunnecessary\s+(?:re-?render|iteration|loop|allocation|copy)\b/,
+      /\bexpensive\b/
+    ]
+  },
+  {
+    theme: "readability",
+    label: "Readability / clarity",
+    patterns: [
+      /\breadab/,
+      /\bclarity\b/,
+      /\bsimplif/,
+      /\bconfusing\b/,
+      /\bhard\s+to\s+(?:read|follow|understand|parse)\b/,
+      /\bcomplicated\b/,
+      /\bself[- ]?explanat/
+    ]
+  },
+  {
+    theme: "type_safety",
+    label: "Type safety / strictness",
+    patterns: [
+      /\btype\s+safe/,
+      /\b(?:use|avoid|remove)\b.*\bany\b/,
+      /\bnarrow\b.*\btype/,
+      /\btype\s+assert/,
+      /\bas\s+unknown\b/,
+      /\bstrict(?:er|ly)?\s+typ/,
+      /\binfer\b.*\btype/
+    ]
+  },
+  {
+    theme: "security",
+    label: "Security / input validation",
+    patterns: [
+      /\bsecur/,
+      /\bsaniti[sz]/,
+      /\bvalidat/,
+      /\binject/,
+      /\bescap(?:e|ing)\b/,
+      /\bauth(?:entication|orization)?\b/,
+      /\bxss\b/i
+    ]
+  },
+  {
+    theme: "api_design",
+    label: "API / interface design",
+    patterns: [
+      /\bapi\s+(?:design|surface|contract|boundary)\b/i,
+      /\bpublic\s+(?:api|interface|surface)\b/,
+      /\bbreaking\s+change/,
+      /\bbackwards?\s+compat/,
+      /\bconsumer\b/,
+      /\bcaller\b/
+    ]
+  },
+  {
+    theme: "consistency",
+    label: "Consistency with existing patterns",
+    patterns: [
+      /\bconsisten/,
+      /\belsewhere\s+(?:we|in)\b/,
+      /\bwe\s+(?:usually|always|typically|normally)\b/,
+      /\bexisting\s+(?:pattern|convention|approach|style)\b/,
+      /\bdoesn'?t\s+match\b/,
+      /\balign\b.*\bwith\b/,
+      /\bin\s+line\s+with\b/
+    ]
+  },
+  {
+    theme: "documentation",
+    label: "Documentation / comments",
+    patterns: [
+      /\bdocument\b/,
+      /\bdocstring\b/,
+      /\bjsdoc\b/,
+      /\bcomment\b.*\b(?:explain|why|add|missing)\b/,
+      /\bexplain\b.*\b(?:why|what|how)\b/,
+      /\breadme\b/i
+    ]
+  },
+  {
+    theme: "dependency_awareness",
+    label: "Dependency / coupling awareness",
+    patterns: [
+      /\bcoupl(?:ed|ing)\b/,
+      /\bdependen(?:cy|cies|t)\b/,
+      /\bcircular\b/,
+      /\bimport\b.*\b(?:heavy|large|unnecessary)\b/,
+      /\btight(?:ly)?\s+coupled\b/,
+      /\bdecouple\b/
+    ]
+  }
+];
+var PRAISE_PATTERNS = [
+  /\bnice\b/,
+  /\bgreat\b/,
+  /\bgood\s+(?:call|catch|point|idea|work|job|stuff)\b/,
+  /\blove\s+(?:this|that|it|the)\b/,
+  /\bclean\b/,
+  /\belegant\b/,
+  /\blgtm\b/i,
+  /\bwell\s+done\b/,
+  /\bsolid\b/,
+  /\b(?:looks?\s+)?good\s+to\s+(?:me|go)\b/,
+  /\+1\b/,
+  /👍|🎉|✅/,
+  /\bneat\b/,
+  /\bawesome\b/
+];
+var EXPLANATION_PATTERNS = [
+  /\bbecause\b/,
+  /\bsince\b/,
+  /\bthe\s+reason\b/,
+  /\bso\s+that\b/,
+  /\bthis\s+(?:ensures?|prevents?|avoids?|allows?|makes?)\b/,
+  /\botherwise\b/,
+  /\bthe\s+(?:problem|issue|risk|concern)\s+(?:is|here|with)\b/
+];
+var SUGGESTIVE_PATTERNS = [
+  /\bconsider\b/,
+  /\bwhat\s+(?:about|if\s+we|do\s+you\s+think)\b/,
+  /\bmaybe\b/,
+  /\balternative(?:ly)?\b/,
+  /\bone\s+option\b/,
+  /\bcould\s+(?:we|you|this)\b/,
+  /\bhow\s+about\b/,
+  /\bwhat\s+(?:do\s+you|would\s+you)\s+think\b/,
+  /\bmight\s+(?:be|want)\b/,
+  /\bwould\s+(?:it\s+)?be\s+(?:better|cleaner|simpler|easier)\b/
+];
+var DIRECTIVE_PATTERNS = [
+  /^(?:rename|remove|delete|drop|change|move|replace|use|add|fix|update|revert|undo)\b/i,
+  /\bplease\s+(?:rename|remove|delete|change|move|replace|use|add|fix|update|revert)\b/,
+  /\bshould\s+be\b/,
+  /\bneeds?\s+to\s+be\b/,
+  /\bmust\s+be\b/,
+  /\bdon'?t\b.*\bhere\b/,
+  /\bthis\s+(?:should|must|needs?)\b/
+];
+function extractRecurringPhrases(comments) {
+  if (comments.length < 5) return [];
+  const phraseCounts = /* @__PURE__ */ new Map();
+  const MIN_PHRASE_LEN = 2;
+  const MAX_PHRASE_LEN = 5;
+  for (const comment of comments) {
+    const lower = comment.toLowerCase().replace(/[^\w\s]/g, " ");
+    const words = lower.split(/\s+/).filter((w) => w.length > 2);
+    const seenInComment = /* @__PURE__ */ new Set();
+    for (let start = 0; start < words.length; start++) {
+      for (let len = MIN_PHRASE_LEN; len <= MAX_PHRASE_LEN && start + len <= words.length; len++) {
+        const phrase = words.slice(start, start + len).join(" ");
+        if (!seenInComment.has(phrase)) {
+          seenInComment.add(phrase);
+          phraseCounts.set(phrase, (phraseCounts.get(phrase) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  const minCount = Math.max(3, Math.floor(comments.length * 0.1));
+  const STOP_WORDS = /* @__PURE__ */ new Set([
+    "the",
+    "this",
+    "that",
+    "with",
+    "from",
+    "have",
+    "has",
+    "been",
+    "will",
+    "would",
+    "could",
+    "should",
+    "can",
+    "are",
+    "for",
+    "not",
+    "but",
+    "and",
+    "you",
+    "was",
+    "were",
+    "than",
+    "also",
+    "its",
+    "into",
+    "here",
+    "there",
+    "then",
+    "when",
+    "what",
+    "which",
+    "where",
+    "how"
+  ]);
+  return [...phraseCounts.entries()].filter(([phrase, count]) => {
+    if (count < minCount) return false;
+    const words = phrase.split(" ");
+    return words.some((w) => !STOP_WORDS.has(w));
+  }).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([phrase]) => phrase);
+}
+function extractRecurringQuestions(comments) {
+  const questions = comments.filter(
+    (c) => c.includes("?") && c.length > 15 && c.length < 300
+  );
+  if (questions.length < 2) return questions.slice(0, 5);
+  const normalise = (q) => q.toLowerCase().replace(/[^\w\s?]/g, "").replace(/\s+/g, " ").trim();
+  const seen = /* @__PURE__ */ new Map();
+  for (const q of questions) {
+    const norm = normalise(q);
+    let isDupe = false;
+    for (const existing of seen.keys()) {
+      if (norm === existing || norm.length > 20 && existing.startsWith(norm.slice(0, 20))) {
+        isDupe = true;
+        break;
+      }
+    }
+    if (!isDupe) {
+      seen.set(norm, q);
+    }
+  }
+  return [...seen.values()].slice(0, 10);
+}
+function matchesAny(text, patterns) {
+  return patterns.some((p) => p.test(text));
+}
+function countMatching(comments, patterns) {
+  return comments.filter((c) => matchesAny(c.toLowerCase(), patterns)).length;
+}
+function sampleMatching(comments, patterns, max) {
+  const matches = [];
+  for (const c of comments) {
+    if (matchesAny(c.toLowerCase(), patterns)) {
+      matches.push(c.length > 200 ? c.slice(0, 200) + "..." : c);
+      if (matches.length >= max) break;
+    }
+  }
+  return matches;
+}
+function extractThemes(comments) {
+  if (comments.length === 0) return [];
+  const themes = [];
+  for (const def of THEME_DEFS) {
+    const matchingComments = [];
+    for (const comment of comments) {
+      const lower = comment.toLowerCase();
+      if (def.patterns.some((p) => p.test(lower))) {
+        matchingComments.push(comment);
+      }
+    }
+    if (matchingComments.length < 2) continue;
+    const ratio = Math.round(matchingComments.length / comments.length * 100) / 100;
+    const snippets = matchingComments.filter((c) => c.length > 20 && c.length < 300).slice(0, 3).map((c) => c.length > 150 ? c.slice(0, 150) + "..." : c);
+    themes.push({
+      theme: def.theme,
+      label: def.label,
+      count: matchingComments.length,
+      ratio,
+      exampleSnippets: snippets
+    });
+  }
+  themes.sort((a, b) => b.count - a.count);
+  return themes;
+}
+function buildToneProfile(comments) {
+  if (comments.length < 5) return void 0;
+  const n = comments.length;
+  const praiseCount = countMatching(comments, PRAISE_PATTERNS);
+  const explanationCount = countMatching(comments, EXPLANATION_PATTERNS);
+  const suggestiveCount = countMatching(comments, SUGGESTIVE_PATTERNS);
+  const directiveCount = countMatching(comments, DIRECTIVE_PATTERNS);
+  return {
+    praiseRatio: Math.round(praiseCount / n * 100) / 100,
+    explanationRatio: Math.round(explanationCount / n * 100) / 100,
+    suggestiveRatio: Math.round(suggestiveCount / n * 100) / 100,
+    directiveRatio: Math.round(directiveCount / n * 100) / 100,
+    praiseExamples: sampleMatching(comments, PRAISE_PATTERNS, 3),
+    explanationExamples: sampleMatching(comments, EXPLANATION_PATTERNS, 3)
+  };
+}
 function summariseReview(signals) {
   const obs = { source: signals.source };
   const comments = signals.reviewComments;
@@ -454,6 +810,10 @@ function summariseReview(signals) {
       indices.filter((i) => i >= 0 && i < n).map((i) => sorted[i])
     )
   ];
+  obs.reviewThemes = extractThemes(comments);
+  obs.toneProfile = buildToneProfile(comments);
+  obs.recurringQuestions = extractRecurringQuestions(comments);
+  obs.recurringPhrases = extractRecurringPhrases(comments);
   return obs;
 }
 
@@ -755,6 +1115,16 @@ function dominantNamingStyle(style) {
   if (style.PascalCase / total > 0.7) return "Strongly prefers PascalCase";
   return null;
 }
+function describeTone(profile) {
+  const traits = [];
+  if (profile.directiveRatio > 0.3) traits.push("direct");
+  else if (profile.suggestiveRatio > 0.3) traits.push("collaborative");
+  if (profile.explanationRatio > 0.3) traits.push("explanatory");
+  if (profile.praiseRatio > 0.15) traits.push("encouraging");
+  else if (profile.praiseRatio < 0.05) traits.push("critique-focused");
+  if (traits.length === 0) traits.push("balanced");
+  return traits.join(", ");
+}
 function buildGhostMarkdown(input) {
   const { contributor, slug, gitObs, codeStyleObs, reviewObs, slackObs, docsSignals, sourcesUsed } = input;
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -773,23 +1143,37 @@ function buildGhostMarkdown(input) {
     "",
     "## Review Philosophy",
     "",
-    "### What they care about most (ranked)",
-    "_[Fill in manually after reviewing the data below \u2014 re-order based on review comment patterns]_",
-    "1. Correctness",
-    "2. Naming",
-    "3. Component / module boundaries",
-    "4. Test coverage",
-    "5. Consistency with existing patterns",
-    "",
-    "### What they tend to ignore",
-    "_[Fill in manually]_",
-    "",
-    "### Dealbreakers",
-    "_[Fill in manually]_",
-    "",
-    "### Recurring questions / phrases"
+    "### What they care about most (ranked)"
   ];
-  if (reviewObs.sampleComments && reviewObs.sampleComments.length > 0) {
+  const themes = reviewObs.reviewThemes;
+  if (themes && themes.length > 0) {
+    lines.push(
+      `_Inferred from ${reviewObs.totalReviewComments ?? "?"} review comments \u2014 verify and re-order as needed_`
+    );
+    for (let i = 0; i < Math.min(themes.length, 8); i++) {
+      const t = themes[i];
+      lines.push(`${i + 1}. ${t.label} _(${t.count} comments, ${Math.round(t.ratio * 100)}%)_`);
+    }
+  } else {
+    lines.push(
+      "_[Fill in manually after reviewing the data below \u2014 re-order based on review comment patterns]_",
+      "1. Correctness",
+      "2. Naming",
+      "3. Component / module boundaries",
+      "4. Test coverage",
+      "5. Consistency with existing patterns"
+    );
+  }
+  lines.push("", "### What they tend to ignore", "_[Fill in manually]_");
+  lines.push("", "### Dealbreakers", "_[Fill in manually]_");
+  lines.push("", "### Recurring questions / phrases");
+  const recurringQs = reviewObs.recurringQuestions;
+  if (recurringQs && recurringQs.length > 0) {
+    for (const q of recurringQs.slice(0, 8)) {
+      const truncated = q.length > 150 ? q.slice(0, 150) + "..." : q;
+      lines.push(`- "${truncated}"`);
+    }
+  } else if (reviewObs.sampleComments && reviewObs.sampleComments.length > 0) {
     const questions = reviewObs.sampleComments.filter((c) => c.endsWith("?"));
     if (questions.length > 0) {
       for (const q of questions.slice(0, 5)) {
@@ -802,6 +1186,19 @@ function buildGhostMarkdown(input) {
   } else {
     lines.push("_[Fill in from sample comments below]_");
   }
+  if (themes && themes.length > 0) {
+    lines.push("");
+    lines.push("### Review concern examples");
+    lines.push("_Verbatim excerpts grouped by detected theme \u2014 use these to validate the ranking above_");
+    for (const t of themes.slice(0, 5)) {
+      if (t.exampleSnippets.length === 0) continue;
+      lines.push("");
+      lines.push(`**${t.label}** (${t.count} comments):`);
+      for (const snippet of t.exampleSnippets) {
+        lines.push(`> ${snippet}`);
+      }
+    }
+  }
   lines.push("", "---", "", "## Communication Style", "");
   if (reviewObs.totalReviewComments != null) {
     lines.push(
@@ -816,9 +1213,28 @@ function buildGhostMarkdown(input) {
     }
     lines.push("");
   }
+  lines.push("### Tone");
+  const tone = reviewObs.toneProfile;
+  if (tone) {
+    const toneDesc = describeTone(tone);
+    lines.push(
+      `${toneDesc} _(inferred from comment language)_`,
+      "",
+      `- Praise ratio: ${Math.round(tone.praiseRatio * 100)}% of comments include positive reinforcement`,
+      `- Explanation ratio: ${Math.round(tone.explanationRatio * 100)}% of comments explain "why"`,
+      `- Suggestive ratio: ${Math.round(tone.suggestiveRatio * 100)}% offer alternatives ("consider", "what about")`,
+      `- Directive ratio: ${Math.round(tone.directiveRatio * 100)}% use direct imperatives ("rename this", "remove this")`
+    );
+    if (tone.praiseExamples.length > 0) {
+      lines.push("", "**Praise examples:**");
+      for (const ex of tone.praiseExamples) {
+        lines.push(`> ${ex.length > 200 ? ex.slice(0, 200) + "..." : ex}`);
+      }
+    }
+  } else {
+    lines.push("_[Fill in manually \u2014 direct? warm? collaborative? terse?]_");
+  }
   lines.push(
-    "### Tone",
-    "_[Fill in manually \u2014 direct? warm? collaborative? terse?]_",
     "",
     "### Severity prefixes they use"
   );
@@ -829,10 +1245,17 @@ function buildGhostMarkdown(input) {
   } else {
     lines.push("_[Derived from comments above \u2014 fill in which they actually use]_");
   }
+  lines.push("", "### Vocabulary / phrases they use");
+  const phrases = reviewObs.recurringPhrases;
+  if (phrases && phrases.length > 0) {
+    lines.push("_Phrases that appear repeatedly across their review comments:_");
+    for (const phrase of phrases.slice(0, 10)) {
+      lines.push(`- "${phrase}"`);
+    }
+  } else {
+    lines.push("_[Fill in from sample comments below]_");
+  }
   lines.push(
-    "",
-    "### Vocabulary / phrases they use",
-    "_[Fill in from sample comments below]_",
     "",
     "---",
     "",
@@ -873,15 +1296,18 @@ function buildGhostMarkdown(input) {
   if (gitObs.primaryExtensions || gitObs.primaryDirectories || gitObs.namingStyle || gitObs.fileTypeProfile) {
     lines.push("");
   }
-  if (codeStyleObs.observations.length > 0) {
+  const personalObs = codeStyleObs.observations.filter((o) => !o.lintEnforceable);
+  const lintObs = codeStyleObs.observations.filter((o) => o.lintEnforceable);
+  if (personalObs.length > 0) {
     lines.push("### Detected Code Style Preferences");
+    lines.push("_These reflect genuine contributor choices, not linter-enforced rules_");
     if (codeStyleObs.primaryLanguage) {
       lines.push(
         `_Primary language: ${codeStyleObs.primaryLanguage} \xB7 ${codeStyleObs.totalLinesAnalyzed} added lines analyzed_`
       );
     }
     lines.push("");
-    for (const obs of codeStyleObs.observations) {
+    for (const obs of personalObs) {
       if (obs.confidence === "strong") {
         lines.push(`- **${obs.category}**: ${obs.observation}`);
       } else {
@@ -890,6 +1316,15 @@ function buildGhostMarkdown(input) {
     }
     lines.push("");
   }
+  if (lintObs.length > 0) {
+    lines.push("### Project-Level Patterns (likely lint-enforced)");
+    lines.push("_These patterns are typically enforced by project linters/formatters \u2014 they describe the project, not the person_");
+    lines.push("");
+    for (const obs of lintObs) {
+      lines.push(`- ~${obs.category}: ${obs.observation}~`);
+    }
+    lines.push("");
+  }
   lines.push(
     "### Patterns they introduce / prefer"
   );
@@ -897,10 +1332,23 @@ function buildGhostMarkdown(input) {
   if (namingInsight) {
     lines.push(`- ${namingInsight}`);
   }
+  if (personalObs.length > 0) {
+    const strong = personalObs.filter((o) => o.confidence === "strong");
+    for (const obs of strong.slice(0, 3)) {
+      lines.push(`- ${obs.observation} _(inferred from code)_`);
+    }
+  }
   lines.push(
     "_[Fill in manually from code inspection and review comment themes]_",
     "",
-    "### Patterns they push back on",
+    "### Patterns they push back on"
+  );
+  if (themes && themes.length > 0) {
+    for (const t of themes.slice(0, 3)) {
+      lines.push(`- Violations of ${t.label.toLowerCase()} _(${t.count} review comments)_`);
+    }
+  }
+  lines.push(
     "_[Fill in manually]_",
     "",
     "---",