claude-presentation-master 6.1.1 → 7.2.0

package/dist/index.mjs

@@ -287,6 +287,439 @@ var KnowledgeGateway = class {
     this.ensureLoaded();
     return this.kb;
   }
+  // ==========================================================================
+  // KB-DRIVEN SLIDEFACTORY METHODS (v7.0.0)
+  // ==========================================================================
+  /**
+   * Get allowed slide types for a specific presentation type.
+   * CRITICAL: SlideFactory must ONLY use types from this list.
+   */
+  getAllowedSlideTypes(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    if (!typeConfig?.slide_types_allowed) {
+      const mode = this.getModeForType(type);
+      const templates = this.getSlideTemplates(mode);
+      return templates.map((t) => t.name.toLowerCase().replace(/\s+/g, "_"));
+    }
+    return typeConfig.slide_types_allowed;
+  }
+  /**
+   * Get validation rules for a specific presentation type.
+   * Returns word limits, bullet limits, whitespace requirements, etc.
+   */
+  getValidationRules(type) {
+    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
+      };
+    }
+    const rules = typeConfig.validation_rules;
+    return {
+      wordsPerSlide: {
+        min: rules.words_per_slide?.min ?? 1,
+        max: rules.words_per_slide?.max ?? 80,
+        ideal: rules.words_per_slide?.ideal ?? 40
+      },
+      whitespace: {
+        min: rules.whitespace?.min ?? 25,
+        ideal: rules.whitespace?.ideal ?? 30
+      },
+      bulletsPerSlide: {
+        max: rules.bullets_per_slide?.max ?? 5
+      },
+      actionTitlesRequired: rules.action_titles_required ?? false,
+      sourcesRequired: rules.sources_required ?? false,
+      calloutsRequired: rules.callouts_required,
+      denseDataAllowed: rules.dense_data_allowed,
+      codeBlocksAllowed: rules.code_blocks_allowed,
+      diagramsRequired: rules.diagrams_required
+    };
+  }
+  /**
+   * Get required elements that MUST be in the deck for this type.
+   */
+  getRequiredElements(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    return typeConfig?.required_elements ?? [];
+  }
+  /**
+   * Get anti-patterns to avoid for this presentation type.
+   */
+  getAntiPatternsForType(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    return typeConfig?.anti_patterns ?? [];
+  }
+  /**
+   * Get typography specifications for this presentation type.
+   */
+  getTypographyForType(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    const typo = typeConfig?.typography;
+    if (!typo) {
+      const mode = this.getModeForType(type);
+      const modeTypo = this.getTypography(mode);
+      const maxFontsValue = modeTypo.max_fonts;
+      return {
+        titles: modeTypo.titles ?? "48px, Bold",
+        body: modeTypo.body_text ?? "24px",
+        maxFonts: typeof maxFontsValue === "number" ? maxFontsValue : 2
+      };
+    }
+    return {
+      titles: typo.titles ?? "48px, Bold",
+      body: typo.body ?? "24px",
+      maxFonts: typeof typo.max_fonts === "number" ? typo.max_fonts : 2,
+      actionTitle: typo.action_title,
+      sectionHeaders: typo.section_headers,
+      dataLabels: typo.data_labels,
+      code: typo.code
+    };
+  }
+  /**
+   * Get CSS variables recipe for this presentation type.
+   */
+  getCSSVariablesForType(type) {
+    this.ensureLoaded();
+    const recipes = this.kb.type_visual_recipes;
+    if (recipes?.[type]?.css_variables) {
+      return recipes[type].css_variables;
+    }
+    return `:root {
+      --color-background: #FAFAF9;
+      --color-primary: #0F172A;
+      --color-secondary: #475569;
+      --color-accent: #0369A1;
+      --color-text: #18181B;
+      --font-display: 'Inter', sans-serif;
+      --font-body: 'Inter', sans-serif;
+    }`;
+  }
+  /**
+   * Get scoring weights for QA evaluation for this type.
+   */
+  getScoringWeights(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    const weights = typeConfig?.scoring_weights;
+    if (!weights) {
+      return {
+        visualQuality: 30,
+        contentQuality: 30,
+        expertCompliance: 30,
+        accessibility: 10
+      };
+    }
+    return {
+      visualQuality: weights.visual_quality ?? 30,
+      contentQuality: weights.content_quality ?? 30,
+      expertCompliance: weights.expert_compliance ?? 30,
+      accessibility: weights.accessibility ?? 10
+    };
+  }
+  /**
+   * Get story structure framework for this presentation type.
+   */
+  getStoryStructure(type) {
+    this.ensureLoaded();
+    const typeConfig = this.kb.presentation_types?.[type];
+    const mode = this.getModeForType(type);
+    if (mode === "business") {
+      return {
+        framework: "scqa",
+        requiredElements: ["situation", "complication", "answer"],
+        optionalElements: ["question", "evidence", "recommendation"]
+      };
+    }
+    return {
+      framework: "sparkline",
+      requiredElements: ["what_is", "what_could_be", "call_to_action"],
+      optionalElements: ["star_moment", "hook"]
+    };
+  }
+  /**
+   * Map a content pattern to the best allowed slide type.
+   * CRITICAL: This is how SlideFactory decides which slide type to use.
+   */
+  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"]
+    };
+    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"
+    ];
+    for (const ct of contentTypes) {
+      if (allowedTypes.includes(ct)) return ct;
+    }
+    return allowedTypes[0] ?? "bullet-points";
+  }
+  /**
+   * Get a specific slide template by name from the KB.
+   */
+  getSlideTemplateByName(name) {
+    this.ensureLoaded();
+    const keynoteTemplates = this.kb.slide_templates?.keynote_mode ?? [];
+    const businessTemplates = this.kb.slide_templates?.business_mode ?? [];
+    const normalizedName = name.toLowerCase().replace(/[-_]/g, " ");
+    for (const template of [...keynoteTemplates, ...businessTemplates]) {
+      const templateName = template.name.toLowerCase().replace(/[-_]/g, " ");
+      if (templateName.includes(normalizedName) || normalizedName.includes(templateName)) {
+        return {
+          name: template.name,
+          purpose: template.purpose,
+          elements: template.elements,
+          components: template.components,
+          wordLimit: template.word_limit ?? 60
+        };
+      }
+    }
+    return void 0;
+  }
+  // ==========================================================================
+  // SLIDE DEFAULTS & LABELS (v7.1.0 - Replace ALL Hardcoded Values)
+  // ==========================================================================
+  /**
+   * Get slide defaults for structural slides (titles, messages, labels).
+   * CRITICAL: SlideFactory must use these instead of hardcoded strings.
+   */
+  getSlideDefaults(type) {
+    this.ensureLoaded();
+    const mode = this.getModeForType(type);
+    const rules = this.getValidationRules(type);
+    const maxWords = rules.wordsPerSlide.max;
+    return {
+      agenda: { title: mode === "business" ? "Agenda" : "What We'll Cover" },
+      thankYou: {
+        title: mode === "business" ? "Thank You" : "Thank You",
+        subtitle: mode === "business" ? "Questions?" : "Let's Connect"
+      },
+      cta: {
+        title: mode === "business" ? "Next Steps" : "Take Action",
+        message: mode === "business" ? "Recommended Actions" : "Ready to Begin?",
+        fallback: mode === "business" ? "Contact us to learn more" : "Take the next step"
+      },
+      metricsGrid: {
+        title: mode === "business" ? "Key Metrics" : "The Numbers",
+        maxMetrics: 4
+      },
+      code: {
+        label: "Code Example",
+        maxChars: 500
+      },
+      comparison: {
+        leftLabel: mode === "business" ? "Current State" : "Before",
+        rightLabel: mode === "business" ? "Future State" : "After",
+        optionLabels: ["Option A", "Option B", "Option C", "Option D"]
+      },
+      column: { labelTemplate: "Point {n}" },
+      subtitle: { maxWords: Math.min(15, Math.floor(maxWords / 3)) },
+      context: { maxWords: Math.min(30, Math.floor(maxWords / 2)) },
+      step: { maxWords: Math.min(20, Math.floor(maxWords / 4)) },
+      columnContent: { maxWords: Math.min(25, Math.floor(maxWords / 3)) }
+    };
+  }
+  /**
+   * Get SCQA framework titles from KB (for business mode).
+   */
+  getSCQATitles(type) {
+    this.ensureLoaded();
+    const mode = this.getModeForType(type);
+    if (mode === "business") {
+      return {
+        situation: "Current Situation",
+        complication: "The Challenge",
+        question: "The Critical Question",
+        answer: "Our Recommendation"
+      };
+    }
+    return {
+      situation: "Where We Are",
+      complication: "What's At Stake",
+      question: "The Question We Face",
+      answer: "The Path Forward"
+    };
+  }
+  /**
+   * Get Sparkline framework titles from KB (for keynote mode).
+   */
+  getSparklineTitles(type) {
+    this.ensureLoaded();
+    return {
+      whatIs: "Where We Are Today",
+      whatCouldBe: "What Could Be",
+      callToAdventure: "The Call to Adventure",
+      newBliss: "The New World"
+    };
+  }
+  /**
+   * Get insight markers for detecting action titles.
+   * These are words/phrases that indicate an insight vs a topic.
+   */
+  getInsightMarkers() {
+    this.ensureLoaded();
+    return [
+      // Trend indicators
+      "increase",
+      "decrease",
+      "grew",
+      "declined",
+      "achieve",
+      "exceed",
+      "improve",
+      "reduce",
+      "save",
+      "gain",
+      "lost",
+      "doubled",
+      "tripled",
+      "outperform",
+      "underperform",
+      "accelerate",
+      "decelerate",
+      // Quantitative markers
+      "%",
+      "percent",
+      "million",
+      "billion",
+      "thousand",
+      "$",
+      "\u20AC",
+      "\xA3",
+      "ROI",
+      "revenue",
+      "cost",
+      "margin",
+      "growth",
+      "decline",
+      // Causality markers
+      "due to",
+      "because",
+      "resulting in",
+      "leading to",
+      "enabling",
+      "driving",
+      "caused by",
+      "attributed to",
+      "as a result of",
+      // Action verbs (Minto Pyramid style)
+      "should",
+      "must",
+      "need to",
+      "recommend",
+      "propose",
+      "suggest",
+      "requires",
+      "demands",
+      "enables",
+      "prevents",
+      "ensures"
+    ];
+  }
+  /**
+   * Get word limit for a specific slide element type.
+   */
+  getWordLimitForElement(type, element) {
+    const rules = this.getValidationRules(type);
+    const maxWords = rules.wordsPerSlide.max;
+    const bulletsMax = rules.bulletsPerSlide.max;
+    switch (element) {
+      case "title":
+        return Math.min(15, Math.floor(maxWords / 4));
+      case "subtitle":
+        return Math.min(15, Math.floor(maxWords / 5));
+      case "bullet":
+        return Math.floor(maxWords / (bulletsMax || 5));
+      case "body":
+        return maxWords;
+      case "quote":
+        return Math.min(40, maxWords);
+      case "step":
+        return Math.min(20, Math.floor(maxWords / 4));
+      default:
+        return maxWords;
+    }
+  }
+  /**
+   * Validate a slide against KB rules for the given presentation type.
+   */
+  validateSlideAgainstKB(slide, type) {
+    const rules = this.getValidationRules(type);
+    const allowedTypes = this.getAllowedSlideTypes(type);
+    const violations = [];
+    const warnings = [];
+    const normalizedType = slide.type.replace(/-/g, "_");
+    const isAllowed = allowedTypes.some(
+      (t) => t === slide.type || t === normalizedType || t.replace(/_/g, "-") === slide.type
+    );
+    if (!isAllowed) {
+      violations.push(`Slide type '${slide.type}' not allowed for ${type}. Allowed: ${allowedTypes.join(", ")}`);
+    }
+    if (slide.wordCount > rules.wordsPerSlide.max) {
+      violations.push(`Word count ${slide.wordCount} exceeds max ${rules.wordsPerSlide.max}`);
+    } else if (slide.wordCount < rules.wordsPerSlide.min) {
+      warnings.push(`Word count ${slide.wordCount} below min ${rules.wordsPerSlide.min}`);
+    }
+    if (slide.bulletCount > rules.bulletsPerSlide.max) {
+      violations.push(`Bullet count ${slide.bulletCount} exceeds max ${rules.bulletsPerSlide.max}`);
+    }
+    if (rules.actionTitlesRequired && !slide.hasActionTitle) {
+      violations.push(`Action title required for ${type} but not present`);
+    }
+    if (rules.sourcesRequired && !slide.hasSource) {
+      warnings.push(`Source citation recommended for ${type}`);
+    }
+    const fixes = {};
+    if (slide.wordCount > rules.wordsPerSlide.max) {
+      fixes.wordCount = rules.wordsPerSlide.max;
+    }
+    if (slide.bulletCount > rules.bulletsPerSlide.max) {
+      fixes.bulletCount = rules.bulletsPerSlide.max;
+    }
+    return {
+      valid: violations.length === 0,
+      violations,
+      warnings,
+      fixes
+    };
+  }
 };
 var gatewayInstance = null;
 async function getKnowledgeGateway() {
@@ -424,12 +857,22 @@ var ContentAnalyzer = class {
   }
   /**
    * Parse content based on type
+   * CRITICAL: Strip code blocks FIRST to prevent code from becoming slides
    */
   parseContent(content, contentType) {
-    if (contentType === "markdown" || content.includes("#") || content.includes("- ")) {
-      return content;
-    }
-    return content;
+    let text = content;
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`[^`]{50,}`/g, "");
+    text = text.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (/^(import|export|const|let|var|function|class|interface|type|async|await|return|if|for|while)\s/.test(trimmed)) return false;
+      if (/^(\/\/|\/\*|\*|#!)/.test(trimmed)) return false;
+      if (/^\s*[{}\[\]();]/.test(trimmed)) return false;
+      if (/^[\w.]+\s*\(.*\)\s*;?\s*$/.test(trimmed)) return false;
+      if (/^[\w.]+\s*=\s*/.test(trimmed) && /[{(\[]/.test(trimmed)) return false;
+      return true;
+    }).join("\n");
+    return text;
   }
   /**
    * Extract the main title from content
@@ -547,6 +990,7 @@ var ContentAnalyzer = class {
   }
   /**
    * Extract SCQA structure (Barbara Minto)
+   * CRITICAL: Answer must be clean prose, NOT bullet points
    */
   extractSCQA(text) {
     const paragraphs = text.split(/\n\n+/).filter((p) => p.trim());
@@ -554,34 +998,45 @@ var ContentAnalyzer = class {
     let complication = "";
     let question = "";
     let answer = "";
-    for (const para of paragraphs.slice(0, 3)) {
+    for (const para of paragraphs.slice(0, 5)) {
+      if (para.startsWith("-") || para.startsWith("#") || para.startsWith("|")) continue;
       if (this.containsSignals(para.toLowerCase(), this.situationSignals)) {
         situation = this.extractFirstSentence(para);
         break;
       }
     }
     for (const para of paragraphs) {
+      if (para.startsWith("-") || para.startsWith("|")) continue;
       if (this.containsSignals(para.toLowerCase(), this.complicationSignals)) {
         complication = this.extractFirstSentence(para);
         break;
       }
     }
-    const middleStart = Math.floor(paragraphs.length * 0.2);
-    const middleEnd = Math.floor(paragraphs.length * 0.8);
-    for (const para of paragraphs.slice(middleStart, middleEnd)) {
+    for (const para of paragraphs) {
+      if (para.startsWith("-") || para.includes("\n-") || para.startsWith("|")) continue;
+      if (para.startsWith("*") && !para.startsWith("**")) continue;
       const lowerPara = para.toLowerCase();
       if (this.containsSignals(lowerPara, this.answerSignals) && !this.containsSignals(lowerPara, this.ctaSignals)) {
-        answer = this.extractFirstSentence(para);
-        break;
+        const sentence = this.extractFirstSentence(para);
+        if (sentence.split(/\s+/).length >= 8 && /\b(is|are|will|can|provides?|delivers?|enables?)\b/i.test(sentence)) {
+          answer = sentence;
+          break;
+        }
       }
     }
-    if (!situation && paragraphs.length > 0 && paragraphs[0]) {
-      situation = this.extractFirstSentence(paragraphs[0]);
+    if (!situation && paragraphs.length > 0) {
+      for (const para of paragraphs.slice(0, 5)) {
+        if (!para.startsWith("-") && !para.startsWith("#") && para.length > 50) {
+          situation = this.extractFirstSentence(para);
+          break;
+        }
+      }
     }
-    if (!answer && paragraphs.length > 2) {
-      for (const para of paragraphs.slice(1, Math.floor(paragraphs.length * 0.5))) {
+    if (!answer) {
+      for (const para of paragraphs) {
+        if (para.startsWith("-") || para.includes("\n-")) continue;
         const lowerPara = para.toLowerCase();
-        if (lowerPara.includes("recommend") || lowerPara.includes("strategy") || lowerPara.includes("solution") || lowerPara.includes("approach")) {
+        if (lowerPara.includes("bottom line") || lowerPara.includes("delivers both") || lowerPara.includes("the result") || lowerPara.includes("in summary")) {
           answer = this.extractFirstSentence(para);
           break;
         }
@@ -740,56 +1195,123 @@ var ContentAnalyzer = class {
   }
   /**
    * Extract data points (metrics with values)
-   * IMPROVED: Smarter label extraction that understands markdown tables
+   * REWRITTEN: Proper markdown table parsing and meaningful label extraction
    */
   extractDataPoints(text) {
     const dataPoints = [];
     const usedValues = /* @__PURE__ */ new Set();
-    const tableLines = text.split("\n").filter((line) => line.includes("|"));
-    if (tableLines.length >= 3) {
-      const dataRows = tableLines.filter((line) => !line.match(/^[\s|:-]+$/));
-      if (dataRows.length >= 2) {
-        for (const row of dataRows.slice(1)) {
-          const cells = row.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
-          if (cells.length >= 2) {
-            const valueCell = cells.find((c) => /^\$?[\d,]+\.?\d*[MBK%]?$/.test(c.replace(/[,$]/g, "")));
-            const labelCell = cells[0];
-            if (valueCell && labelCell && !usedValues.has(valueCell)) {
-              usedValues.add(valueCell);
-              dataPoints.push({ value: valueCell, label: labelCell.slice(0, 40) });
-            }
+    const bulletPatterns = text.match(/^[-*]\s+([^:]+):\s*(\$?[\d,.]+[MBK%]?(?:\s*\([^)]+\))?)/gm);
+    if (bulletPatterns) {
+      for (const match of bulletPatterns) {
+        const parsed = match.match(/^[-*]\s+([^:]+):\s*(\$?[\d,.]+[MBK%]?)/);
+        if (parsed && parsed[1] && parsed[2]) {
+          const label = parsed[1].trim();
+          const value = parsed[2].trim();
+          if (!usedValues.has(value) && label.length >= 5) {
+            usedValues.add(value);
+            dataPoints.push({ value, label: this.cleanMetricLabel(label) });
           }
         }
       }
     }
     const lines = text.split("\n");
+    let inTable = false;
+    let tableRows = [];
+    let headerRow = [];
     for (const line of lines) {
-      if (line.includes("|")) continue;
-      const percentMatch = line.match(/(\w+(?:\s+\w+){0,4})\s+(?:by\s+)?(\d+(?:\.\d+)?%)/i);
-      if (percentMatch && percentMatch[2] && percentMatch[1] && !usedValues.has(percentMatch[2])) {
-        usedValues.add(percentMatch[2]);
-        dataPoints.push({ value: percentMatch[2], label: percentMatch[1].slice(0, 40) });
+      if (line.includes("|") && line.trim().length > 3) {
+        const cells = line.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+        if (cells.every((c) => /^[-:]+$/.test(c))) continue;
+        if (!inTable) {
+          headerRow = cells;
+          inTable = true;
+        } else {
+          tableRows.push(cells);
+        }
+      } else if (inTable && tableRows.length > 0) {
+        this.extractMetricsFromTable(headerRow, tableRows, dataPoints, usedValues);
+        inTable = false;
+        tableRows = [];
+        headerRow = [];
       }
-      const dollarMatch = line.match(/\$(\d+(?:\.\d+)?)\s*(million|billion|M|B|K)?/i);
-      if (dollarMatch && dataPoints.length < 6) {
-        const fullValue = "$" + dollarMatch[1] + (dollarMatch[2] ? " " + dollarMatch[2] : "");
-        if (!usedValues.has(fullValue)) {
-          usedValues.add(fullValue);
-          const label = this.extractLabelFromLine(line, fullValue);
-          dataPoints.push({ value: fullValue, label });
+    }
+    if (tableRows.length > 0) {
+      this.extractMetricsFromTable(headerRow, tableRows, dataPoints, usedValues);
+    }
+    for (const line of lines) {
+      if (line.includes("|")) continue;
+      if (/```/.test(line)) continue;
+      const percentPattern = line.match(/(\d+(?:\.\d+)?%)\s+(reduction|increase|improvement|growth|decrease)\s+(?:in\s+)?([^.]+)/i);
+      if (percentPattern && percentPattern[1] && percentPattern[3]) {
+        const value = percentPattern[1];
+        if (!usedValues.has(value)) {
+          usedValues.add(value);
+          const action = percentPattern[2] || "change";
+          const subject = percentPattern[3].slice(0, 30).trim();
+          dataPoints.push({ value, label: `${action} in ${subject}` });
         }
       }
     }
     return dataPoints.slice(0, 4);
   }
+  /**
+   * Extract metrics from a parsed markdown table
+   */
+  extractMetricsFromTable(headers, rows, dataPoints, usedValues) {
+    for (const row of rows) {
+      const label = row[0];
+      if (!label || label.length < 3) continue;
+      for (let i = 1; i < row.length; i++) {
+        const cell = row[i];
+        if (!cell) continue;
+        if (/^\$?[\d,]+\.?\d*[%MBK]?$/.test(cell.replace(/[,\s]/g, "")) || /^\d+\s*(seconds?|minutes?|hours?|ms|gb|mb)$/i.test(cell)) {
+          if (!usedValues.has(cell)) {
+            usedValues.add(cell);
+            const colHeader = headers[i] || "";
+            const fullLabel = colHeader && colHeader !== label ? `${label} (${colHeader})` : label;
+            dataPoints.push({
+              value: cell,
+              label: this.cleanMetricLabel(fullLabel)
+            });
+            break;
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Clean a metric label to ensure it's complete and meaningful
+   */
+  cleanMetricLabel(raw) {
+    let label = raw.replace(/\*\*/g, "").replace(/\|/g, " ").replace(/[:\-–—]+$/, "").replace(/\s+/g, " ").trim();
+    if (label.length > 0) {
+      label = label.charAt(0).toUpperCase() + label.slice(1);
+    }
+    if (label.length > 40) {
+      const words = label.split(/\s+/);
+      label = "";
+      for (const word of words) {
+        if ((label + " " + word).length <= 40) {
+          label = label ? label + " " + word : word;
+        } else {
+          break;
+        }
+      }
+    }
+    return label || "Value";
+  }
   /**
    * Extract a meaningful label from a line containing a metric
    */
   extractLabelFromLine(line, value) {
+    const colonMatch = line.match(/([^:]+):\s*\$?[\d]/);
+    if (colonMatch && colonMatch[1]) {
+      return this.cleanMetricLabel(colonMatch[1]);
+    }
     const cleaned = line.replace(/\*\*/g, "").replace(/\|/g, " ").trim();
     const beforeValue = cleaned.split(value)[0] || "";
     const words = beforeValue.split(/\s+/).filter((w) => w.length > 2);
-    return words.slice(-4).join(" ").slice(0, 40) || "Value";
+    return this.cleanMetricLabel(words.slice(-4).join(" "));
   }
   /**
    * Check if text contains any of the signals
@@ -816,531 +1338,897 @@ var ContentAnalyzer = class {
   }
 };
 
-// src/core/SlideFactory.ts
-var SlideFactory = class {
-  templates;
-  usedContent = /* @__PURE__ */ new Set();
-  constructor() {
-    this.templates = this.initializeTemplates();
-  }
+// src/core/ContentPatternClassifier.ts
+var ContentPatternClassifier = class {
+  // Regex patterns for content detection
+  patterns = {
+    // Big numbers: $4.88M, 23%, 10x, 500+, etc.
+    bigNumber: /(\$[\d,.]+[MBK]?|\d+(?:\.\d+)?%|\d+[xX]|\d{2,}(?:\+|,\d{3})+)/,
+    // Comparison language
+    comparison: /\b(vs\.?|versus|compared\s+to|before\s+(?:and\s+)?after|better\s+than|worse\s+than|alternative|option\s+[A-Z1-3])\b/i,
+    // Timeline markers
+    timeline: /\b(phase\s*\d|week\s*\d|month\s*\d|day\s*\d|Q[1-4]|20\d{2}|step\s*\d|year\s*\d|sprint\s*\d)\b/i,
+    // Process/steps language
+    process: /\b(step\s*\d|stage\s*\d|pillar|phase|first|second|third|finally|then|next|workflow|process)\b/i,
+    // Quote patterns
+    quote: /^[""]|[""]\s*[-—–]\s*|^\s*>\s*|[""]$/,
+    // Code patterns
+    code: /```|`[^`]+`|function\s*\(|const\s+\w+\s*=|import\s+{|class\s+\w+|=>\s*{/,
+    // Metric patterns (for detecting multiple metrics)
+    metric: /(\d+(?:\.\d+)?(?:%|[xX]|[MBK])?)\s*[-–:]\s*|\b(?:increased|decreased|grew|improved|reduced)\s+(?:by\s+)?(\d+)/gi
+  };
   /**
-   * Check if content has already been used (deduplication)
+   * Classify a content section to determine its primary pattern.
+   * Returns a ContentPattern object used by SlideFactory to select slide type.
    */
-  isContentUsed(content) {
-    if (!content) return true;
-    const normalized = content.toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, 50);
-    if (this.usedContent.has(normalized)) {
-      return true;
+  classify(section) {
+    const fullText = `${section.header} ${section.content} ${section.bullets.join(" ")}`;
+    const wordCount = fullText.split(/\s+/).filter((w) => w.length > 0).length;
+    const hasBigNumber = this.patterns.bigNumber.test(fullText);
+    const bigNumberMatch = fullText.match(this.patterns.bigNumber);
+    const hasComparison = this.patterns.comparison.test(fullText);
+    const hasTimeline = this.patterns.timeline.test(fullText);
+    const hasProcess = this.patterns.process.test(section.header) || section.bullets.length >= 3 && this.hasNumberedItems(section.bullets);
+    const hasQuote = this.patterns.quote.test(section.content);
+    const hasCode = this.patterns.code.test(section.content);
+    const metricMatches = fullText.match(this.patterns.metric);
+    const hasMetrics = section.metrics.length >= 3 || metricMatches && metricMatches.length >= 3;
+    let primaryPattern = "prose";
+    if (hasQuote && section.content.length > 20) {
+      primaryPattern = "quote";
+    } else if (hasCode) {
+      primaryPattern = "code";
+    } else if (hasBigNumber && wordCount < 30) {
+      primaryPattern = "big_number";
+    } else if (hasMetrics) {
+      primaryPattern = "metrics";
+    } else if (hasComparison) {
+      primaryPattern = "comparison";
+    } else if (hasTimeline) {
+      primaryPattern = "timeline";
+    } else if (hasProcess && section.bullets.length >= 3) {
+      primaryPattern = "process";
+    } else if (section.bullets.length >= 2) {
+      primaryPattern = "bullets";
+    } else {
+      primaryPattern = "prose";
     }
-    this.usedContent.add(normalized);
-    return false;
+    const result = {
+      hasBigNumber,
+      hasComparison,
+      hasTimeline,
+      hasProcess,
+      hasMetrics: !!hasMetrics,
+      hasQuote,
+      hasCode,
+      bulletCount: section.bullets.length,
+      wordCount,
+      primaryPattern
+    };
+    if (bigNumberMatch && bigNumberMatch[1]) {
+      result.bigNumberValue = bigNumberMatch[1];
+    }
+    return result;
   }
   /**
-   * Create slides from analyzed content.
-   *
-   * ARCHITECTURE (per KB expert methodologies):
-   * 1. Title slide - always first
-   * 2. Agenda slide - business mode only with 3+ sections
-   * 3. SCQA slides - Situation, Complication (per Minto)
-   * 4. Content slides - from sections with bullets/content
-   * 5. Metrics slide - if data points exist
-   * 6. Solution slide - SCQA answer
-   * 7. STAR moments - only if high-quality (per Duarte)
-   * 8. CTA slide - if call to action exists
-   * 9. Thank you slide - always last
-   */
-  async createSlides(analysis, mode) {
-    const slides = [];
-    let slideIndex = 0;
-    this.usedContent.clear();
-    slides.push(this.createTitleSlide(slideIndex++, analysis));
-    this.isContentUsed(analysis.titles[0] ?? "");
-    const substantiveSections = analysis.sections.filter(
-      (s) => s.level === 2 && (s.bullets.length > 0 || s.content.length > 50)
-    );
-    if (mode === "business" && substantiveSections.length >= 3) {
-      slides.push(this.createAgendaSlide(slideIndex++, analysis));
-    }
-    if (analysis.scqa.situation && analysis.scqa.situation.length > 30 && !this.isContentUsed(analysis.scqa.situation)) {
-      slides.push(this.createContextSlide(slideIndex++, analysis, mode));
-    }
-    if (analysis.scqa.complication && analysis.scqa.complication.length > 30 && !this.isContentUsed(analysis.scqa.complication)) {
-      slides.push(this.createProblemSlide(slideIndex++, analysis, mode));
-    }
-    for (const section of substantiveSections.slice(0, 4)) {
-      const headerUsed = this.isContentUsed(section.header);
-      const contentUsed = section.content.length > 30 && this.isContentUsed(section.content.slice(0, 80));
-      if (!headerUsed && !contentUsed) {
-        if (section.bullets.length > 0) {
-          slides.push(this.createSectionBulletSlide(slideIndex++, section, mode));
-        } else if (section.content.length > 50) {
-          slides.push(this.createSectionContentSlide(slideIndex++, section, mode));
-        }
+   * Check if bullets appear to be numbered/ordered items
+   */
+  hasNumberedItems(bullets) {
+    let numberedCount = 0;
+    for (const bullet of bullets) {
+      if (/^\d+[.)]\s|^[a-z][.)]\s|^step\s*\d/i.test(bullet.trim())) {
+        numberedCount++;
       }
     }
-    for (const message of analysis.keyMessages) {
-      const wordCount = message.split(/\s+/).length;
-      if (wordCount >= 6 && !/^(The |Our |Your |Overview|Introduction|Conclusion)/i.test(message) && !this.isContentUsed(message)) {
-        slides.push(this.createMessageSlide(slideIndex++, message, mode));
+    return numberedCount >= 2;
+  }
+  /**
+   * Extract the big number value from content for display
+   */
+  extractBigNumber(content) {
+    const match = content.match(this.patterns.bigNumber);
+    if (!match || !match[1]) return null;
+    const value = match[1];
+    const afterNumber = content.slice(content.indexOf(value) + value.length);
+    const context = afterNumber.trim().slice(0, 60).split(/[.!?]/)[0]?.trim() ?? "";
+    return { value, context };
+  }
+  /**
+   * Extract comparison elements from content
+   */
+  extractComparison(section) {
+    const text = section.content;
+    const vsMatch = text.match(/(.{10,50})\s+(?:vs\.?|versus)\s+(.{10,50})/i);
+    if (vsMatch && vsMatch[1] && vsMatch[2]) {
+      return { left: vsMatch[1].trim(), right: vsMatch[2].trim() };
+    }
+    const beforeAfterMatch = text.match(/before[:\s]+(.{10,100})(?:after[:\s]+(.{10,100}))?/i);
+    if (beforeAfterMatch && beforeAfterMatch[1]) {
+      const left = beforeAfterMatch[1].trim();
+      const right = beforeAfterMatch[2] ? beforeAfterMatch[2].trim() : "After";
+      return { left, right };
+    }
+    if (section.bullets.length === 2) {
+      const left = section.bullets[0];
+      const right = section.bullets[1];
+      if (left && right) {
+        return { left, right };
       }
     }
-    if (analysis.dataPoints.length >= 2) {
-      slides.push(this.createMetricsSlide(slideIndex++, analysis.dataPoints));
-    }
-    if (analysis.scqa.answer && analysis.scqa.answer.length > 30 && !this.isContentUsed(analysis.scqa.answer)) {
-      slides.push(this.createSolutionSlide(slideIndex++, analysis, mode));
-    }
-    const verbPattern = /\b(is|are|was|were|will|can|should|must|has|have|provides?|enables?|allows?|achieves?|exceeds?|results?|generates?|delivers?|creates?)\b/i;
-    for (const starMoment of analysis.starMoments.slice(0, 2)) {
-      const wordCount = starMoment.split(/\s+/).length;
-      const hasVerb = verbPattern.test(starMoment);
-      if (wordCount >= 6 && starMoment.length >= 40 && hasVerb && !this.isContentUsed(starMoment)) {
-        slides.push(this.createStarMomentSlide(slideIndex++, starMoment, mode));
+    return null;
+  }
+  /**
+   * Extract timeline/process steps from content
+   */
+  extractSteps(section) {
+    const steps = [];
+    for (const bullet of section.bullets) {
+      const stepMatch = bullet.match(/^((?:step|phase|stage)\s*\d+|[1-9]\.|\d+\))\s*[-:.]?\s*(.+)/i);
+      if (stepMatch && stepMatch[1] && stepMatch[2]) {
+        steps.push({
+          label: stepMatch[1].trim(),
+          description: stepMatch[2].trim()
+        });
+      } else {
+        steps.push({
+          label: `${steps.length + 1}`,
+          description: bullet
+        });
       }
     }
-    if (analysis.sparkline.callToAdventure && analysis.sparkline.callToAdventure.length > 20 && !this.isContentUsed(analysis.sparkline.callToAdventure)) {
-      slides.push(this.createCTASlide(slideIndex++, analysis, mode));
-    }
-    slides.push(this.createThankYouSlide(slideIndex++));
-    return slides;
+    return steps;
   }
   /**
-   * Create a slide from a section with bullets
+   * Determine if content is suitable for a three-column layout
+   * (3 pillars, 3 key points, etc.)
    */
-  createSectionBulletSlide(index, section, mode) {
-    const bullets = section.bullets.slice(0, mode === "keynote" ? 3 : 5);
-    return {
-      index,
-      type: "bullet-points",
-      data: {
-        title: this.truncate(section.header, 60),
-        bullets: bullets.map((b) => this.cleanText(b).slice(0, 80))
-      },
-      classes: ["slide-bullet-points"]
-    };
+  isSuitableForThreeColumn(section) {
+    if (section.bullets.length === 3) return true;
+    if (/three|3\s*(pillar|point|key|step)/i.test(section.header)) return true;
+    const threePartPattern = /first[,.].*second[,.].*third/i;
+    if (threePartPattern.test(section.content)) return true;
+    return false;
   }
   /**
-   * Create a slide from a section with body content
+   * Check if content should be displayed as a quote slide
    */
-  createSectionContentSlide(index, section, mode) {
-    if (mode === "keynote") {
-      return {
-        index,
-        type: "single-statement",
-        data: {
-          title: this.truncate(this.extractFirstSentence(section.content), 80),
-          keyMessage: section.header
-        },
-        classes: ["slide-single-statement"]
-      };
+  isQuoteContent(section) {
+    const content = section.content.trim();
+    if (!this.patterns.quote.test(content)) {
+      return { isQuote: false };
     }
-    return {
-      index,
-      type: "two-column",
-      data: {
-        title: this.truncate(section.header, 60),
-        body: this.truncate(section.content, 200)
-      },
-      classes: ["slide-two-column"]
-    };
+    const attrMatch = content.match(/[-—–]\s*(.+)$/);
+    if (attrMatch && attrMatch[1]) {
+      return { isQuote: true, attribution: attrMatch[1].trim() };
+    }
+    return { isQuote: true };
   }
-  /**
-   * Extract first sentence from text
-   */
-  extractFirstSentence(text) {
-    const cleaned = this.cleanText(text);
-    const match = cleaned.match(/^[^.!?]+[.!?]/);
-    return match ? match[0].trim() : cleaned.slice(0, 100);
+};
+
+// src/core/SlideFactory.ts
+var SlideFactory = class {
+  kb;
+  presentationType;
+  classifier;
+  config;
+  usedContent;
+  usedTitles;
+  constructor(kb, type) {
+    this.kb = kb;
+    this.presentationType = type;
+    this.classifier = new ContentPatternClassifier();
+    this.usedContent = /* @__PURE__ */ new Set();
+    this.usedTitles = /* @__PURE__ */ new Set();
+    this.config = this.loadKBConfig(type);
+    console.log(`  \u2713 SlideFactory v7.1.0 initialized for ${type} (${this.config.mode} mode)`);
+    console.log(`  \u2713 KB Config loaded: ${this.config.allowedTypes.length} allowed types`);
   }
   /**
-   * Create a metrics slide from data points
+   * Load ALL configuration from KB - ZERO hardcoded values after this.
    */
-  createMetricsSlide(index, dataPoints) {
-    const metrics = dataPoints.slice(0, 4).map((dp) => ({
-      value: dp.value,
-      label: this.cleanText(dp.label).slice(0, 40)
-    }));
+  loadKBConfig(type) {
     return {
-      index,
-      type: "metrics-grid",
-      data: {
-        title: "Key Metrics",
-        metrics
-      },
-      classes: ["slide-metrics-grid"]
+      defaults: this.kb.getSlideDefaults(type),
+      scqaTitles: this.kb.getSCQATitles(type),
+      sparklineTitles: this.kb.getSparklineTitles(type),
+      rules: this.kb.getValidationRules(type),
+      allowedTypes: this.kb.getAllowedSlideTypes(type),
+      mode: this.kb.getModeForType(type),
+      insightMarkers: this.kb.getInsightMarkers(),
+      glanceTest: this.kb.getDuarteGlanceTest(),
+      millersLaw: this.kb.getMillersLaw(),
+      typography: this.kb.getTypographyForType(type),
+      antiPatterns: this.kb.getAntiPatternsForType(type),
+      requiredElements: this.kb.getRequiredElements(type)
     };
   }
   /**
-   * Create a title slide.
+   * Create all slides from content analysis.
+   * This is the main entry point - orchestrates the entire slide creation process.
    */
+  async createSlides(analysis) {
+    const slides = [];
+    const storyStructure = this.kb.getStoryStructure(this.presentationType);
+    console.log(`  \u2713 Using ${storyStructure.framework} story framework`);
+    slides.push(this.createTitleSlide(0, analysis));
+    const minSectionsForAgenda = Math.max(3, this.config.rules.bulletsPerSlide.max - 2);
+    if (this.config.mode === "business" && analysis.sections.length >= minSectionsForAgenda) {
+      slides.push(this.createAgendaSlide(slides.length, analysis));
+    }
+    if (storyStructure.framework === "scqa") {
+      this.addSCQASlides(slides, analysis);
+    } else if (storyStructure.framework === "sparkline") {
+      this.addSparklineSlides(slides, analysis);
+    }
+    for (const section of analysis.sections) {
+      const contentKey = this.normalizeKey(section.header);
+      if (this.usedContent.has(contentKey)) continue;
+      this.usedContent.add(contentKey);
+      const pattern = this.classifier.classify(section);
+      const slideType = this.kb.mapContentPatternToSlideType(pattern, this.config.allowedTypes);
+      const slide = this.createSlideByType(slides.length, slideType, section, pattern);
+      if (slide) {
+        slides.push(slide);
+      }
+    }
+    const minDataPointsForMetrics = 2;
+    if (analysis.dataPoints.length >= minDataPointsForMetrics) {
+      const hasMetricsSlide = slides.some(
+        (s) => s.type === "metrics-grid" || s.type === "big-number"
+      );
+      if (!hasMetricsSlide) {
+        slides.push(this.createMetricsGridSlide(slides.length, analysis.dataPoints));
+      }
+    }
+    if (analysis.sparkline?.callToAdventure || analysis.scqa?.answer) {
+      slides.push(this.createCTASlide(slides.length, analysis));
+    }
+    slides.push(this.createThankYouSlide(slides.length));
+    const validatedSlides = this.validateAndFixSlides(slides);
+    this.checkRequiredElements(validatedSlides);
+    this.checkAntiPatterns(validatedSlides);
+    console.log(`  \u2713 Created ${validatedSlides.length} validated slides`);
+    return validatedSlides;
+  }
+  // ===========================================================================
+  // SLIDE TYPE ROUTER - Routes to appropriate creator based on KB-selected type
+  // ===========================================================================
+  createSlideByType(index, type, section, pattern) {
+    const normalizedType = type.toLowerCase().replace(/_/g, "-");
+    switch (normalizedType) {
+      case "big-number":
+      case "data-insight":
+        return this.createBigNumberSlide(index, section, pattern);
+      case "comparison":
+      case "options-comparison":
+        return this.createComparisonSlide(index, section);
+      case "timeline":
+      case "process-timeline":
+      case "roadmap":
+        return this.createTimelineSlide(index, section);
+      case "process":
+        return this.createProcessSlide(index, section);
+      case "three-column":
+        return this.createThreeColumnSlide(index, section);
+      case "two-column":
+        return this.createTwoColumnSlide(index, section);
+      case "quote":
+      case "testimonial":
+      case "social-proof":
+        return this.createQuoteSlide(index, section);
+      case "metrics-grid":
+        return this.createMetricsGridSlide(index, section.metrics);
+      case "bullet-points":
+      case "detailed-findings":
+        return this.createBulletSlide(index, section);
+      case "single-statement":
+      case "big-idea":
+        return this.createSingleStatementSlide(index, section);
+      case "code-snippet":
+      case "technical":
+        return this.createCodeSlide(index, section);
+      default:
+        console.log(`  \u26A0 Unknown slide type '${type}', using bullet-points`);
+        return this.createBulletSlide(index, section);
+    }
+  }
+  // ===========================================================================
+  // STRUCTURAL SLIDES (title, agenda, thank you) - ALL from KB
+  // ===========================================================================
   createTitleSlide(index, analysis) {
-    let subtitle = "";
-    if (analysis.scqa.answer && analysis.scqa.answer.length > 10) {
-      subtitle = analysis.scqa.answer;
-    } else if (analysis.starMoments.length > 0 && analysis.starMoments[0]) {
-      subtitle = analysis.starMoments[0];
+    const data = {
+      title: this.truncateText(analysis.title, this.config.rules.wordsPerSlide.max)
+    };
+    if (analysis.keyMessages[0]) {
+      data.subtitle = this.truncateText(
+        analysis.keyMessages[0],
+        this.config.defaults.subtitle.maxWords
+        // FROM KB
+      );
     }
     return {
       index,
       type: "title",
-      data: {
-        title: analysis.titles[0] ?? "Presentation",
-        subtitle: this.truncate(subtitle, 80),
-        keyMessage: analysis.scqa.answer
-      },
-      classes: ["slide-title"]
+      data,
+      classes: ["title-slide"]
     };
   }
-  /**
-   * Create an agenda slide.
-   */
   createAgendaSlide(index, analysis) {
+    const agendaItems = analysis.sections.filter((s) => s.level <= 2).slice(0, this.config.rules.bulletsPerSlide.max).map((s) => this.cleanText(s.header));
     return {
       index,
       type: "agenda",
       data: {
-        title: "Agenda",
-        bullets: analysis.keyMessages.map((msg, i) => `${i + 1}. ${this.truncate(msg, 50)}`)
+        title: this.config.defaults.agenda.title,
+        // FROM KB - not hardcoded 'Agenda'
+        bullets: agendaItems
       },
-      classes: ["slide-agenda"]
+      classes: ["agenda-slide"]
     };
   }
-  /**
-   * Create a context/situation slide.
-   */
-  createContextSlide(index, analysis, mode) {
-    if (mode === "keynote") {
-      return {
-        index,
+  createThankYouSlide(index) {
+    return {
+      index,
+      type: "thank-you",
+      data: {
+        title: this.config.defaults.thankYou.title,
+        // FROM KB - not hardcoded 'Thank You'
+        subtitle: this.config.defaults.thankYou.subtitle
+        // FROM KB - not hardcoded 'Questions?'
+      },
+      classes: ["thank-you-slide"]
+    };
+  }
+  // ===========================================================================
+  // STORY FRAMEWORK SLIDES (SCQA, Sparkline) - ALL titles from KB
+  // ===========================================================================
+  addSCQASlides(slides, analysis) {
+    const scqa = analysis.scqa;
+    const titles = this.config.scqaTitles;
+    if (scqa?.situation && !this.usedContent.has("scqa-situation")) {
+      this.usedContent.add("scqa-situation");
+      slides.push({
+        index: slides.length,
         type: "single-statement",
         data: {
-          title: this.truncate(analysis.scqa.situation, 80),
-          keyMessage: "The current state"
+          title: titles.situation,
+          // FROM KB - not hardcoded 'Current Situation'
+          body: this.truncateText(scqa.situation, this.config.rules.wordsPerSlide.max)
         },
-        classes: ["slide-single-statement"]
-      };
+        classes: ["situation-slide"]
+      });
+    }
+    if (scqa?.complication && !this.usedContent.has("scqa-complication")) {
+      this.usedContent.add("scqa-complication");
+      slides.push({
+        index: slides.length,
+        type: "single-statement",
+        data: {
+          title: titles.complication,
+          // FROM KB - not hardcoded 'The Challenge'
+          body: this.truncateText(scqa.complication, this.config.rules.wordsPerSlide.max)
+        },
+        classes: ["complication-slide"]
+      });
+    }
+    if (scqa?.question && !this.usedContent.has("scqa-question")) {
+      this.usedContent.add("scqa-question");
+      slides.push({
+        index: slides.length,
+        type: "single-statement",
+        data: {
+          title: titles.question,
+          // FROM KB - not hardcoded 'The Question'
+          body: this.truncateText(scqa.question, this.config.rules.wordsPerSlide.max)
+        },
+        classes: ["question-slide"]
+      });
+    }
+  }
+  addSparklineSlides(slides, analysis) {
+    const spark = analysis.sparkline;
+    const titles = this.config.sparklineTitles;
+    const whatIsFirst = spark?.whatIs?.[0];
+    if (whatIsFirst && !this.usedContent.has("spark-what-is")) {
+      this.usedContent.add("spark-what-is");
+      slides.push({
+        index: slides.length,
+        type: "single-statement",
+        data: {
+          title: titles.whatIs,
+          // FROM KB - not hardcoded 'Where We Are Today'
+          body: this.truncateText(whatIsFirst, this.config.rules.wordsPerSlide.max)
+        },
+        classes: ["what-is-slide"]
+      });
+    }
+    const whatCouldBeFirst = spark?.whatCouldBe?.[0];
+    if (whatCouldBeFirst && !this.usedContent.has("spark-could-be")) {
+      this.usedContent.add("spark-could-be");
+      slides.push({
+        index: slides.length,
+        type: "single-statement",
+        data: {
+          title: titles.whatCouldBe,
+          // FROM KB - not hardcoded 'What Could Be'
+          body: this.truncateText(whatCouldBeFirst, this.config.rules.wordsPerSlide.max)
+        },
+        classes: ["what-could-be-slide"]
+      });
     }
+  }
+  // ===========================================================================
+  // CONTENT SLIDES - ALL values from KB
+  // ===========================================================================
+  createBigNumberSlide(index, section, pattern) {
+    const bigNumber = this.classifier.extractBigNumber(
+      `${section.header} ${section.content} ${section.bullets.join(" ")}`
+    );
     return {
       index,
-      type: "two-column",
+      type: "big-number",
       data: {
-        title: "Current Situation",
-        body: analysis.scqa.situation,
-        bullets: analysis.sparkline.whatIs.slice(0, 3)
+        title: this.createTitle(section.header, section),
+        keyMessage: bigNumber?.value || pattern.bigNumberValue || "0",
+        body: bigNumber?.context || this.truncateText(
+          section.content,
+          this.config.defaults.context.maxWords
+          // FROM KB - not hardcoded 30
+        )
       },
-      classes: ["slide-two-column"]
+      classes: ["big-number-slide"]
     };
   }
-  /**
-   * Create a problem/complication slide.
-   */
-  createProblemSlide(index, analysis, mode) {
-    if (mode === "keynote") {
-      return {
-        index,
-        type: "big-idea",
-        data: {
-          title: this.truncate(analysis.scqa.complication, 60),
-          keyMessage: "The challenge we face"
-        },
-        classes: ["slide-big-idea"]
-      };
-    }
+  createComparisonSlide(index, section) {
+    const comparison = this.classifier.extractComparison(section);
+    const labels = this.config.defaults.comparison;
+    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;
     return {
       index,
-      type: "bullet-points",
+      type: "comparison",
       data: {
-        title: "The Challenge",
-        body: analysis.scqa.complication,
-        bullets: this.extractBullets(analysis.scqa.complication)
+        title: this.createTitle(section.header, section),
+        columns: [
+          {
+            title: labels.leftLabel,
+            // FROM KB - not hardcoded 'Before'
+            content: this.truncateText(leftColumn, this.config.rules.wordsPerSlide.max)
+          },
+          {
+            title: labels.rightLabel,
+            // FROM KB - not hardcoded 'After'
+            content: this.truncateText(rightColumn, this.config.rules.wordsPerSlide.max)
+          }
+        ]
       },
-      classes: ["slide-bullet-points"]
+      classes: ["comparison-slide"]
     };
   }
-  /**
-   * Create a key message slide.
-   */
-  createMessageSlide(index, message, mode) {
-    if (mode === "keynote") {
-      return {
-        index,
-        type: "single-statement",
-        data: {
-          title: this.truncate(message, 60),
-          keyMessage: message
-        },
-        classes: ["slide-single-statement"]
-      };
-    }
+  createTimelineSlide(index, section) {
+    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
+    );
     return {
       index,
-      type: "bullet-points",
+      type: "timeline",
       data: {
-        title: this.extractActionTitle(message),
-        body: message,
-        bullets: this.extractBullets(message)
+        title: this.createTitle(section.header, section),
+        steps: steps.slice(0, maxSteps).map((step) => ({
+          label: step.label,
+          description: this.truncateText(
+            step.description,
+            this.config.defaults.step.maxWords
+            // FROM KB - not hardcoded 20
+          )
+        }))
       },
-      classes: ["slide-bullet-points"]
+      classes: ["timeline-slide"]
     };
   }
-  /**
-   * Create a STAR moment slide.
-   */
-  createStarMomentSlide(index, starMoment, mode) {
-    const statMatch = starMoment.match(/(\d+[%xX]|\$[\d,]+(?:\s*(?:million|billion))?)/);
-    if (statMatch && statMatch[1]) {
-      const stat = statMatch[1];
-      return {
-        index,
-        type: "big-number",
-        data: {
-          title: stat,
-          subtitle: this.removeStatistic(starMoment, stat),
-          keyMessage: starMoment
-        },
-        classes: ["slide-big-number"]
-      };
+  createProcessSlide(index, section) {
+    const steps = this.classifier.extractSteps(section);
+    const maxSteps = Math.min(steps.length, this.config.rules.bulletsPerSlide.max);
+    return {
+      index,
+      type: "process",
+      data: {
+        title: this.createTitle(section.header, section),
+        steps: steps.slice(0, maxSteps).map((step, i) => ({
+          number: i + 1,
+          title: step.label,
+          description: this.truncateText(
+            step.description,
+            this.config.defaults.step.maxWords
+            // FROM KB - not hardcoded 15
+          )
+        }))
+      },
+      classes: ["process-slide"]
+    };
+  }
+  createThreeColumnSlide(index, section) {
+    const columns = section.bullets.slice(0, 3);
+    while (columns.length < 3) {
+      columns.push("");
     }
-    if (mode === "keynote") {
-      return {
-        index,
-        type: "big-idea",
-        data: {
-          title: this.truncate(starMoment, 80),
-          keyMessage: "A key insight"
+    const labelTemplate = this.config.defaults.column.labelTemplate;
+    return {
+      index,
+      type: "three-column",
+      data: {
+        title: this.createTitle(section.header, section),
+        columns: columns.map((content, i) => ({
+          title: labelTemplate.replace("{n}", String(i + 1)),
+          // FROM KB - not hardcoded 'Point ${i+1}'
+          content: this.truncateText(
+            content,
+            this.config.defaults.columnContent.maxWords
+            // FROM KB - not hardcoded 25
+          )
+        }))
+      },
+      classes: ["three-column-slide"]
+    };
+  }
+  createTwoColumnSlide(index, section) {
+    const midpoint = Math.ceil(section.bullets.length / 2);
+    const leftBullets = section.bullets.slice(0, midpoint);
+    const rightBullets = section.bullets.slice(midpoint);
+    const wordsPerBullet = Math.floor(
+      this.config.rules.wordsPerSlide.max / this.config.rules.bulletsPerSlide.max
+    );
+    return {
+      index,
+      type: "two-column",
+      data: {
+        title: this.createTitle(section.header, section),
+        leftColumn: {
+          bullets: leftBullets.map((b) => this.truncateText(this.cleanText(b), wordsPerBullet))
         },
-        classes: ["slide-big-idea"]
-      };
+        rightColumn: {
+          bullets: rightBullets.map((b) => this.truncateText(this.cleanText(b), wordsPerBullet))
+        }
+      },
+      classes: ["two-column-slide"]
+    };
+  }
+  createQuoteSlide(index, section) {
+    const quoteInfo = this.classifier.isQuoteContent(section);
+    const quoteText = section.content.replace(/^[""]|[""]$/g, "").trim();
+    const quoteWordLimit = Math.min(
+      this.config.glanceTest.wordLimit * 2,
+      // FROM KB - not hardcoded
+      this.config.rules.wordsPerSlide.max
+    );
+    const data = {
+      title: this.createTitle(section.header, section),
+      quote: this.truncateText(quoteText, quoteWordLimit)
+    };
+    if (quoteInfo.attribution) {
+      data.attribution = quoteInfo.attribution;
     }
     return {
       index,
       type: "quote",
+      data,
+      classes: ["quote-slide"]
+    };
+  }
+  createMetricsGridSlide(index, metrics) {
+    const maxMetrics = this.config.defaults.metricsGrid.maxMetrics;
+    const cleanedMetrics = metrics.slice(0, maxMetrics).map((m) => ({
+      value: this.cleanText(m.value),
+      label: this.cleanMetricLabel(m.label)
+    }));
+    return {
+      index,
+      type: "metrics-grid",
       data: {
-        quote: starMoment,
-        attribution: "Key Insight"
+        title: this.config.defaults.metricsGrid.title,
+        // FROM KB - not hardcoded 'Key Metrics'
+        metrics: cleanedMetrics
       },
-      classes: ["slide-quote"]
+      classes: ["metrics-grid-slide"]
     };
   }
-  /**
-   * Create a solution/answer slide.
-   */
-  createSolutionSlide(index, analysis, mode) {
-    if (mode === "keynote") {
-      return {
-        index,
-        type: "big-idea",
-        data: {
-          title: this.truncate(analysis.scqa.answer, 60),
-          keyMessage: "Our answer"
-        },
-        classes: ["slide-big-idea"]
-      };
+  createBulletSlide(index, section) {
+    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 && section.content) {
+      return this.createSingleStatementSlide(index, section);
     }
     return {
       index,
-      type: "two-column",
+      type: "bullet-points",
       data: {
-        title: "The Solution",
-        body: analysis.scqa.answer,
-        bullets: analysis.sparkline.whatCouldBe.slice(0, 4)
+        title: this.createTitle(section.header, section),
+        bullets: cleanedBullets
       },
-      classes: ["slide-two-column"]
+      classes: ["bullet-points-slide"]
     };
   }
-  /**
-   * Create a call-to-action slide.
-   */
-  createCTASlide(index, analysis, mode) {
+  createSingleStatementSlide(index, section) {
     return {
       index,
-      type: "cta",
+      type: "single-statement",
       data: {
-        title: mode === "keynote" ? "Take Action" : "Next Steps",
-        body: analysis.sparkline.callToAdventure,
-        keyMessage: "What we need from you"
+        title: this.createTitle(section.header, section),
+        body: this.truncateText(
+          section.content || section.bullets[0] || "",
+          this.config.rules.wordsPerSlide.max
+          // FROM KB
+        )
       },
-      classes: ["slide-cta"]
+      classes: ["single-statement-slide"]
     };
   }
-  /**
-   * Create a thank you slide.
-   */
-  createThankYouSlide(index) {
+  createCodeSlide(index, section) {
+    const codeMatch = section.content.match(/```[\s\S]*?```|`[^`]+`/);
+    const code = codeMatch ? codeMatch[0].replace(/```/g, "").trim() : section.content;
     return {
       index,
-      type: "thank-you",
+      type: "two-column",
+      // Code slides use two-column layout
       data: {
-        title: "Thank You",
-        subtitle: "Questions?"
+        title: this.createTitle(section.header, section),
+        leftColumn: {
+          body: this.config.defaults.code.label
+          // FROM KB - not hardcoded 'Code Example'
+        },
+        rightColumn: {
+          body: code.slice(0, this.config.defaults.code.maxChars)
+          // FROM KB - not hardcoded 500
+        }
       },
-      classes: ["slide-thank-you"]
+      classes: ["code-slide"]
     };
   }
-  /**
-   * Initialize slide templates with constraints.
-   */
-  initializeTemplates() {
-    const templates = /* @__PURE__ */ new Map();
-    templates.set("title", {
-      type: "title",
-      requiredFields: ["title"],
-      optionalFields: ["subtitle", "author", "date"],
-      keynoteSuitable: true,
-      businessSuitable: true,
-      maxWords: 15
-    });
-    templates.set("big-idea", {
-      type: "big-idea",
-      requiredFields: ["title"],
-      optionalFields: ["keyMessage"],
-      keynoteSuitable: true,
-      businessSuitable: false,
-      maxWords: 10
-    });
-    templates.set("single-statement", {
-      type: "single-statement",
-      requiredFields: ["title"],
-      optionalFields: ["keyMessage"],
-      keynoteSuitable: true,
-      businessSuitable: false,
-      maxWords: 15
-    });
-    templates.set("big-number", {
-      type: "big-number",
-      requiredFields: ["title"],
-      optionalFields: ["subtitle", "source"],
-      keynoteSuitable: true,
-      businessSuitable: true,
-      maxWords: 10
-    });
-    templates.set("quote", {
-      type: "quote",
-      requiredFields: ["quote"],
-      optionalFields: ["attribution", "source"],
-      keynoteSuitable: true,
-      businessSuitable: true,
-      maxWords: 30
-    });
-    templates.set("bullet-points", {
-      type: "bullet-points",
-      requiredFields: ["title", "bullets"],
-      optionalFields: ["body"],
-      keynoteSuitable: false,
-      businessSuitable: true,
-      maxWords: 80
-    });
-    templates.set("two-column", {
-      type: "two-column",
-      requiredFields: ["title"],
-      optionalFields: ["body", "bullets", "images"],
-      keynoteSuitable: false,
-      businessSuitable: true,
-      maxWords: 100
-    });
-    templates.set("agenda", {
-      type: "agenda",
-      requiredFields: ["title", "bullets"],
-      optionalFields: [],
-      keynoteSuitable: false,
-      businessSuitable: true,
-      maxWords: 50
-    });
-    templates.set("cta", {
+  createCTASlide(index, analysis) {
+    const ctaDefaults = this.config.defaults.cta;
+    const ctaText = analysis.sparkline?.callToAdventure || analysis.scqa?.answer || ctaDefaults.fallback;
+    return {
+      index,
       type: "cta",
-      requiredFields: ["title"],
-      optionalFields: ["body", "keyMessage"],
-      keynoteSuitable: true,
-      businessSuitable: true,
-      maxWords: 30
-    });
-    templates.set("thank-you", {
-      type: "thank-you",
-      requiredFields: ["title"],
-      optionalFields: ["subtitle"],
-      keynoteSuitable: true,
-      businessSuitable: true,
-      maxWords: 10
-    });
-    return templates;
+      data: {
+        title: ctaDefaults.title,
+        // FROM KB - not hardcoded 'Next Steps'
+        body: this.truncateText(ctaText, this.config.rules.wordsPerSlide.max),
+        keyMessage: ctaDefaults.message
+        // FROM KB - not hardcoded 'Ready to Begin?'
+      },
+      classes: ["cta-slide"]
+    };
+  }
+  // ===========================================================================
+  // VALIDATION - Ensure all slides comply with KB rules AND FIX ISSUES
+  // ===========================================================================
+  validateAndFixSlides(slides) {
+    const validatedSlides = [];
+    for (const slide of slides) {
+      const wordCount = this.countWords(slide);
+      const bulletCount = slide.data.bullets?.length || 0;
+      const validation = this.kb.validateSlideAgainstKB(
+        {
+          type: slide.type,
+          wordCount,
+          bulletCount,
+          hasActionTitle: this.isActionTitle(slide.data.title),
+          hasSource: !!slide.data.source
+        },
+        this.presentationType
+      );
+      if (validation.fixes.wordCount) {
+        if (slide.data.body) {
+          slide.data.body = this.truncateText(slide.data.body, validation.fixes.wordCount);
+        }
+        if (slide.data.bullets) {
+          const wordsPerBullet = Math.floor(validation.fixes.wordCount / slide.data.bullets.length);
+          slide.data.bullets = slide.data.bullets.map((b) => this.truncateText(b, wordsPerBullet));
+        }
+      }
+      if (validation.fixes.bulletCount && slide.data.bullets) {
+        slide.data.bullets = slide.data.bullets.slice(0, validation.fixes.bulletCount);
+      }
+      if (validation.violations.length > 0) {
+        console.log(`  \u26A0 Slide ${slide.index} (${slide.type}): Fixed ${Object.keys(validation.fixes).length} issues, ${validation.violations.length} remaining`);
+      }
+      if (validation.warnings.length > 0) {
+        slide.notes = (slide.notes || "") + "\nWarnings: " + validation.warnings.join(", ");
+      }
+      validatedSlides.push(slide);
+    }
+    return validatedSlides;
   }
-  // === Helper Methods ===
   /**
-   * Clean text by removing all markdown and content markers.
-   * CRITICAL: Must strip all formatting to prevent garbage in slides
+   * Check that required elements exist in the deck (from KB)
    */
-  cleanText(text) {
-    if (!text) return "";
-    return text.replace(/^#+\s+/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\|/g, " ").replace(/-{3,}/g, "").replace(/\[HEADER\]\s*/g, "").replace(/\[BULLET\]\s*/g, "").replace(/\[NUMBERED\]\s*/g, "").replace(/\[EMPHASIS\]/g, "").replace(/\[\/EMPHASIS\]/g, "").replace(/\[CODE BLOCK\]/g, "").replace(/\[IMAGE\]/g, "").replace(/\n{2,}/g, " ").replace(/\s+/g, " ").trim();
+  checkRequiredElements(slides) {
+    const required = this.config.requiredElements;
+    if (required.length === 0) return;
+    const slideTypes = slides.map((s) => s.type);
+    const missingElements = [];
+    for (const element of required) {
+      const lowerElement = element.toLowerCase();
+      if (lowerElement.includes("hook") || lowerElement.includes("opening")) {
+        const titleSlide = slides.find((s) => s.type === "title");
+        if (!titleSlide || !titleSlide.data.subtitle) {
+          missingElements.push(element);
+        }
+      }
+      if (lowerElement.includes("call to action") || lowerElement.includes("cta")) {
+        if (!slideTypes.includes("cta")) {
+          missingElements.push(element);
+        }
+      }
+      if (lowerElement.includes("star moment") || lowerElement.includes("memorable")) {
+        const hasStarMoment = slideTypes.some(
+          (t) => t === "big-number" || t === "quote" || t === "single-statement"
+        );
+        if (!hasStarMoment) {
+          missingElements.push(element);
+        }
+      }
+    }
+    if (missingElements.length > 0) {
+      console.log(`  \u26A0 Missing required elements: ${missingElements.join(", ")}`);
+    }
   }
   /**
-   * Truncate text to max length at sentence boundary when possible.
-   * CRITICAL: Never cut mid-number (99.5% should not become 99.)
+   * Check for anti-patterns from KB
    */
-  truncate(text, maxLength) {
-    const cleanedText = this.cleanText(text);
-    if (!cleanedText || cleanedText.length <= maxLength) {
-      return cleanedText;
-    }
-    const sentences = cleanedText.match(/[^.!?]+[.!?]/g);
-    if (sentences) {
-      let result = "";
-      for (const sentence of sentences) {
-        if ((result + sentence).length <= maxLength) {
-          result += sentence;
-        } else {
-          break;
+  checkAntiPatterns(slides) {
+    const antiPatterns = this.config.antiPatterns;
+    if (antiPatterns.length === 0) return;
+    const violations = [];
+    for (const pattern of antiPatterns) {
+      const lowerPattern = pattern.toLowerCase();
+      if (lowerPattern.includes("bullet") && this.config.mode === "keynote") {
+        const bulletSlides = slides.filter(
+          (s) => s.type === "bullet-points" || s.data.bullets && s.data.bullets.length > 3
+        );
+        if (bulletSlides.length > 0) {
+          violations.push(`${pattern} (${bulletSlides.length} slides)`);
         }
       }
-      if (result.length > maxLength * 0.5) {
-        return result.trim();
+      if (lowerPattern.includes("text") || lowerPattern.includes("overload")) {
+        const overloadedSlides = slides.filter((s) => {
+          const wordCount = this.countWords(s);
+          return wordCount > this.config.glanceTest.wordLimit;
+        });
+        if (overloadedSlides.length > 0) {
+          violations.push(`${pattern} (${overloadedSlides.length} slides exceed glance test)`);
+        }
       }
     }
-    const truncated = cleanedText.slice(0, maxLength);
-    let lastSpace = truncated.lastIndexOf(" ");
-    const afterCut = cleanedText.slice(lastSpace + 1, maxLength + 10);
-    if (/^[\d.,%$]+/.test(afterCut)) {
-      lastSpace = truncated.slice(0, lastSpace).lastIndexOf(" ");
+    if (violations.length > 0) {
+      console.log(`  \u26A0 Anti-pattern violations: ${violations.join(", ")}`);
+    }
+  }
+  // ===========================================================================
+  // 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)`;
     }
-    if (lastSpace > maxLength * 0.5) {
-      return truncated.slice(0, lastSpace) + "...";
+    this.usedTitles.add(cleanHeader.toLowerCase());
+    if (this.config.rules.actionTitlesRequired) {
+      return this.createActionTitle(cleanHeader, section);
     }
-    return truncated + "...";
+    return cleanHeader;
   }
   /**
-   * Extract an action title from a message.
+   * Create an action title (Minto/McKinsey style)
+   * Title should communicate the conclusion, not the topic
    */
-  extractActionTitle(message) {
-    const cleanedMessage = this.cleanText(message);
-    const firstSentence = cleanedMessage.split(/[.!?]/)[0];
-    if (firstSentence && firstSentence.length <= 50) {
-      return firstSentence;
+  createActionTitle(header, section) {
+    const titleWordLimit = this.kb.getWordLimitForElement(this.presentationType, "title");
+    const firstBullet = section.bullets[0];
+    if (firstBullet && this.isInsightful(firstBullet)) {
+      return this.truncateText(this.cleanText(firstBullet), titleWordLimit);
+    }
+    if (section.content && this.isInsightful(section.content)) {
+      const sentences = section.content.split(/[.!?]/);
+      const firstSentence = sentences[0];
+      if (firstSentence) {
+        return this.truncateText(this.cleanText(firstSentence), titleWordLimit);
+      }
     }
-    const words = cleanedMessage.split(/\s+/).slice(0, 6);
-    return words.join(" ");
+    return header;
+  }
+  /**
+   * Check if text contains an insight (not just a topic) - uses KB markers
+   */
+  isInsightful(text) {
+    const lowerText = text.toLowerCase();
+    return this.config.insightMarkers.some(
+      (marker) => (
+        // FROM KB - not hardcoded array
+        lowerText.includes(marker.toLowerCase())
+      )
+    );
+  }
+  /**
+   * Check if a title is an action title
+   */
+  isActionTitle(title) {
+    if (!title) return false;
+    return this.isInsightful(title);
+  }
+  /**
+   * Count words in a slide
+   */
+  countWords(slide) {
+    let text = "";
+    const data = slide.data;
+    if (data.title) text += data.title + " ";
+    if (data.subtitle) text += data.subtitle + " ";
+    if (data.body) text += data.body + " ";
+    if (data.keyMessage) text += data.keyMessage + " ";
+    if (data.bullets) text += data.bullets.join(" ") + " ";
+    if (data.quote) text += data.quote + " ";
+    return text.split(/\s+/).filter((w) => w.length > 0).length;
   }
   /**
-   * Extract bullet points from text.
+   * Truncate text to word limit at sentence boundaries
    */
-  extractBullets(text) {
-    if (!text) return [];
-    const bulletMatches = text.match(/\[BULLET\]\s*(.+)/g);
-    if (bulletMatches && bulletMatches.length > 0) {
-      return bulletMatches.map((b) => this.cleanText(b)).slice(0, 5);
+  truncateText(text, maxWords) {
+    const cleaned = this.cleanText(text);
+    const words = cleaned.split(/\s+/);
+    if (words.length <= maxWords) {
+      return cleaned;
+    }
+    const sentences = cleaned.match(/[^.!?]+[.!?]?/g) || [cleaned];
+    let result = "";
+    for (const sentence of sentences) {
+      const testResult = result + sentence;
+      if (testResult.split(/\s+/).length <= maxWords) {
+        result = testResult;
+      } else {
+        break;
+      }
     }
-    const cleanedText = this.cleanText(text);
-    const sentences = cleanedText.split(/[.!?]+/).filter((s) => s.trim().length > 10);
-    return sentences.slice(0, 5).map((s) => s.trim());
+    if (result.trim().length > 0) {
+      return result.trim();
+    }
+    return words.slice(0, maxWords).join(" ") + "...";
+  }
+  /**
+   * Clean text by removing content markers and normalizing
+   */
+  cleanText(text) {
+    if (!text) return "";
+    return text.replace(/\[HEADER\]\s*/g, "").replace(/\[BULLET\]\s*/g, "").replace(/\[NUMBERED\]\s*/g, "").replace(/\[EMPHASIS\]/g, "").replace(/\[\/EMPHASIS\]/g, "").replace(/\[CODE BLOCK\]/g, "").replace(/\[IMAGE\]/g, "").replace(/\*\*/g, "").replace(/\*/g, "").replace(/#{1,6}\s*/g, "").replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Clean metric labels (strip table syntax)
+   */
+  cleanMetricLabel(label) {
+    if (!label) return "";
+    return label.replace(/\|/g, " ").replace(/-{3,}/g, "").replace(/\s{2,}/g, " ").replace(/^\s*\d+\.\s*/, "").trim();
   }
   /**
-   * Remove a statistic from text and clean thoroughly.
+   * Normalize a key for deduplication
    */
-  removeStatistic(text, stat) {
-    const cleaned = this.cleanText(text).replace(stat, "").replace(/^\s*[-–—:,]\s*/, "").trim();
-    const firstSentence = cleaned.match(/^[^.!?]+[.!?]?/);
-    return firstSentence ? firstSentence[0].slice(0, 80) : cleaned.slice(0, 80);
+  normalizeKey(text) {
+    return text.toLowerCase().replace(/[^a-z0-9]/g, "");
   }
 };
+function createSlideFactory(kb, type) {
+  return new SlideFactory(kb, type);
+}
 
 // src/core/TemplateEngine.ts
 import Handlebars from "handlebars";
@@ -2751,99 +3639,1044 @@ var QAEngine = class {
     score -= Math.round((1 - signalPass / slideCount) * 30);
     return Math.max(0, score);
   }
-  calculateExpertScore(results) {
-    const experts = [results.duarte, results.reynolds, results.gallo, results.anderson];
-    const totalScore = experts.reduce((sum, e) => sum + e.score, 0);
-    return totalScore / experts.length;
+  calculateExpertScore(results) {
+    const experts = [results.duarte, results.reynolds, results.gallo, results.anderson];
+    const totalScore = experts.reduce((sum, e) => sum + e.score, 0);
+    return totalScore / experts.length;
+  }
+  calculateA11yScore(results) {
+    let score = 100;
+    score -= Math.min(40, results.fontSizeIssues.length * 10);
+    score -= Math.min(40, results.contrastIssues.length * 10);
+    if (results.focusCoverage < 1) score -= 20;
+    return Math.max(0, score);
+  }
+  // ===========================================================================
+  // ISSUE COLLECTION
+  // ===========================================================================
+  collectIssues(visual, content, expert, accessibility) {
+    const issues = [];
+    visual.perSlide.forEach((slide) => {
+      slide.issues.forEach((issue) => {
+        issues.push({
+          severity: slide.whitespace > 70 || slide.whitespace < 20 ? "error" : "warning",
+          category: "visual",
+          slideIndex: slide.slideIndex,
+          message: issue
+        });
+      });
+    });
+    content.perSlide.forEach((slide) => {
+      slide.issues.forEach((issue) => {
+        issues.push({
+          severity: "warning",
+          category: "content",
+          slideIndex: slide.slideIndex,
+          message: issue
+        });
+      });
+    });
+    content.glanceTest.filter((g) => !g.passed).forEach((g) => {
+      const issue = {
+        severity: "warning",
+        category: "content",
+        slideIndex: g.slideIndex,
+        message: `Glance test failed: "${g.keyMessage.substring(0, 50)}..." takes ${g.readingTime}s to read`
+      };
+      if (g.recommendation) {
+        issue.suggestion = g.recommendation;
+      }
+      issues.push(issue);
+    });
+    [expert.duarte, expert.reynolds, expert.gallo, expert.anderson].forEach((e) => {
+      e.violations.forEach((v) => {
+        issues.push({
+          severity: "warning",
+          category: "expert",
+          message: `${e.expertName}: ${v}`
+        });
+      });
+    });
+    accessibility.fontSizeIssues.forEach((issue) => {
+      issues.push({
+        severity: "error",
+        category: "accessibility",
+        slideIndex: issue.slideIndex,
+        message: `Font size ${issue.actualSize}px below minimum ${issue.minimumSize}px`,
+        suggestion: `Increase font size to at least ${issue.minimumSize}px`
+      });
+    });
+    accessibility.contrastIssues.forEach((issue) => {
+      issues.push({
+        severity: "error",
+        category: "accessibility",
+        slideIndex: issue.slideIndex,
+        message: `Contrast ratio ${issue.ratio.toFixed(2)} below required ${issue.required}`,
+        suggestion: "Increase contrast between text and background"
+      });
+    });
+    return issues;
+  }
+  // ===========================================================================
+  // BROWSER MANAGEMENT
+  // ===========================================================================
+  async initBrowser() {
+    if (!this.browser) {
+      this.browser = await chromium.launch({ headless: true });
+    }
+  }
+  async closeBrowser() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+};
+
+// 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
+    };
+  }
+  /**
+   * Score layout dimension (whitespace, visual balance, structure)
+   */
+  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++;
+      }
+    }
+    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)}%`
+      }
+    };
+  }
+  /**
+   * 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;
+    }
+    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;
+        }
+      }
+    }
+    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;
+      }
+      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;
+        }
+        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;
+        }
+        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;
+        }
+        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;
+      }
+      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
+      }
+    };
+  }
+  /**
+   * 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;
+      }
+      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;
+      }
+    }
+    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
+      }
+    };
+  }
+  /**
+   * 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 (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
+      }
+    };
+  }
+  /**
+   * 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`);
+      }
+      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;
+  }
+  /**
+   * Apply automatic fixes to slides based on scoring results.
+   */
+  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);
+      }
+    }
+    const summary = this.generateSummary(fixesApplied, fixesSkipped);
+    return {
+      slidesFixed,
+      fixesApplied,
+      fixesSkipped,
+      summary
+    };
+  }
+  /**
+   * Apply a single fix based on the issue.
+   */
+  async applyFix(slides, issue) {
+    const result = {
+      slideIndex: issue.slideIndex,
+      dimension: issue.dimension,
+      originalValue: issue.currentValue,
+      newValue: null,
+      description: issue.message,
+      applied: false
+    };
+    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;
+    }
+  }
+  /**
+   * Fix content-related issues (word count, bullet count).
+   */
+  fixContentIssue(slides, issue, result) {
+    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
+      return result;
+    }
+    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`;
+    }
+    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}`;
+      }
+    }
+    return result;
+  }
+  /**
+   * Fix clarity-related issues (key message length, title length).
+   */
+  fixClarityIssue(slides, issue, result) {
+    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
+      return result;
+    }
+    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`;
+      }
+    }
+    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`;
+      }
+    }
+    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);
+    }
+    return result;
   }
-  calculateA11yScore(results) {
-    let score = 100;
-    score -= Math.min(40, results.fontSizeIssues.length * 10);
-    score -= Math.min(40, results.contrastIssues.length * 10);
-    if (results.focusCoverage < 1) score -= 20;
-    return Math.max(0, score);
+  /**
+   * Fix layout-related issues.
+   */
+  fixLayoutIssue(slides, issue, result) {
+    if (issue.slideIndex < 0 || issue.slideIndex >= slides.length) {
+      return result;
+    }
+    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`;
+    }
+    return result;
   }
-  // ===========================================================================
-  // ISSUE COLLECTION
-  // ===========================================================================
-  collectIssues(visual, content, expert, accessibility) {
-    const issues = [];
-    visual.perSlide.forEach((slide) => {
-      slide.issues.forEach((issue) => {
-        issues.push({
-          severity: slide.whitespace > 70 || slide.whitespace < 20 ? "error" : "warning",
-          category: "visual",
-          slideIndex: slide.slideIndex,
-          message: issue
-        });
-      });
-    });
-    content.perSlide.forEach((slide) => {
-      slide.issues.forEach((issue) => {
-        issues.push({
-          severity: "warning",
-          category: "content",
-          slideIndex: slide.slideIndex,
-          message: issue
-        });
-      });
-    });
-    content.glanceTest.filter((g) => !g.passed).forEach((g) => {
-      const issue = {
-        severity: "warning",
-        category: "content",
-        slideIndex: g.slideIndex,
-        message: `Glance test failed: "${g.keyMessage.substring(0, 50)}..." takes ${g.readingTime}s to read`
-      };
-      if (g.recommendation) {
-        issue.suggestion = g.recommendation;
+  /**
+   * 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++;
+        }
       }
-      issues.push(issue);
-    });
-    [expert.duarte, expert.reynolds, expert.gallo, expert.anderson].forEach((e) => {
-      e.violations.forEach((v) => {
-        issues.push({
-          severity: "warning",
-          category: "expert",
-          message: `${e.expertName}: ${v}`
-        });
-      });
-    });
-    accessibility.fontSizeIssues.forEach((issue) => {
-      issues.push({
-        severity: "error",
-        category: "accessibility",
-        slideIndex: issue.slideIndex,
-        message: `Font size ${issue.actualSize}px below minimum ${issue.minimumSize}px`,
-        suggestion: `Increase font size to at least ${issue.minimumSize}px`
-      });
-    });
-    accessibility.contrastIssues.forEach((issue) => {
-      issues.push({
-        severity: "error",
-        category: "accessibility",
-        slideIndex: issue.slideIndex,
-        message: `Contrast ratio ${issue.ratio.toFixed(2)} below required ${issue.required}`,
-        suggestion: "Increase contrast between text and background"
-      });
-    });
-    return issues;
+      result.originalValue = "Mixed casing";
+      result.newValue = "Title Case";
+      result.applied = fixedCount > 0;
+      result.description = `Applied Title Case to ${fixedCount} slide titles`;
+    }
+    return result;
   }
-  // ===========================================================================
-  // BROWSER MANAGEMENT
-  // ===========================================================================
-  async initBrowser() {
-    if (!this.browser) {
-      this.browser = await chromium.launch({ headless: true });
+  /**
+   * 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;
+      }
     }
+    filtered = filtered.slice(0, breakPoint);
+    let result = filtered.join(" ");
+    if (!result.endsWith(".") && !result.endsWith("!") && !result.endsWith("?")) {
+      result = result.replace(/[,;:]$/, "") + "...";
+    }
+    return result;
   }
-  async closeBrowser() {
-    if (this.browser) {
-      await this.browser.close();
-      this.browser = null;
+  /**
+   * 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();
+      }
+      if (minorWords.has(word.toLowerCase())) {
+        return word.toLowerCase();
+      }
+      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}`);
+      }
+      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`);
+      }
     }
+    return lines.join("\n");
   }
 };
+function createAutoFixEngine(mode, presentationType) {
+  return new AutoFixEngine(mode, presentationType);
+}
 
 // src/generators/html/RevealJsGenerator.ts
 var RevealJsGenerator = class {
@@ -3439,6 +5272,182 @@ ${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) {
+      console.log("\n\u{1F504} Starting Iterative QA Process");
+      console.log(`   Target Score: ${opts.minScore}/100`);
+      console.log(`   Max Iterations: ${opts.maxIterations}`);
+      console.log("");
+    }
+    for (let i = 0; i < opts.maxIterations; i++) {
+      const iterationNum = i + 1;
+      if (opts.verbose) {
+        console.log(`\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) {
+        console.log(`   Score: ${scoringResult.overallScore}/100`);
+      }
+      if (scoringResult.passed) {
+        if (opts.verbose) {
+          console.log(`   \u2705 PASSED - Score meets threshold (${opts.minScore})`);
+        }
+        break;
+      }
+      if (i < opts.maxIterations - 1) {
+        if (opts.verbose) {
+          console.log(`   \u26A0\uFE0F  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) {
+            console.log(`   \u{1F527} Applied ${fixResult.fixesApplied.length} fixes`);
+          }
+          autoFixSummary += fixResult.summary + "\n";
+        } else {
+          if (opts.verbose) {
+            console.log(`   \u26A0\uFE0F  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) {
+      console.log(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
 import PptxGenJS from "pptxgenjs";
 
@@ -4173,15 +6182,14 @@ var PowerPointGenerator = class {
 // src/core/PresentationEngine.ts
 var PresentationEngine = class {
   contentAnalyzer;
-  slideFactory;
   templateEngine;
   scoreCalculator;
   qaEngine;
   htmlGenerator;
   pptxGenerator;
+  kb;
   constructor() {
     this.contentAnalyzer = new ContentAnalyzer();
-    this.slideFactory = new SlideFactory();
     this.templateEngine = new TemplateEngine();
     this.scoreCalculator = new ScoreCalculator();
     this.qaEngine = new QAEngine();
@@ -4196,10 +6204,15 @@ var PresentationEngine = class {
    */
   async generate(config) {
     this.validateConfig(config);
+    console.log("\u{1F4DA} Loading knowledge base...");
+    this.kb = await getKnowledgeGateway();
     console.log("\u{1F4DD} Analyzing content...");
     const analysis = await this.contentAnalyzer.analyze(config.content, config.contentType);
+    const presentationType = config.presentationType || analysis.detectedType;
+    console.log(`  \u2713 Presentation type: ${presentationType}`);
+    const slideFactory = createSlideFactory(this.kb, presentationType);
     console.log("\u{1F3A8} Creating slides...");
-    const slides = await this.slideFactory.createSlides(analysis, config.mode);
+    const slides = await slideFactory.createSlides(analysis);
     console.log("\u2705 Validating structure...");
     const structureErrors = this.validateStructure(slides, config.mode);
     if (structureErrors.length > 0) {
@@ -4220,23 +6233,52 @@ var PresentationEngine = class {
     }
     let qaResults;
     let score = 100;
+    let iterativeResult = null;
+    let finalSlides = slides;
+    let finalHtml = outputs.html;
     if (!config.skipQA && outputs.html) {
-      console.log("\u{1F50D} Running QA validation...");
-      qaResults = await this.qaEngine.validate(outputs.html, {
-        mode: config.mode,
-        strictMode: true
-      });
-      score = this.scoreCalculator.calculate(qaResults);
-      console.log(`\u{1F4CA} QA Score: ${score}/100`);
       const threshold = config.qaThreshold ?? 95;
-      if (score < threshold) {
-        throw new QAFailureError(score, threshold, qaResults);
+      const maxIterations = config.maxIterations ?? 5;
+      const useIterativeQA = config.useIterativeQA !== false;
+      if (useIterativeQA) {
+        console.log("\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 {
+        console.log("\u{1F50D} Running QA validation (legacy mode)...");
+        qaResults = await this.qaEngine.validate(outputs.html, {
+          mode: config.mode,
+          strictMode: true
+        });
+        score = this.scoreCalculator.calculate(qaResults);
+        console.log(`\u{1F4CA} QA Score: ${score}/100`);
+        if (score < threshold) {
+          throw new QAFailureError(score, threshold, qaResults);
+        }
       }
     } else {
       qaResults = this.qaEngine.createEmptyResults();
       console.log("\u26A0\uFE0F  QA validation skipped (NOT RECOMMENDED)");
     }
-    const metadata = this.buildMetadata(config, analysis, slides);
+    const metadata = this.buildMetadata(config, analysis, finalSlides, iterativeResult);
     return {
       outputs,
       qaResults,
@@ -4244,6 +6286,46 @@ var PresentationEngine = class {
       metadata
     };
   }
+  /**
+   * Build QA results structure from 7-dimension scoring.
+   */
+  buildQAResultsFrom7Dimension(iterativeResult) {
+    const scoring = iterativeResult.finalScoring;
+    return {
+      passed: scoring.passed,
+      score: scoring.overallScore,
+      visual: {
+        whitespacePercentage: scoring.dimensions.layout.score,
+        layoutBalance: scoring.dimensions.layout.score / 100,
+        colorContrast: scoring.dimensions.contrast.score / 100
+      },
+      content: {
+        perSlide: [],
+        issues: scoring.issues.filter((i) => i.dimension === "content")
+      },
+      accessibility: {
+        wcagLevel: scoring.dimensions.contrast.score >= 95 ? "AAA" : "AA",
+        issues: scoring.issues.filter((i) => i.dimension === "contrast")
+      },
+      issues: scoring.issues.map((issue) => ({
+        severity: issue.severity,
+        message: issue.message,
+        slideIndex: issue.slideIndex,
+        dimension: issue.dimension
+      })),
+      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
+      },
+      iterations: iterativeResult.iterations,
+      report: iterativeResult.report
+    };
+  }
   /**
    * Validate presentation configuration.
    */
@@ -4314,13 +6396,13 @@ var PresentationEngine = class {
   /**
    * Build presentation metadata.
    */
-  buildMetadata(config, analysis, slides) {
+  buildMetadata(config, analysis, slides, iterativeResult) {
     const wordCounts = slides.map((s) => this.countWords(s));
     const totalWords = wordCounts.reduce((sum, count) => sum + count, 0);
     const avgWordsPerSlide = Math.round(totalWords / slides.length);
     const minutesPerSlide = config.mode === "keynote" ? 1.5 : 2;
     const estimatedDuration = Math.round(slides.length * minutesPerSlide);
-    return {
+    const metadata = {
       title: config.title,
       author: config.author ?? "Unknown",
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4329,8 +6411,15 @@ var PresentationEngine = class {
       wordCount: totalWords,
       avgWordsPerSlide,
       estimatedDuration,
-      frameworks: this.detectFrameworks(analysis)
+      frameworks: this.detectFrameworks(analysis),
+      presentationType: config.presentationType || analysis.detectedType
     };
+    if (iterativeResult) {
+      metadata.qaIterations = iterativeResult.totalIterations;
+      metadata.qaMaxIterations = iterativeResult.maxIterations;
+      metadata.dimensionScores = iterativeResult.finalScoring.dimensions;
+    }
+    return metadata;
   }
   /**
    * Detect which expert frameworks were applied.
@@ -4353,6 +6442,95 @@ var PresentationEngine = class {
   }
 };
 
+// src/core/SlideGenerator.ts
+var SlideGenerator = class {
+  kb;
+  factory;
+  mode = "keynote";
+  presentationType = "ted_keynote";
+  async initialize() {
+    this.kb = await getKnowledgeGateway();
+  }
+  /**
+   * Generate slides from analyzed content using KB-driven SlideFactory.
+   *
+   * @version 7.0.0 - Now delegates ALL slide creation to SlideFactory
+   * SlideFactory queries KB for every decision:
+   * - Allowed slide types per presentation type
+   * - Word limits per type
+   * - Bullet limits per type
+   * - Content pattern to slide type mapping
+   * - Slide validation against KB rules
+   */
+  async generate(analysis, type) {
+    await this.initialize();
+    this.presentationType = type || analysis.detectedType;
+    this.mode = this.kb.getModeForType(this.presentationType);
+    console.log(`  \u2713 Using ${this.mode} mode for ${this.presentationType}`);
+    this.factory = createSlideFactory(this.kb, this.presentationType);
+    const slides = await this.factory.createSlides(analysis);
+    const legacySlides = this.convertToLegacyFormat(slides);
+    console.log(`  \u2713 Generated ${legacySlides.length} KB-validated slides`);
+    return legacySlides;
+  }
+  /**
+   * Convert new Slide format to legacy format for backwards compatibility
+   */
+  convertToLegacyFormat(slides) {
+    return slides.map((slide) => ({
+      index: slide.index,
+      type: slide.type,
+      title: slide.data.title || "",
+      content: {
+        subtitle: slide.data.subtitle,
+        statement: slide.data.body,
+        body: slide.data.body,
+        bullets: slide.data.bullets,
+        metrics: slide.data.metrics,
+        quote: slide.data.quote ? { text: slide.data.quote, attribution: slide.data.attribution } : void 0,
+        callToAction: slide.data.keyMessage
+      },
+      notes: slide.notes,
+      template: this.mapTypeToTemplate(slide.type)
+    }));
+  }
+  /**
+   * Map slide type to template name for backwards compatibility
+   */
+  mapTypeToTemplate(type) {
+    const templateMap = {
+      "title": "Title Impact",
+      "agenda": "Detailed Findings",
+      "big-number": "Data Insight",
+      "metrics-grid": "Data Insight",
+      "bullet-points": "Detailed Findings",
+      "two-column": "Two Column",
+      "three-column": "Three Column",
+      "comparison": "Comparison",
+      "timeline": "Process Timeline",
+      "process": "Process",
+      "quote": "Quote",
+      "single-statement": "Single Statement",
+      "cta": "Call to Action",
+      "thank-you": "Title Impact"
+    };
+    return templateMap[type] || "Detailed Findings";
+  }
+  // =========================================================================
+  // All slide creation is now handled by SlideFactory
+  // Old methods removed in v7.0.0 - KB-driven SlideFactory handles:
+  // - createTitleSlide, createAgendaSlide, createSituationSlide, etc.
+  // - Content pattern classification
+  // - KB-based slide type selection
+  // - Text truncation, cleaning, deduplication
+  // =========================================================================
+};
+async function initSlideGenerator() {
+  const generator = new SlideGenerator();
+  await generator.initialize();
+  return generator;
+}
+
 // src/media/ImageProvider.ts
 var LocalImageProvider = class {
   name = "local";
@@ -4541,7 +6719,7 @@ async function validate(presentation, options) {
     score
   };
 }
-var VERSION = "6.0.0";
+var VERSION = "7.1.0";
 var index_default = {
   generate,
   validate,
@@ -4550,10 +6728,13 @@ var index_default = {
   VERSION
 };
 export {
+  AutoFixEngine,
   ChartJsProvider,
   CompositeChartProvider,
   CompositeImageProvider,
   ContentAnalyzer,
+  ContentPatternClassifier,
+  IterativeQAEngine,
   KnowledgeGateway,
   LocalImageProvider,
   MermaidProvider,
@@ -4565,17 +6746,23 @@ export {
   QuickChartProvider,
   RevealJsGenerator,
   ScoreCalculator,
+  SevenDimensionScorer,
   SlideFactory,
+  SlideGenerator,
   TemplateEngine,
   TemplateNotFoundError,
   UnsplashImageProvider,
   VERSION,
   ValidationError,
+  createAutoFixEngine,
   createDefaultChartProvider,
   createDefaultImageProvider,
+  createIterativeQAEngine,
+  createSlideFactory,
   index_default as default,
   generate,
   getKnowledgeGateway,
+  initSlideGenerator,
   validate
 };
 /**