@chemx/starter-kit 26.9.11-481 → 26.9.12-107

package/cli/audit/metrics.js

@@ -7,6 +7,7 @@ export const calculateMolecularHealthScore = (violations, totalFiles) => {
 
   let penalty = 0;
   for (const v of violations) {
+    if (v.isAiSlop) continue;
     if (v.severity === 'CRITICAL') penalty += 8;
     else if (v.severity === 'HIGH') penalty += 4;
     else if (v.severity === 'MEDIUM') penalty += 2;
@@ -56,6 +57,7 @@ export const calculatePillarBreakdown = (violations) => {
   }
 
   for (const v of violations) {
+    if (v.isAiSlop) continue;
     const pillarName = v.pillar || PILLARS.PILLAR_1;
     if (!breakdown[pillarName]) {
       breakdown[pillarName] = {
@@ -177,3 +179,70 @@ export const calculateHotspots = (violations, fileStats, limit = 5) => {
 };
 
 export const calculateQuantumHealthScore = calculateMolecularHealthScore;
+
+export const calculateAiSlopScore = (violations, totalFiles) => {
+  const slopViolations = violations.filter((v) => v.isAiSlop);
+  if (totalFiles === 0) {
+    return {
+      score: 100,
+      grade: 'A+',
+      label: 'Pure Artisanal',
+      violationsCount: 0,
+      breakdown: { critical: 0, high: 0, medium: 0, low: 0 }
+    };
+  }
+
+  let penalty = 0;
+  let critical = 0;
+  let high = 0;
+  let medium = 0;
+  let low = 0;
+
+  for (const v of slopViolations) {
+    if (v.severity === 'CRITICAL') {
+      penalty += 10;
+      critical += 1;
+    } else if (v.severity === 'HIGH') {
+      penalty += 5;
+      high += 1;
+    } else if (v.severity === 'MEDIUM') {
+      penalty += 2;
+      medium += 1;
+    } else {
+      penalty += 1;
+      low += 1;
+    }
+  }
+
+  const scale = Math.max(1, Math.log10(totalFiles + 1));
+  const adjustedPenalty = penalty / scale;
+  const score = Math.max(0, Math.min(100, Math.round(100 - adjustedPenalty)));
+
+  let grade = 'F';
+  let label = 'Severe AI Slop Infection';
+
+  if (score >= 95) {
+    grade = 'A+';
+    label = 'Pure Artisanal';
+  } else if (score >= 90) {
+    grade = 'A';
+    label = 'Near-Zero Slop';
+  } else if (score >= 80) {
+    grade = 'B';
+    label = 'Low AI Residue';
+  } else if (score >= 70) {
+    grade = 'C';
+    label = 'Moderate Slop Drift';
+  } else if (score >= 60) {
+    grade = 'D';
+    label = 'High AI Slop Hazard';
+  }
+
+  return {
+    score,
+    grade,
+    label,
+    violationsCount: slopViolations.length,
+    breakdown: { critical, high, medium, low }
+  };
+};

package/cli/audit/prompts.js

@@ -1,35 +1,108 @@
+import { groupViolationsByRule } from './reporter-grouping.js';
+
 const CYAN = '\x1b[38;2;98;201;255m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
-export const buildGradeFPrompt = (report) => {
-  const { violations, hotspots } = report;
-  const critical = violations.filter((v) => v.severity === 'CRITICAL');
+const buildPathTree = (violations) => {
+  const root = { dirs: new Map(), files: new Map() };
+
+  for (const v of violations) {
+    const rawPath = v.filePath || '';
+    const normalized = rawPath.replace(/\\/g, '/').replace(/^\.\//, '');
+    const segments = normalized.split('/');
+    const fileName = segments.pop();
+
+    let current = root;
+    for (const seg of segments) {
+      const segName = seg.endsWith('/') ? seg : `${seg}/`;
+      if (!current.dirs.has(segName)) {
+        current.dirs.set(segName, { dirs: new Map(), files: new Map() });
+      }
+      current = current.dirs.get(segName);
+    }
+
+    if (!current.files.has(fileName)) {
+      current.files.set(fileName, []);
+    }
+    const loc = v.column ? `${v.line}:${v.column}` : `${v.line}`;
+    current.files.get(fileName).push(loc);
+  }
+
+  return root;
+};
+
+const renderTreeLines = (node, depth = 0) => {
+  const lines = [];
+  const indent = '   ' + '  '.repeat(depth);
+
+  const sortedDirs = Array.from(node.dirs.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [dirName, childNode] of sortedDirs) {
+    lines.push(`${indent}* ${dirName}`);
+    const childLines = renderTreeLines(childNode, depth + 1);
+    lines.push(...childLines);
+  }
+
+  const sortedFiles = Array.from(node.files.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [fileName, locs] of sortedFiles) {
+    const uniqueLocs = Array.from(new Set(locs)).join(', ');
+    lines.push(`${indent}- \`${fileName}:${uniqueLocs}\``);
+  }
+
+  return lines;
+};
+
+export const formatGroupedPromptViolations = (violations = []) => {
+  const hasNoViolations = violations.length === 0;
+  if (hasNoViolations) return [];
+
+  const ruleGroups = groupViolationsByRule(violations);
+  const lines = [];
+
+  ruleGroups.forEach((rg, idx) => {
+    const countLabel = rg.total === 1 ? '1 item' : `${rg.total} items`;
+    lines.push(`${idx + 1}. [${rg.rule}] (${countLabel})`);
+    lines.push(`   Hazard: ${rg.hazard}`);
+    lines.push(`   Directive: ${rg.directive}`);
+    lines.push('   Locations:');
+
+    const tree = buildPathTree(rg.violations);
+    const treeLines = renderTreeLines(tree, 0);
+    lines.push(...treeLines);
+    lines.push('');
+  });
+
+  return lines;
+};
+
+export const buildGradeFPrompt = (report, options = {}) => {
+  const { excludeAiSlop = false } = options;
+  const { violations = [], hotspots = [] } = report;
+  const critical = violations
+    .filter((v) => v.severity === 'CRITICAL')
+    .filter((v) => (excludeAiSlop ? !v.isAiSlop : true));
   const extremeMonoliths = hotspots.filter((h) => h.lineCount >= 2000);
 
-  if (critical.length === 0 && extremeMonoliths.length === 0) return '';
+  const hasNoCritical = critical.length === 0;
+  const hasNoMonoliths = extremeMonoliths.length === 0;
+  if (hasNoCritical && hasNoMonoliths) return '';
 
   const lines = [];
   lines.push('Act as a Principal Systems Architect. Surgically refactor the following Grade F Critical Context Hazards in our codebase according to Chemical X Molecular Architecture Standards:\n');
 
   if (extremeMonoliths.length > 0) {
     lines.push('### EXTREME MONOLITHS (>= 2,000 lines of code) : MONOLITH DECOMPOSITION');
+    lines.push('Action: Decompose into crystalline single-responsibility capsules (< 100 lines per molecule). Convert top-level view into a declarative Table-of-Contents view.\n');
     extremeMonoliths.forEach((h, i) => {
       lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
-      lines.push('   Action: Decompose this monolith into crystalline single-responsibility capsules (< 100 lines per molecule). Convert top-level view into a declarative Table-of-Contents view.');
     });
     lines.push('');
   }
 
   if (critical.length > 0) {
     lines.push('### CRITICAL AST VIOLATIONS');
-    critical.forEach((v, i) => {
-      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
-      lines.push(`   Hazard: ${v.hazard}`);
-      lines.push(`   Directive: ${v.directive}`);
-    });
-    lines.push('');
+    lines.push(...formatGroupedPromptViolations(critical));
   }
 
   lines.push('### STRICT EXECUTION RULES:');
@@ -42,33 +115,33 @@ export const buildGradeFPrompt = (report) => {
   return lines.join('\n');
 };
 
-export const buildGradeDPrompt = (report) => {
-  const { violations, hotspots } = report;
-  const high = violations.filter((v) => v.severity === 'HIGH');
+export const buildGradeDPrompt = (report, options = {}) => {
+  const { excludeAiSlop = false } = options;
+  const { violations = [], hotspots = [] } = report;
+  const high = violations
+    .filter((v) => v.severity === 'HIGH')
+    .filter((v) => (excludeAiSlop ? !v.isAiSlop : true));
   const severeMonoliths = hotspots.filter((h) => h.lineCount >= 1000 && h.lineCount < 2000);
 
-  if (high.length === 0 && severeMonoliths.length === 0) return '';
+  const hasNoHigh = high.length === 0;
+  const hasNoMonoliths = severeMonoliths.length === 0;
+  if (hasNoHigh && hasNoMonoliths) return '';
 
   const lines = [];
   lines.push('Act as a Principal Systems Architect. Refactor the following Grade D High-Severity Architectural Debts according to Chemical X Molecular Architecture Standards:\n');
 
   if (severeMonoliths.length > 0) {
     lines.push('### SEVERE MONOLITHS (1,000 - 1,999 lines of code)');
+    lines.push('Action: Extract sub-features into isolated molecule capsules (< 100 lines of code) and domain composables.\n');
     severeMonoliths.forEach((h, i) => {
       lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
-      lines.push('   Action: Extract sub-features into isolated molecule capsules (< 100 lines of code) and domain composables.');
     });
     lines.push('');
   }
 
   if (high.length > 0) {
     lines.push('### HIGH SEVERITY VIOLATIONS');
-    high.forEach((v, i) => {
-      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
-      lines.push(`   Hazard: ${v.hazard}`);
-      lines.push(`   Directive: ${v.directive}`);
-    });
-    lines.push('');
+    lines.push(...formatGroupedPromptViolations(high));
   }
 
   lines.push('### STRICT EXECUTION RULES:');
@@ -79,33 +152,33 @@ export const buildGradeDPrompt = (report) => {
   return lines.join('\n');
 };
 
-export const buildGradeCPrompt = (report) => {
-  const { violations, hotspots } = report;
-  const medium = violations.filter((v) => v.severity === 'MEDIUM');
+export const buildGradeCPrompt = (report, options = {}) => {
+  const { excludeAiSlop = false } = options;
+  const { violations = [], hotspots = [] } = report;
+  const medium = violations
+    .filter((v) => v.severity === 'MEDIUM')
+    .filter((v) => (excludeAiSlop ? !v.isAiSlop : true));
   const warningMonoliths = hotspots.filter((h) => h.lineCount >= 500 && h.lineCount < 1000);
 
-  if (medium.length === 0 && warningMonoliths.length === 0) return '';
+  const hasNoMedium = medium.length === 0;
+  const hasNoMonoliths = warningMonoliths.length === 0;
+  if (hasNoMedium && hasNoMonoliths) return '';
 
   const lines = [];
   lines.push('Act as a Senior Frontend Engineer. Refactor the following Grade C Medium-Severity Technical Debts according to Chemical X Molecular Architecture Standards:\n');
 
   if (warningMonoliths.length > 0) {
     lines.push('### WARNING MONOLITHS (500 - 999 lines of code)');
+    lines.push('Action: Bring file under 500 line budget by extracting helper functions, types, and child molecules.\n');
     warningMonoliths.forEach((h, i) => {
       lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines)`);
-      lines.push('   Action: Bring file under 500 line budget by extracting helper functions, types, and child molecules.');
     });
     lines.push('');
   }
 
   if (medium.length > 0) {
     lines.push('### MEDIUM SEVERITY VIOLATIONS');
-    medium.forEach((v, i) => {
-      lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
-      lines.push(`   Hazard: ${v.hazard}`);
-      lines.push(`   Directive: ${v.directive}`);
-    });
-    lines.push('');
+    lines.push(...formatGroupedPromptViolations(medium));
   }
 
   lines.push('### STRICT EXECUTION RULES:');
@@ -116,22 +189,21 @@ export const buildGradeCPrompt = (report) => {
   return lines.join('\n');
 };
 
-export const buildGradeBPrompt = (report) => {
-  const { violations } = report;
-  const low = violations.filter((v) => v.severity === 'LOW');
+export const buildGradeBPrompt = (report, options = {}) => {
+  const { excludeAiSlop = false } = options;
+  const { violations = [] } = report;
+  const low = violations
+    .filter((v) => v.severity === 'LOW')
+    .filter((v) => (excludeAiSlop ? !v.isAiSlop : true));
 
-  if (low.length === 0) return '';
+  const hasNoLow = low.length === 0;
+  if (hasNoLow) return '';
 
   const lines = [];
   lines.push('Act as a Clean Code Specialist. Clean up the following Grade B Low-Severity Hygiene Issues according to Chemical X standards:\n');
 
   lines.push('### LOW HYGIENE VIOLATIONS');
-  low.forEach((v, i) => {
-    lines.push(`${i + 1}. \`${v.filePath}:${v.line}:${v.column}\` [${v.rule}]`);
-    lines.push(`   Hazard: ${v.hazard}`);
-    lines.push(`   Directive: ${v.directive}`);
-  });
-  lines.push('');
+  lines.push(...formatGroupedPromptViolations(low));
 
   lines.push('### STRICT EXECUTION RULES:');
   lines.push('1. Typography Hygiene: Replace all em dashes with standard hyphens (-) or colons (:).');
@@ -141,15 +213,70 @@ export const buildGradeBPrompt = (report) => {
   return lines.join('\n');
 };
 
+export const buildAiSlopPrompt = (report) => {
+  const { violations = [] } = report;
+  const slopViolations = violations.filter((v) => Boolean(v.isAiSlop));
+
+  const hasNoSlop = slopViolations.length === 0;
+  if (hasNoSlop) return '';
+
+  const lines = [];
+  lines.push('Act as a Clean Code Specialist and Code Authenticity Guardian. Eliminate the following AI Slop and conversational artifacts from our codebase according to Chemical X standards:\n');
+
+  lines.push('### AI SLOP & CODE AUTHENTICITY VIOLATIONS');
+  lines.push(...formatGroupedPromptViolations(slopViolations));
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Conversational Residue: Completely remove leaked AI conversational preambles, assistant markdown code fences, and pleasantry comments.');
+  lines.push('2. Truncation Placeholders: Replace lazy AI truncation placeholders with complete, robust, and verifiable implementations.');
+  lines.push('3. Echo Comments: Delete trivial parroting comments that merely restate adjacent self-documenting code.');
+  lines.push('4. Paranoia Catch Wrappers: Replace shallow or empty catch blocks with intentional error propagation or ResultTuple ([data, error]).');
+  lines.push('5. Inline Utility Reinventions: Replace reinvented inline helper utilities with shared project utilities or native methods.');
+  lines.push('6. Type Widening: Eliminate lazy "any" type casts on error parameters or variables; enforce strict typing.');
+
+  return lines.join('\n');
+};
+
+export const buildHotspotsPrompt = (report) => {
+  const { hotspots = [] } = report;
+  const monolithHotspots = hotspots.filter((h) => h.isMonolith || h.lineCount > 500);
+
+  const hasNoMonoliths = monolithHotspots.length === 0;
+  if (hasNoMonoliths) return '';
+
+  const lines = [];
+  lines.push('Act as a Principal Systems Architect. Surgically decompose the following monolithic hotspot files according to Chemical X Molecular Architecture Standards:\n');
+
+  lines.push('### MONOLITHIC REFACTORING HOTSPOTS');
+  lines.push('Action: Decompose into single-responsibility crystalline molecule capsules (< 100 lines) and dedicated domain composables.\n');
+  monolithHotspots.forEach((h, i) => {
+    const tier = h.monolithTier ? `[${h.monolithTier} MONOLITH]` : '[MONOLITH]';
+    lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines, ${h.violationCount} hazards) ${tier}`);
+  });
+  lines.push('');
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Molecular Limits: Molecule capsules must strictly remain under 100 lines per file.');
+  lines.push('2. Table-of-Contents Views: Top-level page views must be 10 to 20 line declarative Table of Contents assembling molecules via named slots.');
+  lines.push('3. Composable Return Contracts: Custom hooks/composables must strictly limit returns to 3 to 5 properties (State + Status + Actions).');
+  lines.push('4. Type Co-location: Co-locate granular types/*.d.ts files inside each feature capsule (< 100 lines per type file) instead of creating type monoliths.');
+  lines.push('5. Zero breaking changes to external component APIs, route exports, or existing props.');
+
+  return lines.join('\n');
+};
+
 export const buildMasterPrompt = (report) => {
   const sections = [
-    buildGradeFPrompt(report),
-    buildGradeDPrompt(report),
-    buildGradeCPrompt(report),
-    buildGradeBPrompt(report)
+    buildGradeFPrompt(report, { excludeAiSlop: true }),
+    buildGradeDPrompt(report, { excludeAiSlop: true }),
+    buildGradeCPrompt(report, { excludeAiSlop: true }),
+    buildGradeBPrompt(report, { excludeAiSlop: true }),
+    buildAiSlopPrompt(report),
+    buildHotspotsPrompt(report)
   ].filter(Boolean);
 
-  if (sections.length === 0) return '';
+  const hasNoSections = sections.length === 0;
+  if (hasNoSections) return '';
 
   const header = `Act as a Principal Systems Architect. Execute a phased architectural refactoring of our codebase according to Chemical X Molecular Architecture Standards.\n\n`;
   return header + sections.join('\n\n---\n\n');

package/cli/audit/reporter-banner.d.ts

@@ -0,0 +1,3 @@
+import type { AuditReport } from './types';
+
+export declare function getChemicalXAsciiBanner(gradeOrReport?: string | AuditReport | null): string;

package/cli/audit/reporter-banner.js

@@ -0,0 +1,74 @@
+import { resolveGradeColor } from './reporter-utils.js';
+import { getAsciiGradeLines } from './reporter-ascii.js';
+
+const BANNER_ART = [
+  ' ██████╗██╗  ██╗███████╗███╗   ███╗██╗ ██████╗ █████╗ ██╗         ██╗  ██╗',
+  '██╔════╝██║  ██║██╔════╝████╗ ████║██║██╔════╝██╔══██╗██║         ╚██╗██╔╝',
+  '██║     ███████║█████╗  ██╔████╔██║██║██║     ███████║██║          ╚███╔╝ ',
+  '██║     ██╔══██║██╔══╝  ██║╚██╔╝██║██║██║     ██╔══██║██║          ██╔██╗ ',
+  '╚██████╗██║  ██║███████╗██║ ╚═╝ ██║██║╚██████╗██║  ██║███████╗    ██╔╝ ██╗',
+  ' ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝    ╚═╝  ╚═╝'
+];
+
+const MAX_BANNER_LEN = 74;
+
+export const getChemicalXAsciiBanner = (gradeOrReport = null) => {
+  const grade = typeof gradeOrReport === 'object' && gradeOrReport !== null
+    ? gradeOrReport.health?.grade
+    : gradeOrReport;
+
+  const lines = [];
+  lines.push('                     \x1b[1m\x1b[37mThe Secret Sauce to \x1b[38;2;98;201;255mVibe Coding\x1b[0m');
+
+  const gColor = grade ? resolveGradeColor(grade) : '';
+  const gradeLines = grade ? getAsciiGradeLines(grade, gColor, true) : [];
+  const termWidth = process.stdout.columns || 0;
+  const isSideBySide = Boolean(!termWidth || termWidth >= 105);
+
+  for (let lineIdx = 0; lineIdx < BANNER_ART.length; lineIdx++) {
+    const line = BANNER_ART[lineIdx];
+    let out = '';
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (ch === ' ') {
+        out += ' ';
+        continue;
+      }
+      const t = i / (MAX_BANNER_LEN - 1);
+      let r;
+      let g;
+      let b;
+      if (t < 0.5) {
+        const factor = t * 2;
+        r = Math.round(244 * (1 - factor) + 192 * factor);
+        g = Math.round(114 * (1 - factor) + 132 * factor);
+        b = Math.round(182 * (1 - factor) + 252 * factor);
+      } else {
+        const factor = (t - 0.5) * 2;
+        r = Math.round(192 * (1 - factor) + 129 * factor);
+        g = Math.round(132 * (1 - factor) + 140 * factor);
+        b = Math.round(252 * (1 - factor) + 248 * factor);
+      }
+      out += `\x1b[38;2;${r};${g};${b}m\x1b[1m${ch}\x1b[0m`;
+    }
+
+    if (isSideBySide && gradeLines.length > lineIdx) {
+      out += `   ${gradeLines[lineIdx]}`;
+    }
+
+    lines.push(out);
+  }
+
+  const subtitle = 'Architectural guardrails to eliminate token burn and AI hallucinations.';
+  const pad = ' '.repeat(Math.max(0, Math.floor((MAX_BANNER_LEN - subtitle.length) / 2)));
+  lines.push(`${pad}\x1b[2m${subtitle}\x1b[0m\n`);
+
+  if (!isSideBySide && gradeLines.length > 0) {
+    for (const gl of gradeLines) {
+      lines.push(`   ${gl}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+};

package/cli/audit/reporter-grades.js

@@ -17,6 +17,7 @@ import {
   groupViolationsBySeverity
 } from './reporter-utils.js';
 import { getReportCardAsciiLines } from './reporter-ascii.js';
+import { renderGroupedViolationsTerminal } from './reporter-grouping.js';
 
 export const formatGradeFSection = (report) => {
   const { violations, hotspots, pillars } = report;
@@ -44,12 +45,8 @@ export const formatGradeFSection = (report) => {
     lines.push(`   ${DIM}Codebase is free of extreme monoliths (>2,000 lines of code) and critical violations.${RESET}`);
   } else {
     if (critical.length > 0) {
-      lines.push(`\n   ${BOLD}${RED}🚨 CRITICAL AST VIOLATIONS (${critical.length}):${RESET}`);
-      critical.forEach((v, idx) => {
-        lines.push(`   ${RED}[#${idx + 1} CRITICAL]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
-        lines.push(`      Hazard:    ${v.hazard}`);
-        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
-      });
+      lines.push(`\n   ${BOLD}${RED}🚨 CRITICAL AST VIOLATIONS (${critical.length}):${RESET}\n`);
+      lines.push(renderGroupedViolationsTerminal(critical));
     }
 
     if (extremeMonoliths.length > 0) {
@@ -105,12 +102,8 @@ export const formatGradeDSection = (report) => {
     lines.push(`   ${DIM}No severe monoliths (1,000-1,999 lines of code) or saturated hook anti-patterns.${RESET}`);
   } else {
     if (high.length > 0) {
-      lines.push(`\n   ${BOLD}${ORANGE}⚠️  HIGH SEVERITY VIOLATIONS (${high.length}):${RESET}`);
-      high.forEach((v, idx) => {
-        lines.push(`   ${ORANGE}[#${idx + 1} HIGH]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
-        lines.push(`      Hazard:    ${v.hazard}`);
-        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
-      });
+      lines.push(`\n   ${BOLD}${ORANGE}⚠️  HIGH SEVERITY VIOLATIONS (${high.length}):${RESET}\n`);
+      lines.push(renderGroupedViolationsTerminal(high));
     }
 
     if (severeMonoliths.length > 0) {
@@ -163,12 +156,8 @@ export const formatGradeCSection = (report) => {
     lines.push(`   ${DIM}All files remain under 500 lines with clean styling and handlers.${RESET}`);
   } else {
     if (medium.length > 0) {
-      lines.push(`\n   ${BOLD}${CYAN}⚡ MEDIUM SEVERITY VIOLATIONS (${medium.length}):${RESET}`);
-      medium.forEach((v, idx) => {
-        lines.push(`   ${YELLOW}[#${idx + 1} MED]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
-        lines.push(`      Hazard:    ${v.hazard}`);
-        lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
-      });
+      lines.push(`\n   ${BOLD}${CYAN}⚡ MEDIUM SEVERITY VIOLATIONS (${medium.length}):${RESET}\n`);
+      lines.push(renderGroupedViolationsTerminal(medium));
     }
 
     if (warningMonoliths.length > 0) {
@@ -209,12 +198,8 @@ export const formatGradeBSection = (report) => {
     lines.push(`\n   ${GREEN}✔ Outstanding hygiene! Zero Grade B issues detected.${RESET}`);
     lines.push(`   ${DIM}Zero em dashes and zero unguarded console statements found.${RESET}`);
   } else {
-    lines.push(`\n   ${BOLD}${YELLOW}ℹ️  LOW HYGIENE VIOLATIONS (${low.length}):${RESET}`);
-    low.forEach((v, idx) => {
-      lines.push(`   ${YELLOW}[#${idx + 1} LOW]${RESET} [${v.rule}] ${YELLOW}${v.filePath}:${v.line}:${v.column}${RESET}`);
-      lines.push(`      Hazard:    ${v.hazard}`);
-      lines.push(`      Directive: ${CYAN}${v.directive}${RESET}\n`);
-    });
+    lines.push(`\n   ${BOLD}${YELLOW}ℹ️  LOW HYGIENE VIOLATIONS (${low.length}):${RESET}\n`);
+    lines.push(renderGroupedViolationsTerminal(low));
   }
 
   const promptB = buildGradeBPrompt(report);
@@ -240,11 +225,11 @@ export const formatGradeASection = (report) => {
   lines.push(`${DIM}   Molecular Architecture verified clean areas and crystalline modules${RESET}`);
   lines.push(`${GREEN}======================================================================${RESET}`);
   lines.push(`   Molecular Health Score:  ${BOLD}${GREEN}${health.score}/100${RESET} [Grade: ${BOLD}${GREEN}${health.grade}${RESET}]`);
-  lines.push(`   Passing Pillars:       ${BOLD}${GREEN}${passedPillars.length} / 7 Pillars PASSED${RESET}`);
+  lines.push(`   Passing Pillars:       ${BOLD}${GREEN}${passedPillars.length} / ${Object.keys(pillars).length} Pillars PASSED${RESET}`);
   lines.push(`   Capsule Compliance:    ${BOLD}${GREEN}${metrics.moleculeCompliantPct}%${RESET} compliant (< 100 lines of code)`);
   lines.push(`${GREEN}----------------------------------------------------------------------${RESET}`);
 
-  lines.push(`\n   ${BOLD}${GREEN}✔ COMPLIANT PILLARS (${passedPillars.length} / 7):${RESET}`);
+  lines.push(`\n   ${BOLD}${GREEN}✔ COMPLIANT PILLARS (${passedPillars.length} / ${Object.keys(pillars).length}):${RESET}`);
   if (passedPillars.length === 0) {
     lines.push(`   ${YELLOW}No pillars are currently 100% compliant.${RESET}\n`);
   } else {

package/cli/audit/reporter-grouping-markdown.js

@@ -0,0 +1,83 @@
+import path from 'node:path';
+import {
+  groupViolationsByDirectory,
+  groupViolationsByRule
+} from './reporter-grouping.js';
+
+export const formatDirectoryRollupMarkdown = (violations = []) => {
+  const dirGroups = groupViolationsByDirectory(violations);
+  const lines = [];
+
+  lines.push('### Directory Hazard Rollup');
+  lines.push('');
+
+  const hasNoViolations = dirGroups.length === 0;
+  if (hasNoViolations) {
+    lines.push('🟢 Zero violations detected across all project directories.');
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  lines.push('| Directory | Total Hazards | Critical | High | Med | Low | Primary Hazards |');
+  lines.push('| :--- | :---: | :---: | :---: | :---: | :---: | :--- |');
+
+  for (const g of dirGroups) {
+    const topHazards = g.topRules
+      .slice(0, 2)
+      .map((r) => `\`${r.rule}\` (${r.count})`)
+      .join(', ');
+    const displayHazards = topHazards || 'None';
+    lines.push(`| \`${g.directory}\` | **${g.total}** | ${g.critical} | ${g.high} | ${g.medium} | ${g.low} | ${displayHazards} |`);
+  }
+  lines.push('');
+
+  return lines.join('\n');
+};
+
+export const renderGroupedViolationsMarkdown = (violations = [], options = {}) => {
+  const { showSeverity = false } = options;
+  const hasNoViolations = violations.length === 0;
+  if (hasNoViolations) return '';
+
+  const ruleGroups = groupViolationsByRule(violations);
+  const lines = [];
+
+  const headers = showSeverity
+    ? '| Rule | Severity | Count | Directive | Affected Locations by Directory |'
+    : '| Rule | Count | Directive | Affected Locations by Directory |';
+  const divider = showSeverity
+    ? '| :--- | :---: | :---: | :--- | :--- |'
+    : '| :--- | :---: | :--- | :--- |';
+
+  lines.push(headers);
+  lines.push(divider);
+
+  for (const rg of ruleGroups) {
+    const dirSummaries = rg.directories.map((d) => {
+      const formatLocationItem = (v) => {
+        const base = path.basename(v.filePath);
+        return `\`${base}:${v.line}\``;
+      };
+
+      const locList = d.violations.slice(0, 3).map(formatLocationItem);
+      const remaining = d.violations.length - 3;
+      const hasRemaining = remaining > 0;
+      if (hasRemaining) {
+        locList.push(`*(+${remaining} more)*`);
+      }
+      return `📁 **\`${d.directory}\`** (${d.count}): ${locList.join(', ')}`;
+    });
+
+    const locationCell = dirSummaries.join('<br>');
+    const sanitizedDirective = rg.directive.replace(/\|/g, '\\|');
+
+    if (showSeverity) {
+      lines.push(`| \`${rg.rule}\` | ${rg.severity} | **${rg.total}** | ${sanitizedDirective} | ${locationCell} |`);
+    } else {
+      lines.push(`| \`${rg.rule}\` | **${rg.total}** | ${sanitizedDirective} | ${locationCell} |`);
+    }
+  }
+  lines.push('');
+
+  return lines.join('\n');
+};