claude-presentation-master 8.0.0 → 8.2.0

package/dist/index.mjs

@@ -1,30 +1,98 @@
 // src/types/index.ts
-var ValidationError = class extends Error {
+var ValidationError = class _ValidationError extends Error {
   constructor(errors, message = "Validation failed") {
-    super(message);
+    const errorList = errors.map((e) => `  \u2022 ${e}`).join("\n");
+    const suggestions = _ValidationError.getSuggestions(errors);
+    const suggestionList = suggestions.length > 0 ? "\n\nHow to fix:\n" + suggestions.map((s) => `  \u2192 ${s}`).join("\n") : "";
+    super(`${message}
+
+Issues found:
+${errorList}${suggestionList}`);
     this.errors = errors;
     this.name = "ValidationError";
+    this.suggestions = suggestions;
+  }
+  suggestions;
+  static getSuggestions(errors) {
+    const suggestions = [];
+    for (const error of errors) {
+      if (error.includes("Content is required")) {
+        suggestions.push("Provide markdown content with at least one ## section header");
+      }
+      if (error.includes("Mode must be")) {
+        suggestions.push('Use mode: "keynote" for TED-style or mode: "business" for corporate');
+      }
+      if (error.includes("Title is required")) {
+        suggestions.push('Add a title: "Your Presentation Title" to your config');
+      }
+      if (error.includes("output format")) {
+        suggestions.push('Specify format: ["html"] or format: ["html", "pdf"]');
+      }
+    }
+    return [...new Set(suggestions)];
   }
 };
-var QAFailureError = class extends Error {
-  constructor(score, threshold, qaResults, message = `QA score ${score} below threshold ${threshold}`) {
-    super(message);
+var QAFailureError = class _QAFailureError extends Error {
+  constructor(score, threshold, qaResults, message) {
+    const topIssues = _QAFailureError.getTopIssues(qaResults);
+    const issueList = topIssues.map((i) => `  \u2022 ${i}`).join("\n");
+    const helpText = `
+
+Score: ${score}/100 (threshold: ${threshold})
+
+Top issues to fix:
+${issueList}
+
+How to improve:
+  \u2192 Ensure each slide has meaningful content (not just a title)
+  \u2192 Keep text concise - aim for <40 words per slide
+  \u2192 Use timeline/process slides for step-by-step content
+  \u2192 Add visuals for data-heavy slides`;
+    super(message || `QA score ${score} below threshold ${threshold}${helpText}`);
     this.score = score;
     this.threshold = threshold;
     this.qaResults = qaResults;
     this.name = "QAFailureError";
+    this.topIssues = topIssues;
   }
+  topIssues;
   getIssues() {
     return this.qaResults.issues.map((issue) => issue.message);
   }
+  static getTopIssues(qaResults) {
+    const issues = [];
+    if (qaResults.slideScores) {
+      for (const slide of qaResults.slideScores) {
+        if (slide.criticalIssues) {
+          issues.push(...slide.criticalIssues);
+        }
+      }
+    }
+    if (qaResults.issues) {
+      issues.push(...qaResults.issues.map((i) => i.message));
+    }
+    return [...new Set(issues)].slice(0, 5);
+  }
 };
 var TemplateNotFoundError = class extends Error {
-  constructor(templatePath, message = `Template not found: ${templatePath}`) {
-    super(message);
+  constructor(templatePath, message) {
+    super(message || `Template not found: ${templatePath}
+
+Available templates: title, content, timeline, process, metrics, quote, cta, thank-you`);
     this.templatePath = templatePath;
     this.name = "TemplateNotFoundError";
   }
 };
+var KnowledgeBaseError = class extends Error {
+  constructor(field, context, message) {
+    super(message || `Knowledge base configuration error: Missing "${field}" in ${context}
+
+Check assets/presentation-knowledge.yaml for the correct structure.`);
+    this.field = field;
+    this.context = context;
+    this.name = "KnowledgeBaseError";
+  }
+};
 
 // src/core/PresentationEngine.ts
 import * as fs2 from "fs";
@@ -33,8 +101,7 @@ import * as os from "os";
 
 // src/kb/KnowledgeGateway.ts
 import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { join } from "path";
 import * as yaml from "yaml";
 
 // src/utils/Logger.ts
@@ -106,9 +173,6 @@ var logger = new Logger({
 
 // src/kb/KnowledgeGateway.ts
 function getModuleDir() {
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    return dirname(fileURLToPath(import.meta.url));
-  }
   if (typeof __dirname !== "undefined") {
     return __dirname;
   }
@@ -778,7 +842,8 @@ var KnowledgeGateway = class {
       // 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)) }
     };
   }
@@ -2797,25 +2862,43 @@ var SlideFactory = class {
   createComparisonSlide(index, section) {
     const comparison = this.classifier.extractComparison(section);
     const labels = this.config.defaults.comparison;
+    const title = this.createTitle(section.header, section);
+    const normalizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "");
     const leftFallback = labels.optionLabels[0] ?? "Option A";
     const rightFallback = labels.optionLabels[1] ?? "Option B";
-    const leftColumn = comparison?.left || section.bullets[0] || leftFallback;
-    const rightColumn = comparison?.right || section.bullets[1] || rightFallback;
+    let leftColumn = comparison?.left || section.bullets[0] || "";
+    let rightColumn = comparison?.right || section.bullets[1] || "";
+    const normalizedLeft = leftColumn.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedRight = rightColumn.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const leftIsDuplicate = normalizedLeft === normalizedTitle || normalizedTitle.includes(normalizedLeft);
+    const rightIsDuplicate = normalizedRight === normalizedTitle || normalizedTitle.includes(normalizedRight);
+    if (leftIsDuplicate || rightIsDuplicate || !leftColumn && !rightColumn) {
+      if (section.bullets.length >= 2) {
+        logger.warn(`Comparison slide "${title}" has duplicate content, using bullet points instead`);
+        return this.createBulletSlide(index, section);
+      }
+      if (leftIsDuplicate && rightIsDuplicate) {
+        logger.warn(`Skipping comparison slide "${title}" - content duplicates title`);
+        return null;
+      }
+      if (leftIsDuplicate) leftColumn = leftFallback;
+      if (rightIsDuplicate) rightColumn = rightFallback;
+    }
     return {
       index,
       type: "comparison",
       data: {
-        title: this.createTitle(section.header, section),
+        title,
         columns: [
           {
             title: labels.leftLabel,
             // FROM KB - not hardcoded 'Before'
-            content: this.truncateText(leftColumn, this.config.rules.wordsPerSlide.max)
+            content: this.truncateText(leftColumn || leftFallback, this.config.rules.wordsPerSlide.max)
           },
           {
             title: labels.rightLabel,
             // FROM KB - not hardcoded 'After'
-            content: this.truncateText(rightColumn, this.config.rules.wordsPerSlide.max)
+            content: this.truncateText(rightColumn || rightFallback, this.config.rules.wordsPerSlide.max)
           }
         ]
       },
@@ -2826,9 +2909,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,
@@ -2850,7 +2932,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",
@@ -3087,10 +3169,21 @@ var SlideFactory = class {
    * Used for section headers with strong conclusions.
    */
   createTitleImpactSlide(index, section) {
+    const title = this.cleanText(section.header);
     const supportingText = section.content || section.bullets.slice(0, 2).join(". ");
     const truncatedSupport = this.truncateText(supportingText, this.config.defaults.context.maxWords);
+    const normalizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const normalizedBody = truncatedSupport.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const bodyIsDuplicate = normalizedBody === normalizedTitle || normalizedTitle.includes(normalizedBody) || normalizedBody.includes(normalizedTitle) || truncatedSupport.length < 10;
+    if (bodyIsDuplicate) {
+      if (section.bullets.length >= 2 && this.config.mode === "business") {
+        return this.createBulletSlide(index, section);
+      }
+      logger.warn(`Skipping title-impact slide "${title}" - no distinct body content`);
+      return null;
+    }
     const data = {
-      title: this.cleanText(section.header)
+      title
     };
     if (truncatedSupport) {
       data.body = truncatedSupport;
@@ -5257,169 +5350,422 @@ var VisualQualityEvaluator = class {
       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`);
+          }
+        }
+        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)`);
+          }
+        }
+      }
+      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)`);
+          }
+        }
+      }
+      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`);
+      }
+      if (horizontalBalance > 0.6 && contentElements.length > 2) {
+        layoutIssues.push(`Horizontal imbalance: ${leftHeavy} left vs ${rightHeavy} right`);
+      }
+      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 (titleSize > 0 && bodySize > 0 && titleSize < bodySize * 1.3) {
+        typographyIssues.push("Title not prominent enough vs body");
+      }
+      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`);
+      }
+      if (body.includes("Lorem") || body.includes("placeholder") || body.includes("TODO")) {
+        completenessIssues.push("Contains placeholder text");
+      }
+      const emptyBullets = bullets.filter((b) => b.length < 3).length;
+      if (emptyBullets > 0 && bullets.length > 0) {
+        completenessIssues.push(`${emptyBullets} empty/minimal bullets`);
+      }
+      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");
+      }
+      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 || "",
-        contentLength: (title + body + bullets.join(" ")).length
+        // 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);
   }
+  /**
+   * 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.
+   */
   scoreSlide(slideIndex, slideData, screenshotPath) {
     if (!slideData) {
-      return {
-        slideIndex,
-        slideType: "unknown",
-        visualImpact: 0,
-        visualImpactNotes: "Could not analyze slide",
-        contentClarity: 0,
-        contentClarityNotes: "Could not analyze slide",
-        professionalPolish: 0,
-        professionalPolishNotes: "Could not analyze slide",
-        themeCoherence: 0,
-        themeCoherenceNotes: "Could not analyze slide",
-        totalScore: 0,
-        screenshotPath
-      };
+      return this.createFailedSlideScore(slideIndex, "unknown", "Could not analyze slide", screenshotPath);
     }
     const slideType = this.inferSlideType(slideData);
-    let visualImpact = 5;
-    const visualNotes = [];
-    if (slideData.hasImage) {
-      visualImpact += 2;
-      visualNotes.push("Has imagery");
+    const criticalFailures = [];
+    if (slideData.isEmptySlide) {
+      criticalFailures.push("EMPTY SLIDE: No meaningful content - slide serves no purpose");
     }
-    if (slideData.hasChart) {
-      visualImpact += 2;
-      visualNotes.push("Has data visualization");
+    if (slideData.hasOnlyTitle && !["title", "agenda", "thank-you", "cta"].includes(slideType)) {
+      criticalFailures.push("INCOMPLETE: Slide has title but no body content - looks unfinished");
     }
-    const highImpactTypes = [
-      "big-number",
-      "big_number",
-      "metrics-grid",
-      "metrics_grid",
-      "three-column",
-      "three_column",
-      "three-points",
-      "three_points",
-      "title-impact",
-      "title_impact",
-      "cta",
-      "call-to-action",
-      "comparison",
-      "timeline",
-      "process",
-      "quote",
-      "testimonial"
-    ];
-    if (highImpactTypes.some((t) => slideType.includes(t.replace(/_/g, "-")) || slideType.includes(t.replace(/-/g, "_")))) {
-      visualImpact += 2;
-      visualNotes.push("High-impact slide type");
+    if (slideData.hasTruncatedText) {
+      criticalFailures.push(`TRUNCATED TEXT: ${slideData.truncatedElements.length} element(s) cut off - message incomplete`);
     }
-    if (slideType === "single-statement" && slideData.body.length < 50) {
-      visualImpact += 2;
-      visualNotes.push("Clean single statement");
+    if (slideData.isRedundant) {
+      criticalFailures.push("REDUNDANT: Title and body say the same thing - violates one-idea rule");
     }
-    if (slideType === "title" && slideData.title.length > 0 && slideData.title.length < 80) {
-      visualImpact += 1;
-      visualNotes.push("Strong title");
+    if (slideData.hasCompletenessIssues) {
+      slideData.completenessIssues.forEach((issue) => {
+        if (issue.includes("empty")) {
+          criticalFailures.push(`INCOMPLETE: ${issue}`);
+        }
+      });
     }
-    if (slideData.contentLength > 300) {
-      visualImpact -= 3;
-      visualNotes.push("Too much text - overwhelming");
+    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) {
-      visualImpact -= 2;
-      visualNotes.push("Too many bullets");
-    }
-    visualImpact = Math.max(0, Math.min(10, visualImpact));
-    let contentClarity = 7;
-    const clarityNotes = [];
-    if (slideData.title.length > 80) {
-      contentClarity -= 2;
-      clarityNotes.push("Title too long");
-    }
-    if (slideData.title.length === 0) {
-      contentClarity -= 3;
-      clarityNotes.push("No title");
-    }
-    if (slideData.body && slideData.body.length > 0 && slideData.body.length < 200) {
-      contentClarity += 1;
-      clarityNotes.push("Good content length");
-    }
-    const avgBulletLength = slideData.bullets.length > 0 ? slideData.bullets.reduce((sum, b) => sum + b.length, 0) / slideData.bullets.length : 0;
-    if (avgBulletLength > 100) {
-      contentClarity -= 2;
-      clarityNotes.push("Bullets too long - not scannable");
-    }
-    contentClarity = Math.max(0, Math.min(10, contentClarity));
-    let professionalPolish = 6;
-    const polishNotes = [];
+      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) {
-      professionalPolish += 2;
-      polishNotes.push("Strong title typography");
-    } else if (titleFontSize < 24) {
-      professionalPolish -= 1;
-      polishNotes.push("Title could be more prominent");
+      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) {
-      professionalPolish += 1;
-      polishNotes.push("Well-balanced content");
-    }
-    const polishedTypes = [
-      "big-number",
-      "metrics-grid",
-      "three-column",
-      "three-points",
-      "comparison",
-      "timeline",
-      "process",
-      "cta",
-      "title",
-      "thank-you"
-    ];
-    if (polishedTypes.some((t) => slideType.includes(t))) {
-      professionalPolish += 1;
-      polishNotes.push("Well-structured layout");
+      professionalExecution += 1;
+      executionNotes.push("Well-balanced content density");
     }
-    professionalPolish = Math.max(0, Math.min(10, professionalPolish));
-    let themeCoherence = 7;
-    const coherenceNotes = [];
     if (slideData.classList.some((c) => c.includes("slide-"))) {
-      themeCoherence += 1;
-      coherenceNotes.push("Has slide type class");
+      professionalExecution += 1;
+      executionNotes.push("Consistent with design system");
     }
-    themeCoherence = Math.max(0, Math.min(10, themeCoherence));
-    const totalScore = visualImpact + contentClarity + professionalPolish + themeCoherence;
+    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 {
       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: visualNotes.join("; ") || "Standard",
+      visualImpactNotes: glanceNotes.join("; ") || "Standard",
       contentClarity,
-      contentClarityNotes: clarityNotes.join("; ") || "Good",
+      contentClarityNotes: oneIdeaNotes.join("; ") || "Good",
       professionalPolish,
-      professionalPolishNotes: polishNotes.join("; ") || "Acceptable",
+      professionalPolishNotes: executionNotes.join("; ") || "Acceptable",
       themeCoherence,
-      themeCoherenceNotes: coherenceNotes.join("; ") || "Consistent",
+      themeCoherenceNotes: "Consistent",
       totalScore,
       screenshotPath
     };
   }
+  /**
+   * Create a failed slide score (for critical failures)
+   */
+  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
+    };
+  }
   inferSlideType(slideData) {
     const classList = slideData.classList || [];
     for (const cls of classList) {
@@ -5531,34 +5877,44 @@ var VisualQualityEvaluator = class {
   evaluateContentQuality(slideScores) {
     let score = 25;
     const notes = [];
-    const clarityScores = slideScores.map((s) => s.contentClarity);
-    const avgClarity = clarityScores.reduce((a, b) => a + b, 0) / clarityScores.length;
-    const messagesAreClear = avgClarity >= 7;
-    if (!messagesAreClear) {
-      score -= 7;
-      notes.push("Messages could be clearer");
+    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 lowClarity = slideScores.filter((s) => s.contentClarity < 5).length;
-    const appropriateDepth = lowClarity < slideScores.length * 0.2;
+    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`);
+    }
+    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`);
+    }
+    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 content issues");
+      notes.push("Some slides have quality issues");
     }
-    const overloadedSlides = slideScores.filter(
-      (s) => s.contentClarityNotes.includes("too long") || s.visualImpactNotes.includes("Too much")
-    ).length;
+    const overloadedSlides = slideScores.filter((s) => s.glanceTest < 5).length;
     const noOverload = overloadedSlides === 0;
     if (!noOverload) {
-      score -= 5;
-      notes.push(`${overloadedSlides} slides have too much content`);
+      score -= 3;
+      notes.push(`${overloadedSlides} slides fail glance test - too dense`);
     }
-    const insightSlides = slideScores.filter(
-      (s) => s.visualImpact >= 7 && s.contentClarity >= 7
-    ).length;
-    const actionableInsights = insightSlides >= slideScores.length * 0.3;
+    const excellentSlides = slideScores.filter((s) => s.totalScore >= 30).length;
+    const actionableInsights = excellentSlides >= slideScores.length * 0.3;
     if (!actionableInsights) {
-      score -= 5;
-      notes.push("Need more high-impact insight slides");
+      score -= 3;
+      notes.push("Need more high-impact slides");
     }
     return {
       score: Math.max(0, score),
@@ -5572,30 +5928,50 @@ var VisualQualityEvaluator = class {
   evaluateExecutiveReadiness(slideScores) {
     let score = 25;
     const notes = [];
-    const avgVisual = slideScores.reduce((sum, s) => sum + s.visualImpact, 0) / slideScores.length;
-    const avgPolish = slideScores.reduce((sum, s) => sum + s.professionalPolish, 0) / slideScores.length;
-    const avgClarity = slideScores.reduce((sum, s) => sum + s.contentClarity, 0) / slideScores.length;
+    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(". ")
+      };
+    }
+    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 = avgTotal >= 26;
+    const wouldImpress = avgGlance >= 7 && avgOneIdea >= 7 && avgExecution >= 7;
     if (!wouldImpress) {
       score -= 7;
       notes.push("Needs more visual impact to impress");
     }
-    const readyForBoardroom = avgPolish >= 6 && avgClarity >= 6;
+    const readyForBoardroom = avgExecution >= 6 && avgDataInk >= 6;
     if (!readyForBoardroom) {
       score -= 7;
-      notes.push("Needs more polish for executive audience");
+      notes.push(`Boardroom readiness: Execution ${avgExecution.toFixed(1)}/10, Data-Ink ${avgDataInk.toFixed(1)}/10`);
     }
-    const compelling = avgVisual >= 6;
+    const compelling = avgGlance >= 6 && avgOneIdea >= 6;
     if (!compelling) {
       score -= 5;
-      notes.push("Could be more visually compelling");
+      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("Less than 40% of slides are excellent");
+      notes.push(`Shareworthy: ${excellentSlides}/${slideScores.length} excellent slides (need 40%)`);
+    }
+    if (wouldImpress && readyForBoardroom && compelling) {
+      notes.push("Meets expert standards - McKinsey/TED quality");
     }
     return {
       score: Math.max(0, score),
@@ -7323,13 +7699,63 @@ var PowerPointGenerator = class {
 
 // src/generators/PDFGenerator.ts
 import puppeteer from "puppeteer";
+var cachedBrowser = null;
+var browserIdleTimeout = null;
+var BROWSER_IDLE_MS = 3e4;
 var PDFGenerator = class {
   defaultOptions = {
     orientation: "landscape",
     printBackground: true,
     format: "Slide",
-    scale: 1
+    scale: 1,
+    reuseBrowser: true
   };
+  /**
+   * Get or create a browser instance
+   */
+  async getBrowser(reuse) {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+      browserIdleTimeout = null;
+    }
+    if (reuse && cachedBrowser && cachedBrowser.connected) {
+      logger.progress("Using cached browser instance");
+      return cachedBrowser;
+    }
+    if (cachedBrowser && !cachedBrowser.connected) {
+      cachedBrowser = null;
+    }
+    logger.progress("Launching new browser instance...");
+    const browser = await puppeteer.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu"
+      ]
+    });
+    if (reuse) {
+      cachedBrowser = browser;
+    }
+    return browser;
+  }
+  /**
+   * Schedule browser cleanup after idle period
+   */
+  scheduleBrowserCleanup() {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+    }
+    browserIdleTimeout = setTimeout(async () => {
+      if (cachedBrowser) {
+        logger.progress("Closing idle browser instance");
+        await cachedBrowser.close().catch(() => {
+        });
+        cachedBrowser = null;
+      }
+    }, BROWSER_IDLE_MS);
+  }
   /**
    * Generate PDF from HTML presentation
    * @param html - The HTML content of the presentation
@@ -7338,18 +7764,14 @@ var PDFGenerator = class {
    */
   async generate(html, options = {}) {
     const opts = { ...this.defaultOptions, ...options };
+    const reuseBrowser = opts.reuseBrowser ?? true;
     logger.progress("\u{1F4C4} Generating PDF...");
-    let browser;
+    let browser = null;
+    let shouldCloseBrowser = !reuseBrowser;
+    let page = null;
     try {
-      browser = await puppeteer.launch({
-        headless: true,
-        args: [
-          "--no-sandbox",
-          "--disable-setuid-sandbox",
-          "--disable-dev-shm-usage"
-        ]
-      });
-      const page = await browser.newPage();
+      browser = await this.getBrowser(reuseBrowser);
+      page = await browser.newPage();
       const printHtml = this.preparePrintHtml(html);
       await page.setViewport({
         width: 1920,
@@ -7385,13 +7807,38 @@ var PDFGenerator = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       logger.error(`PDF generation failed: ${errorMessage}`);
+      shouldCloseBrowser = true;
       throw new Error(`PDF generation failed: ${errorMessage}`);
     } finally {
-      if (browser) {
-        await browser.close();
+      if (page) {
+        await page.close().catch(() => {
+        });
+      }
+      if (shouldCloseBrowser && browser) {
+        await browser.close().catch(() => {
+        });
+        if (browser === cachedBrowser) {
+          cachedBrowser = null;
+        }
+      } else if (reuseBrowser) {
+        this.scheduleBrowserCleanup();
       }
     }
   }
+  /**
+   * Manually close the cached browser (call before process exit)
+   */
+  static async closeBrowser() {
+    if (browserIdleTimeout) {
+      clearTimeout(browserIdleTimeout);
+      browserIdleTimeout = null;
+    }
+    if (cachedBrowser) {
+      await cachedBrowser.close().catch(() => {
+      });
+      cachedBrowser = null;
+    }
+  }
   /**
    * Prepare HTML for print/PDF output
    * Modifies the HTML to work better as a printed document
@@ -7405,12 +7852,24 @@ var PDFGenerator = class {
           margin: 0;
         }
 
+        /* Font rendering optimization for print */
+        * {
+          -webkit-font-smoothing: antialiased;
+          -moz-osx-font-smoothing: grayscale;
+          text-rendering: optimizeLegibility;
+          font-feature-settings: "liga" 1, "kern" 1;
+        }
+
         @media print {
           html, body {
             margin: 0;
             padding: 0;
             width: 1920px;
             height: 1080px;
+            /* Print color optimization */
+            color-adjust: exact;
+            -webkit-print-color-adjust: exact;
+            print-color-adjust: exact;
           }
 
           .reveal .slides {
@@ -7427,7 +7886,8 @@ var PDFGenerator = class {
             width: 1920px !important;
             height: 1080px !important;
             margin: 0 !important;
-            padding: 60px !important;
+            /* Professional safe margins: 80px (4.2%) */
+            padding: 80px !important;
             box-sizing: border-box;
             position: relative !important;
             top: auto !important;
@@ -7451,7 +7911,7 @@ var PDFGenerator = class {
           }
 
           /* Disable animations for print */
-          * {
+          *, *::before, *::after {
             animation: none !important;
             transition: none !important;
           }
@@ -7467,6 +7927,30 @@ var PDFGenerator = class {
           .reveal .navigate-down {
             display: none !important;
           }
+
+          /* Typography refinements for print */
+          h1, h2, h3, h4 {
+            orphans: 3;
+            widows: 3;
+            page-break-after: avoid;
+          }
+
+          p, li {
+            orphans: 2;
+            widows: 2;
+          }
+
+          /* Ensure links are readable in print */
+          a {
+            text-decoration: none;
+          }
+
+          /* Prevent image overflow */
+          img {
+            max-width: 100%;
+            height: auto;
+            page-break-inside: avoid;
+          }
         }
 
         /* Force print mode in Puppeteer */
@@ -7474,6 +7958,11 @@ var PDFGenerator = class {
           page-break-after: always;
           page-break-inside: avoid;
         }
+
+        /* High contrast mode for business presentations */
+        .reveal section {
+          color-scheme: light;
+        }
       </style>
     `;
     if (html.includes("</head>")) {
@@ -8066,6 +8555,7 @@ export {
   CompositeImageProvider,
   ContentAnalyzer,
   ContentPatternClassifier,
+  KnowledgeBaseError,
   KnowledgeGateway,
   LocalImageProvider,
   MermaidProvider,