claude-presentation-master 7.4.0 → 8.1.0

package/dist/index.js

@@ -30,13 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AutoFixEngine: () => AutoFixEngine,
   ChartJsProvider: () => ChartJsProvider,
   CompositeChartProvider: () => CompositeChartProvider,
   CompositeImageProvider: () => CompositeImageProvider,
   ContentAnalyzer: () => ContentAnalyzer,
   ContentPatternClassifier: () => ContentPatternClassifier,
-  IterativeQAEngine: () => IterativeQAEngine,
   KnowledgeGateway: () => KnowledgeGateway,
   LocalImageProvider: () => LocalImageProvider,
   MermaidProvider: () => MermaidProvider,
@@ -48,7 +46,6 @@ __export(index_exports, {
   QuickChartProvider: () => QuickChartProvider,
   RevealJsGenerator: () => RevealJsGenerator,
   ScoreCalculator: () => ScoreCalculator,
-  SevenDimensionScorer: () => SevenDimensionScorer,
   SlideFactory: () => SlideFactory,
   SlideGenerator: () => SlideGenerator,
   TemplateEngine: () => TemplateEngine,
@@ -56,12 +53,12 @@ __export(index_exports, {
   UnsplashImageProvider: () => UnsplashImageProvider,
   VERSION: () => VERSION,
   ValidationError: () => ValidationError,
-  createAutoFixEngine: () => createAutoFixEngine,
+  VisualQualityEvaluator: () => VisualQualityEvaluator,
   createDefaultChartProvider: () => createDefaultChartProvider,
   createDefaultImageProvider: () => createDefaultImageProvider,
-  createIterativeQAEngine: () => createIterativeQAEngine,
   createSlideFactory: () => createSlideFactory,
   default: () => index_default,
+  evaluatePresentation: () => evaluatePresentation,
   generate: () => generate,
   getKnowledgeGateway: () => getKnowledgeGateway,
   initSlideGenerator: () => initSlideGenerator,
@@ -97,6 +94,11 @@ var TemplateNotFoundError = class extends Error {
   }
 };
 
+// src/core/PresentationEngine.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+
 // src/kb/KnowledgeGateway.ts
 var import_fs = require("fs");
 var import_path = require("path");
@@ -200,12 +202,12 @@ var KnowledgeGateway = class {
       (0, import_path.join)(process.cwd(), "assets/presentation-knowledge.yaml"),
       (0, import_path.join)(process.cwd(), "node_modules/claude-presentation-master/assets/presentation-knowledge.yaml")
     ];
-    for (const path of possiblePaths) {
+    for (const path3 of possiblePaths) {
       try {
-        const content = (0, import_fs.readFileSync)(path, "utf-8");
+        const content = (0, import_fs.readFileSync)(path3, "utf-8");
         this.kb = yaml.parse(content);
         this.loaded = true;
-        logger.step(`Knowledge base loaded from ${path}`);
+        logger.step(`Knowledge base loaded from ${path3}`);
         return;
       } catch {
       }
@@ -230,33 +232,54 @@ var KnowledgeGateway = class {
     return "keynote";
   }
   /**
-   * Get word limits for the specified mode
+   * Get word limits for the specified mode.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getWordLimits(mode) {
+    this.ensureLoaded();
     const modeConfig = this.getMode(mode);
-    const range = modeConfig.characteristics.words_per_slide;
-    if (mode === "keynote") {
-      return { min: 6, max: 15, ideal: 10 };
-    } else {
-      return { min: 40, max: 80, ideal: 60 };
+    const rangeStr = modeConfig.characteristics.words_per_slide;
+    const match = rangeStr.match(/(\d+)-(\d+)/);
+    if (!match || !match[1] || !match[2]) {
+      throw new Error(`[KB ERROR] Invalid words_per_slide format in KB for ${mode}: "${rangeStr}". Expected "min-max" format.`);
     }
+    const min = parseInt(match[1], 10);
+    const max = parseInt(match[2], 10);
+    const ideal = Math.round((min + max) / 2);
+    logger.debug(`[KB] getWordLimits(${mode}): min=${min}, max=${max}, ideal=${ideal} (from KB: "${rangeStr}")`);
+    return { min, max, ideal };
   }
   /**
-   * Get bullet point limits
+   * Get bullet point limits.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getBulletLimits(mode) {
-    if (mode === "keynote") {
-      return { maxBullets: 3, maxWordsPerBullet: 8 };
-    } else {
-      return { maxBullets: 5, maxWordsPerBullet: 20 };
+    this.ensureLoaded();
+    const type = mode === "keynote" ? "ted_keynote" : "consulting_deck";
+    const typeConfig = this.kb.presentation_types?.[type];
+    if (typeConfig?.validation_rules?.bullets_per_slide) {
+      const maxBullets = typeConfig.validation_rules.bullets_per_slide.max;
+      const wordLimits = this.getWordLimits(mode);
+      const maxWordsPerBullet = maxBullets > 0 ? Math.floor(wordLimits.max / maxBullets) : 0;
+      logger.debug(`[KB] getBulletLimits(${mode}): maxBullets=${maxBullets}, maxWordsPerBullet=${maxWordsPerBullet} (from KB presentation_types.${type})`);
+      return { maxBullets, maxWordsPerBullet };
     }
+    throw new Error(`[KB ERROR] Missing bullets_per_slide in KB for presentation_types.${type}.validation_rules`);
   }
   /**
-   * Get whitespace percentage requirement
+   * Get whitespace percentage requirement.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getWhitespaceRequirement(mode) {
-    if (mode === "keynote") return 0.4;
-    return 0.25;
+    this.ensureLoaded();
+    const type = mode === "keynote" ? "ted_keynote" : "consulting_deck";
+    const typeConfig = this.kb.presentation_types?.[type];
+    if (typeConfig?.validation_rules?.whitespace?.min) {
+      const whitespace = typeConfig.validation_rules.whitespace.min / 100;
+      logger.debug(`[KB] getWhitespaceRequirement(${mode}): ${whitespace} (from KB presentation_types.${type})`);
+      return whitespace;
+    }
+    throw new Error(`[KB ERROR] Missing whitespace.min in KB for presentation_types.${type}.validation_rules`);
   }
   /**
    * Get slide templates for the specified mode
@@ -367,29 +390,54 @@ var KnowledgeGateway = class {
     return null;
   }
   /**
-   * Get Duarte's glance test requirements
+   * Get Duarte's glance test requirements.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getDuarteGlanceTest() {
     this.ensureLoaded();
-    const duarte = this.kb.experts.nancy_duarte;
-    return {
-      wordLimit: duarte.core_principles.glance_test.word_limit || 25,
-      timeSeconds: 3
-    };
+    const duarte = this.kb.experts?.nancy_duarte;
+    if (!duarte?.core_principles?.glance_test?.word_limit) {
+      throw new Error("[KB ERROR] Missing experts.nancy_duarte.core_principles.glance_test.word_limit in KB");
+    }
+    if (!duarte?.core_principles?.glance_test?.time_limit) {
+      throw new Error("[KB ERROR] Missing experts.nancy_duarte.core_principles.glance_test.time_limit in KB");
+    }
+    const wordLimit = duarte.core_principles.glance_test.word_limit;
+    const timeSeconds = parseInt(duarte.core_principles.glance_test.time_limit.replace(/\D/g, ""), 10);
+    logger.debug(`[KB] getDuarteGlanceTest(): wordLimit=${wordLimit}, timeSeconds=${timeSeconds} (from KB experts.nancy_duarte)`);
+    return { wordLimit, timeSeconds };
   }
   /**
-   * Get Miller's Law constraints
+   * Get Miller's Law constraints.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getMillersLaw() {
     this.ensureLoaded();
-    return { minItems: 5, maxItems: 9 };
+    const millersLaw = this.kb.cognitive_science?.millers_law;
+    if (!millersLaw?.principle) {
+      throw new Error("[KB ERROR] Missing cognitive_science.millers_law.principle in KB");
+    }
+    const match = millersLaw.principle.match(/(\d+)\s*[±+-]\s*(\d+)/);
+    if (!match) {
+      throw new Error(`[KB ERROR] Cannot parse Miller's Law from KB: "${millersLaw.principle}". Expected format: "7 \xB1 2"`);
+    }
+    const center = parseInt(match[1], 10);
+    const range = parseInt(match[2], 10);
+    const minItems = center - range;
+    const maxItems = center + range;
+    logger.debug(`[KB] getMillersLaw(): minItems=${minItems}, maxItems=${maxItems} (from KB: "${millersLaw.principle}")`);
+    return { minItems, maxItems };
   }
   /**
-   * Get cognitive load constraints
+   * Get cognitive load constraints.
+   * READS FROM KB - NO HARDCODED VALUES.
    */
   getCognitiveLoadLimits() {
     this.ensureLoaded();
-    return { maxItemsPerChunk: 7 };
+    const millers = this.getMillersLaw();
+    const maxItemsPerChunk = millers.maxItems - 2;
+    logger.debug(`[KB] getCognitiveLoadLimits(): maxItemsPerChunk=${maxItemsPerChunk} (derived from Miller's Law)`);
+    return { maxItemsPerChunk };
   }
   /**
    * Get chart selection guidance
@@ -453,42 +501,40 @@ var KnowledgeGateway = class {
     this.ensureLoaded();
     const typeConfig = this.kb.presentation_types?.[type];
     if (!typeConfig?.validation_rules) {
-      const mode = this.getModeForType(type);
-      return mode === "keynote" ? {
-        wordsPerSlide: { min: 1, max: 25, ideal: 10 },
-        whitespace: { min: 40, ideal: 50 },
-        bulletsPerSlide: { max: 3 },
-        actionTitlesRequired: false,
-        sourcesRequired: false
-      } : {
-        wordsPerSlide: { min: 40, max: 80, ideal: 60 },
-        whitespace: { min: 25, ideal: 30 },
-        bulletsPerSlide: { max: 5 },
-        actionTitlesRequired: true,
-        sourcesRequired: true
-      };
+      throw new Error(`[KB ERROR] Missing presentation_types.${type}.validation_rules in KB. Cannot proceed without KB rules.`);
     }
     const rules = typeConfig.validation_rules;
-    return {
+    if (rules.words_per_slide?.max === void 0) {
+      throw new Error(`[KB ERROR] Missing presentation_types.${type}.validation_rules.words_per_slide.max in KB`);
+    }
+    if (rules.whitespace?.min === void 0) {
+      throw new Error(`[KB ERROR] Missing presentation_types.${type}.validation_rules.whitespace.min in KB`);
+    }
+    if (rules.bullets_per_slide?.max === void 0) {
+      throw new Error(`[KB ERROR] Missing presentation_types.${type}.validation_rules.bullets_per_slide.max in KB`);
+    }
+    const result = {
       wordsPerSlide: {
-        min: rules.words_per_slide?.min ?? 1,
-        max: rules.words_per_slide?.max ?? 80,
-        ideal: rules.words_per_slide?.ideal ?? 40
+        min: rules.words_per_slide.min,
+        max: rules.words_per_slide.max,
+        ideal: rules.words_per_slide.ideal
       },
       whitespace: {
-        min: rules.whitespace?.min ?? 25,
-        ideal: rules.whitespace?.ideal ?? 30
+        min: rules.whitespace.min,
+        ideal: rules.whitespace.ideal
       },
       bulletsPerSlide: {
-        max: rules.bullets_per_slide?.max ?? 5
+        max: rules.bullets_per_slide.max
       },
-      actionTitlesRequired: rules.action_titles_required ?? false,
-      sourcesRequired: rules.sources_required ?? false,
+      actionTitlesRequired: rules.action_titles_required,
+      sourcesRequired: rules.sources_required,
       calloutsRequired: rules.callouts_required,
       denseDataAllowed: rules.dense_data_allowed,
       codeBlocksAllowed: rules.code_blocks_allowed,
       diagramsRequired: rules.diagrams_required
     };
+    logger.debug(`[KB] getValidationRules(${type}): words=${result.wordsPerSlide.min}-${result.wordsPerSlide.max}, bullets=${result.bulletsPerSlide.max}, whitespace=${result.whitespace.min}%`);
+    return result;
   }
   /**
    * Get required elements that MUST be in the deck for this type.
@@ -598,39 +644,146 @@ var KnowledgeGateway = class {
    * Map a content pattern to the best allowed slide type.
    * CRITICAL: This is how SlideFactory decides which slide type to use.
    */
+  /**
+   * Map semantic slide types to structural types that SlideFactory can handle.
+   * This bridges the gap between KB's rich semantic types and code's structural types.
+   */
+  normalizeToStructuralType(semanticType) {
+    const normalizedType = semanticType.toLowerCase().replace(/_/g, "-");
+    const structuralTypes = /* @__PURE__ */ new Set([
+      "title",
+      "agenda",
+      "thank-you",
+      "cta",
+      "single-statement",
+      "big-number",
+      "quote",
+      "bullet-points",
+      "two-column",
+      "three-column",
+      "three-points",
+      "comparison",
+      "timeline",
+      "process",
+      "metrics-grid",
+      "data-insight",
+      "full-image",
+      "screenshot",
+      "code-snippet",
+      "title-impact"
+    ]);
+    if (structuralTypes.has(normalizedType)) {
+      return normalizedType;
+    }
+    const semanticToStructural = {
+      // TED Keynote semantic types
+      "star-moment": "single-statement",
+      "call-to-action": "cta",
+      // Sales pitch semantic types
+      "problem-statement": "single-statement",
+      "solution-overview": "single-statement",
+      "social-proof": "quote",
+      "testimonial": "quote",
+      "pricing": "metrics-grid",
+      "demo-screenshot": "screenshot",
+      // Consulting deck semantic types
+      "executive-summary-scr": "bullet-points",
+      "executive-summary": "bullet-points",
+      "mece-breakdown": "three-column",
+      "process-timeline": "timeline",
+      "recommendation": "single-statement",
+      "risks-mitigation": "two-column",
+      "next-steps": "bullet-points",
+      "detailed-findings": "bullet-points",
+      // Investment banking semantic types
+      "situation-overview": "bullet-points",
+      "credentials": "metrics-grid",
+      "valuation-summary": "metrics-grid",
+      "football-field": "comparison",
+      "comparable-companies": "metrics-grid",
+      "precedent-transactions": "metrics-grid",
+      "dcf-summary": "metrics-grid",
+      "waterfall-bridge": "timeline",
+      "sources-uses": "two-column",
+      "risk-factors": "bullet-points",
+      // Investor pitch semantic types
+      "problem": "single-statement",
+      "solution": "single-statement",
+      "market-size": "big-number",
+      "product": "three-points",
+      "business-model": "three-column",
+      "traction": "metrics-grid",
+      "competition": "comparison",
+      "team": "three-column",
+      "financials": "metrics-grid",
+      "ask": "single-statement",
+      // Technical presentation semantic types
+      "architecture-diagram": "full-image",
+      "data-flow": "full-image",
+      "metrics": "metrics-grid",
+      "tradeoffs": "comparison",
+      // All hands semantic types
+      "celebration": "single-statement",
+      "announcement": "single-statement",
+      "milestones": "timeline",
+      "team-recognition": "three-column",
+      "roadmap": "timeline"
+    };
+    return semanticToStructural[normalizedType] || "bullet-points";
+  }
   mapContentPatternToSlideType(pattern, allowedTypes) {
     const patternToTypes = {
-      big_number: ["big_number", "big-number", "data_insight", "metrics_grid", "metrics-grid"],
-      comparison: ["comparison", "options_comparison", "two_column", "two-column"],
-      timeline: ["timeline", "process_timeline", "process", "roadmap"],
-      process: ["process", "process_timeline", "timeline", "three_column", "three-column"],
-      metrics: ["metrics_grid", "metrics-grid", "data_insight", "big_number", "big-number"],
-      quote: ["quote", "testimonial", "social_proof", "social-proof"],
-      code: ["code_snippet", "technical", "two_column", "two-column"],
-      bullets: ["bullet_points", "bullet-points", "detailed_findings", "two_column", "two-column"],
-      prose: ["two_column", "two-column", "bullet_points", "bullet-points", "single_statement"]
+      big_number: ["big-number", "metrics-grid", "single-statement"],
+      comparison: ["comparison", "two-column", "three-column"],
+      timeline: ["timeline", "process", "three-points", "bullet-points"],
+      process: ["process", "timeline", "three-column", "three-points", "bullet-points"],
+      metrics: ["metrics-grid", "big-number", "three-points"],
+      quote: ["quote", "single-statement"],
+      code: ["code-snippet", "two-column"],
+      bullets: ["bullet-points", "three-points", "three-column", "two-column", "process"],
+      prose: ["single-statement", "title-impact", "two-column"]
     };
+    if (pattern.primaryPattern === "process" || pattern.primaryPattern === "bullets") {
+      if (pattern.bulletCount === 3) {
+        const threePointTypes = ["three-points", "three-column"];
+        for (const t of threePointTypes) {
+          if (this.isTypeAllowed(t, allowedTypes)) return t;
+        }
+      }
+      if (pattern.bulletCount && pattern.bulletCount >= 2 && pattern.bulletCount <= 6) {
+        const processTypes = ["timeline", "process", "bullet-points"];
+        for (const t of processTypes) {
+          if (this.isTypeAllowed(t, allowedTypes)) return t;
+        }
+      }
+    }
     const preferredTypes = patternToTypes[pattern.primaryPattern] || patternToTypes.prose || [];
     for (const preferred of preferredTypes) {
-      const underscoreVersion = preferred.replace(/-/g, "_");
-      const dashVersion = preferred.replace(/_/g, "-");
-      if (allowedTypes.includes(preferred)) return preferred;
-      if (allowedTypes.includes(underscoreVersion)) return underscoreVersion;
-      if (allowedTypes.includes(dashVersion)) return dashVersion;
-    }
-    const contentTypes = [
-      "bullet_points",
-      "bullet-points",
-      "two_column",
-      "two-column",
-      "three_column",
-      "three-column",
-      "data_insight"
-    ];
+      if (this.isTypeAllowed(preferred, allowedTypes)) {
+        return preferred;
+      }
+    }
+    const contentTypes = ["bullet-points", "three-points", "single-statement"];
     for (const ct of contentTypes) {
-      if (allowedTypes.includes(ct)) return ct;
+      if (this.isTypeAllowed(ct, allowedTypes)) return ct;
+    }
+    return this.normalizeToStructuralType(allowedTypes[0] ?? "bullet-points");
+  }
+  /**
+   * Check if a structural type is allowed (directly or via semantic mapping)
+   */
+  isTypeAllowed(structuralType, allowedTypes) {
+    const normalized = structuralType.toLowerCase().replace(/_/g, "-");
+    const underscored = normalized.replace(/-/g, "_");
+    if (allowedTypes.includes(normalized) || allowedTypes.includes(underscored)) {
+      return true;
+    }
+    for (const allowed of allowedTypes) {
+      if (this.normalizeToStructuralType(allowed) === normalized) {
+        return true;
+      }
     }
-    return allowedTypes[0] ?? "bullet-points";
+    return false;
   }
   /**
    * Get a specific slide template by name from the KB.
@@ -691,9 +844,11 @@ var KnowledgeGateway = class {
         optionLabels: ["Option A", "Option B", "Option C", "Option D"]
       },
       column: { labelTemplate: "Point {n}" },
-      subtitle: { maxWords: Math.min(15, Math.floor(maxWords / 3)) },
+      // Subtitle needs more room for complete phrases - at least 10 words for keynote
+      subtitle: { maxWords: mode === "keynote" ? 12 : Math.min(20, Math.floor(maxWords / 2)) },
       context: { maxWords: Math.min(30, Math.floor(maxWords / 2)) },
-      step: { maxWords: Math.min(20, Math.floor(maxWords / 4)) },
+      // Step descriptions need minimum 8 words for meaningful content
+      step: { maxWords: Math.max(8, Math.min(20, Math.floor(maxWords / 3))) },
       columnContent: { maxWords: Math.min(25, Math.floor(maxWords / 3)) }
     };
   }
@@ -1046,7 +1201,14 @@ var ContentAnalyzer = class {
       if (foundTitle && i > titleLineIndex && line.length > 0) {
         if (line.startsWith("#")) break;
         if (line.startsWith("-") || line.startsWith("*") || /^\d+\./.test(line)) break;
-        subtitle = line.replace(/\*\*/g, "").trim().slice(0, 100);
+        const cleanLine = line.replace(/\*\*/g, "").trim();
+        if (cleanLine.length <= 120) {
+          subtitle = cleanLine;
+        } else {
+          const truncated = cleanLine.slice(0, 120);
+          const lastSpace = truncated.lastIndexOf(" ");
+          subtitle = lastSpace > 80 ? truncated.slice(0, lastSpace) : truncated;
+        }
         break;
       }
     }
@@ -1169,7 +1331,60 @@ var ContentAnalyzer = class {
         sections.push(currentSection);
       }
     }
-    return sections;
+    return this.combineParentChildSections(sections);
+  }
+  /**
+   * Combine parent sections with their child sub-sections.
+   * Detects patterns like "Three Pillars" + 3 child sections and merges them.
+   */
+  combineParentChildSections(sections) {
+    const result = [];
+    let i = 0;
+    while (i < sections.length) {
+      const current = sections[i];
+      if (current && current.level === 2 && (!current.content || current.content.length < 20) && current.bullets.length === 0) {
+        const children = [];
+        let j = i + 1;
+        while (j < sections.length && children.length < 4) {
+          const child = sections[j];
+          if (!child || child.level !== 3) break;
+          children.push(child);
+          j++;
+        }
+        if (children.length >= 2 && children.length <= 4) {
+          const combined = {
+            header: current.header,
+            level: current.level,
+            content: "",
+            // Will use bullets instead
+            bullets: children.map((child) => {
+              const title = child.header.replace(/^\d+\.\s*/, "").trim();
+              if (child.content) {
+                return `**${title}**: ${child.content.split("\n")[0] || ""}`;
+              }
+              return title;
+            }),
+            metrics: [
+              ...current.metrics,
+              ...children.flatMap((c) => c.metrics)
+            ],
+            // Add sub-sections as a property for advanced slide types
+            subSections: children.map((child) => ({
+              title: child.header.replace(/^\d+\.\s*/, "").trim(),
+              content: child.content
+            }))
+          };
+          result.push(combined);
+          i = j;
+          continue;
+        }
+      }
+      if (current) {
+        result.push(current);
+      }
+      i++;
+    }
+    return result;
   }
   /**
    * Extract SCQA structure (Barbara Minto)
@@ -1752,11 +1967,538 @@ var ContentPatternClassifier = class {
   }
 };
 
+// src/kb/ExpertGuidanceEngine.ts
+var ExpertGuidanceEngine = class {
+  kb;
+  presentationType;
+  constructor(kb, presentationType) {
+    this.kb = kb;
+    this.presentationType = presentationType;
+  }
+  /**
+   * Get the narrative arc for this presentation type.
+   * Returns the story structure with required elements and their purposes.
+   */
+  getNarrativeArc() {
+    const mode = this.kb.getModeForType(this.presentationType);
+    if (mode === "keynote") {
+      return {
+        framework: "Duarte Sparkline",
+        expert: "Nancy Duarte",
+        description: "Alternate between What Is (current reality) and What Could Be (possibility), building emotional tension to a climax, then resolve with New Bliss",
+        elements: [
+          {
+            id: "opening_hook",
+            name: "Opening Hook",
+            purpose: "Grab attention in first 10 seconds with something unexpected",
+            expertSource: 'Chris Anderson: "You have one chance to hook them"',
+            designPrinciples: [
+              "Start with a story, question, or surprising fact",
+              "Create curiosity gap - make them NEED to know more",
+              "Touch heart before head (Gallo)"
+            ],
+            required: true
+          },
+          {
+            id: "what_is",
+            name: "What Is (Current Reality)",
+            purpose: "Establish the current state that audience recognizes",
+            expertSource: 'Nancy Duarte: "Ground them in familiar reality"',
+            designPrinciples: [
+              "Use concrete, recognizable situations",
+              "Create emotional resonance with current pain",
+              "Keep it brief - setup for contrast"
+            ],
+            required: true
+          },
+          {
+            id: "what_could_be",
+            name: "What Could Be (Vision)",
+            purpose: "Paint the picture of the transformed future",
+            expertSource: 'Nancy Duarte: "Make them FEEL the possibility"',
+            designPrinciples: [
+              "Be specific and vivid about the future state",
+              "Connect emotionally - how will they FEEL?",
+              "Create contrast with What Is"
+            ],
+            required: true
+          },
+          {
+            id: "star_moment",
+            name: "STAR Moment",
+            purpose: "Something They'll Always Remember - the emotional climax",
+            expertSource: 'Nancy Duarte: "One dramatic memorable moment"',
+            designPrinciples: [
+              "Make it unexpected and emotionally impactful",
+              "Use a dramatic statistic, story, or demonstration",
+              "This is what they'll tell others about",
+              "It should give them chills or make them gasp"
+            ],
+            required: true
+          },
+          {
+            id: "call_to_action",
+            name: "Call to Action",
+            purpose: "Clear next step that audience can take",
+            expertSource: 'Chris Anderson: "Give them something to DO"',
+            designPrinciples: [
+              "Be specific and actionable",
+              "Make it achievable - first step, not whole journey",
+              "Connect action to the vision you painted"
+            ],
+            required: true
+          },
+          {
+            id: "new_bliss",
+            name: "New Bliss (Resolution)",
+            purpose: "Leave them with the transformed future firmly in mind",
+            expertSource: 'Nancy Duarte: "End with the new world, not the old"',
+            designPrinciples: [
+              "Reinforce the vision one final time",
+              "Make them want to be part of it",
+              "End on emotional high, not logistics"
+            ],
+            required: false
+          }
+        ]
+      };
+    } else {
+      return {
+        framework: "Minto Pyramid (SCQA)",
+        expert: "Barbara Minto",
+        description: "Lead with the answer/recommendation, then support with evidence in MECE structure",
+        elements: [
+          {
+            id: "situation",
+            name: "Situation",
+            purpose: "Context the audience already knows and agrees with",
+            expertSource: 'Barbara Minto: "Start from common ground"',
+            designPrinciples: [
+              "Facts everyone agrees on",
+              "Recent and relevant context",
+              "Brief - not the star of the show"
+            ],
+            required: true
+          },
+          {
+            id: "complication",
+            name: "Complication",
+            purpose: "The problem, threat, or opportunity that requires action",
+            expertSource: 'Barbara Minto: "Why are we here?"',
+            designPrinciples: [
+              "Clear articulation of the challenge",
+              "Why the status quo is unacceptable",
+              "Creates urgency for the answer"
+            ],
+            required: true
+          },
+          {
+            id: "answer",
+            name: "Answer/Recommendation",
+            purpose: "The core recommendation - upfront, not buried",
+            expertSource: 'Barbara Minto: "Answer first, evidence second"',
+            designPrinciples: [
+              "Clear, actionable recommendation",
+              "Use an action title that states the conclusion",
+              "Executive should understand even if they stop here"
+            ],
+            required: true
+          },
+          {
+            id: "evidence",
+            name: "Supporting Evidence",
+            purpose: "MECE support for the recommendation",
+            expertSource: 'Barbara Minto: "Mutually Exclusive, Collectively Exhaustive"',
+            designPrinciples: [
+              "Group into 3-5 supporting pillars",
+              "Each pillar has sub-evidence",
+              "No gaps, no overlaps (MECE)",
+              "Use action titles throughout"
+            ],
+            required: true
+          },
+          {
+            id: "next_steps",
+            name: "Next Steps",
+            purpose: "Clear actions with owners and timelines",
+            expertSource: 'Analyst Academy: "End with who does what by when"',
+            designPrinciples: [
+              'Specific actions, not vague "follow up"',
+              "Named owners where possible",
+              "Realistic timelines"
+            ],
+            required: true
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Get expert guidance for designing a specific type of slide.
+   * This returns PRINCIPLES for excellence, not constraints.
+   */
+  getSlideDesignGuidance(slideType) {
+    const mode = this.kb.getModeForType(this.presentationType);
+    switch (slideType) {
+      case "title":
+      case "title_impact":
+        return {
+          purpose: "Create immediate emotional connection and establish the one idea worth spreading",
+          principles: [
+            {
+              expert: "Chris Anderson",
+              principle: "One Idea Worth Spreading",
+              application: "The title should encapsulate a single powerful idea that the audience will remember",
+              technique: "Ask: If they remember ONE thing, what should it be? That's your title."
+            },
+            {
+              expert: "Carmine Gallo",
+              principle: "Headline Test",
+              application: "Title should work as a Twitter headline - compelling in under 280 characters",
+              technique: "Write 10 versions, pick the one that makes you want to hear more"
+            },
+            {
+              expert: "Nancy Duarte",
+              principle: "Glance Test",
+              application: "Audience should grasp the essence in 3 seconds",
+              technique: "Show it to someone for 3 seconds, ask what they remember"
+            }
+          ],
+          whatMakesItGreat: [
+            "Creates curiosity - makes audience WANT to hear more",
+            "Emotionally resonant - connects to something they care about",
+            "Unexpected angle - not the obvious framing",
+            "Memorable - they could repeat it to someone else"
+          ],
+          antiPatterns: [
+            'Generic topic labels ("Q4 Update")',
+            "Long sentences that require reading",
+            "Jargon or acronyms",
+            "Multiple ideas competing for attention"
+          ],
+          questions: [
+            "Would someone share this title with a colleague?",
+            "Does it create a curiosity gap?",
+            "Can you understand the value in 3 seconds?",
+            "Is there emotional resonance?"
+          ]
+        };
+      case "single_statement":
+      case "big_idea":
+        return {
+          purpose: "Communicate ONE powerful insight that shifts perspective",
+          principles: [
+            {
+              expert: "Garr Reynolds",
+              principle: "Signal to Noise",
+              application: "Everything on the slide should serve the one message. Eliminate ruthlessly.",
+              technique: "For each element, ask: Does this AMPLIFY the message or distract from it?"
+            },
+            {
+              expert: "Garr Reynolds",
+              principle: "Amplification Through Simplification",
+              application: "Empty space makes the remaining content more powerful",
+              technique: "Try removing 50% of what's there. Is it clearer?"
+            },
+            {
+              expert: "Nancy Duarte",
+              principle: "Audience Paradox",
+              application: "They will read OR listen, never both. Design for one.",
+              technique: "If presenting live, the statement should be short enough to absorb while listening"
+            }
+          ],
+          whatMakesItGreat: [
+            "One clear insight that shifts thinking",
+            "Ample whitespace that emphasizes the message",
+            "Words are carefully chosen - each one earns its place",
+            "Can be absorbed in a glance"
+          ],
+          antiPatterns: [
+            "Cramming multiple points onto one slide",
+            'Adding "supporting" text that dilutes the message',
+            "Decorative elements that don't serve the idea",
+            "Topic labels instead of insights"
+          ],
+          questions: [
+            "What is the ONE thing this slide should communicate?",
+            "If I remove this word/element, is the message clearer?",
+            "Will this shift how they think about the topic?"
+          ]
+        };
+      case "star_moment":
+        return {
+          purpose: "Create the moment they'll remember forever and tell others about",
+          principles: [
+            {
+              expert: "Nancy Duarte",
+              principle: "STAR Moment",
+              application: "Something They'll Always Remember - this is the emotional climax",
+              technique: "What would make the audience gasp, laugh, or get chills?"
+            },
+            {
+              expert: "Chip & Dan Heath",
+              principle: "Unexpected",
+              application: "Break a pattern to get attention. Violate expectations.",
+              technique: "What assumption can you shatter? What surprise can you deliver?"
+            }
+          ],
+          whatMakesItGreat: [
+            "Creates visceral emotional response",
+            "Breaks expectations - genuinely surprising",
+            "Connects logically to the core message",
+            "Memorable enough to retell"
+          ],
+          antiPatterns: [
+            "Playing it safe with expected information",
+            "Burying the dramatic element in other content",
+            "Gimmicks that don't connect to the message"
+          ],
+          questions: [
+            "Will this give them chills or make them gasp?",
+            "Would they tell someone about this tomorrow?",
+            "Does it support or distract from the core message?"
+          ]
+        };
+      case "big_number":
+      case "data_insight":
+        return {
+          purpose: "Make data memorable by providing context that reveals meaning",
+          principles: [
+            {
+              expert: "Edward Tufte",
+              principle: "Data-Ink Ratio",
+              application: "Maximize ink used for data, minimize everything else",
+              technique: "Remove all decoration. Is the data still clear? Good. Now make it beautiful."
+            },
+            {
+              expert: "Lea Pica",
+              principle: "One Insight Per Chart",
+              application: "Don't let data speak for itself - tell them exactly what to see",
+              technique: "What's the ONE conclusion? Make that the headline."
+            },
+            {
+              expert: "Cole Knaflic",
+              principle: "Context Creates Meaning",
+              application: "Numbers mean nothing without context",
+              technique: "Compare to something they understand - time, money, scale"
+            }
+          ],
+          whatMakesItGreat: [
+            "The number is HUGE and simple",
+            "Context makes the number meaningful",
+            "Audience immediately understands significance",
+            "One clear insight, not a data dump"
+          ],
+          antiPatterns: [
+            "Multiple competing numbers",
+            'Data without context ("$5M" - is that good?)',
+            "Complex charts when simple would work",
+            "Decorative elements that distract from data"
+          ],
+          questions: [
+            "What is the ONE insight this data reveals?",
+            "What context makes this number meaningful?",
+            "Can someone understand the significance in 3 seconds?"
+          ]
+        };
+      case "three_points":
+      case "three_column":
+        return {
+          purpose: "Present key messages in memorable groups of three",
+          principles: [
+            {
+              expert: "Carmine Gallo",
+              principle: "Rule of Three",
+              application: "Three is the magic number for memory. Not two, not four.",
+              technique: "Can you group your content into exactly three main points?"
+            },
+            {
+              expert: "Barbara Minto",
+              principle: "MECE",
+              application: "Points should be Mutually Exclusive (no overlap) and Collectively Exhaustive (no gaps)",
+              technique: "Do these three points cover everything without repeating?"
+            }
+          ],
+          whatMakesItGreat: [
+            "Exactly three points - no more, no less",
+            "Each point is substantively different",
+            "Together they tell a complete story",
+            "Each point is memorable on its own"
+          ],
+          antiPatterns: [
+            "Forcing content into three when it should be two or four",
+            "Overlapping points that aren't distinct",
+            "Generic labels instead of insights",
+            "Uneven importance across points"
+          ],
+          questions: [
+            "Are these three truly distinct and non-overlapping?",
+            "Do they together cover the complete picture?",
+            "Is each point valuable on its own?"
+          ]
+        };
+      case "call_to_action":
+      case "cta":
+        return {
+          purpose: "Give the audience a clear, compelling next step they can take",
+          principles: [
+            {
+              expert: "Chris Anderson",
+              principle: "Gift Giving",
+              application: "Your job is to give them something valuable they can USE",
+              technique: "What can they DO tomorrow because of this presentation?"
+            },
+            {
+              expert: "Robert Cialdini",
+              principle: "Commitment",
+              application: "Small commitments lead to larger ones",
+              technique: "What's the smallest first step that gets them moving?"
+            }
+          ],
+          whatMakesItGreat: [
+            'Specific and actionable - not vague "learn more"',
+            "Achievable first step, not overwhelming",
+            "Clearly connected to the value proposition",
+            "Creates urgency without being pushy"
+          ],
+          antiPatterns: [
+            'Vague calls to action ("contact us")',
+            "Multiple competing CTAs",
+            "Actions that feel like too much work",
+            "Disconnected from the presentation content"
+          ],
+          questions: [
+            "Can they do this tomorrow?",
+            "Is this the logical first step?",
+            "Does it connect to the value you promised?"
+          ]
+        };
+      default:
+        return {
+          purpose: "Communicate one clear message that advances the narrative",
+          principles: [
+            {
+              expert: "Garr Reynolds",
+              principle: "Signal to Noise",
+              application: "Maximize signal (valuable content), minimize noise (distractions)",
+              technique: "For every element, ask: Does this serve the message?"
+            },
+            {
+              expert: "Nancy Duarte",
+              principle: "Glance Test",
+              application: "Key message should be clear in 3 seconds",
+              technique: "What would someone remember after a 3-second glance?"
+            }
+          ],
+          whatMakesItGreat: [
+            "One clear message per slide",
+            "Visual hierarchy guides the eye",
+            "Every element serves a purpose",
+            "Can be understood at a glance"
+          ],
+          antiPatterns: [
+            "Multiple competing messages",
+            "Decorative elements that distract",
+            "Text-heavy slides that require reading",
+            "Unclear what's most important"
+          ],
+          questions: [
+            "What is the ONE message?",
+            "What can be removed without losing meaning?",
+            "Does visual hierarchy match content hierarchy?"
+          ]
+        };
+    }
+  }
+  /**
+   * Get guidance for extracting the core message from content.
+   * This helps identify WHAT should be on the slide, not just how to fit content.
+   */
+  getCoreMessageGuidance() {
+    return [
+      {
+        expert: "Chris Anderson",
+        principle: "One Idea Worth Spreading",
+        application: "Find the single most valuable insight in this content",
+        technique: "If they could only remember ONE thing, what should it be?"
+      },
+      {
+        expert: "Carmine Gallo",
+        principle: "Twitter Test",
+        application: "Can you express the key insight in a tweet?",
+        technique: "Write the insight in under 280 characters. If you can't, you don't understand it well enough."
+      },
+      {
+        expert: "Barbara Minto",
+        principle: "So What?",
+        application: 'Keep asking "so what?" until you reach the insight',
+        technique: 'For every statement, ask "so what?" The answer is closer to the real message.'
+      }
+    ];
+  }
+  /**
+   * Evaluate whether a slide meets expert standards.
+   * Returns guidance on how to improve, not just pass/fail.
+   */
+  evaluateSlideExcellence(slide) {
+    const guidance = this.getSlideDesignGuidance(slide.type);
+    const strengths = [];
+    const improvements = [];
+    const expertFeedback = [];
+    let score = 50;
+    for (const quality of guidance.whatMakesItGreat) {
+    }
+    for (const antiPattern of guidance.antiPatterns) {
+    }
+    for (const question of guidance.questions) {
+      expertFeedback.push(`Ask: ${question}`);
+    }
+    if (slide.title) {
+      if (slide.title.length <= 60) {
+        strengths.push("Title passes Duarte Glance Test (under 60 chars)");
+        score += 10;
+      } else {
+        improvements.push("Shorten title - Duarte says 3 seconds to comprehend");
+      }
+      if (!/^(update|overview|introduction|summary)$/i.test(slide.title)) {
+        strengths.push("Title is specific, not generic (Gallo Headline Test)");
+        score += 5;
+      } else {
+        improvements.push("Replace generic title with insight - Gallo says it should work as a headline");
+        score -= 10;
+      }
+      if (!slide.title.includes(" and ") && !slide.title.includes(" & ")) {
+        strengths.push("Title focuses on one idea (Chris Anderson)");
+        score += 5;
+      } else {
+        improvements.push("Split into two slides - Anderson says one idea per slide");
+      }
+    }
+    if (slide.bullets && slide.bullets.length > 5) {
+      improvements.push("Reduce bullets to 3-5 - Reynolds says maximize signal, eliminate noise");
+      score -= 10;
+    }
+    return {
+      score: Math.max(0, Math.min(100, score)),
+      strengths,
+      improvements,
+      expertFeedback
+    };
+  }
+};
+function createExpertGuidanceEngine(kb, presentationType) {
+  return new ExpertGuidanceEngine(kb, presentationType);
+}
+
 // src/core/SlideFactory.ts
 var SlideFactory = class {
   kb;
   presentationType;
   classifier;
+  expertEngine;
+  // NEW: Expert guidance for world-class slides
+  narrativeArc;
+  // NEW: Story structure from experts
   config;
   usedContent;
   usedTitles;
@@ -1767,7 +2509,10 @@ var SlideFactory = class {
     this.usedContent = /* @__PURE__ */ new Set();
     this.usedTitles = /* @__PURE__ */ new Set();
     this.config = this.loadKBConfig(type);
-    logger.step(`SlideFactory v7.1.0 initialized for ${type} (${this.config.mode} mode)`);
+    this.expertEngine = createExpertGuidanceEngine(kb, type);
+    this.narrativeArc = this.expertEngine.getNarrativeArc();
+    logger.step(`SlideFactory v8.0.0 initialized for ${type} (${this.config.mode} mode)`);
+    logger.step(`Using ${this.narrativeArc.framework} narrative (${this.narrativeArc.expert})`);
     logger.step(`KB Config loaded: ${this.config.allowedTypes.length} allowed types`);
   }
   /**
@@ -1807,15 +2552,56 @@ var SlideFactory = class {
     } else if (storyStructure.framework === "sparkline") {
       this.addSparklineSlides(slides, analysis);
     }
+    let hasCTASection = false;
     for (const section of analysis.sections) {
+      logger.debug(`[TRACE] Processing section: "${section.header}"`);
+      logger.debug(`[TRACE]   Level: ${section.level}, Content: ${section.content?.length ?? 0} chars`);
+      logger.debug(`[TRACE]   Bullets: ${section.bullets?.length ?? 0} items`);
+      if (section.bullets?.length > 0) {
+        section.bullets.slice(0, 3).forEach((b, i) => {
+          logger.debug(`[TRACE]   Bullet ${i}: "${b.slice(0, 50)}..."`);
+        });
+      }
       const contentKey = this.normalizeKey(section.header);
-      if (this.usedContent.has(contentKey)) continue;
+      if (this.usedContent.has(contentKey)) {
+        logger.debug(`[TRACE]   SKIPPED: Already used content key "${contentKey}"`);
+        continue;
+      }
       this.usedContent.add(contentKey);
+      const headerLower = section.header.toLowerCase();
+      const isCTASection = headerLower.includes("call to action") || headerLower.includes("next step") || headerLower.includes("take action") || headerLower.includes("get started") || headerLower.includes("start today");
+      if (isCTASection) {
+        hasCTASection = true;
+        const ctaDefaults = this.config.defaults.cta;
+        const ctaContent = section.bullets.length > 0 ? section.bullets.slice(0, 4).join(". ") : section.content || ctaDefaults.fallback;
+        const craftedCTA = this.craftExpertContent(
+          ctaContent,
+          "call_to_action",
+          this.config.rules.wordsPerSlide.max * 3
+          // Allow more words for CTA steps
+        );
+        slides.push({
+          index: slides.length,
+          type: "cta",
+          data: {
+            title: section.header,
+            body: craftedCTA,
+            keyMessage: ctaDefaults.message
+          },
+          classes: ["cta-slide"]
+        });
+        continue;
+      }
       const pattern = this.classifier.classify(section);
+      logger.debug(`[TRACE]   Pattern: ${pattern.primaryPattern}, bulletCount: ${pattern.bulletCount}`);
       const slideType = this.kb.mapContentPatternToSlideType(pattern, this.config.allowedTypes);
+      logger.debug(`[TRACE]   KB returned slide type: "${slideType}"`);
       const slide = this.createSlideByType(slides.length, slideType, section, pattern);
-      if (slide) {
+      if (slide && slide.type && slide.data) {
+        logger.debug(`[TRACE]   Created slide type: "${slide.type}" with ${slide.data.bullets?.length ?? 0} bullets`);
         slides.push(slide);
+      } else {
+        logger.debug(`[TRACE]   SKIPPED: Slide filtered out (no valid content)`);
       }
     }
     const minDataPointsForMetrics = 2;
@@ -1827,7 +2613,7 @@ var SlideFactory = class {
         slides.push(this.createMetricsGridSlide(slides.length, analysis.dataPoints));
       }
     }
-    if (analysis.sparkline?.callToAdventure || analysis.scqa?.answer) {
+    if (!hasCTASection && (analysis.sparkline?.callToAdventure || analysis.scqa?.answer)) {
       slides.push(this.createCTASlide(slides.length, analysis));
     }
     slides.push(this.createThankYouSlide(slides.length));
@@ -1843,34 +2629,55 @@ var SlideFactory = class {
   createSlideByType(index, type, section, pattern) {
     const normalizedType = type.toLowerCase().replace(/_/g, "-");
     switch (normalizedType) {
+      // Big number slides - show prominent metrics
       case "big-number":
-      case "data-insight":
         return this.createBigNumberSlide(index, section, pattern);
+      // Data insight - for findings that may or may not have numbers
+      case "data-insight":
+        return this.createDataInsightSlide(index, section, pattern);
+      // Comparison slides
       case "comparison":
       case "options-comparison":
         return this.createComparisonSlide(index, section);
+      // Timeline and roadmap slides
       case "timeline":
       case "process-timeline":
       case "roadmap":
         return this.createTimelineSlide(index, section);
+      // Process flow slides (with steps)
       case "process":
+      case "mece-breakdown":
         return this.createProcessSlide(index, section);
+      // Three points slide (for exactly 3 items)
+      case "three-points":
+        return this.createThreePointsSlide(index, section);
+      // Column layouts
       case "three-column":
         return this.createThreeColumnSlide(index, section);
       case "two-column":
         return this.createTwoColumnSlide(index, section);
+      // Quote and testimonial slides
       case "quote":
       case "testimonial":
       case "social-proof":
         return this.createQuoteSlide(index, section);
+      // Metrics grid for multiple KPIs
       case "metrics-grid":
         return this.createMetricsGridSlide(index, section.metrics);
+      // Standard bullet point slides
       case "bullet-points":
-      case "detailed-findings":
         return this.createBulletSlide(index, section);
+      // Title impact - emphasized single statement
+      case "title-impact":
+        return this.createTitleImpactSlide(index, section);
+      // Single statement slides
       case "single-statement":
       case "big-idea":
         return this.createSingleStatementSlide(index, section);
+      // Detailed findings - bullets with context
+      case "detailed-findings":
+        return this.createDetailedFindingsSlide(index, section);
+      // Code and technical slides
       case "code-snippet":
       case "technical":
         return this.createCodeSlide(index, section);
@@ -1883,15 +2690,21 @@ var SlideFactory = class {
   // STRUCTURAL SLIDES (title, agenda, thank you) - ALL from KB
   // ===========================================================================
   createTitleSlide(index, analysis) {
+    const craftedTitle = this.craftExpertContent(
+      analysis.title,
+      "title",
+      this.config.rules.wordsPerSlide.max
+    );
     const data = {
-      title: this.truncateText(analysis.title, this.config.rules.wordsPerSlide.max)
+      title: craftedTitle
     };
     const subtitleSource = analysis.subtitle || analysis.keyMessages[0] || "";
     if (subtitleSource) {
-      data.subtitle = this.truncateText(
+      data.subtitle = this.craftExpertContent(
         subtitleSource,
+        "title",
+        // Use title guidance for subtitle too
         this.config.defaults.subtitle.maxWords
-        // FROM KB
       );
     }
     return {
@@ -1980,31 +2793,43 @@ var SlideFactory = class {
   addSparklineSlides(slides, analysis) {
     const spark = analysis.sparkline;
     const titles = this.config.sparklineTitles;
+    const maxWords = this.config.rules.wordsPerSlide.max;
     const whatIsFirst = spark?.whatIs?.[0];
-    const whatIsBody = whatIsFirst ? this.truncateText(whatIsFirst, this.config.rules.wordsPerSlide.max) : "";
-    if (whatIsBody.length >= 20 && !this.usedContent.has("spark-what-is")) {
+    const whatIsBody = whatIsFirst ? this.craftExpertContent(whatIsFirst, "single_statement", maxWords) : "";
+    const whatCouldBeFirst = spark?.whatCouldBe?.[0];
+    const whatCouldBeBody = whatCouldBeFirst ? this.craftExpertContent(whatCouldBeFirst, "single_statement", maxWords) : "";
+    const normalizedTitle = analysis.title.toLowerCase().slice(0, 50);
+    const normalizedSubtitle = (analysis.subtitle || "").toLowerCase().slice(0, 50);
+    const normalizedWhatIs = whatIsBody.toLowerCase().slice(0, 50);
+    const normalizedWhatCouldBe = whatCouldBeBody.toLowerCase().slice(0, 50);
+    const whatIsDuplicatesTitle = normalizedWhatIs === normalizedTitle || normalizedWhatIs.includes(normalizedTitle.slice(0, 30)) || normalizedTitle.includes(normalizedWhatIs.slice(0, 30));
+    const whatIsDuplicatesSubtitle = normalizedWhatIs === normalizedSubtitle || normalizedWhatIs.includes(normalizedSubtitle.slice(0, 30)) || normalizedSubtitle.includes(normalizedWhatIs.slice(0, 30));
+    const isDuplicatePair = normalizedWhatIs === normalizedWhatCouldBe;
+    if (whatIsBody.length >= 30 && !isDuplicatePair && !whatIsDuplicatesTitle && !whatIsDuplicatesSubtitle && !this.usedContent.has("spark-what-is")) {
       this.usedContent.add("spark-what-is");
+      this.usedContent.add(normalizedWhatIs);
       slides.push({
         index: slides.length,
         type: "single-statement",
         data: {
           title: titles.whatIs,
-          // FROM KB - not hardcoded 'Where We Are Today'
+          // FROM KB
           body: whatIsBody
         },
         classes: ["what-is-slide"]
       });
     }
-    const whatCouldBeFirst = spark?.whatCouldBe?.[0];
-    const whatCouldBeBody = whatCouldBeFirst ? this.truncateText(whatCouldBeFirst, this.config.rules.wordsPerSlide.max) : "";
-    if (whatCouldBeBody.length >= 20 && !this.usedContent.has("spark-could-be")) {
+    const whatCouldBeDuplicatesTitle = normalizedWhatCouldBe === normalizedTitle || normalizedWhatCouldBe.includes(normalizedTitle.slice(0, 30)) || normalizedTitle.includes(normalizedWhatCouldBe.slice(0, 30));
+    const whatCouldBeDuplicatesSubtitle = normalizedWhatCouldBe === normalizedSubtitle || normalizedWhatCouldBe.includes(normalizedSubtitle.slice(0, 30)) || normalizedSubtitle.includes(normalizedWhatCouldBe.slice(0, 30));
+    if (whatCouldBeBody.length >= 30 && !isDuplicatePair && !whatCouldBeDuplicatesTitle && !whatCouldBeDuplicatesSubtitle && !this.usedContent.has("spark-could-be")) {
       this.usedContent.add("spark-could-be");
+      this.usedContent.add(normalizedWhatCouldBe);
       slides.push({
         index: slides.length,
         type: "single-statement",
         data: {
           title: titles.whatCouldBe,
-          // FROM KB - not hardcoded 'What Could Be'
+          // FROM KB
           body: whatCouldBeBody
         },
         classes: ["what-could-be-slide"]
@@ -2022,17 +2847,19 @@ var SlideFactory = class {
       logger.warn(`No number found for big-number slide, falling back to single-statement`);
       return this.createSingleStatementSlide(index, section);
     }
+    const contextContent = bigNumber?.context || section.content;
+    const craftedContext = this.craftExpertContent(
+      contextContent,
+      "big_number",
+      this.config.defaults.context.maxWords
+    );
     return {
       index,
       type: "big-number",
       data: {
         title: this.createTitle(section.header, section),
         keyMessage: actualValue,
-        body: bigNumber?.context || this.truncateText(
-          section.content,
-          this.config.defaults.context.maxWords
-          // FROM KB - not hardcoded 30
-        )
+        body: craftedContext
       },
       classes: ["big-number-slide"]
     };
@@ -2069,9 +2896,8 @@ var SlideFactory = class {
     const steps = this.classifier.extractSteps(section);
     const maxSteps = Math.min(
       steps.length,
-      this.config.rules.bulletsPerSlide.max,
       this.config.millersLaw.maxItems
-      // FROM KB - 7±2 rule
+      // FROM KB - 7±2 rule (max 9)
     );
     return {
       index,
@@ -2079,7 +2905,8 @@ var SlideFactory = class {
       data: {
         title: this.createTitle(section.header, section),
         steps: steps.slice(0, maxSteps).map((step) => ({
-          label: step.label,
+          label: this.cleanText(step.label),
+          // Clean markdown from labels
           description: this.truncateText(
             step.description,
             this.config.defaults.step.maxWords
@@ -2092,7 +2919,7 @@ var SlideFactory = class {
   }
   createProcessSlide(index, section) {
     const steps = this.classifier.extractSteps(section);
-    const maxSteps = Math.min(steps.length, this.config.rules.bulletsPerSlide.max);
+    const maxSteps = Math.min(steps.length, this.config.millersLaw.maxItems);
     return {
       index,
       type: "process",
@@ -2100,7 +2927,8 @@ var SlideFactory = class {
         title: this.createTitle(section.header, section),
         steps: steps.slice(0, maxSteps).map((step, i) => ({
           number: i + 1,
-          title: step.label,
+          title: this.cleanText(step.label),
+          // Clean markdown from labels
           description: this.truncateText(
             step.description,
             this.config.defaults.step.maxWords
@@ -2135,6 +2963,69 @@ var SlideFactory = class {
       classes: ["three-column-slide"]
     };
   }
+  /**
+   * Create a three-points slide for exactly 3 key points.
+   * Used for content that fits the "rule of three" (Carmine Gallo).
+   */
+  createThreePointsSlide(index, section) {
+    const points = [];
+    if (section.bullets.length >= 3) {
+      for (let i = 0; i < 3; i++) {
+        const bullet = section.bullets[i] || "";
+        const extracted = this.classifier.extractSteps({ ...section, bullets: [bullet] });
+        if (extracted.length > 0 && extracted[0] && extracted[0].description) {
+          points.push({
+            number: i + 1,
+            title: this.cleanText(extracted[0].label) || `Step ${i + 1}`,
+            description: this.truncateText(extracted[0].description, 20)
+          });
+        } else {
+          const firstWords = this.cleanText(bullet).split(/\s+/).slice(0, 3).join(" ");
+          points.push({
+            number: i + 1,
+            title: firstWords || `Step ${i + 1}`,
+            description: this.truncateText(bullet, 20)
+          });
+        }
+      }
+    } else if (section.bullets.length > 0) {
+      for (let i = 0; i < 3; i++) {
+        const bullet = section.bullets[i % section.bullets.length] || "";
+        const firstWords = this.cleanText(bullet).split(/\s+/).slice(0, 3).join(" ");
+        points.push({
+          number: i + 1,
+          title: firstWords || `Step ${i + 1}`,
+          description: this.truncateText(bullet, 20)
+        });
+      }
+    } else {
+      const sentences = section.content.split(/[.!?]+/).filter((s) => s.trim().length > 0).slice(0, 3);
+      sentences.forEach((s, i) => {
+        const firstWords = this.cleanText(s.trim()).split(/\s+/).slice(0, 3).join(" ");
+        points.push({
+          number: i + 1,
+          title: firstWords || `Step ${i + 1}`,
+          description: this.truncateText(s.trim(), 20)
+        });
+      });
+    }
+    return {
+      index,
+      type: "three-column",
+      // Uses three-column template
+      data: {
+        title: this.createTitle(section.header, section),
+        columns: points.map((p) => ({
+          title: String(p.number),
+          // Use the sequential number
+          content: p.description,
+          subtitle: p.title
+          // Use extracted title as subtitle
+        }))
+      },
+      classes: ["three-points-slide", "three-column-slide"]
+    };
+  }
   createTwoColumnSlide(index, section) {
     const midpoint = Math.ceil(section.bullets.length / 2);
     const leftBullets = section.bullets.slice(0, midpoint);
@@ -2197,10 +3088,22 @@ var SlideFactory = class {
     };
   }
   createBulletSlide(index, section) {
+    logger.debug(`[TRACE] createBulletSlide for "${section.header}"`);
+    logger.debug(`[TRACE]   Input bullets: ${section.bullets?.length ?? 0}`);
     const maxBullets = this.config.rules.bulletsPerSlide.max;
     const wordsPerBullet = Math.floor(this.config.rules.wordsPerSlide.max / maxBullets);
-    const cleanedBullets = section.bullets.slice(0, maxBullets).map((b) => this.truncateText(this.cleanText(b), wordsPerBullet)).filter((b) => b.length > 0);
+    logger.debug(`[TRACE]   maxBullets: ${maxBullets}, wordsPerBullet: ${wordsPerBullet}`);
+    const slicedBullets = section.bullets.slice(0, maxBullets);
+    logger.debug(`[TRACE]   After slice: ${slicedBullets.length} bullets`);
+    const cleanedBullets = slicedBullets.map((b, i) => {
+      const cleaned = this.cleanText(b);
+      const truncated = this.truncateText(cleaned, wordsPerBullet);
+      logger.debug(`[TRACE]   Bullet ${i}: "${b.slice(0, 30)}..." \u2192 "${truncated.slice(0, 30)}..."`);
+      return truncated;
+    }).filter((b) => b.length > 0);
+    logger.debug(`[TRACE]   Final cleaned bullets: ${cleanedBullets.length}`);
     if (cleanedBullets.length === 0 && section.content) {
+      logger.debug(`[TRACE]   No bullets, falling back to single-statement`);
       return this.createSingleStatementSlide(index, section);
     }
     return {
@@ -2214,22 +3117,107 @@ var SlideFactory = class {
     };
   }
   createSingleStatementSlide(index, section) {
+    const title = this.createTitle(section.header, section);
+    const titleWords = title.split(/\s+/).length;
+    const maxTotalWords = this.config.rules.wordsPerSlide.max;
+    const maxBodyWords = Math.max(3, maxTotalWords - titleWords);
     const bodyContent = section.content || section.bullets.join(" ") || "";
-    const truncatedBody = this.truncateText(bodyContent, this.config.rules.wordsPerSlide.max);
-    if (truncatedBody.length < 15 && section.bullets.length > 0) {
-      return this.createBulletSlide(index, section);
+    const craftedBody = this.craftExpertContent(
+      bodyContent,
+      "single_statement",
+      // Tell expert engine what type of slide this is
+      maxBodyWords
+    );
+    const normalizedBody = craftedBody.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const bodyIsDuplicate = normalizedBody === normalizedTitle || craftedBody.length < 10;
+    if (bodyIsDuplicate) {
+      if (section.bullets.length >= 2 && this.config.mode === "business") {
+        return this.createBulletSlide(index, section);
+      }
+      if (section.metrics.length >= 2) {
+        return this.createMetricsGridSlide(index, section.metrics);
+      }
+      logger.warn(`Skipping slide "${title}" - no distinct body content`);
+      return null;
     }
     return {
       index,
       type: "single-statement",
       data: {
-        title: this.createTitle(section.header, section),
-        body: truncatedBody || section.header
-        // Fallback to header if no body
+        title,
+        body: craftedBody
       },
       classes: ["single-statement-slide"]
     };
   }
+  /**
+   * Create a title impact slide - emphasized statement with key takeaway.
+   * Used for section headers with strong conclusions.
+   */
+  createTitleImpactSlide(index, section) {
+    const supportingText = section.content || section.bullets.slice(0, 2).join(". ");
+    const truncatedSupport = this.truncateText(supportingText, this.config.defaults.context.maxWords);
+    const data = {
+      title: this.cleanText(section.header)
+    };
+    if (truncatedSupport) {
+      data.body = truncatedSupport;
+    }
+    return {
+      index,
+      type: "single-statement",
+      // Uses single-statement template
+      data,
+      classes: ["title-impact-slide", "single-statement-slide"]
+    };
+  }
+  /**
+   * Create a data insight slide - for presenting key findings with context.
+   * Similar to big-number but works even without a prominent metric.
+   */
+  createDataInsightSlide(index, section, pattern) {
+    const fullContent = `${section.header} ${section.content} ${section.bullets.join(" ")}`;
+    const bigNumber = this.classifier.extractBigNumber(fullContent);
+    if (bigNumber?.value || pattern.bigNumberValue) {
+      return this.createBigNumberSlide(index, section, pattern);
+    }
+    const keyInsight = section.content || section.bullets[0] || section.header;
+    return {
+      index,
+      type: "single-statement",
+      data: {
+        title: this.createTitle(section.header, section),
+        body: this.truncateText(keyInsight, this.config.rules.wordsPerSlide.max)
+      },
+      classes: ["data-insight-slide", "single-statement-slide"]
+    };
+  }
+  /**
+   * Create a detailed findings slide - bullet points with introductory context.
+   */
+  createDetailedFindingsSlide(index, section) {
+    const introText = section.content ? this.truncateText(section.content, this.config.defaults.context.maxWords) : "";
+    const maxBullets = this.config.rules.bulletsPerSlide.max;
+    const wordsPerBullet = Math.floor(this.config.rules.wordsPerSlide.max / maxBullets);
+    const cleanedBullets = section.bullets.slice(0, maxBullets).map((b) => this.truncateText(this.cleanText(b), wordsPerBullet)).filter((b) => b.length > 0);
+    if (cleanedBullets.length === 0) {
+      return this.createSingleStatementSlide(index, section);
+    }
+    const data = {
+      title: this.createTitle(section.header, section),
+      bullets: cleanedBullets
+    };
+    if (introText) {
+      data.body = introText;
+    }
+    return {
+      index,
+      type: "bullet-points",
+      data,
+      classes: ["detailed-findings-slide", "bullet-points-slide"]
+    };
+  }
   createCodeSlide(index, section) {
     const codeMatch = section.content.match(/```[\s\S]*?```|`[^`]+`/);
     const code = codeMatch ? codeMatch[0].replace(/```/g, "").trim() : section.content;
@@ -2254,13 +3242,18 @@ var SlideFactory = class {
   createCTASlide(index, analysis) {
     const ctaDefaults = this.config.defaults.cta;
     const ctaText = analysis.sparkline?.callToAdventure || analysis.scqa?.answer || ctaDefaults.fallback;
+    const craftedCTA = this.craftExpertContent(
+      ctaText,
+      "call_to_action",
+      this.config.rules.wordsPerSlide.max
+    );
     return {
       index,
       type: "cta",
       data: {
         title: ctaDefaults.title,
         // FROM KB - not hardcoded 'Next Steps'
-        body: this.truncateText(ctaText, this.config.rules.wordsPerSlide.max),
+        body: craftedCTA,
         keyMessage: ctaDefaults.message
         // FROM KB - not hardcoded 'Ready to Begin?'
       },
@@ -2373,12 +3366,221 @@ var SlideFactory = class {
     }
   }
   // ===========================================================================
-  // HELPER METHODS - All use KB configuration
+  // EXPERT-DRIVEN CONTENT CRAFTING (v8.0.0)
+  // Instead of truncating content, we CRAFT it using expert principles
   // ===========================================================================
   /**
-   * Create a title for a slide - uses action titles for business mode per KB
-   */
-  createTitle(header, section) {
+   * Craft content using expert principles - NOT truncation.
+   *
+   * The old approach: "Take 100 words, chop to 15, add ellipsis"
+   * The new approach: "What would Nancy Duarte say is the ONE thing to remember?"
+   *
+   * @param content - The raw content to craft from
+   * @param slideType - The type of slide being created
+   * @param maxWords - Word budget from KB
+   * @returns Expertly crafted content that serves the slide's purpose
+   */
+  craftExpertContent(content, slideType, maxWords) {
+    if (!content || content.trim().length === 0) return "";
+    const guidance = this.expertEngine.getSlideDesignGuidance(slideType);
+    switch (slideType) {
+      case "title":
+      case "title_impact":
+        return this.extractCoreIdea(content, maxWords);
+      case "star_moment":
+        return this.extractDramaticElement(content, maxWords);
+      case "big_number":
+      case "data_insight":
+        return this.extractDataInsight(content, maxWords);
+      case "single_statement":
+      case "big_idea":
+        return this.extractSingleInsight(content, maxWords);
+      case "call_to_action":
+      case "cta":
+        return this.extractActionableStep(content, maxWords);
+      default:
+        return this.extractCoreIdea(content, maxWords);
+    }
+  }
+  /**
+   * Chris Anderson's "One Idea Worth Spreading"
+   * Extract the single most valuable insight from content.
+   */
+  extractCoreIdea(content, maxWords) {
+    const cleaned = this.cleanText(content);
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    let bestSentence = sentences[0] || cleaned;
+    let bestScore = 0;
+    for (const sentence of sentences) {
+      let score = 0;
+      const lowerSentence = sentence.toLowerCase();
+      for (const marker of this.config.insightMarkers) {
+        if (lowerSentence.includes(marker.toLowerCase())) {
+          score += 10;
+        }
+      }
+      if (/\d+%|\$[\d,]+|\d+x|\d+\+/.test(sentence)) {
+        score += 5;
+      }
+      if (/transform|revolutionize|breakthrough|critical|essential|must|never|always/i.test(sentence)) {
+        score += 3;
+      }
+      if (/overview|introduction|agenda|summary|the following/i.test(sentence)) {
+        score -= 10;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestSentence = sentence.trim();
+      }
+    }
+    const words = bestSentence.split(/\s+/);
+    if (words.length <= maxWords) {
+      return bestSentence;
+    }
+    return this.extractKeyPhrase(bestSentence, maxWords);
+  }
+  /**
+   * Extract the key phrase from a sentence - the part that matters most.
+   */
+  extractKeyPhrase(sentence, maxWords) {
+    const patterns = [
+      /(?:the key (?:is|to)|critical|essential|must|should)\s+(.+)/i,
+      /(.+?)\s+(?:is critical|is essential|matters most)/i,
+      /^(.+?)\s*[-–—:]\s*.+$/
+      // Before a colon/dash is often the key
+    ];
+    for (const pattern of patterns) {
+      const match = sentence.match(pattern);
+      if (match && match[1]) {
+        const extracted = match[1].trim();
+        if (extracted.split(/\s+/).length <= maxWords) {
+          return extracted;
+        }
+      }
+    }
+    const words = sentence.split(/\s+/);
+    let result = words.slice(0, maxWords).join(" ");
+    const lastPunctuation = result.lastIndexOf(",");
+    if (lastPunctuation > result.length / 2) {
+      result = result.slice(0, lastPunctuation);
+    }
+    return result;
+  }
+  /**
+   * Nancy Duarte's "STAR Moment" - Something They'll Always Remember
+   * Find the most dramatic, unexpected element.
+   */
+  extractDramaticElement(content, maxWords) {
+    const cleaned = this.cleanText(content);
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    let mostDramatic = sentences[0] || cleaned;
+    let highestDrama = 0;
+    for (const sentence of sentences) {
+      let drama = 0;
+      const numbers = sentence.match(/\d+/g);
+      if (numbers) {
+        for (const num of numbers) {
+          const value = parseInt(num);
+          if (value >= 1e3) drama += 15;
+          else if (value >= 100) drama += 10;
+          else if (value >= 50) drama += 5;
+        }
+      }
+      if (/\d+%/.test(sentence)) drama += 10;
+      if (/\$[\d,]+[MBK]?/i.test(sentence)) drama += 12;
+      if (/never|always|revolutionary|transforming|critical|dramatic|shocking|surprising/i.test(sentence)) {
+        drama += 8;
+      }
+      if (/but|however|yet|instead|versus|vs/i.test(sentence)) {
+        drama += 5;
+      }
+      if (drama > highestDrama) {
+        highestDrama = drama;
+        mostDramatic = sentence.trim();
+      }
+    }
+    const words = mostDramatic.split(/\s+/);
+    if (words.length <= maxWords) {
+      return mostDramatic;
+    }
+    return this.extractKeyPhrase(mostDramatic, maxWords);
+  }
+  /**
+   * Edward Tufte / Cole Knaflic - Extract data insight with context
+   */
+  extractDataInsight(content, maxWords) {
+    const cleaned = this.cleanText(content);
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    const datasentences = sentences.filter(
+      (s) => /\d+%|\$[\d,]+|\d+x|\d+ (million|billion|thousand)/i.test(s)
+    );
+    if (datasentences.length > 0 && datasentences[0]) {
+      const best = datasentences[0].trim();
+      const words = best.split(/\s+/);
+      if (words.length <= maxWords) {
+        return best;
+      }
+      return this.extractKeyPhrase(best, maxWords);
+    }
+    return this.extractCoreIdea(content, maxWords);
+  }
+  /**
+   * Garr Reynolds - Signal to Noise
+   * Extract the ONE insight, eliminate everything else.
+   */
+  extractSingleInsight(content, maxWords) {
+    const cleaned = this.cleanText(content);
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    const conclusionPatterns = [
+      /(?:therefore|thus|hence|consequently|as a result|this means|the bottom line|in conclusion)/i,
+      /(?:we (?:must|should|need to)|it's (?:critical|essential|important) to)/i,
+      /(?:the key (?:is|takeaway)|what this means)/i
+    ];
+    for (const sentence of sentences) {
+      for (const pattern of conclusionPatterns) {
+        if (pattern.test(sentence)) {
+          const words = sentence.trim().split(/\s+/);
+          if (words.length <= maxWords) {
+            return sentence.trim();
+          }
+          return this.extractKeyPhrase(sentence, maxWords);
+        }
+      }
+    }
+    return this.extractCoreIdea(content, maxWords);
+  }
+  /**
+   * Chris Anderson - Gift Giving
+   * What can they DO tomorrow?
+   */
+  extractActionableStep(content, maxWords) {
+    const cleaned = this.cleanText(content);
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    const actionPatterns = [
+      /(?:start|begin|try|implement|apply|use|adopt|build|create|develop)/i,
+      /(?:step \d|first,|next,|then,|finally)/i,
+      /(?:you (?:can|should|must|need to))/i
+    ];
+    for (const sentence of sentences) {
+      for (const pattern of actionPatterns) {
+        if (pattern.test(sentence)) {
+          const words = sentence.trim().split(/\s+/);
+          if (words.length <= maxWords) {
+            return sentence.trim();
+          }
+          return this.extractKeyPhrase(sentence, maxWords);
+        }
+      }
+    }
+    return this.extractCoreIdea(content, maxWords);
+  }
+  // ===========================================================================
+  // HELPER METHODS - All use KB configuration
+  // ===========================================================================
+  /**
+   * Create a title for a slide - uses action titles for business mode per KB
+   */
+  createTitle(header, section) {
     const cleanHeader = this.cleanText(header);
     if (this.usedTitles.has(cleanHeader.toLowerCase())) {
       return `${cleanHeader} (continued)`;
@@ -4021,949 +5223,837 @@ var QAEngine = class {
   }
 };
 
-// src/qa/SevenDimensionScorer.ts
-var DIMENSION_WEIGHTS = {
-  layout: 0.15,
-  contrast: 0.15,
-  graphics: 0.1,
-  content: 0.2,
-  clarity: 0.15,
-  effectiveness: 0.15,
-  consistency: 0.1
-};
-var SevenDimensionScorer = class {
-  kb;
-  mode;
-  presentationType;
-  constructor(mode, presentationType) {
-    this.mode = mode;
-    this.presentationType = presentationType;
-  }
-  /**
-   * Score a presentation across all 7 dimensions.
-   */
-  async score(slides, html, threshold = 95) {
-    this.kb = await getKnowledgeGateway();
-    const layout = await this.scoreLayout(slides, html);
-    const contrast = await this.scoreContrast(html);
-    const graphics = await this.scoreGraphics(slides);
-    const content = await this.scoreContent(slides);
-    const clarity = await this.scoreClarity(slides);
-    const effectiveness = await this.scoreEffectiveness(slides);
-    const consistency = await this.scoreConsistency(slides, html);
-    const overallScore = Math.round(
-      layout.score * DIMENSION_WEIGHTS.layout + contrast.score * DIMENSION_WEIGHTS.contrast + graphics.score * DIMENSION_WEIGHTS.graphics + content.score * DIMENSION_WEIGHTS.content + clarity.score * DIMENSION_WEIGHTS.clarity + effectiveness.score * DIMENSION_WEIGHTS.effectiveness + consistency.score * DIMENSION_WEIGHTS.consistency
-    );
-    const issues = [
-      ...layout.issues,
-      ...contrast.issues,
-      ...graphics.issues,
-      ...content.issues,
-      ...clarity.issues,
-      ...effectiveness.issues,
-      ...consistency.issues
-    ];
-    return {
-      overallScore,
-      dimensions: {
-        layout,
-        contrast,
-        graphics,
-        content,
-        clarity,
-        effectiveness,
-        consistency
-      },
-      issues,
-      passed: overallScore >= threshold,
-      threshold
-    };
+// src/qa/VisualQualityEvaluator.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var VisualQualityEvaluator = class {
+  browser = null;
+  page = null;
+  screenshotDir;
+  constructor(screenshotDir = "/tmp/presentation-qa") {
+    this.screenshotDir = screenshotDir;
   }
   /**
-   * Score layout dimension (whitespace, visual balance, structure)
+   * Evaluate a presentation's visual quality.
+   * This opens the HTML in a real browser and evaluates each slide.
    */
-  async scoreLayout(slides, html) {
-    const issues = [];
-    let totalScore = 0;
-    let checks = 0;
-    const minWhitespace = this.mode === "keynote" ? 0.45 : 0.35;
-    const maxWhitespace = 0.6;
-    const slideSections = html.match(/<section[^>]*>[\s\S]*?<\/section>/gi) || [];
-    for (let i = 0; i < slideSections.length; i++) {
-      const section = slideSections[i];
-      if (!section) continue;
-      const textContent = section.replace(/<[^>]+>/g, "").trim();
-      const totalArea = 1920 * 1080;
-      const estimatedTextArea = textContent.length * 100;
-      const whitespaceRatio = 1 - Math.min(estimatedTextArea / totalArea, 1);
-      if (whitespaceRatio < minWhitespace) {
-        issues.push({
-          slideIndex: i,
-          dimension: "layout",
-          severity: "error",
-          message: `Slide ${i + 1}: Insufficient whitespace (${Math.round(whitespaceRatio * 100)}% < ${Math.round(minWhitespace * 100)}%)`,
-          currentValue: whitespaceRatio,
-          expectedValue: minWhitespace,
-          autoFixable: true,
-          fixSuggestion: "Reduce content or increase margins"
-        });
-        totalScore += 50;
-      } else if (whitespaceRatio > maxWhitespace) {
-        issues.push({
-          slideIndex: i,
-          dimension: "layout",
-          severity: "warning",
-          message: `Slide ${i + 1}: Too much whitespace (${Math.round(whitespaceRatio * 100)}% > ${Math.round(maxWhitespace * 100)}%)`,
-          currentValue: whitespaceRatio,
-          expectedValue: maxWhitespace,
-          autoFixable: false,
-          fixSuggestion: "Add more content or reduce margins"
-        });
-        totalScore += 80;
-      } else {
-        totalScore += 100;
-      }
-      checks++;
-    }
-    for (let i = 0; i < slides.length; i++) {
-      const slide = slides[i];
-      if (!slide) continue;
-      if (!["thank-you", "section-divider"].includes(slide.type)) {
-        if (!slide.data.title || slide.data.title.trim().length === 0) {
-          issues.push({
-            slideIndex: i,
-            dimension: "layout",
-            severity: "warning",
-            message: `Slide ${i + 1}: Missing title`,
-            autoFixable: false,
-            fixSuggestion: "Add a clear slide title"
-          });
-          totalScore += 70;
-        } else {
-          totalScore += 100;
-        }
-        checks++;
-      }
+  async evaluate(htmlPath) {
+    if (!fs.existsSync(this.screenshotDir)) {
+      fs.mkdirSync(this.screenshotDir, { recursive: true });
     }
-    const score = checks > 0 ? Math.round(totalScore / checks) : 100;
-    return {
-      name: "Layout",
-      score,
-      weight: DIMENSION_WEIGHTS.layout,
-      issues,
-      details: {
-        slidesAnalyzed: slides.length,
-        whitespaceTarget: `${Math.round(minWhitespace * 100)}-${Math.round(maxWhitespace * 100)}%`
+    try {
+      await this.launchBrowser();
+      const absolutePath = path.resolve(htmlPath);
+      await this.page.goto(`file://${absolutePath}`, { waitUntil: "networkidle" });
+      await this.page.waitForSelector(".reveal", { timeout: 5e3 });
+      await this.page.waitForTimeout(1e3);
+      const slideCount = await this.getSlideCount();
+      console.log(`Evaluating ${slideCount} slides...`);
+      const slideScores = [];
+      for (let i = 0; i < slideCount; i++) {
+        const score = await this.evaluateSlide(i);
+        slideScores.push(score);
       }
-    };
-  }
-  /**
-   * Score contrast dimension (WCAG compliance, readability)
-   */
-  async scoreContrast(html) {
-    const issues = [];
-    let score = 100;
-    const minContrastRatio = 4.5;
-    const colorMatches = html.match(/color:\s*([^;]+);/gi) || [];
-    const bgColorMatches = html.match(/background(-color)?:\s*([^;]+);/gi) || [];
-    const hasGoodContrast = html.includes("color: #fff") || html.includes("color: white") || html.includes("color: #18181B") || html.includes("color: #F5F5F4");
-    const hasDarkBackground = html.includes("background-color: #18181B") || html.includes("background: #18181B") || html.includes("background-color: rgb(24, 24, 27)");
-    if (html.includes("color: gray") || html.includes("color: #999") || html.includes("color: #888")) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "contrast",
-        severity: "error",
-        message: "Low contrast text color detected (gray text)",
-        currentValue: "gray",
-        expectedValue: "High contrast color",
-        autoFixable: true,
-        fixSuggestion: "Use white (#fff) or dark (#18181B) text depending on background"
-      });
-      score -= 20;
-    }
-    if (!hasGoodContrast && !hasDarkBackground) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "contrast",
-        severity: "warning",
-        message: "Could not verify WCAG-compliant contrast ratios",
-        autoFixable: false,
-        fixSuggestion: "Ensure text has 4.5:1 contrast ratio against background"
-      });
-      score -= 10;
-    }
-    const hasSmallFont = html.match(/font-size:\s*(1[0-3]|[0-9])px/i) !== null;
-    if (hasSmallFont) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "contrast",
-        severity: "error",
-        message: "Font size too small for presentation (< 14px)",
-        currentValue: "Small font",
-        expectedValue: "18px minimum for body text",
-        autoFixable: true,
-        fixSuggestion: "Increase font size to minimum 18px"
-      });
-      score -= 15;
+      const narrativeFlow = this.evaluateNarrativeFlow(slideScores);
+      const visualConsistency = this.evaluateVisualConsistency(slideScores);
+      const contentQuality = this.evaluateContentQuality(slideScores);
+      const executiveReadiness = this.evaluateExecutiveReadiness(slideScores);
+      const overallScore = Math.round(
+        narrativeFlow.score + visualConsistency.score + contentQuality.score + executiveReadiness.score
+      );
+      const verdict = this.determineVerdict(overallScore);
+      const { topIssues, topStrengths } = this.extractTopIssuesAndStrengths(slideScores);
+      return {
+        overallScore,
+        narrativeFlow,
+        visualConsistency,
+        contentQuality,
+        executiveReadiness,
+        slideScores,
+        verdict,
+        verdictExplanation: this.explainVerdict(verdict, overallScore),
+        topIssues,
+        topStrengths
+      };
+    } finally {
+      await this.closeBrowser();
     }
-    return {
-      name: "Contrast",
-      score: Math.max(0, score),
-      weight: DIMENSION_WEIGHTS.contrast,
-      issues,
-      details: {
-        wcagLevel: "AA",
-        minContrastRatio,
-        colorDefinitions: colorMatches.length,
-        backgroundDefinitions: bgColorMatches.length
-      }
-    };
   }
-  /**
-   * Score graphics dimension (images, placement, relevance)
-   */
-  async scoreGraphics(slides) {
-    const issues = [];
-    let score = 100;
-    let slidesWithImages = 0;
-    let totalImageSlides = 0;
-    for (let i = 0; i < slides.length; i++) {
-      const slide = slides[i];
-      if (!slide) continue;
-      const shouldHaveImage = ["hero", "image", "feature"].includes(slide.type);
-      if (shouldHaveImage) {
-        totalImageSlides++;
-        if (slide.data.image || slide.data.backgroundImage) {
-          slidesWithImages++;
-        } else {
-          issues.push({
-            slideIndex: i,
-            dimension: "graphics",
-            severity: "warning",
-            message: `Slide ${i + 1} (${slide.type}): Missing expected image`,
-            autoFixable: false,
-            fixSuggestion: "Add a relevant image or change slide type"
-          });
-          score -= 5;
-        }
-      }
+  // ===========================================================================
+  // BROWSER MANAGEMENT
+  // ===========================================================================
+  async launchBrowser() {
+    const { chromium: chromium2 } = await import("playwright");
+    this.browser = await chromium2.launch({ headless: true });
+    const context = await this.browser.newContext({
+      viewport: { width: 1920, height: 1080 }
+    });
+    this.page = await context.newPage();
+  }
+  async closeBrowser() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.page = null;
     }
-    return {
-      name: "Graphics",
-      score: Math.max(0, score),
-      weight: DIMENSION_WEIGHTS.graphics,
-      issues,
-      details: {
-        slidesWithImages,
-        expectedImageSlides: totalImageSlides,
-        imageRatio: totalImageSlides > 0 ? slidesWithImages / totalImageSlides : 1
-      }
-    };
   }
-  /**
-   * Score content dimension (word limits, bullet counts, structure)
-   * This is critical - must use KB rules exactly.
-   */
-  async scoreContent(slides) {
-    const issues = [];
-    let totalScore = 0;
-    let checks = 0;
-    const wordLimits = this.kb.getWordLimits(this.mode);
-    const bulletLimits = this.kb.getBulletLimits(this.mode);
-    const defaultMaxWords = this.mode === "keynote" ? 25 : 80;
-    const defaultMinWords = this.mode === "keynote" ? 3 : 15;
-    const defaultMaxBullets = 5;
-    for (let i = 0; i < slides.length; i++) {
-      const slide = slides[i];
-      if (!slide) continue;
-      const wordCount = this.countWords(slide);
-      const slideType = slide.type;
-      const maxWords = wordLimits[slideType] ?? defaultMaxWords;
-      const minWords = defaultMinWords;
-      if (wordCount > maxWords) {
-        const severity = wordCount > maxWords * 1.5 ? "error" : "warning";
-        issues.push({
-          slideIndex: i,
-          dimension: "content",
-          severity,
-          message: `Slide ${i + 1}: Word count ${wordCount} exceeds limit of ${maxWords} for ${this.mode} mode`,
-          currentValue: wordCount,
-          expectedValue: maxWords,
-          autoFixable: true,
-          fixSuggestion: "Condense text to key points only"
-        });
-        totalScore += severity === "error" ? 40 : 70;
-      } else if (wordCount < minWords && !["title", "section-divider", "thank-you"].includes(slide.type)) {
-        issues.push({
-          slideIndex: i,
-          dimension: "content",
-          severity: "warning",
-          message: `Slide ${i + 1}: Word count ${wordCount} may be too sparse (min: ${minWords})`,
-          currentValue: wordCount,
-          expectedValue: minWords,
-          autoFixable: false,
-          fixSuggestion: "Add supporting content"
-        });
-        totalScore += 80;
-      } else {
-        totalScore += 100;
+  async getSlideCount() {
+    return await this.page.evaluate(() => {
+      const slides = document.querySelectorAll(".slides > section");
+      return slides.length;
+    });
+  }
+  // ===========================================================================
+  // SLIDE-LEVEL EVALUATION
+  // ===========================================================================
+  async evaluateSlide(slideIndex) {
+    await this.page.evaluate((index) => {
+      window.Reveal?.slide(index, 0);
+    }, slideIndex);
+    await this.page.waitForTimeout(600);
+    await this.page.evaluate(() => {
+      const currentSlide = document.querySelector(".present");
+      if (currentSlide) {
+        currentSlide.getAnimations().forEach((anim) => anim.finish());
       }
-      checks++;
-      if (slide.data.bullets && Array.isArray(slide.data.bullets)) {
-        const bulletCount = slide.data.bullets.length;
-        const maxBullets = bulletLimits[slideType] ?? defaultMaxBullets;
-        if (bulletCount > maxBullets) {
-          issues.push({
-            slideIndex: i,
-            dimension: "content",
-            severity: "error",
-            message: `Slide ${i + 1}: ${bulletCount} bullets exceeds limit of ${maxBullets}`,
-            currentValue: bulletCount,
-            expectedValue: maxBullets,
-            autoFixable: true,
-            fixSuggestion: "Reduce to top 3-5 key points"
-          });
-          totalScore += 50;
-        } else {
-          totalScore += 100;
+    });
+    await this.page.waitForTimeout(100);
+    const screenshotPath = path.join(this.screenshotDir, `slide-${slideIndex}.png`);
+    await this.page.screenshot({ path: screenshotPath, fullPage: false });
+    const slideData = await this.page.evaluate(() => {
+      const currentSlide = document.querySelector(".present");
+      if (!currentSlide) return null;
+      const title = currentSlide.querySelector("h1, h2, .title")?.textContent?.trim() || "";
+      const body = currentSlide.querySelector(".body, p:not(.subtitle)")?.textContent?.trim() || "";
+      const bullets = Array.from(currentSlide.querySelectorAll("li")).map((li) => li.textContent?.trim() || "");
+      const hasSteps = !!currentSlide.querySelector(".steps, .process-steps, .timeline");
+      const steps = Array.from(currentSlide.querySelectorAll(".step, .process-step, .timeline-item")).map(
+        (s) => s.textContent?.trim() || ""
+      );
+      const hasMetrics = !!currentSlide.querySelector(".metrics, .metric");
+      const hasImage = !!currentSlide.querySelector("img");
+      const hasChart = !!currentSlide.querySelector(".chart, svg, canvas");
+      const classList = Array.from(currentSlide.classList);
+      const backgroundColor = window.getComputedStyle(currentSlide).backgroundColor;
+      const titleEl = currentSlide.querySelector("h1, h2, .title");
+      const titleStyles = titleEl ? window.getComputedStyle(titleEl) : null;
+      const truncatedElements = [];
+      const contentElements = currentSlide.querySelectorAll("h1, h2, h3, p, span, li, .body, .step-desc, .step-title, .timeline-content");
+      contentElements.forEach((el, idx) => {
+        const styles = window.getComputedStyle(el);
+        const text = el.textContent?.trim() || "";
+        if (text.length < 15) return;
+        const isLayoutContainer = el.classList?.contains("slide-content") || el.classList?.contains("steps") || el.classList?.contains("timeline") || el.classList?.contains("process-steps");
+        if (isLayoutContainer) return;
+        if (styles.textOverflow === "ellipsis") {
+          if (el.scrollWidth > el.clientWidth + 5) {
+            truncatedElements.push(`Element ${idx}: "${text.substring(0, 30)}..." is truncated horizontally`);
+          }
         }
-        checks++;
-      }
-    }
-    const score = checks > 0 ? Math.round(totalScore / checks) : 100;
-    return {
-      name: "Content",
-      score,
-      weight: DIMENSION_WEIGHTS.content,
-      issues,
-      details: {
-        mode: this.mode,
-        wordLimits,
-        bulletLimits,
-        totalSlides: slides.length
-      }
-    };
-  }
-  /**
-   * Score clarity dimension (message focus, information density)
-   */
-  async scoreClarity(slides) {
-    const issues = [];
-    let totalScore = 0;
-    let checks = 0;
-    for (let i = 0; i < slides.length; i++) {
-      const slide = slides[i];
-      if (!slide) continue;
-      if (slide.data.keyMessage) {
-        const keyMessageWords = slide.data.keyMessage.split(/\s+/).length;
-        const maxKeyMessageWords = this.mode === "keynote" ? 15 : 25;
-        if (keyMessageWords > maxKeyMessageWords) {
-          issues.push({
-            slideIndex: i,
-            dimension: "clarity",
-            severity: "warning",
-            message: `Slide ${i + 1}: Key message too long (${keyMessageWords} words > ${maxKeyMessageWords})`,
-            currentValue: keyMessageWords,
-            expectedValue: maxKeyMessageWords,
-            autoFixable: true,
-            fixSuggestion: "Shorten key message to one impactful sentence"
-          });
-          totalScore += 70;
-        } else {
-          totalScore += 100;
+        const scrollHeight = el.scrollHeight;
+        const clientHeight = el.clientHeight;
+        if (scrollHeight > clientHeight + 20) {
+          const overflow = styles.overflow || styles.overflowY;
+          if (overflow === "hidden" || overflow === "clip") {
+            truncatedElements.push(`Element ${idx}: "${text.substring(0, 30)}..." is truncated vertically`);
+          }
+        }
+      });
+      const allVisibleText = Array.from(currentSlide.querySelectorAll("*")).map((el) => el.textContent?.trim() || "").join(" ").trim();
+      const isEmptySlide = allVisibleText.length < 10 && !hasImage && !hasChart;
+      const hasOnlyTitle = title.length > 0 && body.length === 0 && bullets.length === 0 && steps.length === 0 && !hasSteps && !hasMetrics && !hasImage && !hasChart;
+      const titleLower = title.toLowerCase();
+      const bodyLower = body.toLowerCase();
+      const isRedundant = titleLower.length > 10 && bodyLower.length > 10 && (titleLower.includes(bodyLower) || bodyLower.includes(titleLower));
+      const contrastIssues = [];
+      const parseRGB = (color) => {
+        const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+        if (match && match[1] !== void 0 && match[2] !== void 0 && match[3] !== void 0) {
+          return { r: parseInt(match[1]), g: parseInt(match[2]), b: parseInt(match[3]) };
+        }
+        return null;
+      };
+      const getLuminance = (rgb) => {
+        const values = [rgb.r, rgb.g, rgb.b].map((c) => {
+          c = c / 255;
+          return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+        });
+        return 0.2126 * (values[0] ?? 0) + 0.7152 * (values[1] ?? 0) + 0.0722 * (values[2] ?? 0);
+      };
+      const getContrastRatio = (fg, bg) => {
+        const l1 = getLuminance(fg);
+        const l2 = getLuminance(bg);
+        const lighter = Math.max(l1, l2);
+        const darker = Math.min(l1, l2);
+        return (lighter + 0.05) / (darker + 0.05);
+      };
+      const bgRGB = parseRGB(backgroundColor);
+      if (titleEl && bgRGB) {
+        const titleRGB = parseRGB(titleStyles?.color || "");
+        if (titleRGB) {
+          const contrast = getContrastRatio(titleRGB, bgRGB);
+          if (contrast < 4.5) {
+            contrastIssues.push(`Title contrast ${contrast.toFixed(1)}:1 (need 4.5:1)`);
+          }
         }
-        checks++;
       }
-      if (slide.data.title) {
-        const title = slide.data.title;
-        const titleWords = title.split(/\s+/).length;
-        if (titleWords > 10) {
-          issues.push({
-            slideIndex: i,
-            dimension: "clarity",
-            severity: "warning",
-            message: `Slide ${i + 1}: Title too long (${titleWords} words)`,
-            currentValue: titleWords,
-            expectedValue: "2-8 words",
-            autoFixable: true,
-            fixSuggestion: "Use action-oriented, concise title"
-          });
-          totalScore += 75;
-        } else {
-          totalScore += 100;
+      const bodyEl = currentSlide.querySelector(".body, p:not(.subtitle)");
+      if (bodyEl && bgRGB) {
+        const bodyStyles2 = window.getComputedStyle(bodyEl);
+        const bodyRGB = parseRGB(bodyStyles2.color);
+        if (bodyRGB) {
+          const contrast = getContrastRatio(bodyRGB, bgRGB);
+          if (contrast < 4.5) {
+            contrastIssues.push(`Body contrast ${contrast.toFixed(1)}:1 (need 4.5:1)`);
+          }
         }
-        checks++;
       }
-      const elementCount = (slide.data.title ? 1 : 0) + (slide.data.subtitle ? 1 : 0) + (slide.data.body ? 1 : 0) + (slide.data.bullets?.length ?? 0) + (slide.data.keyMessage ? 1 : 0) + (slide.data.image ? 1 : 0);
-      const maxElements = this.mode === "keynote" ? 4 : 6;
-      if (elementCount > maxElements) {
-        issues.push({
-          slideIndex: i,
-          dimension: "clarity",
-          severity: "warning",
-          message: `Slide ${i + 1}: Too many elements (${elementCount} > ${maxElements})`,
-          currentValue: elementCount,
-          expectedValue: maxElements,
-          autoFixable: true,
-          fixSuggestion: "Split into multiple slides for clarity"
-        });
-        totalScore += 70;
-      } else {
-        totalScore += 100;
+      const hasContrastIssues = contrastIssues.length > 0;
+      const layoutIssues = [];
+      const slideRect = currentSlide.getBoundingClientRect();
+      const layoutElements = currentSlide.querySelectorAll("h1, h2, h3, p, ul, ol, .number, .metric, img, canvas, svg");
+      let topHeavy = 0;
+      let bottomHeavy = 0;
+      let leftHeavy = 0;
+      let rightHeavy = 0;
+      let centerY = slideRect.height / 2;
+      let centerX = slideRect.width / 2;
+      layoutElements.forEach((el) => {
+        const rect = el.getBoundingClientRect();
+        const elCenterY = rect.top + rect.height / 2 - slideRect.top;
+        const elCenterX = rect.left + rect.width / 2 - slideRect.left;
+        if (elCenterY < centerY) topHeavy++;
+        else bottomHeavy++;
+        if (elCenterX < centerX) leftHeavy++;
+        else rightHeavy++;
+      });
+      const verticalBalance = Math.abs(topHeavy - bottomHeavy) / Math.max(1, topHeavy + bottomHeavy);
+      const horizontalBalance = Math.abs(leftHeavy - rightHeavy) / Math.max(1, leftHeavy + rightHeavy);
+      if (verticalBalance > 0.6 && contentElements.length > 2) {
+        layoutIssues.push(`Vertical imbalance: ${topHeavy} top vs ${bottomHeavy} bottom`);
       }
-      checks++;
-    }
-    const score = checks > 0 ? Math.round(totalScore / checks) : 100;
-    return {
-      name: "Clarity",
-      score,
-      weight: DIMENSION_WEIGHTS.clarity,
-      issues,
-      details: {
-        slidesAnalyzed: slides.length,
-        mode: this.mode
+      if (horizontalBalance > 0.6 && contentElements.length > 2) {
+        layoutIssues.push(`Horizontal imbalance: ${leftHeavy} left vs ${rightHeavy} right`);
       }
-    };
-  }
-  /**
-   * Score effectiveness dimension (expert methodology compliance)
-   */
-  async scoreEffectiveness(slides) {
-    const issues = [];
-    let score = 100;
-    if (slides.length >= 3) {
-      const firstSlide = slides[0];
-      const lastSlide = slides[slides.length - 1];
-      if (firstSlide && !["title", "hero"].includes(firstSlide.type)) {
-        issues.push({
-          slideIndex: 0,
-          dimension: "effectiveness",
-          severity: "warning",
-          message: "Presentation should start with a title or hero slide",
-          currentValue: firstSlide.type,
-          expectedValue: "title or hero",
-          autoFixable: false,
-          fixSuggestion: "Add a compelling opening slide"
-        });
-        score -= 10;
+      const hasLayoutIssues = layoutIssues.length > 0;
+      const typographyIssues = [];
+      const titleSize = parseFloat(titleStyles?.fontSize || "0");
+      const bodyStyles = bodyEl ? window.getComputedStyle(bodyEl) : null;
+      const bodySize = parseFloat(bodyStyles?.fontSize || "0");
+      if (titleSize > 0 && bodySize > 0 && titleSize <= bodySize) {
+        typographyIssues.push("Title not larger than body - hierarchy broken");
       }
-      if (lastSlide && !["thank-you", "cta", "closing"].includes(lastSlide.type)) {
-        issues.push({
-          slideIndex: slides.length - 1,
-          dimension: "effectiveness",
-          severity: "warning",
-          message: "Presentation should end with a closing or CTA slide",
-          currentValue: lastSlide.type,
-          expectedValue: "thank-you, cta, or closing",
-          autoFixable: false,
-          fixSuggestion: "Add a clear call-to-action or closing"
-        });
-        score -= 10;
+      if (titleSize > 0 && bodySize > 0 && titleSize < bodySize * 1.3) {
+        typographyIssues.push("Title not prominent enough vs body");
       }
-    }
-    const keyMessages = slides.filter((s) => s.data.keyMessage);
-    if (keyMessages.length > 0 && keyMessages.length !== 3 && keyMessages.length > 4) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "effectiveness",
-        severity: "info",
-        message: `Consider using Rule of Three: ${keyMessages.length} key messages found`,
-        currentValue: keyMessages.length,
-        expectedValue: 3,
-        autoFixable: false,
-        fixSuggestion: "Group messages into 3 main themes"
-      });
-      score -= 5;
-    }
-    const hasScqaElements = slides.some(
-      (s) => s.data.scqaType || s.data.title && s.data.title.toLowerCase().includes("challenge") || s.data.title && s.data.title.toLowerCase().includes("solution") || s.data.title && s.data.title.toLowerCase().includes("recommendation")
-    );
-    if (!hasScqaElements && this.presentationType === "consulting_deck") {
-      issues.push({
-        slideIndex: -1,
-        dimension: "effectiveness",
-        severity: "warning",
-        message: "Consulting deck should follow SCQA structure (Situation, Complication, Question, Answer)",
-        autoFixable: false,
-        fixSuggestion: "Organize content using Barbara Minto Pyramid Principle"
-      });
-      score -= 10;
-    }
-    const firstSlideType = slides[0]?.type;
-    const lastSlideType = slides[slides.length - 1]?.type;
-    return {
-      name: "Effectiveness",
-      score: Math.max(0, score),
-      weight: DIMENSION_WEIGHTS.effectiveness,
-      issues,
-      details: {
-        presentationType: this.presentationType,
-        slideCount: slides.length,
-        hasOpeningSlide: firstSlideType ? ["title", "hero"].includes(firstSlideType) : false,
-        hasClosingSlide: lastSlideType ? ["thank-you", "cta", "closing"].includes(lastSlideType) : false
+      const hasTypographyIssues = typographyIssues.length > 0;
+      const completenessIssues = [];
+      const emptySteps = currentSlide.querySelectorAll(".steps:empty, .timeline:empty, .process-steps:empty, .steps > :empty");
+      if (emptySteps.length > 0) {
+        completenessIssues.push(`${emptySteps.length} empty step/timeline container(s) - content missing`);
       }
-    };
-  }
-  /**
-   * Score consistency dimension (style uniformity, design coherence)
-   */
-  async scoreConsistency(slides, html) {
-    const issues = [];
-    let score = 100;
-    const hasCssVariables = html.includes("var(--") || html.includes(":root");
-    if (!hasCssVariables) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "consistency",
-        severity: "warning",
-        message: "Presentation lacks CSS variables for consistent styling",
-        autoFixable: true,
-        fixSuggestion: "Use CSS variables for colors, fonts, and spacing"
-      });
-      score -= 10;
-    }
-    const titlePatterns = /* @__PURE__ */ new Set();
-    for (const slide of slides) {
-      if (slide.data.title) {
-        const isUpperCase = slide.data.title === slide.data.title.toUpperCase();
-        const words = slide.data.title.split(" ").filter((w) => w.length > 0);
-        const isTitleCase = words.length > 0 && words.every(
-          (w) => w.length > 0 && w[0] === w[0]?.toUpperCase()
-        );
-        titlePatterns.add(isUpperCase ? "UPPER" : isTitleCase ? "Title" : "sentence");
+      if (body.includes("Lorem") || body.includes("placeholder") || body.includes("TODO")) {
+        completenessIssues.push("Contains placeholder text");
       }
-    }
-    if (titlePatterns.size > 1) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "consistency",
-        severity: "warning",
-        message: `Inconsistent title casing: ${Array.from(titlePatterns).join(", ")}`,
-        autoFixable: true,
-        fixSuggestion: "Use consistent title case throughout"
-      });
-      score -= 10;
-    }
-    const fontMatches = html.match(/font-family:\s*([^;]+);/gi) || [];
-    const uniqueFonts = new Set(fontMatches.map((f) => f.toLowerCase()));
-    if (uniqueFonts.size > 3) {
-      issues.push({
-        slideIndex: -1,
-        dimension: "consistency",
-        severity: "warning",
-        message: `Too many font families (${uniqueFonts.size} > 3)`,
-        autoFixable: true,
-        fixSuggestion: "Use 2-3 complementary fonts max"
-      });
-      score -= 10;
-    }
-    return {
-      name: "Consistency",
-      score: Math.max(0, score),
-      weight: DIMENSION_WEIGHTS.consistency,
-      issues,
-      details: {
-        hasCssVariables,
-        titlePatterns: Array.from(titlePatterns),
-        fontFamilyCount: uniqueFonts.size
+      const emptyBullets = bullets.filter((b) => b.length < 3).length;
+      if (emptyBullets > 0 && bullets.length > 0) {
+        completenessIssues.push(`${emptyBullets} empty/minimal bullets`);
       }
-    };
-  }
-  /**
-   * Count words in a slide.
-   */
-  countWords(slide) {
-    let text = "";
-    if (slide.data.title) text += slide.data.title + " ";
-    if (slide.data.subtitle) text += slide.data.subtitle + " ";
-    if (slide.data.body) text += slide.data.body + " ";
-    if (slide.data.bullets) text += slide.data.bullets.join(" ") + " ";
-    if (slide.data.keyMessage) text += slide.data.keyMessage + " ";
-    return text.split(/\s+/).filter((w) => w.length > 0).length;
-  }
-  /**
-   * Get a formatted report of the scoring results.
-   */
-  formatReport(result) {
-    const lines = [];
-    lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
-    lines.push("\u2551           7-DIMENSION QUALITY ASSESSMENT               \u2551");
-    lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
-    lines.push("");
-    lines.push(`Overall Score: ${result.overallScore}/100 ${result.passed ? "\u2705 PASSED" : "\u274C FAILED"}`);
-    lines.push(`Threshold: ${result.threshold}/100`);
-    lines.push("");
-    lines.push("Dimension Breakdown:");
-    lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    const dims = result.dimensions;
-    const formatDim = (name, d) => {
-      const bar = "\u2588".repeat(Math.floor(d.score / 10)) + "\u2591".repeat(10 - Math.floor(d.score / 10));
-      const status = d.score >= 95 ? "\u2705" : d.score >= 80 ? "\u26A0\uFE0F" : "\u274C";
-      return `${status} ${name.padEnd(14)} ${bar} ${d.score.toString().padStart(3)}/100 (${(d.weight * 100).toFixed(0)}%)`;
-    };
-    lines.push(formatDim("Layout", dims.layout));
-    lines.push(formatDim("Contrast", dims.contrast));
-    lines.push(formatDim("Graphics", dims.graphics));
-    lines.push(formatDim("Content", dims.content));
-    lines.push(formatDim("Clarity", dims.clarity));
-    lines.push(formatDim("Effectiveness", dims.effectiveness));
-    lines.push(formatDim("Consistency", dims.consistency));
-    lines.push("");
-    const errors = result.issues.filter((i) => i.severity === "error");
-    const warnings = result.issues.filter((i) => i.severity === "warning");
-    if (errors.length > 0) {
-      lines.push("\u274C Errors:");
-      errors.forEach((e) => lines.push(`   \u2022 ${e.message}`));
-      lines.push("");
-    }
-    if (warnings.length > 0) {
-      lines.push("\u26A0\uFE0F  Warnings:");
-      warnings.slice(0, 10).forEach((w) => lines.push(`   \u2022 ${w.message}`));
-      if (warnings.length > 10) {
-        lines.push(`   ... and ${warnings.length - 10} more warnings`);
+      const hasCompletenessIssues = completenessIssues.length > 0;
+      const visualNeedsIssues = [];
+      const visualRequiredTypes = ["data", "chart", "metrics", "comparison", "process", "timeline"];
+      const visualRecommendedTypes = ["big-number", "quote", "testimonial"];
+      const slideClasses = Array.from(currentSlide.classList).join(" ").toLowerCase();
+      const needsVisual = visualRequiredTypes.some((t) => slideClasses.includes(t));
+      const visualRecommended = visualRecommendedTypes.some((t) => slideClasses.includes(t));
+      const contentText = (title + " " + body).toLowerCase();
+      const dataIndicators = /\d+%|\$[\d,]+|\d+x|million|billion|percent|growth|increase|decrease|comparison|versus|vs\b|before|after/i;
+      const hasDataContent = dataIndicators.test(contentText);
+      const hasAnyVisual = hasImage || hasChart;
+      if (needsVisual && !hasAnyVisual) {
+        visualNeedsIssues.push("Data/process slide missing visual - needs chart, diagram, or image");
+      } else if (hasDataContent && !hasAnyVisual && bullets.length === 0) {
+        visualNeedsIssues.push("Content has numbers/data but no visualization - chart would help");
+      } else if (visualRecommended && !hasAnyVisual) {
+        visualNeedsIssues.push("Visual recommended for this slide type");
       }
-      lines.push("");
-    }
-    const autoFixable = result.issues.filter((i) => i.autoFixable);
-    if (autoFixable.length > 0) {
-      lines.push(`\u{1F527} ${autoFixable.length} issues can be auto-fixed`);
-    }
-    return lines.join("\n");
-  }
-};
-
-// src/qa/AutoFixEngine.ts
-var AutoFixEngine = class {
-  kb;
-  mode;
-  presentationType;
-  constructor(mode, presentationType) {
-    this.mode = mode;
-    this.presentationType = presentationType;
+      if (hasImage) {
+        const img = currentSlide.querySelector("img");
+        const imgSrc = img?.getAttribute("src") || "";
+        if (imgSrc.includes("placeholder") || imgSrc.includes("picsum") || imgSrc.includes("via.placeholder")) {
+          visualNeedsIssues.push("Placeholder image detected - needs real visual");
+        }
+      }
+      const needsVisualButMissing = visualNeedsIssues.length > 0;
+      const visualScore = hasAnyVisual ? 10 : needsVisual || hasDataContent ? 0 : 5;
+      return {
+        title,
+        body,
+        bullets,
+        steps,
+        // NEW: Timeline/process step content
+        hasSteps,
+        // NEW: Has .steps/.process-steps container
+        hasMetrics,
+        // NEW: Has metrics content
+        hasImage,
+        hasChart,
+        classList,
+        backgroundColor,
+        titleFontSize: titleStyles?.fontSize || "",
+        titleColor: titleStyles?.color || "",
+        // Include steps in content length calculation
+        contentLength: (title + body + bullets.join(" ") + steps.join(" ")).length,
+        // Visual quality flags
+        hasTruncatedText: truncatedElements.length > 0,
+        truncatedElements,
+        isEmptySlide,
+        hasOnlyTitle,
+        isRedundant,
+        allVisibleTextLength: allVisibleText.length,
+        // NEW: Expert quality checks
+        hasContrastIssues,
+        contrastIssues,
+        hasLayoutIssues,
+        layoutIssues,
+        hasTypographyIssues,
+        typographyIssues,
+        hasCompletenessIssues,
+        completenessIssues,
+        // Visual needs analysis
+        needsVisualButMissing,
+        visualNeedsIssues,
+        visualScore
+      };
+    });
+    return this.scoreSlide(slideIndex, slideData, screenshotPath);
   }
   /**
-   * Apply automatic fixes to slides based on scoring results.
+   * EXPERT-LEVEL SLIDE SCORING
+   *
+   * This evaluates each slide like Nancy Duarte, Carmine Gallo, or a McKinsey partner would.
+   * It's not about rules - it's about whether the slide WORKS.
    */
-  async fix(slides, scoringResult) {
-    this.kb = await getKnowledgeGateway();
-    const slidesFixed = JSON.parse(JSON.stringify(slides));
-    const fixesApplied = [];
-    const fixesSkipped = [];
-    const autoFixableIssues = scoringResult.issues.filter((i) => i.autoFixable);
-    for (const issue of autoFixableIssues) {
-      const result = await this.applyFix(slidesFixed, issue);
-      if (result.applied) {
-        fixesApplied.push(result);
-      } else {
-        fixesSkipped.push(result);
-      }
+  scoreSlide(slideIndex, slideData, screenshotPath) {
+    if (!slideData) {
+      return this.createFailedSlideScore(slideIndex, "unknown", "Could not analyze slide", screenshotPath);
+    }
+    const slideType = this.inferSlideType(slideData);
+    const criticalFailures = [];
+    if (slideData.isEmptySlide) {
+      criticalFailures.push("EMPTY SLIDE: No meaningful content - slide serves no purpose");
+    }
+    if (slideData.hasOnlyTitle && !["title", "agenda", "thank-you", "cta"].includes(slideType)) {
+      criticalFailures.push("INCOMPLETE: Slide has title but no body content - looks unfinished");
+    }
+    if (slideData.hasTruncatedText) {
+      criticalFailures.push(`TRUNCATED TEXT: ${slideData.truncatedElements.length} element(s) cut off - message incomplete`);
+    }
+    if (slideData.isRedundant) {
+      criticalFailures.push("REDUNDANT: Title and body say the same thing - violates one-idea rule");
+    }
+    if (slideData.hasCompletenessIssues) {
+      slideData.completenessIssues.forEach((issue) => {
+        if (issue.includes("empty")) {
+          criticalFailures.push(`INCOMPLETE: ${issue}`);
+        }
+      });
     }
-    const summary = this.generateSummary(fixesApplied, fixesSkipped);
+    if (criticalFailures.length > 0) {
+      return this.createFailedSlideScore(slideIndex, slideType, criticalFailures.join("; "), screenshotPath, criticalFailures);
+    }
+    let glanceTest = 8;
+    const glanceNotes = [];
+    const wordCount = slideData.contentLength / 6;
+    if (wordCount > 40) {
+      glanceTest = 3;
+      glanceNotes.push("Too much text - fails glance test");
+    } else if (wordCount > 25) {
+      glanceTest -= 3;
+      glanceNotes.push("Text-heavy - borderline glance test");
+    } else if (wordCount < 15) {
+      glanceTest += 1;
+      glanceNotes.push("Clean, minimal text - passes glance test easily");
+    }
+    if (slideData.bullets.length > 5) {
+      glanceTest -= 4;
+      glanceNotes.push("Too many bullets - cannot scan in 3 seconds");
+    } else if (slideData.bullets.length > 3) {
+      glanceTest -= 2;
+      glanceNotes.push("Multiple bullets - needs careful structuring");
+    }
+    if (slideData.hasImage || slideData.hasChart) {
+      glanceTest += 1;
+      glanceNotes.push("Visual element aids quick comprehension");
+    }
+    glanceTest = Math.max(0, Math.min(10, glanceTest));
+    let oneIdea = 7;
+    const oneIdeaNotes = [];
+    if (slideData.title.length > 0 && slideData.title.length < 60) {
+      oneIdea += 1;
+      oneIdeaNotes.push("Clear, focused title");
+    } else if (slideData.title.length > 80) {
+      oneIdea -= 2;
+      oneIdeaNotes.push("Title too long - multiple ideas?");
+    } else if (slideData.title.length === 0) {
+      oneIdea -= 4;
+      oneIdeaNotes.push("No title - what is the one idea?");
+    }
+    const focusedTypes = ["big-number", "single-statement", "quote", "cta", "title"];
+    if (focusedTypes.some((t) => slideType.includes(t))) {
+      oneIdea += 2;
+      oneIdeaNotes.push("Slide type naturally focuses on one idea");
+    }
+    if (slideData.bullets.length > 4) {
+      oneIdea -= 3;
+      oneIdeaNotes.push("Multiple bullets dilute the message");
+    }
+    oneIdea = Math.max(0, Math.min(10, oneIdea));
+    let dataInkRatio = 7;
+    const dataInkNotes = [];
+    const structuredTypes = ["big-number", "metrics-grid", "three-column", "timeline", "process", "comparison"];
+    if (structuredTypes.some((t) => slideType.includes(t))) {
+      dataInkRatio += 1;
+      dataInkNotes.push("Structured layout");
+    }
+    if (slideData.hasChart) {
+      dataInkRatio += 2;
+      dataInkNotes.push("Data visualization present - excellent");
+    }
+    if (slideData.hasImage) {
+      dataInkRatio += 1;
+      dataInkNotes.push("Supporting visual present");
+    }
+    if (slideData.needsVisualButMissing) {
+      dataInkRatio -= 3;
+      slideData.visualNeedsIssues.forEach((issue) => {
+        dataInkNotes.push(`Visual: ${issue}`);
+      });
+    } else if (slideData.visualScore === 10) {
+      dataInkNotes.push("Appropriate visuals for content type");
+    }
+    if (slideData.contentLength > 400) {
+      dataInkRatio -= 4;
+      dataInkNotes.push("Excessive text - low information density");
+    }
+    dataInkRatio = Math.max(0, Math.min(10, dataInkRatio));
+    let professionalExecution = 7;
+    const executionNotes = [];
+    const titleFontSize = parseFloat(slideData.titleFontSize || "0");
+    if (titleFontSize >= 40) {
+      professionalExecution += 1;
+      executionNotes.push("Strong title typography");
+    } else if (titleFontSize > 0 && titleFontSize < 24) {
+      professionalExecution -= 1;
+      executionNotes.push("Title could be more prominent");
+    }
+    if (slideData.contentLength > 10 && slideData.contentLength < 200) {
+      professionalExecution += 1;
+      executionNotes.push("Well-balanced content density");
+    }
+    if (slideData.classList.some((c) => c.includes("slide-"))) {
+      professionalExecution += 1;
+      executionNotes.push("Consistent with design system");
+    }
+    if (slideData.hasContrastIssues) {
+      professionalExecution -= 3;
+      slideData.contrastIssues.forEach((issue) => {
+        executionNotes.push(`Contrast: ${issue}`);
+      });
+    } else {
+      executionNotes.push("Good text contrast");
+    }
+    if (slideData.hasLayoutIssues) {
+      professionalExecution -= 2;
+      slideData.layoutIssues.forEach((issue) => {
+        executionNotes.push(`Layout: ${issue}`);
+      });
+    } else if (slideData.contentLength > 50) {
+      executionNotes.push("Balanced layout");
+    }
+    if (slideData.hasTypographyIssues) {
+      professionalExecution -= 2;
+      slideData.typographyIssues.forEach((issue) => {
+        executionNotes.push(`Typography: ${issue}`);
+      });
+    } else if (titleFontSize > 0) {
+      executionNotes.push("Good type hierarchy");
+    }
+    professionalExecution = Math.max(0, Math.min(10, professionalExecution));
+    const totalScore = glanceTest + oneIdea + dataInkRatio + professionalExecution;
+    const visualImpact = Math.round((glanceTest + oneIdea) / 2);
+    const contentClarity = oneIdea;
+    const professionalPolish = Math.round((dataInkRatio + professionalExecution) / 2);
+    const themeCoherence = professionalExecution;
     return {
-      slidesFixed,
-      fixesApplied,
-      fixesSkipped,
-      summary
+      slideIndex,
+      slideType,
+      // New expert dimensions
+      glanceTest,
+      glanceTestNotes: glanceNotes.join("; ") || "Passes glance test",
+      oneIdea,
+      oneIdeaNotes: oneIdeaNotes.join("; ") || "Clear single message",
+      dataInkRatio,
+      dataInkNotes: dataInkNotes.join("; ") || "Good information density",
+      professionalExecution,
+      professionalExecutionNotes: executionNotes.join("; ") || "Professional quality",
+      // Critical failures
+      hasCriticalFailure: false,
+      criticalFailures: [],
+      // Legacy dimensions (for compatibility)
+      visualImpact,
+      visualImpactNotes: glanceNotes.join("; ") || "Standard",
+      contentClarity,
+      contentClarityNotes: oneIdeaNotes.join("; ") || "Good",
+      professionalPolish,
+      professionalPolishNotes: executionNotes.join("; ") || "Acceptable",
+      themeCoherence,
+      themeCoherenceNotes: "Consistent",
+      totalScore,
+      screenshotPath
     };
   }
   /**
-   * Apply a single fix based on the issue.
+   * Create a failed slide score (for critical failures)
    */
-  async applyFix(slides, issue) {
-    const result = {
-      slideIndex: issue.slideIndex,
-      dimension: issue.dimension,
-      originalValue: issue.currentValue,
-      newValue: null,
-      description: issue.message,
-      applied: false
+  createFailedSlideScore(slideIndex, slideType, reason, screenshotPath, criticalFailures = []) {
+    return {
+      slideIndex,
+      slideType,
+      glanceTest: 0,
+      glanceTestNotes: "CRITICAL FAILURE: " + reason,
+      oneIdea: 0,
+      oneIdeaNotes: "CRITICAL FAILURE: " + reason,
+      dataInkRatio: 0,
+      dataInkNotes: "CRITICAL FAILURE: " + reason,
+      professionalExecution: 0,
+      professionalExecutionNotes: "CRITICAL FAILURE: " + reason,
+      hasCriticalFailure: true,
+      criticalFailures: criticalFailures.length > 0 ? criticalFailures : [reason],
+      visualImpact: 0,
+      visualImpactNotes: "CRITICAL: " + reason,
+      contentClarity: 0,
+      contentClarityNotes: "CRITICAL: " + reason,
+      professionalPolish: 0,
+      professionalPolishNotes: "CRITICAL: " + reason,
+      themeCoherence: 0,
+      themeCoherenceNotes: "CRITICAL: " + reason,
+      totalScore: 0,
+      screenshotPath
     };
-    switch (issue.dimension) {
-      case "content":
-        return this.fixContentIssue(slides, issue, result);
-      case "clarity":
-        return this.fixClarityIssue(slides, issue, result);
-      case "layout":
-        return this.fixLayoutIssue(slides, issue, result);
-      case "consistency":
-        return this.fixConsistencyIssue(slides, issue, result);
-      case "contrast":
-        return this.fixContrastIssue(slides, issue, result);
-      default:
-        result.description = `No auto-fix available for ${issue.dimension}`;
-        return result;
+  }
+  inferSlideType(slideData) {
+    const classList = slideData.classList || [];
+    for (const cls of classList) {
+      if (cls.includes("metrics-grid")) return "metrics-grid";
+      if (cls.includes("three-column")) return "three-column";
+      if (cls.includes("three-points")) return "three-points";
+      if (cls.includes("two-column")) return "two-column";
+      if (cls.includes("big-number")) return "big-number";
+      if (cls.includes("comparison")) return "comparison";
+      if (cls.includes("timeline")) return "timeline";
+      if (cls.includes("process")) return "process";
+      if (cls.includes("quote")) return "quote";
+      if (cls.includes("testimonial")) return "testimonial";
+      if (cls.includes("cta")) return "cta";
+      if (cls.includes("thank-you")) return "thank-you";
+      if (cls.includes("title")) return "title";
+      if (cls.includes("bullet")) return "bullet-points";
+      if (cls.includes("single-statement")) return "single-statement";
+      if (cls.includes("agenda")) return "agenda";
+    }
+    if (!slideData.body && slideData.bullets.length > 0) return "bullet-points";
+    if (slideData.body && !slideData.bullets.length) return "content";
+    if (slideData.hasChart) return "data-visualization";
+    return "standard";
+  }
+  // ===========================================================================
+  // PRESENTATION-LEVEL EVALUATION
+  // ===========================================================================
+  evaluateNarrativeFlow(slideScores) {
+    let score = 25;
+    const notes = [];
+    const firstSlide = slideScores[0];
+    const hasStrongOpening = Boolean(firstSlide && (firstSlide.slideType === "title" || firstSlide.visualImpact >= 7));
+    if (!hasStrongOpening) {
+      score -= 5;
+      notes.push("Opening could be stronger");
+    }
+    const middleSlides = slideScores.slice(1, -1);
+    const highImpactMiddle = middleSlides.filter((s) => s.visualImpact >= 7).length;
+    const hasCompellingMiddle = highImpactMiddle >= middleSlides.length * 0.3;
+    if (!hasCompellingMiddle) {
+      score -= 7;
+      notes.push("Middle section needs more visual variety");
+    }
+    const lastSlide = slideScores[slideScores.length - 1];
+    const secondLastSlide = slideScores[slideScores.length - 2];
+    const closingTypes = ["cta", "thank-you", "call-to-action"];
+    const hasMemorableClose = Boolean(
+      lastSlide && (closingTypes.includes(lastSlide.slideType) || lastSlide.visualImpact >= 7) || secondLastSlide && closingTypes.includes(secondLastSlide.slideType)
+    );
+    if (!hasMemorableClose) {
+      score -= 5;
+      notes.push("Ending should be more memorable");
+    }
+    const slideTypes = new Set(slideScores.map((s) => s.slideType));
+    const storyArcComplete = slideTypes.size >= 3;
+    if (!storyArcComplete) {
+      score -= 5;
+      notes.push("Needs more variety in slide types");
     }
+    return {
+      score: Math.max(0, score),
+      hasStrongOpening,
+      hasCompellingMiddle,
+      hasMemorableClose,
+      storyArcComplete,
+      notes: notes.join(". ") || "Good narrative structure"
+    };
   }
-  /**
-   * Fix content-related issues (word count, bullet count).
-   */
-  fixContentIssue(slides, issue, result) {
-    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
-      return result;
+  evaluateVisualConsistency(slideScores) {
+    let score = 25;
+    const notes = [];
+    const visualScores = slideScores.map((s) => s.visualImpact);
+    const avgVisual = visualScores.reduce((a, b) => a + b, 0) / visualScores.length;
+    const variance = visualScores.reduce((sum, s) => sum + Math.pow(s - avgVisual, 2), 0) / visualScores.length;
+    const colorPaletteConsistent = variance < 4;
+    if (!colorPaletteConsistent) {
+      score -= 5;
+      notes.push("Visual quality varies too much between slides");
     }
-    const slide = slides[issue.slideIndex];
-    if (!slide) return result;
-    if (issue.message.includes("Word count") && issue.message.includes("exceeds")) {
-      const maxWords = issue.expectedValue;
-      result.originalValue = this.countWords(slide);
-      if (slide.data.body) {
-        slide.data.body = this.condenseText(slide.data.body, maxWords / 2);
-      }
-      if (slide.data.bullets && slide.data.bullets.length > 0) {
-        const bulletCount = slide.data.bullets.length;
-        slide.data.bullets = slide.data.bullets.map(
-          (bullet) => this.condenseText(bullet, Math.floor(maxWords / bulletCount))
-        );
-      }
-      if (slide.data.subtitle) {
-        slide.data.subtitle = this.condenseText(slide.data.subtitle, 10);
-      }
-      result.newValue = this.countWords(slide);
-      result.applied = result.newValue <= maxWords;
-      result.description = `Condensed content from ${result.originalValue} to ${result.newValue} words`;
+    const polishScores = slideScores.map((s) => s.professionalPolish);
+    const avgPolish = polishScores.reduce((a, b) => a + b, 0) / polishScores.length;
+    const typographyConsistent = avgPolish >= 6;
+    if (!typographyConsistent) {
+      score -= 5;
+      notes.push("Typography could be more polished");
     }
-    if (issue.message.includes("bullets exceeds")) {
-      const maxBullets = issue.expectedValue;
-      if (slide.data.bullets) {
-        result.originalValue = slide.data.bullets.length;
-        slide.data.bullets = slide.data.bullets.slice(0, maxBullets);
-        result.newValue = slide.data.bullets.length;
-        result.applied = true;
-        result.description = `Reduced bullets from ${result.originalValue} to ${result.newValue}`;
-      }
+    const coherenceScores = slideScores.map((s) => s.themeCoherence);
+    const avgCoherence = coherenceScores.reduce((a, b) => a + b, 0) / coherenceScores.length;
+    const layoutPatternsConsistent = avgCoherence >= 6;
+    if (!layoutPatternsConsistent) {
+      score -= 5;
+      notes.push("Layout patterns should be more consistent");
     }
-    return result;
+    const professionalLook = avgPolish >= 7 && avgCoherence >= 7;
+    if (!professionalLook) {
+      score -= 5;
+      notes.push("Overall polish could be improved");
+    }
+    return {
+      score: Math.max(0, score),
+      colorPaletteConsistent,
+      typographyConsistent,
+      layoutPatternsConsistent,
+      professionalLook,
+      notes: notes.join(". ") || "Consistent visual design"
+    };
   }
-  /**
-   * Fix clarity-related issues (key message length, title length).
-   */
-  fixClarityIssue(slides, issue, result) {
-    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
-      return result;
+  evaluateContentQuality(slideScores) {
+    let score = 25;
+    const notes = [];
+    const criticalFailureSlides = slideScores.filter((s) => s.hasCriticalFailure);
+    if (criticalFailureSlides.length > 0) {
+      score = Math.max(0, 25 - criticalFailureSlides.length * 8);
+      notes.push(`CRITICAL: ${criticalFailureSlides.length} slide(s) have critical failures`);
+      criticalFailureSlides.forEach((s) => {
+        s.criticalFailures.forEach((f) => notes.push(`  - Slide ${s.slideIndex}: ${f}`));
+      });
     }
-    const slide = slides[issue.slideIndex];
-    if (!slide) return result;
-    if (issue.message.includes("Key message too long")) {
-      if (slide.data.keyMessage) {
-        result.originalValue = slide.data.keyMessage;
-        const maxWords = issue.expectedValue;
-        slide.data.keyMessage = this.condenseText(slide.data.keyMessage, maxWords);
-        result.newValue = slide.data.keyMessage;
-        result.applied = true;
-        result.description = `Shortened key message to ${maxWords} words`;
-      }
+    const avgGlance = slideScores.reduce((sum, s) => sum + s.glanceTest, 0) / slideScores.length;
+    const passesGlanceTest = avgGlance >= 6;
+    if (!passesGlanceTest) {
+      score -= 5;
+      notes.push(`Glance Test: Average ${avgGlance.toFixed(1)}/10 - too text-heavy`);
     }
-    if (issue.message.includes("Title too long")) {
-      if (slide.data.title) {
-        result.originalValue = slide.data.title;
-        const words = slide.data.title.split(/\s+/);
-        const originalLength = words.length;
-        if (words.length > 6) {
-          slide.data.title = words.slice(0, 6).join(" ");
-        }
-        result.newValue = slide.data.title;
-        result.applied = true;
-        result.description = `Shortened title from ${originalLength} to ${slide.data.title.split(/\s+/).length} words`;
-      }
+    const avgOneIdea = slideScores.reduce((sum, s) => sum + s.oneIdea, 0) / slideScores.length;
+    const hasOneIdeaPerSlide = avgOneIdea >= 6;
+    if (!hasOneIdeaPerSlide) {
+      score -= 5;
+      notes.push(`One Idea Rule: Average ${avgOneIdea.toFixed(1)}/10 - messages diluted`);
     }
-    if (issue.message.includes("Too many elements")) {
-      result.originalValue = issue.currentValue;
-      if (slide.data.subtitle && slide.data.body) {
-        delete slide.data.subtitle;
-        result.applied = true;
-        result.description = "Removed subtitle to reduce element count";
-      } else if (slide.data.body && slide.data.bullets && slide.data.bullets.length > 0) {
-        delete slide.data.body;
-        result.applied = true;
-        result.description = "Removed body text, keeping bullets";
-      }
-      result.newValue = this.countElements(slide);
+    const messagesAreClear = avgOneIdea >= 7;
+    const lowScoreSlides = slideScores.filter((s) => s.totalScore < 20).length;
+    const appropriateDepth = lowScoreSlides < slideScores.length * 0.2;
+    if (!appropriateDepth) {
+      score -= 5;
+      notes.push("Some slides have quality issues");
     }
-    return result;
-  }
-  /**
-   * Fix layout-related issues.
-   */
-  fixLayoutIssue(slides, issue, result) {
-    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
-      return result;
+    const overloadedSlides = slideScores.filter((s) => s.glanceTest < 5).length;
+    const noOverload = overloadedSlides === 0;
+    if (!noOverload) {
+      score -= 3;
+      notes.push(`${overloadedSlides} slides fail glance test - too dense`);
     }
-    const slide = slides[issue.slideIndex];
-    if (!slide) return result;
-    if (issue.message.includes("Insufficient whitespace")) {
-      const currentWordCount = this.countWords(slide);
-      const targetReduction = 0.3;
-      const targetWords = Math.floor(currentWordCount * (1 - targetReduction));
-      result.originalValue = currentWordCount;
-      if (slide.data.body) {
-        slide.data.body = this.condenseText(slide.data.body, Math.floor(targetWords * 0.5));
-      }
-      if (slide.data.bullets && slide.data.bullets.length > 0) {
-        const wordsPerBullet = Math.floor(targetWords / (slide.data.bullets.length * 2));
-        slide.data.bullets = slide.data.bullets.map((b) => this.condenseText(b, wordsPerBullet));
-      }
-      result.newValue = this.countWords(slide);
-      result.applied = true;
-      result.description = `Reduced content from ${result.originalValue} to ${result.newValue} words for better whitespace`;
+    const excellentSlides = slideScores.filter((s) => s.totalScore >= 30).length;
+    const actionableInsights = excellentSlides >= slideScores.length * 0.3;
+    if (!actionableInsights) {
+      score -= 3;
+      notes.push("Need more high-impact slides");
     }
-    return result;
+    return {
+      score: Math.max(0, score),
+      messagesAreClear,
+      appropriateDepth,
+      noOverload,
+      actionableInsights,
+      notes: notes.join(". ") || "Strong content quality"
+    };
   }
-  /**
-   * Fix consistency-related issues.
-   */
-  fixConsistencyIssue(slides, issue, result) {
-    if (issue.message.includes("Inconsistent title casing")) {
-      let fixedCount = 0;
-      for (const slide of slides) {
-        if (slide.data.title) {
-          const original = slide.data.title;
-          slide.data.title = this.toTitleCase(slide.data.title);
-          if (slide.data.title !== original) fixedCount++;
-        }
-      }
-      result.originalValue = "Mixed casing";
-      result.newValue = "Title Case";
-      result.applied = fixedCount > 0;
-      result.description = `Applied Title Case to ${fixedCount} slide titles`;
+  evaluateExecutiveReadiness(slideScores) {
+    let score = 25;
+    const notes = [];
+    const criticalFailureSlides = slideScores.filter((s) => s.hasCriticalFailure);
+    if (criticalFailureSlides.length > 0) {
+      score = 0;
+      notes.push(`CRITICAL: ${criticalFailureSlides.length} slide(s) have critical failures - CANNOT show to executives`);
+      criticalFailureSlides.forEach((s) => {
+        notes.push(`  - Slide ${s.slideIndex} (${s.slideType}): ${s.criticalFailures[0]}`);
+      });
+      return {
+        score: 0,
+        wouldImpress: false,
+        readyForBoardroom: false,
+        compelling: false,
+        shareworthy: false,
+        notes: notes.join(". ")
+      };
     }
-    return result;
-  }
-  /**
-   * Fix contrast-related issues.
-   * Note: These are CSS fixes, typically handled at generation time.
-   */
-  fixContrastIssue(slides, issue, result) {
-    result.description = "Contrast issues flagged for CSS regeneration";
-    result.applied = false;
-    return result;
-  }
-  /**
-   * Condense text to approximately maxWords.
-   * Uses smart truncation that preserves meaning.
-   */
-  condenseText(text, maxWords) {
-    const words = text.split(/\s+/);
-    if (words.length <= maxWords) {
-      return text;
-    }
-    const fillerWords = /* @__PURE__ */ new Set([
-      "very",
-      "really",
-      "actually",
-      "basically",
-      "literally",
-      "obviously",
-      "clearly",
-      "simply",
-      "just",
-      "that",
-      "which",
-      "would",
-      "could",
-      "should",
-      "might"
-    ]);
-    let filtered = words.filter((w) => !fillerWords.has(w.toLowerCase()));
-    if (filtered.length <= maxWords) {
-      return filtered.join(" ");
-    }
-    const punctuation = [".", ",", ";", ":", "-"];
-    let breakPoint = maxWords;
-    for (let i = maxWords - 1; i >= maxWords - 5 && i >= 0; i--) {
-      const word = filtered[i];
-      if (word && punctuation.some((p) => word.endsWith(p))) {
-        breakPoint = i + 1;
-        break;
-      }
+    const avgGlance = slideScores.reduce((sum, s) => sum + s.glanceTest, 0) / slideScores.length;
+    const avgOneIdea = slideScores.reduce((sum, s) => sum + s.oneIdea, 0) / slideScores.length;
+    const avgDataInk = slideScores.reduce((sum, s) => sum + s.dataInkRatio, 0) / slideScores.length;
+    const avgExecution = slideScores.reduce((sum, s) => sum + s.professionalExecution, 0) / slideScores.length;
+    const avgTotal = slideScores.reduce((sum, s) => sum + s.totalScore, 0) / slideScores.length;
+    const wouldImpress = avgGlance >= 7 && avgOneIdea >= 7 && avgExecution >= 7;
+    if (!wouldImpress) {
+      score -= 7;
+      notes.push("Needs more visual impact to impress");
+    }
+    const readyForBoardroom = avgExecution >= 6 && avgDataInk >= 6;
+    if (!readyForBoardroom) {
+      score -= 7;
+      notes.push(`Boardroom readiness: Execution ${avgExecution.toFixed(1)}/10, Data-Ink ${avgDataInk.toFixed(1)}/10`);
+    }
+    const compelling = avgGlance >= 6 && avgOneIdea >= 6;
+    if (!compelling) {
+      score -= 5;
+      notes.push(`Compelling: Glance ${avgGlance.toFixed(1)}/10, OneIdea ${avgOneIdea.toFixed(1)}/10`);
+    }
+    const excellentSlides = slideScores.filter((s) => s.totalScore >= 30).length;
+    const shareworthy = excellentSlides >= slideScores.length * 0.4;
+    if (!shareworthy) {
+      score -= 5;
+      notes.push(`Shareworthy: ${excellentSlides}/${slideScores.length} excellent slides (need 40%)`);
     }
-    filtered = filtered.slice(0, breakPoint);
-    let result = filtered.join(" ");
-    if (!result.endsWith(".") && !result.endsWith("!") && !result.endsWith("?")) {
-      result = result.replace(/[,;:]$/, "") + "...";
+    if (wouldImpress && readyForBoardroom && compelling) {
+      notes.push("Meets expert standards - McKinsey/TED quality");
     }
-    return result;
+    return {
+      score: Math.max(0, score),
+      wouldImpress,
+      readyForBoardroom,
+      compelling,
+      shareworthy,
+      notes: notes.join(". ") || "Executive-ready presentation"
+    };
   }
-  /**
-   * Convert text to Title Case.
-   */
-  toTitleCase(text) {
-    const minorWords = /* @__PURE__ */ new Set([
-      "a",
-      "an",
-      "the",
-      "and",
-      "but",
-      "or",
-      "for",
-      "nor",
-      "on",
-      "at",
-      "to",
-      "by",
-      "of",
-      "in",
-      "with"
-    ]);
-    return text.split(" ").map((word, index) => {
-      if (index === 0) {
-        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  // ===========================================================================
+  // VERDICT & SUMMARY
+  // ===========================================================================
+  determineVerdict(score) {
+    if (score >= 90) return "world-class";
+    if (score >= 80) return "professional";
+    if (score >= 65) return "acceptable";
+    if (score >= 50) return "needs-work";
+    return "poor";
+  }
+  explainVerdict(verdict, score) {
+    const explanations = {
+      "world-class": `Score: ${score}/100. This presentation would impress any audience. Ready for TED, boardrooms, and high-stakes pitches.`,
+      "professional": `Score: ${score}/100. Solid professional presentation. Ready for most business contexts with minor polish.`,
+      "acceptable": `Score: ${score}/100. Meets basic standards but lacks the polish and impact of world-class work.`,
+      "needs-work": `Score: ${score}/100. Significant improvements needed in visual design, content clarity, or structure.`,
+      "poor": `Score: ${score}/100. Fundamental issues with content, design, or structure. Major rework required.`
+    };
+    return explanations[verdict];
+  }
+  extractTopIssuesAndStrengths(slideScores) {
+    const issues = [];
+    const strengths = [];
+    for (const slide of slideScores) {
+      if (slide.visualImpact < 5) {
+        issues.push(`Slide ${slide.slideIndex}: Low visual impact - ${slide.visualImpactNotes}`);
       }
-      if (minorWords.has(word.toLowerCase())) {
-        return word.toLowerCase();
+      if (slide.contentClarity < 5) {
+        issues.push(`Slide ${slide.slideIndex}: Clarity issue - ${slide.contentClarityNotes}`);
       }
-      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-    }).join(" ");
-  }
-  /**
-   * Count words in a slide.
-   */
-  countWords(slide) {
-    let text = "";
-    if (slide.data.title) text += slide.data.title + " ";
-    if (slide.data.subtitle) text += slide.data.subtitle + " ";
-    if (slide.data.body) text += slide.data.body + " ";
-    if (slide.data.bullets) text += slide.data.bullets.join(" ") + " ";
-    if (slide.data.keyMessage) text += slide.data.keyMessage + " ";
-    return text.split(/\s+/).filter((w) => w.length > 0).length;
-  }
-  /**
-   * Count elements in a slide.
-   */
-  countElements(slide) {
-    return (slide.data.title ? 1 : 0) + (slide.data.subtitle ? 1 : 0) + (slide.data.body ? 1 : 0) + (slide.data.bullets?.length || 0) + (slide.data.keyMessage ? 1 : 0) + (slide.data.image ? 1 : 0);
-  }
-  /**
-   * Generate a summary of fixes applied.
-   */
-  generateSummary(applied, skipped) {
-    const lines = [];
-    lines.push(`
-\u{1F527} Auto-Fix Summary`);
-    lines.push(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
-    lines.push(`Fixes Applied: ${applied.length}`);
-    lines.push(`Fixes Skipped: ${skipped.length}`);
-    lines.push("");
-    if (applied.length > 0) {
-      lines.push("\u2705 Applied Fixes:");
-      for (const fix of applied) {
-        lines.push(`   \u2022 ${fix.description}`);
+      if (slide.totalScore >= 35) {
+        strengths.push(`Slide ${slide.slideIndex}: Excellent overall (${slide.slideType})`);
       }
+    }
+    return {
+      topIssues: issues.slice(0, 5),
+      topStrengths: strengths.slice(0, 3)
+    };
+  }
+  // ===========================================================================
+  // FORMATTED REPORT
+  // ===========================================================================
+  generateReport(result) {
+    const lines = [
+      "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+      "\u2551           VISUAL QUALITY EVALUATION REPORT                       \u2551",
+      "\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563",
+      "",
+      `  VERDICT: ${result.verdict.toUpperCase()}`,
+      `  ${result.verdictExplanation}`,
+      "",
+      "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+      "\u2502 DIMENSION SCORES                                                 \u2502",
+      "\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",
+      `\u2502 Narrative Flow:      ${this.scoreBar(result.narrativeFlow.score, 25)}  ${result.narrativeFlow.score}/25`,
+      `\u2502 Visual Consistency:  ${this.scoreBar(result.visualConsistency.score, 25)}  ${result.visualConsistency.score}/25`,
+      `\u2502 Content Quality:     ${this.scoreBar(result.contentQuality.score, 25)}  ${result.contentQuality.score}/25`,
+      `\u2502 Executive Readiness: ${this.scoreBar(result.executiveReadiness.score, 25)}  ${result.executiveReadiness.score}/25`,
+      "\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",
+      `\u2502 OVERALL SCORE:       ${this.scoreBar(result.overallScore, 100)}  ${result.overallScore}/100`,
+      "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
+      ""
+    ];
+    if (result.topStrengths.length > 0) {
+      lines.push("\u2713 TOP STRENGTHS:");
+      result.topStrengths.forEach((s) => lines.push(`  \u2022 ${s}`));
       lines.push("");
     }
-    if (skipped.length > 0) {
-      lines.push("\u26A0\uFE0F  Skipped Fixes (require manual attention):");
-      for (const fix of skipped.slice(0, 5)) {
-        lines.push(`   \u2022 ${fix.description}`);
-      }
-      if (skipped.length > 5) {
-        lines.push(`   ... and ${skipped.length - 5} more`);
-      }
+    if (result.topIssues.length > 0) {
+      lines.push("\u2717 TOP ISSUES:");
+      result.topIssues.forEach((i) => lines.push(`  \u2022 ${i}`));
+      lines.push("");
     }
+    lines.push("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    lines.push("\u2502 SLIDE-BY-SLIDE BREAKDOWN                                         \u2502");
+    lines.push("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    for (const slide of result.slideScores) {
+      const scoreColor = slide.totalScore >= 30 ? "\u2713" : slide.totalScore >= 20 ? "\u25D0" : "\u2717";
+      lines.push(`\u2502 ${scoreColor} Slide ${slide.slideIndex.toString().padStart(2)} (${slide.slideType.padEnd(18)}): ${slide.totalScore}/40`);
+      lines.push(`\u2502   Visual: ${slide.visualImpact}/10  Clarity: ${slide.contentClarity}/10  Polish: ${slide.professionalPolish}/10  Theme: ${slide.themeCoherence}/10`);
+    }
+    lines.push("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    lines.push("");
+    lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
     return lines.join("\n");
   }
+  scoreBar(score, max) {
+    const percentage = score / max;
+    const filled = Math.round(percentage * 20);
+    const empty = 20 - filled;
+    return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  }
 };
-function createAutoFixEngine(mode, presentationType) {
-  return new AutoFixEngine(mode, presentationType);
+async function evaluatePresentation(htmlPath, screenshotDir) {
+  const evaluator = new VisualQualityEvaluator(screenshotDir);
+  return evaluator.evaluate(htmlPath);
 }
 
 // src/generators/html/RevealJsGenerator.ts
@@ -5257,7 +6347,7 @@ ${slides}
     .reveal .number {
       font-size: 4em;
       font-weight: 800;
-      color: var(--color-highlight);
+      color: var(--color-primary);
       text-align: center;
     }
 
@@ -5308,12 +6398,12 @@ ${slides}
     .reveal .metric-value {
       font-size: 2em;
       font-weight: 700;
-      color: var(--color-highlight);
+      color: var(--color-primary);
     }
 
     .reveal .metric-label {
       font-size: 0.8em;
-      color: var(--color-text-light);
+      color: var(--color-text);
     }
 
     .reveal .metric-change {
@@ -5390,27 +6480,31 @@ ${slides}
        ================================================================ */
 
     /* Title slide: Bold background - makes strong first impression */
-    .reveal .slide-title {
-      background: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
-    }
-    .reveal .slide-title h1,
-    .reveal .slide-title h2,
-    .reveal .slide-title p,
-    .reveal .slide-title .subtitle {
-      color: ${isDark ? primary : "#ffffff"};
+    /* Using .slides section.slide-title for higher specificity than .reveal .slides section */
+    .reveal .slides section.slide-title {
+      background-color: ${titleBg} !important;
+      background-image: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
+    }
+    .reveal .slides section.slide-title h1,
+    .reveal .slides section.slide-title h2,
+    .reveal .slides section.slide-title p,
+    .reveal .slides section.slide-title .subtitle {
+      color: ${isDark ? "#ffffff" : "#ffffff"} !important;
+      -webkit-text-fill-color: ${isDark ? "#ffffff" : "#ffffff"} !important;
+      background: none !important;
     }
 
     /* Section dividers: Subtle visual breaks */
-    .reveal .slide-section-divider {
+    .reveal .slides section.slide-section-divider {
       background: ${isDark ? this.lightenColor(background, 8) : `linear-gradient(180deg, ${this.lightenColor(primary, 85)} 0%, ${this.lightenColor(primary, 92)} 100%)`};
     }
 
     /* Big number slides: Clean with accent highlight - emphasizes the data */
-    .reveal .slide-big-number {
+    .reveal .slides section.slide-big-number {
       background: var(--color-background);
       border-left: 8px solid var(--color-highlight);
     }
-    .reveal .slide-big-number .number {
+    .reveal .slides section.slide-big-number .number {
       font-size: 5em;
       background: linear-gradient(135deg, var(--color-highlight) 0%, var(--color-accent) 100%);
       -webkit-background-clip: text;
@@ -5419,50 +6513,56 @@ ${slides}
     }
 
     /* Metrics grid: Light accent background - data-focused */
-    .reveal .slide-metrics-grid {
+    .reveal .slides section.slide-metrics-grid {
       background: ${isDark ? this.lightenColor(background, 8) : this.lightenColor(accent, 90)};
     }
-    ${isDark ? `.reveal .slide-metrics-grid { color: ${text}; }` : ""}
+    ${isDark ? `.reveal .slides section.slide-metrics-grid { color: ${text}; }` : ""}
 
-    /* CTA slide: Highlight color - drives action */
-    .reveal .slide-cta {
-      background: linear-gradient(135deg, var(--color-highlight) 0%, var(--color-accent) 100%);
-    }
-    .reveal .slide-cta h2,
-    .reveal .slide-cta p {
-      color: #ffffff;
-    }
-    .reveal .slide-cta .cta-button {
+    /* CTA slide: Highlight color - drives action (darkened for 7:1 contrast with white) */
+    .reveal .slides section.slide-cta {
+      background-color: ${this.darkenColor(highlight, 30)} !important;
+      background-image: linear-gradient(135deg, ${this.darkenColor(highlight, 25)} 0%, ${this.darkenColor(accent, 30)} 100%);
+    }
+    .reveal .slides section.slide-cta h2,
+    .reveal .slides section.slide-cta p {
+      color: #ffffff !important;
+      -webkit-text-fill-color: #ffffff !important;
+      background: none !important;
+    }
+    .reveal .slides section.slide-cta .cta-button {
       background: #ffffff;
       color: var(--color-highlight);
     }
 
     /* Thank you slide: Matches title for bookend effect */
-    .reveal .slide-thank-you {
-      background: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
+    .reveal .slides section.slide-thank-you {
+      background-color: ${titleBg} !important;
+      background-image: linear-gradient(135deg, ${titleBg} 0%, ${titleBgEnd} 100%);
     }
-    .reveal .slide-thank-you h2,
-    .reveal .slide-thank-you p,
-    .reveal .slide-thank-you .subtitle {
-      color: ${isDark ? primary : "#ffffff"};
+    .reveal .slides section.slide-thank-you h2,
+    .reveal .slides section.slide-thank-you p,
+    .reveal .slides section.slide-thank-you .subtitle {
+      color: #ffffff !important;
+      -webkit-text-fill-color: #ffffff !important;
+      background: none !important;
     }
 
     /* Quote slides: Elegant subtle background */
-    .reveal .slide-quote {
+    .reveal .slides section.slide-quote {
       background: ${isDark ? this.lightenColor(background, 5) : this.lightenColor(secondary, 92)};
     }
-    .reveal .slide-quote blockquote {
+    .reveal .slides section.slide-quote blockquote {
       border-left-color: var(--color-accent);
       font-size: 1.3em;
     }
-    ${isDark ? `.reveal .slide-quote { color: ${text}; }` : ""}
+    ${isDark ? `.reveal .slides section.slide-quote { color: ${text}; }` : ""}
 
     /* Single statement: Clean, centered, impactful */
-    .reveal .slide-single-statement {
+    .reveal .slides section.slide-single-statement {
       background: var(--color-background);
     }
-    .reveal .slide-single-statement .statement,
-    .reveal .slide-single-statement .big-idea-text {
+    .reveal .slides section.slide-single-statement .statement,
+    .reveal .slides section.slide-single-statement .big-idea-text {
       font-size: 2.2em;
       max-width: 80%;
       margin: 0 auto;
@@ -5479,52 +6579,77 @@ ${slides}
       padding-right: 30px;
     }
     .reveal .column-title {
-      font-size: 1.2em;
+      font-size: 1.3em;
       font-weight: 600;
       margin-bottom: 0.5em;
-      color: var(--color-accent);
+      color: var(--color-primary);
     }
     .reveal .column-content,
     .reveal .column-body {
       line-height: 1.6;
     }
 
-    /* Timeline/Process: Visual flow */
+    /* Timeline/Process: Visual flow - ENHANCED */
+    .reveal .slide-timeline .slide-content,
+    .reveal .slide-process .slide-content {
+      justify-content: center;
+    }
     .reveal .slide-timeline .steps,
     .reveal .slide-timeline .timeline,
     .reveal .slide-process .steps,
     .reveal .slide-process .process-steps {
       display: flex;
-      gap: 20px;
+      gap: 24px;
       flex-wrap: wrap;
       justify-content: center;
+      align-items: stretch;
+      margin-top: 30px;
+      padding: 0 20px;
     }
     .reveal .slide-timeline .step,
     .reveal .slide-timeline .timeline-item,
     .reveal .slide-process .step,
     .reveal .slide-process .process-step {
-      flex: 1;
-      min-width: 150px;
-      max-width: 250px;
-      padding: 20px;
-      background: ${isDark ? this.lightenColor(background, 10) : this.lightenColor(secondary, 92)};
-      border-radius: 8px;
-      border-top: 4px solid var(--color-accent);
+      flex: 1 1 200px;
+      min-width: 180px;
+      max-width: 280px;
+      padding: 28px 24px;
+      background: ${isDark ? this.lightenColor(background, 10) : "#ffffff"};
+      border-radius: 12px;
+      border-top: 5px solid var(--color-accent);
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
       ${isDark ? `color: ${text};` : ""}
+      transition: transform 0.2s ease, box-shadow 0.2s ease;
+    }
+    .reveal .slide-timeline .step:hover,
+    .reveal .slide-timeline .timeline-item:hover,
+    .reveal .slide-process .step:hover,
+    .reveal .slide-process .process-step:hover {
+      transform: translateY(-4px);
+      box-shadow: 0 8px 20px rgba(0, 0, 0, 0.12);
     }
     .reveal .step-number {
-      font-size: 1.5em;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 40px;
+      height: 40px;
+      background: var(--color-accent);
+      color: #ffffff;
+      border-radius: 50%;
+      font-size: 1.2em;
       font-weight: 700;
-      color: var(--color-accent);
-      margin-bottom: 0.5em;
+      margin-bottom: 16px;
     }
     .reveal .step-title {
-      font-size: 1.1em;
+      font-size: 1.3em;
       font-weight: 600;
-      margin-bottom: 0.5em;
+      margin-bottom: 8px;
+      color: var(--color-primary);
     }
     .reveal .step-desc {
-      font-size: 0.9em;
+      font-size: 0.95em;
+      line-height: 1.5;
       color: var(--color-text-light);
     }
     .reveal .step-arrow {
@@ -5534,6 +6659,54 @@ ${slides}
       color: var(--color-accent);
     }
 
+    /* Improved slide layout - PROFESSIONAL */
+    .reveal .slides section {
+      overflow: hidden;
+    }
+    .reveal .slides section .slide-content {
+      overflow-y: auto;
+      overflow-x: hidden;
+      max-height: calc(100vh - 120px);
+    }
+
+    /* Three column professional styling */
+    .reveal .three-columns .column {
+      padding: 24px;
+      background: ${isDark ? this.lightenColor(background, 8) : "#f8f9fa"};
+      border-radius: 12px;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+    }
+    .reveal .three-columns .column-title {
+      font-size: 1.3em;
+      color: var(--color-primary);
+      border-bottom: 2px solid var(--color-accent);
+      padding-bottom: 8px;
+      margin-bottom: 12px;
+    }
+
+    /* Bullets professional styling */
+    .reveal .bullets {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+    }
+    .reveal .bullets li {
+      position: relative;
+      padding-left: 28px;
+      margin-bottom: 16px;
+      line-height: 1.5;
+    }
+    .reveal .bullets li::before {
+      content: "";
+      position: absolute;
+      left: 0;
+      top: 8px;
+      width: 8px;
+      height: 8px;
+      background: var(--color-accent);
+      border-radius: 50%;
+    }
+
     /* Progress bar enhancement */
     .reveal .progress {
       background: ${this.lightenColor(primary, 80)};
@@ -5769,182 +6942,6 @@ ${slides}
   }
 };
 
-// src/qa/IterativeQAEngine.ts
-var DEFAULT_OPTIONS = {
-  minScore: 95,
-  maxIterations: 5,
-  verbose: true
-};
-var IterativeQAEngine = class {
-  kb;
-  scorer;
-  fixer;
-  generator;
-  mode;
-  presentationType;
-  config;
-  constructor(mode, presentationType, config) {
-    this.mode = mode;
-    this.presentationType = presentationType;
-    this.config = config;
-    this.scorer = new SevenDimensionScorer(mode, presentationType);
-    this.fixer = new AutoFixEngine(mode, presentationType);
-    this.generator = new RevealJsGenerator();
-  }
-  /**
-   * Run the iterative QA process.
-   */
-  async run(initialSlides, initialHtml, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    this.kb = await getKnowledgeGateway();
-    const iterations = [];
-    let currentSlides = initialSlides;
-    let currentHtml = initialHtml;
-    let scoringResult;
-    let autoFixSummary = "";
-    let totalFixesApplied = 0;
-    if (opts.verbose) {
-      logger.progress("\n\u{1F504} Starting Iterative QA Process");
-      logger.info(`   Target Score: ${opts.minScore}/100`);
-      logger.info(`   Max Iterations: ${opts.maxIterations}`);
-      logger.progress("");
-    }
-    for (let i = 0; i < opts.maxIterations; i++) {
-      const iterationNum = i + 1;
-      if (opts.verbose) {
-        logger.progress(`\u{1F4CA} Iteration ${iterationNum}/${opts.maxIterations}...`);
-      }
-      scoringResult = await this.scorer.score(currentSlides, currentHtml, opts.minScore);
-      iterations.push({
-        iteration: iterationNum,
-        score: scoringResult.overallScore,
-        dimensionScores: {
-          layout: scoringResult.dimensions.layout.score,
-          contrast: scoringResult.dimensions.contrast.score,
-          graphics: scoringResult.dimensions.graphics.score,
-          content: scoringResult.dimensions.content.score,
-          clarity: scoringResult.dimensions.clarity.score,
-          effectiveness: scoringResult.dimensions.effectiveness.score,
-          consistency: scoringResult.dimensions.consistency.score
-        },
-        fixesApplied: 0,
-        timestamp: /* @__PURE__ */ new Date()
-      });
-      if (opts.verbose) {
-        logger.info(`   Score: ${scoringResult.overallScore}/100`);
-      }
-      if (scoringResult.passed) {
-        if (opts.verbose) {
-          logger.success(`PASSED - Score meets threshold (${opts.minScore})`);
-        }
-        break;
-      }
-      if (i < opts.maxIterations - 1) {
-        if (opts.verbose) {
-          logger.warn("Below threshold, applying auto-fixes...");
-        }
-        const fixResult = await this.fixer.fix(currentSlides, scoringResult);
-        if (fixResult.fixesApplied.length > 0) {
-          currentSlides = fixResult.slidesFixed;
-          currentHtml = await this.generator.generate(currentSlides, this.config);
-          const lastIteration = iterations[iterations.length - 1];
-          if (lastIteration) {
-            lastIteration.fixesApplied = fixResult.fixesApplied.length;
-          }
-          totalFixesApplied += fixResult.fixesApplied.length;
-          if (opts.verbose) {
-            logger.info(`   \u{1F527} Applied ${fixResult.fixesApplied.length} fixes`);
-          }
-          autoFixSummary += fixResult.summary + "\n";
-        } else {
-          if (opts.verbose) {
-            logger.warn("No auto-fixes available, manual review needed");
-          }
-          break;
-        }
-      }
-    }
-    if (!scoringResult.passed) {
-      scoringResult = await this.scorer.score(currentSlides, currentHtml, opts.minScore);
-    }
-    const report = this.generateReport(
-      scoringResult,
-      iterations,
-      opts,
-      totalFixesApplied
-    );
-    if (opts.verbose) {
-      logger.info(report);
-    }
-    return {
-      finalScore: scoringResult.overallScore,
-      passed: scoringResult.passed,
-      threshold: opts.minScore,
-      iterations,
-      totalIterations: iterations.length,
-      maxIterations: opts.maxIterations,
-      slides: currentSlides,
-      html: currentHtml,
-      finalScoring: scoringResult,
-      autoFixSummary,
-      report
-    };
-  }
-  /**
-   * Generate a comprehensive report.
-   */
-  generateReport(finalScoring, iterations, options, totalFixesApplied) {
-    const lines = [];
-    lines.push("");
-    lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
-    lines.push("\u2551           ITERATIVE QA FINAL REPORT                    \u2551");
-    lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
-    lines.push("");
-    const passStatus = finalScoring.passed ? "\u2705 PASSED" : "\u274C FAILED";
-    lines.push(`Final Score: ${finalScoring.overallScore}/100 ${passStatus}`);
-    lines.push(`Threshold: ${options.minScore}/100`);
-    lines.push(`Iterations: ${iterations.length}/${options.maxIterations}`);
-    lines.push(`Total Fixes Applied: ${totalFixesApplied}`);
-    lines.push("");
-    if (iterations.length > 1) {
-      lines.push("Score Progression:");
-      lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-      for (const iter of iterations) {
-        const bar = "\u2588".repeat(Math.floor(iter.score / 10)) + "\u2591".repeat(10 - Math.floor(iter.score / 10));
-        lines.push(`  Iter ${iter.iteration}: ${bar} ${iter.score}/100 (+${iter.fixesApplied} fixes)`);
-      }
-      lines.push("");
-    }
-    lines.push(this.scorer.formatReport(finalScoring));
-    lines.push("");
-    lines.push("\u{1F4DA} Knowledge Base Compliance:");
-    lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    lines.push(`   Mode: ${this.mode}`);
-    lines.push(`   Presentation Type: ${this.presentationType}`);
-    lines.push(`   Word Limits: ${this.mode === "keynote" ? "6-25" : "40-80"} per slide`);
-    lines.push(`   Expert Frameworks: Duarte, Reynolds, Gallo, Anderson`);
-    lines.push("");
-    if (!finalScoring.passed) {
-      lines.push("\u{1F4CB} Recommendations for Manual Review:");
-      lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-      const manualIssues = finalScoring.issues.filter((i) => !i.autoFixable);
-      for (const issue of manualIssues.slice(0, 5)) {
-        lines.push(`   \u2022 ${issue.message}`);
-        if (issue.fixSuggestion) {
-          lines.push(`     \u2192 ${issue.fixSuggestion}`);
-        }
-      }
-      if (manualIssues.length > 5) {
-        lines.push(`   ... and ${manualIssues.length - 5} more issues`);
-      }
-    }
-    return lines.join("\n");
-  }
-};
-function createIterativeQAEngine(mode, presentationType, config) {
-  return new IterativeQAEngine(mode, presentationType, config);
-}
-
 // src/generators/pptx/PowerPointGenerator.ts
 var import_pptxgenjs = __toESM(require("pptxgenjs"));
 
@@ -6714,11 +7711,11 @@ var PDFGenerator = class {
         waitUntil: ["networkidle0", "domcontentloaded"]
       });
       await page.evaluate(() => {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           if (document.fonts && document.fonts.ready) {
-            document.fonts.ready.then(() => resolve());
+            document.fonts.ready.then(() => resolve2());
           } else {
-            setTimeout(resolve, 1e3);
+            setTimeout(resolve2, 1e3);
           }
         });
       });
@@ -6898,46 +7895,38 @@ var PresentationEngine = class {
     }
     let qaResults;
     let score = 100;
-    let iterativeResult = null;
-    let finalSlides = slides;
-    let finalHtml = outputs.html;
+    let visualQAResult = null;
+    const finalSlides = slides;
+    const finalHtml = outputs.html;
     if (!config.skipQA && outputs.html) {
-      const threshold = config.qaThreshold ?? 95;
-      const maxIterations = config.maxIterations ?? 5;
-      const useIterativeQA = config.useIterativeQA !== false;
-      if (useIterativeQA) {
-        logger.progress("\u{1F50D} Running Iterative QA (7-Dimension Scoring)...");
-        const iterativeEngine = createIterativeQAEngine(
-          config.mode,
-          presentationType,
-          config
-        );
-        iterativeResult = await iterativeEngine.run(slides, outputs.html, {
-          minScore: threshold,
-          maxIterations,
-          verbose: true
-        });
-        score = iterativeResult.finalScore;
-        finalSlides = iterativeResult.slides;
-        finalHtml = iterativeResult.html;
-        if (outputs.html) {
-          outputs.html = finalHtml;
-        }
-        qaResults = this.buildQAResultsFrom7Dimension(iterativeResult);
-        if (!iterativeResult.passed) {
-          throw new QAFailureError(score, threshold, qaResults);
-        }
-      } else {
-        logger.progress("\u{1F50D} Running QA validation (legacy mode)...");
-        qaResults = await this.qaEngine.validate(outputs.html, {
-          mode: config.mode,
-          strictMode: true
-        });
-        score = this.scoreCalculator.calculate(qaResults);
-        logger.info(`\u{1F4CA} QA Score: ${score}/100`);
+      const threshold = config.qaThreshold ?? 80;
+      logger.progress("\u{1F50D} Running Visual Quality Evaluation (Playwright)...");
+      const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "presentation-qa-"));
+      const tempHtmlPath = path2.join(tempDir, "presentation.html");
+      fs2.writeFileSync(tempHtmlPath, outputs.html);
+      try {
+        const visualEvaluator = new VisualQualityEvaluator(path2.join(tempDir, "screenshots"));
+        visualQAResult = await visualEvaluator.evaluate(tempHtmlPath);
+        score = visualQAResult.overallScore;
+        logger.info(`\u{1F4CA} Visual QA Score: ${score}/100 (${visualQAResult.verdict.toUpperCase()})`);
+        logger.info(`   Narrative Flow: ${visualQAResult.narrativeFlow.score}/25`);
+        logger.info(`   Visual Consistency: ${visualQAResult.visualConsistency.score}/25`);
+        logger.info(`   Content Quality: ${visualQAResult.contentQuality.score}/25`);
+        logger.info(`   Executive Readiness: ${visualQAResult.executiveReadiness.score}/25`);
+        qaResults = this.buildQAResultsFromVisual(visualQAResult);
         if (score < threshold) {
+          logger.warn(`\u26A0\uFE0F Score ${score} below threshold ${threshold}`);
+          if (visualQAResult.topIssues.length > 0) {
+            logger.warn("Top issues:");
+            visualQAResult.topIssues.forEach((issue) => logger.warn(`  \u2022 ${issue}`));
+          }
           throw new QAFailureError(score, threshold, qaResults);
         }
+      } finally {
+        try {
+          fs2.rmSync(tempDir, { recursive: true, force: true });
+        } catch {
+        }
       }
     } else {
       qaResults = this.qaEngine.createEmptyResults();
@@ -6953,7 +7942,7 @@ var PresentationEngine = class {
         logger.warn(`PDF generation failed (non-critical): ${errorMsg}`);
       }
     }
-    const metadata = this.buildMetadata(config, analysis, finalSlides, iterativeResult);
+    const metadata = this.buildMetadata(config, analysis, finalSlides, visualQAResult);
     return {
       outputs,
       qaResults,
@@ -6962,43 +7951,57 @@ var PresentationEngine = class {
     };
   }
   /**
-   * Build QA results structure from 7-dimension scoring.
+   * Build QA results structure from visual quality evaluation.
    */
-  buildQAResultsFrom7Dimension(iterativeResult) {
-    const scoring = iterativeResult.finalScoring;
+  buildQAResultsFromVisual(visualResult) {
+    const passed = visualResult.overallScore >= 80;
     return {
-      passed: scoring.passed,
-      score: scoring.overallScore,
+      passed,
+      score: visualResult.overallScore,
       visual: {
-        whitespacePercentage: scoring.dimensions.layout.score,
-        layoutBalance: scoring.dimensions.layout.score / 100,
-        colorContrast: scoring.dimensions.contrast.score / 100
+        whitespacePercentage: visualResult.visualConsistency.score * 4,
+        // Scale 25 to 100
+        layoutBalance: visualResult.visualConsistency.professionalLook ? 1 : 0.7,
+        colorContrast: visualResult.visualConsistency.colorPaletteConsistent ? 0.95 : 0.8
       },
       content: {
-        perSlide: [],
-        issues: scoring.issues.filter((i) => i.dimension === "content")
+        perSlide: visualResult.slideScores.map((slide) => ({
+          slideIndex: slide.slideIndex,
+          wordCount: 0,
+          // Not tracked by visual QA
+          bulletCount: 0,
+          withinLimit: true,
+          hasActionTitle: slide.contentClarity >= 7,
+          issues: slide.contentClarity < 7 ? [slide.contentClarityNotes] : []
+        })),
+        issues: visualResult.topIssues.map((issue) => ({
+          severity: "warning",
+          message: issue,
+          dimension: "content"
+        }))
       },
       accessibility: {
-        wcagLevel: scoring.dimensions.contrast.score >= 95 ? "AAA" : "AA",
-        issues: scoring.issues.filter((i) => i.dimension === "contrast")
+        wcagLevel: visualResult.visualConsistency.professionalLook ? "AA" : "A",
+        issues: []
       },
-      issues: scoring.issues.map((issue) => ({
-        severity: issue.severity,
-        message: issue.message,
-        slideIndex: issue.slideIndex,
-        dimension: issue.dimension
+      issues: visualResult.topIssues.map((issue, i) => ({
+        severity: "warning",
+        message: issue,
+        slideIndex: i,
+        dimension: "visual"
       })),
       dimensions: {
-        layout: scoring.dimensions.layout.score,
-        contrast: scoring.dimensions.contrast.score,
-        graphics: scoring.dimensions.graphics.score,
-        content: scoring.dimensions.content.score,
-        clarity: scoring.dimensions.clarity.score,
-        effectiveness: scoring.dimensions.effectiveness.score,
-        consistency: scoring.dimensions.consistency.score
+        layout: visualResult.narrativeFlow.score * 4,
+        contrast: visualResult.visualConsistency.colorPaletteConsistent ? 100 : 80,
+        graphics: visualResult.executiveReadiness.score * 4,
+        content: visualResult.contentQuality.score * 4,
+        clarity: visualResult.contentQuality.messagesAreClear ? 100 : 75,
+        effectiveness: visualResult.executiveReadiness.wouldImpress ? 100 : 60,
+        consistency: visualResult.visualConsistency.score * 4
       },
-      iterations: iterativeResult.iterations,
-      report: iterativeResult.report
+      iterations: [],
+      // Visual QA is single-pass, no iteration history
+      report: visualResult.verdictExplanation
     };
   }
   /**
@@ -7084,7 +8087,7 @@ var PresentationEngine = class {
   /**
    * Build presentation metadata.
    */
-  buildMetadata(config, analysis, slides, iterativeResult) {
+  buildMetadata(config, analysis, slides, visualResult) {
     const wordCounts = slides.map((s) => this.countWords(s));
     const totalWords = wordCounts.reduce((sum, count) => sum + count, 0);
     const avgWordsPerSlide = Math.round(totalWords / slides.length);
@@ -7102,10 +8105,9 @@ var PresentationEngine = class {
       frameworks: this.detectFrameworks(analysis),
       presentationType: config.presentationType || analysis.detectedType
     };
-    if (iterativeResult) {
-      metadata.qaIterations = iterativeResult.totalIterations;
-      metadata.qaMaxIterations = iterativeResult.maxIterations;
-      metadata.dimensionScores = iterativeResult.finalScoring.dimensions;
+    if (visualResult) {
+      metadata.qaIterations = 1;
+      metadata.qaMaxIterations = 1;
     }
     return metadata;
   }
@@ -7347,7 +8349,7 @@ var UnsplashImageProvider = class {
     };
   }
   delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 };
 var CompositeImageProvider = class {
@@ -7398,16 +8400,11 @@ async function generate(config) {
   const engine = new PresentationEngine();
   return engine.generate(config);
 }
-async function validate(presentation, options) {
-  const qaEngine = new QAEngine();
-  const results = await qaEngine.validate(presentation, options);
-  const score = qaEngine.calculateScore(results);
-  return {
-    ...results,
-    score
-  };
+async function validate(htmlPath, options) {
+  const evaluator = new VisualQualityEvaluator(options?.screenshotDir);
+  return evaluator.evaluate(htmlPath);
 }
-var VERSION = "7.1.0";
+var VERSION = "9.0.0";
 var index_default = {
   generate,
   validate,
@@ -7417,13 +8414,11 @@ var index_default = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AutoFixEngine,
   ChartJsProvider,
   CompositeChartProvider,
   CompositeImageProvider,
   ContentAnalyzer,
   ContentPatternClassifier,
-  IterativeQAEngine,
   KnowledgeGateway,
   LocalImageProvider,
   MermaidProvider,
@@ -7435,7 +8430,6 @@ var index_default = {
   QuickChartProvider,
   RevealJsGenerator,
   ScoreCalculator,
-  SevenDimensionScorer,
   SlideFactory,
   SlideGenerator,
   TemplateEngine,
@@ -7443,11 +8437,11 @@ var index_default = {
   UnsplashImageProvider,
   VERSION,
   ValidationError,
-  createAutoFixEngine,
+  VisualQualityEvaluator,
   createDefaultChartProvider,
   createDefaultImageProvider,
-  createIterativeQAEngine,
   createSlideFactory,
+  evaluatePresentation,
   generate,
   getKnowledgeGateway,
   initSlideGenerator,