claude-presentation-master 5.0.0 → 6.0.0

package/dist/index.mjs

@@ -26,8 +26,280 @@ var TemplateNotFoundError = class extends Error {
   }
 };
 
+// src/kb/KnowledgeGateway.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import * as yaml from "yaml";
+function getModuleDir() {
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return dirname(fileURLToPath(import.meta.url));
+  }
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  return process.cwd();
+}
+var KnowledgeGateway = class {
+  kb;
+  loaded = false;
+  constructor() {
+  }
+  /**
+   * Load the knowledge base from YAML file
+   */
+  async load() {
+    if (this.loaded) return;
+    const moduleDir = getModuleDir();
+    const possiblePaths = [
+      join(moduleDir, "../../assets/presentation-knowledge.yaml"),
+      join(moduleDir, "../assets/presentation-knowledge.yaml"),
+      join(moduleDir, "../../../assets/presentation-knowledge.yaml"),
+      join(moduleDir, "assets/presentation-knowledge.yaml"),
+      join(process.cwd(), "assets/presentation-knowledge.yaml"),
+      join(process.cwd(), "node_modules/claude-presentation-master/assets/presentation-knowledge.yaml")
+    ];
+    for (const path of possiblePaths) {
+      try {
+        const content = readFileSync(path, "utf-8");
+        this.kb = yaml.parse(content);
+        this.loaded = true;
+        console.log(`  \u2713 Knowledge base loaded from ${path}`);
+        return;
+      } catch {
+      }
+    }
+    throw new Error(`Knowledge base not found. Tried: ${possiblePaths.join(", ")}`);
+  }
+  /**
+   * Get presentation mode configuration (keynote or business)
+   */
+  getMode(mode) {
+    this.ensureLoaded();
+    return this.kb.presentation_modes[mode];
+  }
+  /**
+   * Determine which mode is best for a given presentation type
+   */
+  getModeForType(type) {
+    const keynoteTypes = ["ted_keynote", "sales_pitch", "all_hands"];
+    const businessTypes = ["consulting_deck", "investment_banking", "investor_pitch", "technical_presentation"];
+    if (keynoteTypes.includes(type)) return "keynote";
+    if (businessTypes.includes(type)) return "business";
+    return "keynote";
+  }
+  /**
+   * Get word limits for the specified mode
+   */
+  getWordLimits(mode) {
+    const modeConfig = this.getMode(mode);
+    const range = modeConfig.characteristics.words_per_slide;
+    if (mode === "keynote") {
+      return { min: 6, max: 15, ideal: 10 };
+    } else {
+      return { min: 40, max: 80, ideal: 60 };
+    }
+  }
+  /**
+   * Get bullet point limits
+   */
+  getBulletLimits(mode) {
+    if (mode === "keynote") {
+      return { maxBullets: 3, maxWordsPerBullet: 8 };
+    } else {
+      return { maxBullets: 5, maxWordsPerBullet: 20 };
+    }
+  }
+  /**
+   * Get whitespace percentage requirement
+   */
+  getWhitespaceRequirement(mode) {
+    if (mode === "keynote") return 0.4;
+    return 0.25;
+  }
+  /**
+   * Get slide templates for the specified mode
+   */
+  getSlideTemplates(mode) {
+    this.ensureLoaded();
+    const key = mode === "keynote" ? "keynote_mode" : "business_mode";
+    return this.kb.slide_templates[key] || [];
+  }
+  /**
+   * Get a specific slide template by name
+   */
+  getSlideTemplate(mode, templateName) {
+    const templates = this.getSlideTemplates(mode);
+    return templates.find((t) => t.name.toLowerCase().includes(templateName.toLowerCase()));
+  }
+  /**
+   * Get quality metrics for grading
+   */
+  getQualityMetrics() {
+    this.ensureLoaded();
+    return this.kb.quality_metrics;
+  }
+  /**
+   * Get anti-patterns to avoid
+   */
+  getAntiPatterns(mode) {
+    this.ensureLoaded();
+    const key = mode === "keynote" ? "keynote_mode" : "business_mode";
+    return this.kb.anti_patterns[key] || [];
+  }
+  /**
+   * Get data visualization anti-patterns
+   */
+  getDataVizAntiPatterns() {
+    this.ensureLoaded();
+    return this.kb.anti_patterns.data_visualization || [];
+  }
+  /**
+   * Get accessibility anti-patterns
+   */
+  getAccessibilityAntiPatterns() {
+    this.ensureLoaded();
+    return this.kb.anti_patterns.accessibility || [];
+  }
+  /**
+   * Get color palette by name
+   */
+  getColorPalette(name) {
+    this.ensureLoaded();
+    const palettes = this.kb.design_system.color_palettes;
+    return palettes[name];
+  }
+  /**
+   * Get recommended color palette for presentation type
+   */
+  getRecommendedPalette(type) {
+    this.ensureLoaded();
+    const palettes = this.kb.design_system.color_palettes;
+    switch (type) {
+      case "consulting_deck":
+        return palettes.consulting_classic;
+      case "investment_banking":
+      case "investor_pitch":
+        return palettes.executive_professional;
+      case "ted_keynote":
+        return palettes.dark_executive;
+      case "sales_pitch":
+        return palettes.modern_business;
+      case "technical_presentation":
+        return palettes.modern_business;
+      case "all_hands":
+        return palettes.strategy_growth;
+      default:
+        return palettes.consulting_classic;
+    }
+  }
+  /**
+   * Get typography guidelines for mode
+   */
+  getTypography(mode) {
+    this.ensureLoaded();
+    const key = mode === "keynote" ? "keynote_mode" : "business_mode";
+    return this.kb.design_system.typography[key];
+  }
+  /**
+   * Get story framework by name
+   */
+  getStoryFramework(name) {
+    this.ensureLoaded();
+    return this.kb.story_frameworks[name];
+  }
+  /**
+   * Get expert principles by name
+   */
+  getExpertPrinciples(expertName) {
+    this.ensureLoaded();
+    if (this.kb.experts[expertName]) {
+      return this.kb.experts[expertName];
+    }
+    if (this.kb.data_visualization_experts) {
+      for (const key of Object.keys(this.kb.data_visualization_experts)) {
+        if (key.includes(expertName.toLowerCase())) {
+          return this.kb.data_visualization_experts[key];
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Get Duarte's glance test requirements
+   */
+  getDuarteGlanceTest() {
+    this.ensureLoaded();
+    const duarte = this.kb.experts.nancy_duarte;
+    return {
+      wordLimit: duarte.core_principles.glance_test.word_limit || 25,
+      timeSeconds: 3
+    };
+  }
+  /**
+   * Get Miller's Law constraints
+   */
+  getMillersLaw() {
+    this.ensureLoaded();
+    return { minItems: 5, maxItems: 9 };
+  }
+  /**
+   * Get cognitive load constraints
+   */
+  getCognitiveLoadLimits() {
+    this.ensureLoaded();
+    return { maxItemsPerChunk: 7 };
+  }
+  /**
+   * Get chart selection guidance
+   */
+  getChartGuidance(purpose) {
+    this.ensureLoaded();
+    return this.kb.chart_selection_guide.by_purpose[purpose];
+  }
+  /**
+   * Get charts to avoid
+   */
+  getChartsToAvoid() {
+    this.ensureLoaded();
+    const knaflic = this.kb.data_visualization_experts.cole_nussbaumer_knaflic;
+    return knaflic.chart_guidance.avoid_these || [];
+  }
+  /**
+   * Get investment banking pitch book structure
+   */
+  getIBPitchBookStructure(type) {
+    this.ensureLoaded();
+    return this.kb.investment_banking?.pitch_book_types[type];
+  }
+  /**
+   * Check if knowledge base is loaded
+   */
+  ensureLoaded() {
+    if (!this.loaded) {
+      throw new Error("Knowledge base not loaded. Call load() first.");
+    }
+  }
+  /**
+   * Get the full knowledge base (for advanced queries)
+   */
+  getRawKB() {
+    this.ensureLoaded();
+    return this.kb;
+  }
+};
+var gatewayInstance = null;
+async function getKnowledgeGateway() {
+  if (!gatewayInstance) {
+    gatewayInstance = new KnowledgeGateway();
+    await gatewayInstance.load();
+  }
+  return gatewayInstance;
+}
+
 // src/core/ContentAnalyzer.ts
 var ContentAnalyzer = class {
+  kb;
   // Signal words for SCQA detection
   situationSignals = [
     "currently",
@@ -39,7 +311,8 @@ var ContentAnalyzer = class {
     "our",
     "the market",
     "industry",
-    "context"
+    "context",
+    "background"
   ];
   complicationSignals = [
     "however",
@@ -57,20 +330,10 @@ var ContentAnalyzer = class {
     "yet",
     "although",
     "despite",
-    "while"
-  ];
-  questionSignals = [
-    "how",
-    "what",
-    "why",
-    "when",
-    "where",
-    "which",
-    "should",
-    "could",
-    "can we",
-    "is it possible",
-    "?"
+    "while",
+    "crisis",
+    "gap",
+    "broken"
   ];
   answerSignals = [
     "therefore",
@@ -86,429 +349,439 @@ var ContentAnalyzer = class {
     "we should",
     "must",
     "need to",
-    "the answer"
+    "the answer",
+    "introducing",
+    "presenting",
+    "platform"
   ];
-  // Sparkline detection
-  whatIsSignals = [
-    "currently",
-    "today",
-    "status quo",
-    "reality",
-    "actual",
-    "now",
-    "existing",
-    "present state",
-    "as-is",
-    "problem"
-  ];
-  whatCouldBeSignals = [
-    "imagine",
-    "vision",
-    "future",
-    "could be",
-    "what if",
-    "possibility",
-    "potential",
-    "opportunity",
-    "transform",
-    "envision",
-    "ideal",
-    "dream",
-    "goal",
-    "aspiration"
+  // CTA signals - used to filter these OUT of answer detection
+  ctaSignals = [
+    "contact",
+    "call us",
+    "email",
+    "schedule",
+    "sign up",
+    "register",
+    "next steps",
+    "get started",
+    "reach out",
+    "visit",
+    "follow"
   ];
+  // Type detection signals
+  typeSignals = {
+    ted_keynote: ["inspire", "vision", "imagine", "dream", "transform", "story", "journey"],
+    sales_pitch: ["buy", "purchase", "pricing", "offer", "deal", "discount", "roi", "value"],
+    consulting_deck: ["recommend", "analysis", "assessment", "strategy", "findings", "options", "mece"],
+    investment_banking: ["valuation", "dcf", "multiple", "enterprise value", "ebitda", "ipo", "m&a"],
+    investor_pitch: ["investment", "funding", "series", "traction", "market size", "tam", "runway"],
+    technical_presentation: ["architecture", "api", "system", "implementation", "code", "database", "deploy"],
+    all_hands: ["team", "quarter", "update", "progress", "celebrate", "recognize", "company"]
+  };
+  async initialize() {
+    this.kb = await getKnowledgeGateway();
+  }
   /**
    * Analyze content and extract structural elements.
    */
   async analyze(content, contentType) {
+    await this.initialize();
     const text = this.parseContent(content, contentType);
-    const paragraphs = this.splitIntoParagraphs(text);
-    const sentences = this.splitIntoSentences(text);
-    const scqa = this.extractSCQA(paragraphs, sentences);
-    const sparkline = this.extractSparkline(paragraphs);
-    const keyMessages = this.extractKeyMessages(text, sentences);
-    const titles = this.generateActionTitles(keyMessages, paragraphs);
-    const starMoments = this.identifyStarMoments(paragraphs);
-    const estimatedSlideCount = this.estimateSlideCount(text, paragraphs);
+    const title = this.extractTitle(text);
+    const detectedType = this.detectPresentationType(text);
+    console.log(`  \u2713 Detected type: ${detectedType}`);
+    const sections = this.extractSections(text);
+    console.log(`  \u2713 Found ${sections.length} sections`);
+    const scqa = this.extractSCQA(text);
+    const sparkline = this.extractSparkline(text);
+    const keyMessages = this.extractKeyMessages(text);
+    const dataPoints = this.extractDataPoints(text);
+    console.log(`  \u2713 Found ${dataPoints.length} data points`);
+    const titles = sections.map((s) => s.header).filter((h) => h.length > 0);
+    const starMoments = this.extractStarMoments(text);
+    const estimatedSlideCount = Math.max(5, sections.length + 3);
     return {
-      scqa,
-      sparkline,
+      detectedType,
+      title,
+      sections,
       keyMessages,
+      dataPoints,
+      scqa: {
+        situation: scqa.situation || "",
+        complication: scqa.complication || "",
+        question: scqa.question || "",
+        answer: scqa.answer || ""
+      },
+      sparkline: {
+        whatIs: sparkline.callToAction ? [sparkline.callToAction] : [],
+        whatCouldBe: keyMessages,
+        callToAdventure: sparkline.callToAction || ""
+      },
       titles,
       starMoments,
       estimatedSlideCount
     };
   }
   /**
-   * Parse content based on its type.
+   * Parse content based on type
    */
   parseContent(content, contentType) {
-    switch (contentType) {
-      case "markdown":
-        return this.parseMarkdown(content);
-      case "json":
-        return this.parseJSON(content);
-      case "yaml":
-        return this.parseYAML(content);
-      case "text":
-      default:
-        return content;
+    if (contentType === "markdown" || content.includes("#") || content.includes("- ")) {
+      return content;
     }
+    return content;
   }
   /**
-   * Parse markdown content to plain text (preserving structure hints).
-   */
-  parseMarkdown(content) {
-    let text = content;
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "\n[HEADER] $1\n");
-    text = text.replace(/^[-*+]\s+(.+)$/gm, "[BULLET] $1");
-    text = text.replace(/^\d+\.\s+(.+)$/gm, "[NUMBERED] $1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "[EMPHASIS] $1 [/EMPHASIS]");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/```[\s\S]*?```/g, "[CODE BLOCK]");
-    text = text.replace(/`(.+?)`/g, "$1");
-    text = text.replace(/\[(.+?)\]\(.+?\)/g, "$1");
-    text = text.replace(/!\[.*?\]\(.+?\)/g, "[IMAGE]");
-    return text.trim();
-  }
-  /**
-   * Parse JSON content.
+   * Extract the main title from content
    */
-  parseJSON(content) {
-    try {
-      const data = JSON.parse(content);
-      return this.flattenObject(data);
-    } catch {
-      return content;
+  extractTitle(text) {
+    const h1Match = text.match(/^#\s+(.+)$/m);
+    if (h1Match && h1Match[1]) {
+      return h1Match[1].replace(/\*\*/g, "").trim();
+    }
+    const lines = text.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length > 0 && lines[0]) {
+      return lines[0].replace(/^#+\s*/, "").replace(/\*\*/g, "").trim().slice(0, 80);
     }
+    return "Presentation";
   }
   /**
-   * Parse YAML content.
+   * Detect presentation type from content signals
    */
-  parseYAML(content) {
-    const lines = content.split("\n");
-    const values = [];
-    for (const line of lines) {
-      const match = line.match(/^[\s-]*(?:\w+:\s*)?(.+)$/);
-      if (match?.[1] && !match[1].includes(":")) {
-        values.push(match[1].trim());
+  detectPresentationType(text) {
+    const lowerText = text.toLowerCase();
+    const scores = {
+      ted_keynote: 0,
+      sales_pitch: 0,
+      consulting_deck: 0,
+      investment_banking: 0,
+      investor_pitch: 0,
+      technical_presentation: 0,
+      all_hands: 0
+    };
+    for (const [type, signals] of Object.entries(this.typeSignals)) {
+      for (const signal of signals) {
+        if (lowerText.includes(signal)) {
+          scores[type]++;
+        }
+      }
+    }
+    let maxScore = 0;
+    let detectedType = "consulting_deck";
+    for (const [type, score] of Object.entries(scores)) {
+      if (score > maxScore) {
+        maxScore = score;
+        detectedType = type;
       }
     }
-    return values.join("\n");
+    return detectedType;
   }
   /**
-   * Flatten object to text.
+   * Extract sections from content (headers, bullets, content)
    */
-  flattenObject(obj, prefix = "") {
-    const parts = [];
-    if (typeof obj === "string") {
-      return obj;
-    }
-    if (Array.isArray(obj)) {
-      for (const item of obj) {
-        parts.push(this.flattenObject(item, prefix));
+  extractSections(text) {
+    const sections = [];
+    const lines = text.split("\n");
+    let currentSection = null;
+    let contentLines = [];
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      const headerMatch = trimmedLine.match(/^(#{1,6})\s+(.+)$/);
+      if (headerMatch) {
+        if (currentSection) {
+          currentSection.content = contentLines.join("\n").trim();
+          if (currentSection.header || currentSection.content || currentSection.bullets.length > 0) {
+            sections.push(currentSection);
+          }
+        }
+        currentSection = {
+          header: (headerMatch[2] || "").replace(/\*\*/g, "").trim(),
+          level: (headerMatch[1] || "").length,
+          content: "",
+          bullets: [],
+          metrics: []
+        };
+        contentLines = [];
+        continue;
+      }
+      const bulletMatch = trimmedLine.match(/^[-*+]\s+(.+)$/);
+      if (bulletMatch && bulletMatch[1] && currentSection) {
+        currentSection.bullets.push(bulletMatch[1]);
+        continue;
+      }
+      const numberedMatch = trimmedLine.match(/^\d+\.\s+(.+)$/);
+      if (numberedMatch && numberedMatch[1] && currentSection) {
+        currentSection.bullets.push(numberedMatch[1]);
+        continue;
+      }
+      const metricMatch = trimmedLine.match(/\$?([\d,]+\.?\d*)[%]?\s*[-–—:]\s*(.+)/);
+      if (metricMatch && metricMatch[1] && metricMatch[2] && currentSection) {
+        currentSection.metrics.push({
+          value: metricMatch[1],
+          label: metricMatch[2].slice(0, 50)
+        });
+        continue;
+      }
+      if (trimmedLine.includes("|") && currentSection) {
+        const cells = trimmedLine.split("|").map((c) => c.trim()).filter((c) => c && !c.match(/^-+$/));
+        if (cells.length >= 2) {
+          const value = cells.find((c) => c.match(/^\$?[\d,]+\.?\d*[%]?$/));
+          const label = cells.find((c) => !c.match(/^\$?[\d,]+\.?\d*[%]?$/) && c.length > 2);
+          if (value && label) {
+            currentSection.metrics.push({ value, label: label.slice(0, 50) });
+          }
+        }
+        continue;
       }
-    } else if (typeof obj === "object" && obj !== null) {
-      for (const [key, value] of Object.entries(obj)) {
-        const newPrefix = prefix ? `${prefix}.${key}` : key;
-        parts.push(this.flattenObject(value, newPrefix));
+      if (trimmedLine && currentSection) {
+        contentLines.push(trimmedLine);
       }
-    } else if (obj !== null && obj !== void 0) {
-      parts.push(String(obj));
     }
-    return parts.join("\n");
-  }
-  /**
-   * Split text into paragraphs.
-   */
-  splitIntoParagraphs(text) {
-    return text.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length > 0);
-  }
-  /**
-   * Split text into sentences.
-   */
-  splitIntoSentences(text) {
-    const cleaned = text.replace(/Mr\./g, "Mr").replace(/Mrs\./g, "Mrs").replace(/Dr\./g, "Dr").replace(/vs\./g, "vs").replace(/etc\./g, "etc").replace(/e\.g\./g, "eg").replace(/i\.e\./g, "ie");
-    return cleaned.split(/[.!?]+/).map((s) => s.trim()).filter((s) => s.length > 10);
+    if (currentSection) {
+      currentSection.content = contentLines.join("\n").trim();
+      if (currentSection.header || currentSection.content || currentSection.bullets.length > 0) {
+        sections.push(currentSection);
+      }
+    }
+    return sections;
   }
   /**
-   * Extract SCQA structure (Barbara Minto's Pyramid Principle).
+   * Extract SCQA structure (Barbara Minto)
    */
-  extractSCQA(paragraphs, sentences) {
+  extractSCQA(text) {
+    const paragraphs = text.split(/\n\n+/).filter((p) => p.trim());
     let situation = "";
     let complication = "";
     let question = "";
     let answer = "";
     for (const para of paragraphs.slice(0, 3)) {
-      if (this.containsSignals(para, this.situationSignals)) {
-        situation = this.extractRelevantSentence(para, this.situationSignals);
+      if (this.containsSignals(para.toLowerCase(), this.situationSignals)) {
+        situation = this.extractFirstSentence(para);
         break;
       }
     }
     for (const para of paragraphs) {
-      if (this.containsSignals(para, this.complicationSignals)) {
-        complication = this.extractRelevantSentence(para, this.complicationSignals);
+      if (this.containsSignals(para.toLowerCase(), this.complicationSignals)) {
+        complication = this.extractFirstSentence(para);
         break;
       }
     }
-    for (const sentence of sentences) {
-      if (sentence.includes("?") || this.containsSignals(sentence, this.questionSignals)) {
-        question = sentence;
+    const middleStart = Math.floor(paragraphs.length * 0.2);
+    const middleEnd = Math.floor(paragraphs.length * 0.8);
+    for (const para of paragraphs.slice(middleStart, middleEnd)) {
+      const lowerPara = para.toLowerCase();
+      if (this.containsSignals(lowerPara, this.answerSignals) && !this.containsSignals(lowerPara, this.ctaSignals)) {
+        answer = this.extractFirstSentence(para);
         break;
       }
     }
-    for (const para of paragraphs.slice(-3)) {
-      if (this.containsSignals(para, this.answerSignals)) {
-        answer = this.extractRelevantSentence(para, this.answerSignals);
-        break;
-      }
+    if (!situation && paragraphs.length > 0 && paragraphs[0]) {
+      situation = this.extractFirstSentence(paragraphs[0]);
     }
-    if (!situation && paragraphs.length > 0) {
-      situation = this.truncateToSentence(paragraphs[0] ?? "", 150);
+    if (!answer && paragraphs.length > 2) {
+      for (const para of paragraphs.slice(1, Math.floor(paragraphs.length * 0.5))) {
+        const lowerPara = para.toLowerCase();
+        if (lowerPara.includes("recommend") || lowerPara.includes("strategy") || lowerPara.includes("solution") || lowerPara.includes("approach")) {
+          answer = this.extractFirstSentence(para);
+          break;
+        }
+      }
     }
-    if (!answer && paragraphs.length > 1) {
-      const lastPara = paragraphs[paragraphs.length - 1];
-      answer = lastPara ? this.truncateToSentence(lastPara, 150) : "";
+    if (complication && !question) {
+      question = `How do we address: ${complication.slice(0, 80)}?`;
     }
     return { situation, complication, question, answer };
   }
   /**
-   * Extract Sparkline structure (Nancy Duarte).
+   * Extract STAR moments (Something They'll Always Remember)
+   * Per Nancy Duarte - these are emotional peaks in the presentation
    */
-  extractSparkline(paragraphs) {
-    const whatIs = [];
-    const whatCouldBe = [];
-    let callToAdventure = "";
-    for (const para of paragraphs) {
-      const lowerPara = para.toLowerCase();
-      if (this.containsSignals(lowerPara, this.whatIsSignals)) {
-        whatIs.push(this.truncateToSentence(para, 100));
+  extractStarMoments(text) {
+    const starMoments = [];
+    const boldMatches = text.match(/\*\*(.+?)\*\*/g);
+    if (boldMatches) {
+      for (const match of boldMatches.slice(0, 5)) {
+        const cleaned = match.replace(/\*\*/g, "").trim();
+        const lowerCleaned = cleaned.toLowerCase();
+        if (cleaned.length > 15 && cleaned.length < 100 && !this.containsSignals(lowerCleaned, this.ctaSignals) && !/^\d+[%x]?\s*$/.test(cleaned)) {
+          starMoments.push(cleaned);
+        }
       }
-      if (this.containsSignals(lowerPara, this.whatCouldBeSignals)) {
-        whatCouldBe.push(this.truncateToSentence(para, 100));
+    }
+    const exclamations = text.match(/[^.!?]*![^.!?]*/g);
+    if (exclamations) {
+      for (const ex of exclamations.slice(0, 2)) {
+        const cleaned = ex.trim();
+        const lowerCleaned = cleaned.toLowerCase();
+        if (cleaned.length > 10 && cleaned.length < 100 && !starMoments.includes(cleaned) && !this.containsSignals(lowerCleaned, this.ctaSignals)) {
+          starMoments.push(cleaned);
+        }
       }
     }
-    for (const para of paragraphs.slice(-2)) {
-      if (this.containsSignals(para.toLowerCase(), ["join", "together", "action", "start", "begin", "now"])) {
-        callToAdventure = this.truncateToSentence(para, 150);
+    return starMoments.slice(0, 3);
+  }
+  /**
+   * Extract Sparkline elements (Nancy Duarte)
+   */
+  extractSparkline(text) {
+    const paragraphs = text.split(/\n\n+/).filter((p) => p.trim());
+    let callToAction = "";
+    const ctaSignals = ["next steps", "call to action", "take action", "start now", "join us", "contact"];
+    for (const para of paragraphs.slice(-3)) {
+      if (this.containsSignals(para.toLowerCase(), ctaSignals)) {
+        callToAction = this.extractFirstSentence(para);
         break;
       }
     }
-    return { whatIs, whatCouldBe, callToAdventure };
+    return { callToAction };
   }
   /**
-   * Extract key messages (max 3 - Rule of Three).
+   * Extract key messages (max 3 - Rule of Three)
    */
-  extractKeyMessages(text, sentences) {
+  extractKeyMessages(text) {
     const messages = [];
-    const emphasisMatches = text.match(/\[EMPHASIS\](.+?)\[\/EMPHASIS\]/g);
-    if (emphasisMatches) {
-      for (const match of emphasisMatches.slice(0, 3)) {
-        const content = match.replace(/\[EMPHASIS\]|\[\/EMPHASIS\]/g, "").trim();
-        if (content.length > 10 && content.length < 100) {
-          messages.push(content);
-        }
-      }
-    }
-    const headerMatches = text.match(/\[HEADER\](.+)/g);
-    if (headerMatches && messages.length < 3) {
-      for (const match of headerMatches.slice(0, 3 - messages.length)) {
-        const content = match.replace("[HEADER]", "").trim();
-        if (content.length > 5 && content.length < 80) {
-          messages.push(content);
+    const h2Matches = text.match(/^##\s+(.+)$/gm);
+    if (h2Matches) {
+      for (const match of h2Matches.slice(0, 3)) {
+        const msg = match.replace(/^##\s+/, "").replace(/\*\*/g, "").trim();
+        if (msg.length > 5 && msg.length < 80) {
+          messages.push(msg);
         }
       }
     }
     if (messages.length < 3) {
-      const strongSentences = sentences.filter((s) => s.length > 20 && s.length < 100).filter((s) => this.containsSignals(s.toLowerCase(), ["key", "important", "critical", "essential", "must", "need"]));
-      for (const sentence of strongSentences.slice(0, 3 - messages.length)) {
-        messages.push(sentence);
-      }
-    }
-    if (messages.length < 3) {
-      for (const sentence of sentences) {
-        if (sentence.length > 30 && sentence.length < 100 && !messages.includes(sentence)) {
-          messages.push(sentence);
-          if (messages.length >= 3) break;
+      const boldMatches = text.match(/\*\*(.+?)\*\*/g);
+      if (boldMatches) {
+        for (const match of boldMatches) {
+          const msg = match.replace(/\*\*/g, "").trim();
+          if (msg.length > 10 && msg.length < 80 && !messages.includes(msg)) {
+            messages.push(msg);
+            if (messages.length >= 3) break;
+          }
         }
       }
     }
     return messages.slice(0, 3);
   }
   /**
-   * Generate action titles (McKinsey-style).
+   * Extract data points (metrics with values)
    */
-  generateActionTitles(keyMessages, paragraphs) {
-    const titles = [];
-    for (const message of keyMessages) {
-      const actionTitle = this.transformToActionTitle(message);
-      if (actionTitle) {
-        titles.push(actionTitle);
+  extractDataPoints(text) {
+    const dataPoints = [];
+    const dollarMatches = text.match(/\$[\d,]+(?:\.\d+)?[MBK]?(?:\s*(?:million|billion|thousand))?/gi);
+    if (dollarMatches) {
+      for (const match of dollarMatches.slice(0, 4)) {
+        const context = this.getContextAroundMatch(text, match);
+        dataPoints.push({
+          value: match,
+          label: this.extractLabelFromContext(context)
+        });
       }
     }
-    for (const para of paragraphs) {
-      if (titles.length >= 10) break;
-      const headerMatch = para.match(/\[HEADER\]\s*(.+)/);
-      if (headerMatch?.[1]) {
-        const title = this.transformToActionTitle(headerMatch[1]);
-        if (title && !titles.includes(title)) {
-          titles.push(title);
+    const percentMatches = text.match(/\d+(?:\.\d+)?%/g);
+    if (percentMatches) {
+      for (const match of percentMatches.slice(0, 4)) {
+        if (!dataPoints.some((d) => d.value === match)) {
+          const context = this.getContextAroundMatch(text, match);
+          dataPoints.push({
+            value: match,
+            label: this.extractLabelFromContext(context)
+          });
         }
       }
     }
-    return titles;
+    return dataPoints.slice(0, 6);
   }
   /**
-   * Transform a statement into an action title.
+   * Get context around a match
    */
-  transformToActionTitle(statement) {
-    let title = statement.replace(/\[(HEADER|EMPHASIS|BULLET|NUMBERED)\]/g, "").trim();
-    const actionVerbs = ["increase", "decrease", "improve", "reduce", "achieve", "deliver", "create", "build", "launch", "transform", "enable", "drive"];
-    const firstWord = title.split(" ")[0]?.toLowerCase();
-    if (firstWord && actionVerbs.includes(firstWord)) {
-      return this.capitalizeFirst(title);
-    }
-    if (title.toLowerCase().includes("should")) {
-      title = title.replace(/we should|you should|should/gi, "").trim();
-      return this.capitalizeFirst(title);
-    }
-    if (title.toLowerCase().includes("need to")) {
-      title = title.replace(/we need to|you need to|need to/gi, "").trim();
-      return this.capitalizeFirst(title);
-    }
-    if (title.length < 50) {
-      return title;
-    }
-    return this.truncateToWords(title, 8);
+  getContextAroundMatch(text, match) {
+    const index = text.indexOf(match);
+    if (index === -1) return "";
+    const start = Math.max(0, index - 50);
+    const end = Math.min(text.length, index + match.length + 50);
+    return text.slice(start, end);
   }
   /**
-   * Identify STAR moments (Something They'll Always Remember).
+   * Extract a label from surrounding context
+   * Fixes the "Century Interactive |" garbage issue by stripping table syntax
    */
-  identifyStarMoments(paragraphs) {
-    const starMoments = [];
-    const starSignals = [
-      "surprising",
-      "amazing",
-      "incredible",
-      "remarkable",
-      "stunning",
-      "imagine",
-      "what if",
-      "breakthrough",
-      "revolutionary",
-      "never before",
-      "first time",
-      "unprecedented",
-      "game-changing",
-      "dramatic"
-    ];
-    for (const para of paragraphs) {
-      if (this.containsSignals(para.toLowerCase(), starSignals)) {
-        const moment = this.truncateToSentence(para, 120);
-        if (moment.length > 20) {
-          starMoments.push(moment);
-        }
-      }
-    }
-    const statPattern = /\d+[%xX]|\$[\d,]+(?:\s*(?:million|billion|trillion))?|\d+(?:\s*(?:million|billion|trillion))/g;
-    for (const para of paragraphs) {
-      if (statPattern.test(para) && starMoments.length < 5) {
-        const moment = this.truncateToSentence(para, 100);
-        if (!starMoments.includes(moment)) {
-          starMoments.push(moment);
-        }
-      }
-    }
-    return starMoments.slice(0, 5);
+  extractLabelFromContext(context) {
+    let cleaned = context.replace(/\|/g, " ").replace(/-{3,}/g, "").replace(/\s{2,}/g, " ").replace(/\*\*/g, "").replace(/#+\s*/g, "").trim();
+    const words = cleaned.split(/\s+/).filter((w) => w.length > 2 && !w.match(/^\d/));
+    return words.slice(0, 4).join(" ") || "Value";
   }
   /**
-   * Estimate slide count based on content.
+   * Check if text contains any of the signals
    */
-  estimateSlideCount(text, paragraphs) {
-    const wordCount = text.split(/\s+/).length;
-    const headerCount = (text.match(/\[HEADER\]/g) ?? []).length;
-    const bulletGroups = (text.match(/\[BULLET\]/g) ?? []).length / 4;
-    const wordBasedEstimate = Math.ceil(wordCount / 35);
-    const estimate = Math.max(
-      5,
-      // Minimum 5 slides
-      Math.ceil((wordBasedEstimate + headerCount + bulletGroups) / 2)
-    );
-    return Math.min(estimate, 30);
-  }
-  // === Helper Methods ===
   containsSignals(text, signals) {
-    const lowerText = text.toLowerCase();
-    return signals.some((signal) => lowerText.includes(signal));
-  }
-  extractRelevantSentence(paragraph, signals) {
-    const sentences = paragraph.split(/[.!?]+/);
-    for (const sentence of sentences) {
-      if (this.containsSignals(sentence.toLowerCase(), signals)) {
-        return sentence.trim();
-      }
-    }
-    return this.truncateToSentence(paragraph, 150);
+    return signals.some((signal) => text.includes(signal));
   }
-  truncateToSentence(text, maxLength) {
-    if (text.length <= maxLength) {
-      return text.trim();
-    }
-    const truncated = text.slice(0, maxLength);
-    const lastPeriod = truncated.lastIndexOf(".");
-    const lastQuestion = truncated.lastIndexOf("?");
-    const lastExclaim = truncated.lastIndexOf("!");
-    const lastBoundary = Math.max(lastPeriod, lastQuestion, lastExclaim);
-    if (lastBoundary > maxLength * 0.5) {
-      return text.slice(0, lastBoundary + 1).trim();
-    }
-    return truncated.trim() + "...";
-  }
-  truncateToWords(text, maxWords) {
-    const words = text.split(/\s+/);
-    if (words.length <= maxWords) {
-      return text;
+  /**
+   * Extract first meaningful sentence from text
+   */
+  extractFirstSentence(text) {
+    const cleaned = text.replace(/^#+\s*/gm, "").replace(/\*\*/g, "").replace(/\|/g, " ").trim();
+    const sentences = cleaned.split(/[.!?]+/);
+    const first = sentences[0]?.trim();
+    if (first && first.length > 10) {
+      return first.slice(0, 150);
     }
-    return words.slice(0, maxWords).join(" ");
-  }
-  capitalizeFirst(text) {
-    if (!text) return "";
-    return text.charAt(0).toUpperCase() + text.slice(1);
+    return cleaned.slice(0, 150);
   }
 };
 
 // src/core/SlideFactory.ts
 var SlideFactory = class {
   templates;
+  usedContent = /* @__PURE__ */ new Set();
   constructor() {
     this.templates = this.initializeTemplates();
   }
+  /**
+   * Check if content has already been used (deduplication)
+   */
+  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;
+    }
+    this.usedContent.add(normalized);
+    return false;
+  }
   /**
    * Create slides from analyzed content.
    */
   async createSlides(analysis, mode) {
     const slides = [];
     let slideIndex = 0;
+    this.usedContent.clear();
     slides.push(this.createTitleSlide(slideIndex++, analysis));
+    this.isContentUsed(analysis.titles[0] ?? "");
     if (mode === "business" && analysis.keyMessages.length >= 2) {
       slides.push(this.createAgendaSlide(slideIndex++, analysis));
     }
-    if (analysis.scqa.situation) {
+    if (analysis.scqa.situation && !this.isContentUsed(analysis.scqa.situation)) {
       slides.push(this.createContextSlide(slideIndex++, analysis, mode));
     }
-    if (analysis.scqa.complication) {
+    if (analysis.scqa.complication && !this.isContentUsed(analysis.scqa.complication)) {
       slides.push(this.createProblemSlide(slideIndex++, analysis, mode));
     }
     for (const message of analysis.keyMessages) {
-      slides.push(this.createMessageSlide(slideIndex++, message, mode));
+      if (!this.isContentUsed(message)) {
+        slides.push(this.createMessageSlide(slideIndex++, message, mode));
+      }
     }
     for (const starMoment of analysis.starMoments.slice(0, 2)) {
-      slides.push(this.createStarMomentSlide(slideIndex++, starMoment, mode));
+      if (!this.isContentUsed(starMoment)) {
+        slides.push(this.createStarMomentSlide(slideIndex++, starMoment, mode));
+      }
     }
-    if (analysis.scqa.answer) {
+    if (analysis.scqa.answer && !this.isContentUsed(analysis.scqa.answer)) {
       slides.push(this.createSolutionSlide(slideIndex++, analysis, mode));
     }
-    if (analysis.sparkline.callToAdventure) {
+    if (analysis.sparkline.callToAdventure && !this.isContentUsed(analysis.sparkline.callToAdventure)) {
       slides.push(this.createCTASlide(slideIndex++, analysis, mode));
     }
     slides.push(this.createThankYouSlide(slideIndex++));
@@ -518,13 +791,18 @@ var SlideFactory = class {
    * Create a title slide.
    */
   createTitleSlide(index, analysis) {
-    const subtitle = analysis.keyMessages[0] ?? analysis.scqa.answer ?? "";
+    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];
+    }
     return {
       index,
       type: "title",
       data: {
         title: analysis.titles[0] ?? "Presentation",
-        subtitle: this.truncate(subtitle, 60),
+        subtitle: this.truncate(subtitle, 80),
         keyMessage: analysis.scqa.answer
       },
       classes: ["slide-title"]
@@ -1755,19 +2033,28 @@ var ScoreCalculator = class {
 import { chromium } from "playwright";
 var QAEngine = class {
   browser = null;
+  kb;
+  /**
+   * Initialize KnowledgeGateway
+   */
+  async initialize() {
+    this.kb = await getKnowledgeGateway();
+  }
   /**
-   * Validate a presentation.
+   * Validate a presentation using KB-driven quality metrics
    */
   async validate(presentation, options) {
+    await this.initialize();
     const html = typeof presentation === "string" ? presentation : presentation.toString("utf-8");
     const mode = options?.mode ?? "keynote";
+    const qualityMetrics = this.kb.getQualityMetrics();
     await this.initBrowser();
     try {
       const [visualResults, contentResults, expertResults, accessibilityResults] = await Promise.all([
-        this.runVisualTests(html, mode),
-        this.runContentTests(html, mode),
+        this.runVisualTests(html, mode, qualityMetrics),
+        this.runContentTests(html, mode, qualityMetrics),
         this.runExpertTests(html, mode),
-        this.runAccessibilityTests(html)
+        this.runAccessibilityTests(html, qualityMetrics)
       ]);
       const issues = this.collectIssues(visualResults, contentResults, expertResults, accessibilityResults);
       const errorCount = issues.filter((i) => i.severity === "error").length;
@@ -1785,18 +2072,18 @@ var QAEngine = class {
     }
   }
   /**
-   * Calculate overall QA score.
+   * Calculate overall QA score using KB-driven weights
    */
   calculateScore(results) {
     const weights = {
       visual: 0.35,
-      // 35%
+      // 35% - Design quality
       content: 0.3,
-      // 30%
+      // 30% - Content quality
       expert: 0.25,
-      // 25%
+      // 25% - Expert methodology
       accessibility: 0.1
-      // 10%
+      // 10% - Accessibility
     };
     const visualScore = this.calculateVisualScore(results.visual);
     const contentScore = this.calculateContentScore(results.content);
@@ -1843,13 +2130,15 @@ var QAEngine = class {
     };
   }
   // ===========================================================================
-  // VISUAL TESTS
+  // VISUAL TESTS - KB-DRIVEN
   // ===========================================================================
-  async runVisualTests(html, mode) {
+  async runVisualTests(html, mode, qualityMetrics) {
     const page = await this.browser.newPage();
     await page.setViewportSize({ width: 1280, height: 720 });
     await page.setContent(html);
     await page.waitForTimeout(1e3);
+    const modeMetrics = mode === "keynote" ? qualityMetrics.keynote_mode : qualityMetrics.business_mode;
+    const minWhitespace = this.kb.getWhitespaceRequirement(mode) * 100;
     const slideCount = await page.evaluate(() => {
       return window.Reveal?.getTotalSlides?.() ?? document.querySelectorAll(".slides > section").length;
     });
@@ -1915,9 +2204,8 @@ var QAEngine = class {
       }, { slideIndex: i });
       if (slideAnalysis) {
         const issues = [];
-        const minWhitespace = mode === "keynote" ? 40 : 25;
         if (slideAnalysis.whitespace < minWhitespace) {
-          issues.push(`Whitespace ${slideAnalysis.whitespace}% below ${minWhitespace}% minimum`);
+          issues.push(`Whitespace ${slideAnalysis.whitespace}% below ${minWhitespace}% minimum (KB-defined)`);
         }
         if (slideAnalysis.whitespace > 80) {
           issues.push(`Whitespace ${slideAnalysis.whitespace}% - slide appears sparse`);
@@ -1972,34 +2260,35 @@ var QAEngine = class {
     };
   }
   // ===========================================================================
-  // CONTENT TESTS
+  // CONTENT TESTS - KB-DRIVEN
   // ===========================================================================
-  async runContentTests(html, mode) {
+  async runContentTests(html, mode, qualityMetrics) {
     const page = await this.browser.newPage();
     await page.setContent(html);
     await page.waitForTimeout(500);
-    const results = await page.evaluate((targetMode) => {
+    const wordLimits = this.kb.getWordLimits(mode);
+    const glanceTest = this.kb.getDuarteGlanceTest();
+    const results = await page.evaluate((params) => {
+      const { targetMode, maxWords, minWords, glanceWordLimit } = params;
       const slides = document.querySelectorAll(".slides > section");
       const perSlide = [];
-      const glanceTest = [];
+      const glanceTestResults = [];
       const signalNoise = [];
       const oneIdea = [];
       slides.forEach((slide, index) => {
         const text = slide.innerText || "";
         const words = text.split(/\s+/).filter((w) => w.length > 0);
         const wordCount = words.length;
-        const maxWords = targetMode === "keynote" ? 25 : 80;
-        const minWords = targetMode === "business" ? 20 : 0;
         const withinLimit = wordCount <= maxWords && wordCount >= minWords;
         const title = slide.querySelector("h2")?.textContent || "";
         const hasVerb = /\b(is|are|was|were|has|have|had|will|can|could|should|would|may|might|must|exceeded|increased|decreased|grew|fell|drove|caused|enabled|prevented|achieved|failed|creates?|generates?|delivers?|provides?|shows?|demonstrates?)\b/i.test(title);
         const hasInsight = title.length > 30 && hasVerb;
         const issues = [];
         if (!withinLimit) {
-          issues.push(`Word count ${wordCount} outside ${minWords}-${maxWords} range`);
+          issues.push(`Word count ${wordCount} outside ${minWords}-${maxWords} range (KB-defined)`);
         }
         if (targetMode === "business" && !hasInsight && index > 0) {
-          issues.push("Title is not action-oriented (missing insight)");
+          issues.push("Title is not action-oriented (missing insight per Minto)");
         }
         perSlide.push({
           slideIndex: index,
@@ -2012,12 +2301,12 @@ var QAEngine = class {
         const keyMessage = prominentElement?.textContent?.trim() || "";
         const keyWordCount = keyMessage.split(/\s+/).filter((w) => w.length > 0).length;
         const readingTime = keyWordCount / 4.2;
-        glanceTest.push({
+        glanceTestResults.push({
           slideIndex: index,
           keyMessage,
           wordCount: keyWordCount,
           readingTime: Math.round(readingTime * 10) / 10,
-          passed: readingTime <= 3 && keyWordCount <= 15,
+          passed: readingTime <= 3 && keyWordCount <= glanceWordLimit,
           recommendation: readingTime > 3 ? `Shorten to ${Math.floor(3 * 4.2)} words or less` : void 0
         });
         const elements = slide.querySelectorAll("h1, h2, h3, p, li, img");
@@ -2044,35 +2333,143 @@ var QAEngine = class {
           conflictingIdeas: ideaCount > 2 ? ["Multiple competing ideas detected"] : void 0
         });
       });
-      return { perSlide, glanceTest, signalNoise, oneIdea };
-    }, mode);
+      return { perSlide, glanceTest: glanceTestResults, signalNoise, oneIdea };
+    }, {
+      targetMode: mode,
+      maxWords: wordLimits.max,
+      minWords: mode === "business" ? 20 : 0,
+      glanceWordLimit: glanceTest.wordLimit
+    });
     await page.close();
     return results;
   }
   // ===========================================================================
-  // EXPERT TESTS
+  // EXPERT TESTS - KB-DRIVEN
   // ===========================================================================
   async runExpertTests(html, mode) {
+    const duartePrinciples = this.kb.getExpertPrinciples("nancy_duarte");
+    const reynoldsPrinciples = this.kb.getExpertPrinciples("garr_reynolds");
+    const galloPrinciples = this.kb.getExpertPrinciples("carmine_gallo");
+    const andersonPrinciples = this.kb.getExpertPrinciples("chris_anderson");
     return {
-      duarte: this.createExpertResult("Nancy Duarte", ["Glance Test", "STAR Moment", "Sparkline"], 85),
-      reynolds: this.createExpertResult("Garr Reynolds", ["Signal-to-Noise", "Simplicity", "Picture Superiority"], 80),
-      gallo: this.createExpertResult("Carmine Gallo", ["Rule of Three", "Emotional Connection"], 85),
-      anderson: this.createExpertResult("Chris Anderson", ["One Idea", "Clarity"], 90)
+      duarte: this.validateDuartePrinciples(html, duartePrinciples),
+      reynolds: this.validateReynoldsPrinciples(html, reynoldsPrinciples),
+      gallo: this.validateGalloPrinciples(html, galloPrinciples),
+      anderson: this.validateAndersonPrinciples(html, andersonPrinciples)
     };
   }
-  createExpertResult(name, principles, score) {
+  validateDuartePrinciples(html, principles) {
+    const violations = [];
+    let score = 100;
+    const slideMatches = html.match(/<section[^>]*>[\s\S]*?<\/section>/gi) || [];
+    slideMatches.forEach((slide, index) => {
+      const h1Match = slide.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+      const h2Match = slide.match(/<h2[^>]*>([\s\S]*?)<\/h2>/i);
+      const keyMessage = (h1Match?.[1] || h2Match?.[1] || "").replace(/<[^>]+>/g, "").trim();
+      const wordCount = keyMessage.split(/\s+/).filter((w) => w.length > 0).length;
+      if (wordCount > 25) {
+        violations.push(`Slide ${index + 1}: Key message exceeds 25 words (Duarte Glance Test)`);
+        score -= 5;
+      }
+    });
+    const hasStarMoment = html.includes("callout") || html.includes("highlight") || html.includes("big-idea");
+    if (!hasStarMoment && slideMatches.length > 5) {
+      violations.push("Missing STAR moment (Something They'll Always Remember)");
+      score -= 10;
+    }
     return {
-      expertName: name,
-      principlesChecked: principles,
+      expertName: "Nancy Duarte",
+      principlesChecked: ["Glance Test", "STAR Moment", "Sparkline Structure"],
       passed: score >= 80,
-      score,
-      violations: score < 80 ? [`${name} principles not fully met`] : []
+      score: Math.max(0, score),
+      violations
+    };
+  }
+  validateReynoldsPrinciples(html, principles) {
+    const violations = [];
+    let score = 100;
+    const decorativeElements = (html.match(/class="[^"]*decorative[^"]*"/gi) || []).length;
+    const randomImages = (html.match(/picsum\.photos/gi) || []).length;
+    if (randomImages > 0) {
+      violations.push(`Found ${randomImages} random stock images (Reynolds: only use purposeful images)`);
+      score -= randomImages * 10;
+    }
+    if (decorativeElements > 3) {
+      violations.push(`Too many decorative elements (${decorativeElements}) - reduces signal-to-noise ratio`);
+      score -= 10;
+    }
+    const columnLayouts = (html.match(/class="[^"]*columns[^"]*"/gi) || []).length;
+    const slideCount = (html.match(/<section/gi) || []).length;
+    if (columnLayouts > slideCount * 0.5) {
+      violations.push("Overuse of column layouts - simplify per Reynolds");
+      score -= 10;
+    }
+    return {
+      expertName: "Garr Reynolds",
+      principlesChecked: ["Signal-to-Noise", "Simplicity", "Picture Superiority"],
+      passed: score >= 80,
+      score: Math.max(0, score),
+      violations
+    };
+  }
+  validateGalloPrinciples(html, principles) {
+    const violations = [];
+    let score = 100;
+    const bulletLists = html.match(/<ul[^>]*>[\s\S]*?<\/ul>/gi) || [];
+    bulletLists.forEach((list, index) => {
+      const bullets = (list.match(/<li/gi) || []).length;
+      if (bullets > 5) {
+        violations.push(`Bullet list ${index + 1} has ${bullets} items (Gallo: max 3-5)`);
+        score -= 5;
+      }
+    });
+    const hasQuote = html.includes("blockquote") || html.includes("quote");
+    const hasStory = html.toLowerCase().includes("story") || html.toLowerCase().includes("journey");
+    if (!hasQuote && !hasStory) {
+      violations.push("Missing emotional connection elements (quotes, stories)");
+      score -= 10;
+    }
+    return {
+      expertName: "Carmine Gallo",
+      principlesChecked: ["Rule of Three", "Emotional Connection", "Headline Power"],
+      passed: score >= 80,
+      score: Math.max(0, score),
+      violations
+    };
+  }
+  validateAndersonPrinciples(html, principles) {
+    const violations = [];
+    let score = 100;
+    const slideMatches = html.match(/<section[^>]*>[\s\S]*?<\/section>/gi) || [];
+    slideMatches.forEach((slide, index) => {
+      const headings = (slide.match(/<h[12][^>]*>/gi) || []).length;
+      if (headings > 2) {
+        violations.push(`Slide ${index + 1}: Multiple ideas detected (Anderson: one idea per slide)`);
+        score -= 5;
+      }
+    });
+    const jargonPatterns = ["synergy", "leverage", "paradigm", "holistic", "streamline"];
+    let jargonCount = 0;
+    jargonPatterns.forEach((pattern) => {
+      const matches = html.toLowerCase().match(new RegExp(pattern, "gi")) || [];
+      jargonCount += matches.length;
+    });
+    if (jargonCount > 5) {
+      violations.push(`Excessive jargon detected (${jargonCount} instances) - simplify language`);
+      score -= 10;
+    }
+    return {
+      expertName: "Chris Anderson",
+      principlesChecked: ["One Idea", "Clarity", "Throughline"],
+      passed: score >= 80,
+      score: Math.max(0, score),
+      violations
     };
   }
   // ===========================================================================
-  // ACCESSIBILITY TESTS
+  // ACCESSIBILITY TESTS - KB-DRIVEN
   // ===========================================================================
-  async runAccessibilityTests(html) {
+  async runAccessibilityTests(html, qualityMetrics) {
     const page = await this.browser.newPage();
     await page.setContent(html);
     await page.waitForTimeout(500);
@@ -2122,7 +2519,7 @@ var QAEngine = class {
     };
   }
   // ===========================================================================
-  // SCORING
+  // SCORING - KB-DRIVEN
   // ===========================================================================
   calculateVisualScore(results) {
     let score = 100;
@@ -2246,6 +2643,7 @@ var QAEngine = class {
 // src/generators/html/RevealJsGenerator.ts
 var RevealJsGenerator = class {
   templateEngine;
+  kb;
   defaultRevealConfig = {
     revealVersion: "5.0.4",
     hash: true,
@@ -2264,20 +2662,32 @@ var RevealJsGenerator = class {
   constructor() {
     this.templateEngine = new TemplateEngine();
   }
+  /**
+   * Initialize KnowledgeGateway
+   */
+  async initialize() {
+    this.kb = await getKnowledgeGateway();
+  }
   /**
    * Generate complete Reveal.js HTML presentation.
    */
   async generate(slides, config) {
+    await this.initialize();
     const templateConfig = {};
     if (config.theme) templateConfig.theme = config.theme;
     if (config.customTemplates) templateConfig.customTemplates = config.customTemplates;
     const slideHtml = this.templateEngine.renderAll(slides, templateConfig);
+    const presentationType = this.detectPresentationType(config);
+    const palette = this.kb.getRecommendedPalette(presentationType);
+    const typography = this.kb.getTypography(config.mode);
     const docConfig = {
       title: config.title,
       slides: slideHtml.join("\n"),
       theme: config.theme ?? "default",
       revealConfig: this.defaultRevealConfig,
-      mode: config.mode
+      mode: config.mode,
+      palette,
+      typography
     };
     if (config.author) docConfig.author = config.author;
     if (config.subject) docConfig.subject = config.subject;
@@ -2288,11 +2698,23 @@ var RevealJsGenerator = class {
     }
     return html;
   }
+  /**
+   * Detect presentation type from config
+   */
+  detectPresentationType(config) {
+    if (config.presentationType) {
+      return config.presentationType;
+    }
+    if (config.mode === "keynote") {
+      return "ted_keynote";
+    }
+    return "consulting_deck";
+  }
   /**
    * Build the complete HTML document.
    */
   buildDocument(options) {
-    const { title, author, subject, slides, theme, customCSS, revealConfig, mode } = options;
+    const { title, author, subject, slides, theme, customCSS, revealConfig, mode, palette, typography } = options;
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -2300,7 +2722,7 @@ var RevealJsGenerator = class {
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <meta name="author" content="${this.escapeHtml(author ?? "Claude Presentation Master")}">
   <meta name="description" content="${this.escapeHtml(subject ?? "")}">
-  <meta name="generator" content="Claude Presentation Master v1.0.0">
+  <meta name="generator" content="Claude Presentation Master v6.0.0">
   <title>${this.escapeHtml(title)}</title>
 
   <!-- Reveal.js CSS -->
@@ -2314,10 +2736,10 @@ var RevealJsGenerator = class {
   <!-- Mermaid for diagrams -->
   <script src="https://cdn.jsdelivr.net/npm/mermaid@10.6.1/dist/mermaid.min.js"></script>
 
-  <!-- Presentation Engine CSS -->
+  <!-- Presentation Engine CSS - KB-Driven Design System -->
   <style>
-${this.getBaseStyles(mode)}
-${this.getThemeStyles(theme)}
+${this.getBaseStyles(mode, palette, typography)}
+${this.getThemeStyles(theme, palette)}
 ${this.getAnimationStyles()}
 ${customCSS ?? ""}
   </style>
@@ -2369,26 +2791,35 @@ ${slides}
 </html>`;
   }
   /**
-   * Get base styles for slides.
+   * Get base styles for slides - KB-DRIVEN
    */
-  getBaseStyles(mode) {
+  getBaseStyles(mode, palette, typography) {
     const fontSize = mode === "keynote" ? "2.5em" : "1.8em";
     const lineHeight = mode === "keynote" ? "1.4" : "1.5";
+    const primary = palette.primary || "#1a1a2e";
+    const secondary = palette.secondary || "#16213e";
+    const accent = palette.accent || "#0f3460";
+    const highlight = palette.accent || "#e94560";
+    const text = palette.text || "#1a1a2e";
+    const background = palette.background || "#ffffff";
     return `
-    /* Base Styles */
+    /* Base Styles - KB-Driven Design System */
     :root {
+      /* Typography from KB */
       --font-heading: 'Source Sans Pro', 'Helvetica Neue', -apple-system, BlinkMacSystemFont, sans-serif;
       --font-body: 'Source Sans Pro', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
       --font-mono: 'SF Mono', 'Fira Code', 'JetBrains Mono', monospace;
 
-      --color-primary: #1a1a2e;
-      --color-secondary: #16213e;
-      --color-accent: #0f3460;
-      --color-highlight: #e94560;
-      --color-text: #1a1a2e;
-      --color-text-light: #4a4a68;
-      --color-background: #ffffff;
+      /* Colors from KB Palette: ${palette.name} */
+      --color-primary: ${primary};
+      --color-secondary: ${secondary};
+      --color-accent: ${accent};
+      --color-highlight: ${highlight};
+      --color-text: ${text};
+      --color-text-light: ${this.lightenColor(text, 30)};
+      --color-background: ${background};
 
+      /* Layout */
       --slide-padding: 60px;
       --content-max-width: 1200px;
     }
@@ -2504,7 +2935,7 @@ ${slides}
       font-size: 0.8em;
     }
 
-    /* Images */
+    /* Images - NO RANDOM PICSUM - Only user-provided or none */
     .reveal img {
       max-width: 100%;
       height: auto;
@@ -2610,9 +3041,25 @@ ${slides}
     `;
   }
   /**
-   * Get theme-specific styles.
+   * Lighten a hex color
+   */
+  lightenColor(hex, percent) {
+    hex = hex.replace("#", "");
+    let r = parseInt(hex.substring(0, 2), 16);
+    let g = parseInt(hex.substring(2, 4), 16);
+    let b = parseInt(hex.substring(4, 6), 16);
+    r = Math.min(255, Math.floor(r + (255 - r) * (percent / 100)));
+    g = Math.min(255, Math.floor(g + (255 - g) * (percent / 100)));
+    b = Math.min(255, Math.floor(b + (255 - b) * (percent / 100)));
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  /**
+   * Get theme-specific styles - KB-DRIVEN
    */
-  getThemeStyles(theme) {
+  getThemeStyles(theme, palette) {
+    if (theme === "default") {
+      return "";
+    }
     const themes = {
       "default": "",
       "light-corporate": `
@@ -2626,10 +3073,10 @@ ${slides}
       `,
       "modern-tech": `
         :root {
-          --color-primary: #1a1a2e;
-          --color-secondary: #16213e;
-          --color-accent: #0f3460;
-          --color-highlight: #e94560;
+          --color-primary: ${palette.primary || "#1a1a2e"};
+          --color-secondary: ${palette.secondary || "#16213e"};
+          --color-accent: ${palette.accent || "#0f3460"};
+          --color-highlight: ${palette.accent || "#e94560"};
           --color-background: #f8f9fa;
         }
       `,
@@ -3875,239 +4322,6 @@ function createDefaultImageProvider(options) {
   return new CompositeImageProvider(providers);
 }
 
-// src/knowledge/KnowledgeBase.ts
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import * as yaml from "yaml";
-function getModuleDir() {
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    return dirname(fileURLToPath(import.meta.url));
-  }
-  if (typeof __dirname !== "undefined") {
-    return __dirname;
-  }
-  return process.cwd();
-}
-var moduleDir = getModuleDir();
-var KnowledgeBase = class {
-  data = null;
-  loaded = false;
-  /**
-   * Load the knowledge base from the bundled YAML file.
-   */
-  async load() {
-    if (this.loaded) return;
-    try {
-      const possiblePaths = [
-        // From dist/: go up to package root
-        join(moduleDir, "../../assets/presentation-knowledge.yaml"),
-        join(moduleDir, "../assets/presentation-knowledge.yaml"),
-        join(moduleDir, "../../../assets/presentation-knowledge.yaml"),
-        // From bundle in dist/index.js: go up one level
-        join(moduleDir, "assets/presentation-knowledge.yaml"),
-        // CWD-based paths for development or local installs
-        join(process.cwd(), "assets/presentation-knowledge.yaml"),
-        join(process.cwd(), "node_modules/claude-presentation-master/assets/presentation-knowledge.yaml")
-      ];
-      let assetPath = "";
-      for (const p of possiblePaths) {
-        try {
-          readFileSync(p);
-          assetPath = p;
-          break;
-        } catch {
-          continue;
-        }
-      }
-      if (!assetPath) {
-        throw new Error("Could not locate knowledge base file");
-      }
-      const content = readFileSync(assetPath, "utf-8");
-      this.data = yaml.parse(content);
-      this.loaded = true;
-      console.log(`\u{1F4DA} Knowledge base loaded: v${this.data.version}`);
-    } catch (error) {
-      console.warn("\u26A0\uFE0F  Could not load knowledge base, using defaults");
-      this.data = this.getDefaultData();
-      this.loaded = true;
-    }
-  }
-  /**
-   * Get expert methodology by name.
-   */
-  getExpert(name) {
-    this.ensureLoaded();
-    return this.data?.experts?.[name];
-  }
-  /**
-   * Get all expert names.
-   */
-  getExpertNames() {
-    this.ensureLoaded();
-    return Object.keys(this.data?.experts ?? {});
-  }
-  /**
-   * Get framework recommendation for audience.
-   */
-  getFrameworkForAudience(audience) {
-    this.ensureLoaded();
-    return this.data?.frameworkSelector?.byAudience?.[audience];
-  }
-  /**
-   * Get framework recommendation for goal.
-   */
-  getFrameworkForGoal(goal) {
-    this.ensureLoaded();
-    return this.data?.frameworkSelector?.byGoal?.[goal];
-  }
-  /**
-   * Get QA scoring rubric.
-   */
-  getScoringRubric() {
-    this.ensureLoaded();
-    return this.data?.automatedQA?.scoringRubric;
-  }
-  /**
-   * Get mode configuration (keynote or business).
-   */
-  getModeConfig(mode) {
-    this.ensureLoaded();
-    return this.data?.modes?.[mode];
-  }
-  /**
-   * Get slide type configuration.
-   */
-  getSlideType(type) {
-    this.ensureLoaded();
-    return this.data?.slideTypes?.[type];
-  }
-  /**
-   * Get the knowledge base version.
-   */
-  getVersion() {
-    this.ensureLoaded();
-    return this.data?.version ?? "unknown";
-  }
-  /**
-   * Validate a slide against expert principles.
-   */
-  validateAgainstExpert(expertName, slideData) {
-    const expert = this.getExpert(expertName);
-    if (!expert) {
-      return { passed: true, violations: [] };
-    }
-    const violations = [];
-    if (expert.wordLimits) {
-      if (expert.wordLimits.max && slideData.wordCount > expert.wordLimits.max) {
-        violations.push(`Exceeds ${expertName} word limit of ${expert.wordLimits.max}`);
-      }
-      if (expert.wordLimits.min && slideData.wordCount < expert.wordLimits.min) {
-        violations.push(`Below ${expertName} minimum of ${expert.wordLimits.min} words`);
-      }
-    }
-    return {
-      passed: violations.length === 0,
-      violations
-    };
-  }
-  /**
-   * Ensure knowledge base is loaded.
-   */
-  ensureLoaded() {
-    if (!this.loaded) {
-      this.data = this.getDefaultData();
-      this.loaded = true;
-    }
-  }
-  /**
-   * Get default data if YAML can't be loaded.
-   */
-  getDefaultData() {
-    return {
-      version: "1.0.0-fallback",
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      experts: {
-        "Nancy Duarte": {
-          name: "Nancy Duarte",
-          principles: [
-            { name: "Glance Test", description: "Message clear in 3 seconds" },
-            { name: "STAR Moment", description: "Something They'll Always Remember" },
-            { name: "Sparkline", description: "Contrast What Is vs What Could Be" }
-          ]
-        },
-        "Garr Reynolds": {
-          name: "Garr Reynolds",
-          principles: [
-            { name: "Signal-to-Noise", description: "Maximize signal, minimize noise" },
-            { name: "Simplicity", description: "Amplify through simplification" }
-          ]
-        },
-        "Carmine Gallo": {
-          name: "Carmine Gallo",
-          principles: [
-            { name: "Rule of Three", description: "Maximum 3 key messages" },
-            { name: "Emotional Connection", description: "Connect emotionally first" }
-          ]
-        },
-        "Chris Anderson": {
-          name: "Chris Anderson",
-          principles: [
-            { name: "One Idea", description: "One powerful idea per talk" },
-            { name: "Dead Laptop Test", description: "Present without slides" }
-          ]
-        }
-      },
-      frameworkSelector: {
-        byAudience: {
-          "board": {
-            primaryFramework: "Barbara Minto",
-            slideTypes: ["executive_summary", "data_insight"]
-          },
-          "sales": {
-            primaryFramework: "Nancy Duarte",
-            slideTypes: ["big_idea", "social_proof"]
-          }
-        },
-        byGoal: {
-          "persuade": {
-            primaryFramework: "Nancy Duarte",
-            slideTypes: ["big_idea", "star_moment"]
-          },
-          "inform": {
-            primaryFramework: "Barbara Minto",
-            slideTypes: ["bullet_points", "data_insight"]
-          }
-        }
-      },
-      automatedQA: {
-        scoringRubric: {
-          totalPoints: 100,
-          passingThreshold: 95,
-          categories: {
-            visual: { weight: 35, checks: {} },
-            content: { weight: 30, checks: {} },
-            expert: { weight: 25, checks: {} },
-            accessibility: { weight: 10, checks: {} }
-          }
-        }
-      },
-      slideTypes: {},
-      modes: {
-        keynote: { maxWords: 25, minWhitespace: 35 },
-        business: { maxWords: 80, minWhitespace: 25 }
-      }
-    };
-  }
-};
-var knowledgeBaseInstance = null;
-function getKnowledgeBase() {
-  if (!knowledgeBaseInstance) {
-    knowledgeBaseInstance = new KnowledgeBase();
-  }
-  return knowledgeBaseInstance;
-}
-
 // src/index.ts
 async function generate(config) {
   const engine = new PresentationEngine();
@@ -4122,7 +4336,7 @@ async function validate(presentation, options) {
     score
   };
 }
-var VERSION = "1.0.0";
+var VERSION = "6.0.0";
 var index_default = {
   generate,
   validate,
@@ -4135,7 +4349,7 @@ export {
   CompositeChartProvider,
   CompositeImageProvider,
   ContentAnalyzer,
-  KnowledgeBase,
+  KnowledgeGateway,
   LocalImageProvider,
   MermaidProvider,
   PlaceholderImageProvider,
@@ -4156,7 +4370,7 @@ export {
   createDefaultImageProvider,
   index_default as default,
   generate,
-  getKnowledgeBase,
+  getKnowledgeGateway,
   validate
 };
 /**