claude-presentation-master 8.0.0 → 8.1.0

package/dist/index.js

@@ -847,7 +847,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)) }
     };
   }
@@ -2895,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,
@@ -2919,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",
@@ -5326,169 +5326,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");
+      professionalExecution += 1;
+      executionNotes.push("Well-balanced content density");
     }
-    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");
-    }
-    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");
+    }
+    if (slideData.hasContrastIssues) {
+      professionalExecution -= 3;
+      slideData.contrastIssues.forEach((issue) => {
+        executionNotes.push(`Contrast: ${issue}`);
+      });
+    } else {
+      executionNotes.push("Good text contrast");
     }
-    themeCoherence = Math.max(0, Math.min(10, themeCoherence));
-    const totalScore = visualImpact + contentClarity + professionalPolish + themeCoherence;
+    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) {
@@ -5600,34 +5853,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),
@@ -5641,30 +5904,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),