claude-presentation-master 2.1.1 → 3.0.1

package/dist/index.d.ts

@@ -148,11 +148,55 @@ interface QAResults {
     expert: ExpertQAResults;
     /** Accessibility compliance */
     accessibility: AccessibilityResults;
+    /** Semantic completeness (optional - requires source content) */
+    semanticCompleteness?: SemanticCompletenessResult$1;
+    /** Vision QA results (optional - requires Claude API key) */
+    visionQA?: VisionQAResults;
     /** Overall pass/fail */
     passed: boolean;
     /** List of issues found */
     issues: QAIssue[];
 }
+interface VisionQAResults {
+    /** Per-slide AI visual analysis */
+    slideAnalyses: VisionSlideAnalysis[];
+    /** Presentation-level assessment */
+    presentationLevel: {
+        visual_consistency: number;
+        story_arc: number;
+        memorable_moments: number;
+        professional_quality: number;
+    };
+    /** Overall score (1-10 scale) */
+    overallScore: number;
+    /** Slides that need improvement */
+    weakSlides: number[];
+    /** Slides that are excellent */
+    strongSlides: number[];
+    /** Critical issues detected */
+    criticalIssues: string[];
+    /** Pass/fail */
+    pass: boolean;
+    /** One-sentence verdict */
+    verdict: string;
+}
+interface VisionSlideAnalysis {
+    slideIndex: number;
+    scores: {
+        typography_hierarchy: number;
+        layout_balance: number;
+        color_harmony: number;
+        professional_polish: number;
+        message_clarity: number;
+        content_density: number;
+        visual_support: number;
+        narrative_flow: number;
+    };
+    overallScore: number;
+    criticalIssues: string[];
+    suggestions: string[];
+    pass: boolean;
+}
 interface VisualQAResults {
     /** Whitespace percentage (target: 35%+ keynote, 25%+ business) */
     whitespacePercentage: number;
@@ -264,7 +308,7 @@ interface QAIssue {
     /** Issue severity */
     severity: 'error' | 'warning' | 'info';
     /** Issue category */
-    category: 'visual' | 'content' | 'expert' | 'accessibility';
+    category: 'visual' | 'content' | 'expert' | 'accessibility' | 'semantic_completeness';
     /** Slide index (if applicable) */
     slideIndex?: number;
     /** Issue description */
@@ -272,6 +316,34 @@ interface QAIssue {
     /** Suggested fix */
     suggestion?: string;
 }
+interface SemanticCompletenessResult$1 {
+    /** Coverage score (0-100) - percentage of source concepts found in output */
+    coverageScore: number;
+    /** Key concepts extracted from source content */
+    sourceConcepts: ExtractedConcept$1[];
+    /** Concepts that were found in the generated slides */
+    foundConcepts: ExtractedConcept$1[];
+    /** Concepts that were NOT found - potential content loss */
+    missingConcepts: ExtractedConcept$1[];
+    /** Whether semantic completeness passed (score >= threshold) */
+    passed: boolean;
+    /** Detailed issues */
+    issues: QAIssue[];
+}
+interface ExtractedConcept$1 {
+    /** The concept text (normalized) */
+    text: string;
+    /** Importance weight (1-10) based on context */
+    importance: number;
+    /** Category: heading, metric, key_term, entity, action */
+    category: 'heading' | 'metric' | 'key_term' | 'entity' | 'action';
+    /** Original text before normalization */
+    original: string;
+    /** Was it found in the output? */
+    found?: boolean;
+    /** Where it was found (slide indices) */
+    foundIn?: number[];
+}
 interface PresentationResult {
     /** Generated outputs */
     outputs: {
@@ -318,6 +390,60 @@ interface ContentAnalysis {
     starMoments: string[];
     /** Estimated slide count */
     estimatedSlideCount: number;
+    /** Extracted data points (metrics, percentages, financial data) */
+    dataPoints: ExtractedDataPoint[];
+    /** Extracted bullet content by section */
+    sectionContent: ExtractedSection[];
+    /** Financial metrics summary */
+    financialSummary?: FinancialSummary | undefined;
+    /** Comparison data (e.g., Year 1 vs Year 2) */
+    comparisons?: ComparisonData[] | undefined;
+}
+/** Represents an extracted data point with context */
+interface ExtractedDataPoint {
+    value: string;
+    numericValue?: number;
+    type: 'currency' | 'percentage' | 'number' | 'ratio' | 'time';
+    context: string;
+    label?: string;
+    trend?: 'positive' | 'negative' | 'neutral';
+}
+/** Represents content from a section header */
+interface ExtractedSection {
+    header: string;
+    level: number;
+    content: string;
+    bullets: string[];
+    metrics: ExtractedDataPoint[];
+    /** Parsed table data if section contains a table */
+    tables?: ParsedTable[];
+}
+/** Represents a parsed markdown table */
+interface ParsedTable {
+    headers: string[];
+    rows: string[][];
+    caption?: string;
+}
+/** Financial summary for investment-type presentations */
+interface FinancialSummary {
+    totalInvestment?: string;
+    npv?: string;
+    irr?: string;
+    paybackPeriod?: string;
+    roi?: string;
+    annualSavings?: string[];
+    revenueImpact?: string;
+}
+/** Comparison data for before/after or year-over-year analysis */
+interface ComparisonData {
+    label: string;
+    before?: string;
+    after?: string;
+    change?: string;
+    periods?: Array<{
+        period: string;
+        value: string;
+    }>;
 }
 interface SCQAStructure {
     situation: string;
@@ -427,16 +553,19 @@ declare class ScoreCalculator {
  * - Visual quality using Playwright screenshots + Canvas API
  * - Layout balance and whitespace distribution
  * - WCAG contrast compliance
- * - Expert methodology adherence
+ * - Expert methodology adherence (Duarte, Reynolds, Gallo, Anderson)
+ * - Presentation effectiveness, completeness, and visual appeal
  */
 
 declare class QAEngine {
     private browser;
+    private typeDetector;
     /**
      * Validate a presentation.
      */
     validate(presentation: string | Buffer, options?: {
         mode?: 'keynote' | 'business';
+        presentationType?: PresentationType;
         strictMode?: boolean;
         threshold?: number;
     }): Promise<QAResults>;
@@ -451,7 +580,38 @@ declare class QAEngine {
     private runVisualTests;
     private runContentTests;
     private runExpertTests;
-    private createExpertResult;
+    /**
+     * Validate Nancy Duarte's principles from Slide:ology and Resonate
+     * - Glance Test: 3 seconds to understand main point
+     * - STAR Moments: Something They'll Always Remember
+     * - Sparkline: Contrast between What Is and What Could Be
+     */
+    private validateDuartePrinciples;
+    /**
+     * Validate Garr Reynolds' principles from Presentation Zen
+     * - Signal-to-Noise: Remove everything non-essential
+     * - Simplicity: Amplification through simplification
+     * - Picture Superiority: Visuals over text
+     */
+    private validateReynoldsPrinciples;
+    /**
+     * Validate Carmine Gallo's principles from Talk Like TED
+     * - Rule of Three: Max 3 key points
+     * - Emotional Connection: 65% stories/emotion
+     * - Jaw-Dropping Moment: One unforgettable element
+     */
+    private validateGalloPrinciples;
+    /**
+     * Validate Chris Anderson's principles from TED Talks official guide
+     * - One Idea: Single throughline per presentation
+     * - Clarity: No jargon, simple explanations
+     * - 3-5 Concepts: Limit complexity
+     */
+    private validateAndersonPrinciples;
+    /**
+     * Calculate variance in an array of numbers
+     */
+    private calculateVariance;
     private runAccessibilityTests;
     private calculateVisualScore;
     private calculateContentScore;
@@ -518,12 +678,14 @@ interface ValidationSummary {
     };
 }
 declare class PPTXValidator {
+    private typeDetector;
     /**
      * Validate a set of slides before PPTX generation.
      * This validation is MANDATORY - export will fail if score < threshold.
      */
     validate(slides: Slide[], options: {
         mode: 'keynote' | 'business';
+        presentationType?: PresentationType | undefined;
         threshold?: number;
         strictMode?: boolean;
     }): Promise<PPTXValidationResult>;
@@ -548,7 +710,18 @@ declare class PPTXValidator {
      */
     private hasContent;
     /**
-     * Count distinct ideas in a slide.
+     * Count distinct ideas on a slide.
+     *
+     * A slide with ONE idea can still have:
+     * - A title (the main idea)
+     * - A keyMessage (reinforcing the same idea)
+     * - Multiple bullets (supporting evidence for the same idea)
+     * - Body text (elaborating on the same idea)
+     *
+     * Multiple ideas are detected when:
+     * - There's a quote AND substantial other content (quote should stand alone)
+     * - The slide has both body AND many bullets (competing content blocks)
+     * - Title introduces one concept but bullets introduce unrelated concepts
      */
     private countIdeas;
     /**
@@ -566,7 +739,7 @@ declare class PPTXValidator {
     /**
      * Convert PPTX validation result to standard QAResults format.
      */
-    toQAResults(result: PPTXValidationResult, mode: 'keynote' | 'business'): QAResults;
+    toQAResults(result: PPTXValidationResult, mode: 'keynote' | 'business', presentationType?: PresentationType): QAResults;
     private createExpertValidation;
     /**
      * Generate human-readable validation report.
@@ -601,11 +774,13 @@ interface RemediationChange {
 type RemediationType = 'word_reduction' | 'slide_split' | 'title_shortening' | 'bullet_consolidation' | 'layout_adjustment' | 'structure_addition' | 'font_size_increase' | 'content_enhancement' | 'whitespace_improvement';
 declare class AutoRemediation {
     private changes;
+    private typeDetector;
     /**
      * Automatically remediate slides until they pass QA.
      */
     remediate(slides: Slide[], issues: QAIssue[] | PPTXIssue[], options: {
         mode: 'keynote' | 'business';
+        presentationType?: PresentationType | undefined;
         targetScore: number;
     }): Promise<Slide[]>;
     /**
@@ -613,7 +788,7 @@ declare class AutoRemediation {
      */
     getChanges(): RemediationChange[];
     /**
-     * Remediate word count issues - the most common problem.
+     * Remediate word count issues - both too many AND too few words.
      */
     private remediateWordCount;
     /**
@@ -624,6 +799,11 @@ declare class AutoRemediation {
      * Remediate bullet point issues.
      */
     private remediateBullets;
+    /**
+     * Remediate multiple-ideas-per-slide violations.
+     * Strategy: Consolidate content to focus on one main idea.
+     */
+    private remediateMultipleIdeas;
     /**
      * Remediate structural issues - missing title slide, conclusion, etc.
      */
@@ -632,12 +812,18 @@ declare class AutoRemediation {
      * Remediate accessibility issues.
      */
     private remediateAccessibility;
+    /**
+     * Enhance a sparse slide by adding substantive content.
+     * Instead of generic filler, we expand existing content intelligently.
+     */
+    private enhanceSparseSlide;
     /**
      * Group issues by their primary type.
      */
     private groupIssuesByType;
     /**
      * Shorten text to approximately N words while preserving meaning.
+     * CRITICAL: Never truncate mid-sentence - always return complete, meaningful phrases.
      */
     private shortenText;
     /**
@@ -710,6 +896,7 @@ declare class HallucinationDetector {
     private datePattern;
     private companyPattern;
     private quotePattern;
+    private commonWords;
     /**
      * Check all slides against source content for hallucinations.
      */
@@ -738,17 +925,27 @@ declare class HallucinationDetector {
 /**
  * Presentation Engine - Main Orchestrator
  *
- * Coordinates content analysis, slide generation, and QA validation
- * to produce world-class presentations.
+ * KNOWLEDGE-DRIVEN ARCHITECTURE
+ *
+ * This engine now routes ALL decisions through the KnowledgeOrchestrator.
+ * The RuVector knowledge base IS the application brain.
+ * This code is just plumbing that executes what the KB dictates.
  *
  * PHILOSOPHY: NEVER FAIL - ALWAYS DELIVER
  *
  * Instead of blocking on QA failures, this engine:
- * 1. Validates the presentation
- * 2. If issues found, automatically remediates them
- * 3. Re-validates
- * 4. Repeats until it passes (max 5 iterations)
- * 5. ALWAYS delivers a working presentation
+ * 1. Analyzes content using KB-driven narrative frameworks
+ * 2. Builds slides using KB-driven expert methodologies
+ * 3. Validates against 40+ expert principles from the KB
+ * 4. Applies persuasion psychology from the KB
+ * 5. Auto-remediates based on KB rules
+ * 6. ALWAYS delivers a working, world-class presentation
+ *
+ * KB INTEGRATION:
+ * - KnowledgeOrchestrator: Routes ALL decisions through KB
+ * - NarrativeAnalyzer: Duarte Sparkline, STAR moments, SCQA
+ * - ExpertValidator: Validates against ALL 40+ experts
+ * - PersuasionEngine: Cialdini, Kahneman, Heath Brothers
  */
 
 declare class PresentationEngine {
@@ -765,15 +962,26 @@ declare class PresentationEngine {
     private hallucinationDetector;
     private htmlGenerator;
     private pptxGenerator;
+    private orchestrator;
+    private narrativeAnalyzer;
+    private expertValidator;
+    private persuasionEngine;
+    private kbQueryCount;
     constructor();
     /**
      * Generate a presentation from content.
      *
+     * KNOWLEDGE-DRIVEN GENERATION:
+     * - ALL decisions route through KnowledgeOrchestrator
+     * - Narrative analysis via Duarte/Minto frameworks
+     * - Expert validation against 40+ methodologies
+     * - Persuasion psychology from Cialdini/Kahneman/Heath
+     *
      * GUARANTEED DELIVERY:
-     * - Validates presentation quality
-     * - Automatically fixes any issues found
+     * - Validates presentation quality against KB rules
+     * - Automatically fixes any issues found using KB guidance
      * - Iterates until quality threshold is met
-     * - ALWAYS returns a working presentation
+     * - ALWAYS returns a working, world-class presentation
      *
      * @param config - Presentation configuration
      * @returns Presentation result with outputs, QA results, and score
@@ -823,7 +1031,7 @@ declare class PresentationEngine {
 }
 
 /**
- * Content Analyzer - Extracts Structure from Raw Content
+ * Content Analyzer - Extracts Structure AND Data from Raw Content
  *
  * Uses expert methodologies to analyze content and extract:
  * - SCQA structure (Barbara Minto)
@@ -831,6 +1039,9 @@ declare class PresentationEngine {
  * - Key messages (Rule of Three)
  * - STAR moments
  * - Action titles
+ * - **NEW**: Actual data points, metrics, financial figures
+ * - **NEW**: Section content with bullets
+ * - **NEW**: Comparison data
  */
 
 declare class ContentAnalyzer {
@@ -841,51 +1052,82 @@ declare class ContentAnalyzer {
     private readonly whatIsSignals;
     private readonly whatCouldBeSignals;
     /**
-     * Analyze content and extract structural elements.
+     * Analyze content and extract structural elements AND data.
      */
     analyze(content: string, contentType: string): Promise<ContentAnalysis>;
     /**
-     * Parse content based on its type.
+     * Parse content and extract structured sections.
      */
-    private parseContent;
+    private parseContentStructured;
     /**
-     * Parse markdown content to plain text (preserving structure hints).
+     * Parse markdown and extract structured sections with content.
      */
-    private parseMarkdown;
+    private parseMarkdownStructured;
     /**
-     * Parse JSON content.
+     * Extract markdown tables from content lines.
+     * Per RuVector knowledge base (Cole Nussbaumer Knaflic):
+     * Tables are for leave-behinds, keep minimal design.
      */
-    private parseJSON;
+    private extractTablesFromLines;
     /**
-     * Parse YAML content.
+     * Remove table markdown lines from content to prevent raw text display.
+     * Lines that are part of tables (start and end with |, or are separator lines).
      */
-    private parseYAML;
+    private removeTableLinesFromContent;
     /**
-     * Flatten object to text.
+     * Extract bullet points from content lines.
      */
-    private flattenObject;
+    private extractBulletsFromLines;
     /**
-     * Split text into paragraphs.
+     * Extract ALL data points from content.
      */
-    private splitIntoParagraphs;
+    private extractAllDataPoints;
     /**
-     * Split text into sentences.
+     * Extract data points from a specific text block.
      */
-    private splitIntoSentences;
+    private extractDataPointsFromText;
+    /**
+     * Get context around a match.
+     */
+    private getContext;
+    /**
+     * Parse numeric value from string.
+     */
+    private parseNumericValue;
+    /**
+     * Detect trend from context.
+     */
+    private detectTrend;
+    /**
+     * Extract a label for the data point from context.
+     */
+    private extractLabel;
+    /**
+     * Extract financial summary from content.
+     */
+    private extractFinancialSummary;
+    /**
+     * Extract comparison data (year-over-year, before/after).
+     */
+    private extractComparisons;
     /**
-     * Extract SCQA structure (Barbara Minto's Pyramid Principle).
+     * Extract SCQA structure from sections and content.
      */
     private extractSCQA;
     /**
-     * Extract Sparkline structure (Nancy Duarte).
+     * Extract first meaningful sentence from text.
+     */
+    private extractFirstMeaningfulSentence;
+    /**
+     * Extract Sparkline structure.
      */
     private extractSparkline;
     /**
-     * Extract key messages (max 3 - Rule of Three).
+     * Extract key messages from actual content.
      */
     private extractKeyMessages;
     /**
-     * Generate action titles (McKinsey-style).
+     * Generate action titles from key insights.
      */
     private generateActionTitles;
     /**
@@ -893,18 +1135,24 @@ declare class ContentAnalyzer {
      */
     private transformToActionTitle;
     /**
-     * Identify STAR moments (Something They'll Always Remember).
+     * Identify STAR moments (dramatic/memorable points).
      */
     private identifyStarMoments;
     /**
      * Estimate slide count based on content.
      */
     private estimateSlideCount;
+    private parseJSON;
+    private parseYAML;
+    private flattenObject;
+    private splitIntoParagraphs;
+    private splitIntoSentences;
     private containsSignals;
-    private extractRelevantSentence;
     private truncateToSentence;
     private truncateToWords;
     private capitalizeFirst;
+    private cleanText;
+    private isActionTitle;
 }
 
 /**
@@ -1219,6 +1467,353 @@ declare class HTMLLayoutValidator {
     generateRemediationPlan(result: LayoutValidationResult): string[];
 }
 
+/**
+ * Semantic Completeness Validator
+ *
+ * Ensures generated presentations retain the key concepts and topics
+ * from the original source content. This prevents loss of critical
+ * information during summarization/remediation.
+ *
+ * Key capabilities:
+ * - Extract key topics/concepts from source content
+ * - Compare source concepts against generated slides
+ * - Flag missing topics that should be covered
+ * - Provide coverage score (0-100)
+ */
+
+interface SemanticCompletenessResult {
+    /** Coverage score (0-100) - percentage of source concepts found in output */
+    coverageScore: number;
+    /** Key concepts extracted from source content */
+    sourceConcepts: ExtractedConcept[];
+    /** Concepts that were found in the generated slides */
+    foundConcepts: ExtractedConcept[];
+    /** Concepts that were NOT found - potential content loss */
+    missingConcepts: ExtractedConcept[];
+    /** Whether semantic completeness passed (score >= threshold) */
+    passed: boolean;
+    /** Detailed issues */
+    issues: SemanticIssue[];
+}
+interface ExtractedConcept {
+    /** The concept text (normalized) */
+    text: string;
+    /** Importance weight (1-10) based on context */
+    importance: number;
+    /** Category: heading, metric, key_term, entity, action */
+    category: 'heading' | 'metric' | 'key_term' | 'entity' | 'action';
+    /** Original text before normalization */
+    original: string;
+    /** Was it found in the output? */
+    found?: boolean;
+    /** Where it was found (slide indices) */
+    foundIn?: number[];
+}
+interface SemanticIssue {
+    severity: 'error' | 'warning' | 'info';
+    category: 'semantic_completeness';
+    message: string;
+    missingConcept?: string;
+    importance?: number;
+    suggestion?: string;
+}
+declare class SemanticCompletenessValidator {
+    /** Minimum coverage score to pass (default: 70%) */
+    private threshold;
+    constructor(threshold?: number);
+    /**
+     * Validate that generated slides contain the key concepts from source content.
+     */
+    validate(sourceContent: string, generatedSlides: Slide[]): SemanticCompletenessResult;
+    /**
+     * Extract key concepts from source content using NLP-like heuristics.
+     */
+    private extractConcepts;
+    /**
+     * Extract all text content from generated slides.
+     */
+    private extractSlideText;
+    /**
+     * Find a concept in the generated slides using fuzzy matching.
+     */
+    private findConceptInSlides;
+    /**
+     * Generate search variations for fuzzy matching.
+     */
+    private generateSearchVariations;
+    /**
+     * Normalize text for comparison.
+     */
+    private normalize;
+    /**
+     * Generate issues for missing concepts.
+     */
+    private generateIssues;
+    /**
+     * Get a human-readable summary of the validation.
+     */
+    getSummary(result: SemanticCompletenessResult): string;
+}
+
+/**
+ * VisionQAEngine - AI-Driven Qualitative Visual Assessment
+ *
+ * Unlike rules-based QA (word counts, whitespace %), this engine uses
+ * Claude's multimodal capabilities to perform actual design quality assessment.
+ *
+ * Purpose: Stop giving 99/100 to presentations that look terrible.
+ *
+ * Features:
+ * - Per-slide visual analysis using Claude Vision
+ * - Presentation-level consistency and narrative assessment
+ * - Critical issue detection (raw markdown, broken images, empty slides)
+ * - Type-specific standards (TED vs consulting vs investment banking)
+ *
+ * @module VisionQAEngine
+ */
+
+interface SlideVisionAnalysis {
+    slideIndex: number;
+    scores: {
+        typography_hierarchy: number;
+        layout_balance: number;
+        color_harmony: number;
+        professional_polish: number;
+        message_clarity: number;
+        content_density: number;
+        visual_support: number;
+        narrative_flow: number;
+    };
+    overallScore: number;
+    criticalIssues: string[];
+    suggestions: string[];
+    pass: boolean;
+    rawResponse?: string | undefined;
+}
+interface PresentationVisionAnalysis {
+    slideAnalyses: SlideVisionAnalysis[];
+    presentationLevel: {
+        visual_consistency: number;
+        story_arc: number;
+        memorable_moments: number;
+        professional_quality: number;
+    };
+    overallScore: number;
+    weakSlides: number[];
+    strongSlides: number[];
+    criticalIssues: string[];
+    pass: boolean;
+    verdict: string;
+}
+interface VisionQAConfig {
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Anthropic API key (defaults to ANTHROPIC_API_KEY env var) */
+    apiKey?: string;
+    /** Model to use for vision analysis */
+    model?: string;
+    /** Skip individual slide analysis (faster, overview only) */
+    overviewOnly?: boolean;
+    /** Maximum slides to analyze (for large decks) */
+    maxSlides?: number;
+    /** Minimum score required to pass (0-10 scale) */
+    passThreshold?: number;
+}
+declare class VisionQAEngine {
+    private client;
+    private kb;
+    private config;
+    constructor(config?: VisionQAConfig);
+    /**
+     * Initialize the engine (lazy - only when needed)
+     */
+    private initialize;
+    /**
+     * Analyze a single slide screenshot using Claude Vision
+     */
+    analyzeSlide(screenshot: Buffer, slideIndex: number, totalSlides: number, presentationType: PresentationType, slideType?: string): Promise<SlideVisionAnalysis>;
+    /**
+     * Analyze the full presentation using Claude Vision
+     */
+    analyzePresentationOverview(screenshots: Buffer[], presentationType: PresentationType, title: string): Promise<{
+        visual_consistency: number;
+        story_arc: number;
+        memorable_moments: number;
+        professional_quality: number;
+        overall_score: number;
+        weak_slides: number[];
+        strong_slides: number[];
+        critical_issues: string[];
+        pass: boolean;
+        verdict: string;
+    }>;
+    /**
+     * Run full vision QA analysis on a presentation
+     */
+    analyze(screenshots: Buffer[], presentationType: PresentationType, title: string, slideTypes?: string[]): Promise<PresentationVisionAnalysis>;
+    /**
+     * Convert vision analysis results to QA issues format
+     */
+    toQAIssues(analysis: PresentationVisionAnalysis): QAIssue[];
+    /**
+     * Calculate a QA score (0-100) from vision analysis
+     */
+    toQAScore(analysis: PresentationVisionAnalysis): number;
+}
+/**
+ * Get or create the VisionQAEngine singleton
+ */
+declare function getVisionQAEngine(config?: VisionQAConfig): VisionQAEngine;
+/**
+ * Create a new VisionQAEngine instance (non-singleton)
+ */
+declare function createVisionQAEngine(config?: VisionQAConfig): VisionQAEngine;
+
+/**
+ * ConsensusValidator - Multi-Agent Consensus Validation
+ *
+ * Combines multiple validation perspectives to provide rigorous QA:
+ * - Rules-based validation (QAEngine)
+ * - AI vision-based assessment (VisionQAEngine)
+ * - Expert methodology validators (Duarte, Reynolds, Minto, etc.)
+ * - Presentation type-specific validators
+ *
+ * The consensus approach ensures:
+ * 1. No single validator can inflate scores artificially
+ * 2. Critical issues are caught across multiple perspectives
+ * 3. Type-specific standards are enforced
+ *
+ * @module ConsensusValidator
+ */
+
+/** Expert agent persona for validation */
+type ExpertAgent = 'duarte' | 'reynolds' | 'minto' | 'tufte' | 'gallo' | 'anderson';
+/** Individual agent's assessment */
+interface AgentAssessment {
+    agent: ExpertAgent;
+    score: number;
+    passed: boolean;
+    criticalIssues: string[];
+    suggestions: string[];
+    verdict: string;
+}
+/** Consensus result from all agents */
+interface ConsensusResult {
+    /** Individual agent assessments */
+    agentAssessments: AgentAssessment[];
+    /** Rules-based QA score (from QAEngine) */
+    rulesScore: number;
+    /** Vision AI assessment score (from VisionQAEngine) */
+    visionScore: number;
+    /** Vision analysis details (if available) */
+    visionAnalysis?: PresentationVisionAnalysis;
+    /** Final consensus score (weighted average) */
+    consensusScore: number;
+    /** All critical issues across validators */
+    criticalIssues: string[];
+    /** Aggregated suggestions */
+    suggestions: string[];
+    /** Pass/fail based on consensus */
+    passed: boolean;
+    /** Human-readable verdict */
+    verdict: string;
+    /** Confidence level (how much agreement between validators) */
+    confidence: 'high' | 'medium' | 'low';
+    /** Detailed breakdown by category */
+    breakdown: {
+        visual: number;
+        content: number;
+        structure: number;
+        methodology: number;
+    };
+}
+/** Configuration for consensus validation */
+interface ConsensusConfig {
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Anthropic API key (for vision analysis) */
+    apiKey?: string;
+    /** Enable vision-based AI assessment */
+    enableVision?: boolean;
+    /** Agents to include (default: all) */
+    agents?: ExpertAgent[];
+    /** Minimum agreement threshold (0-1, default: 0.6) */
+    agreementThreshold?: number;
+    /** Weights for final score calculation */
+    weights?: {
+        rules?: number;
+        vision?: number;
+        agents?: number;
+    };
+    /** Presentation type for specialized validation */
+    presentationType?: PresentationType;
+}
+declare class ConsensusValidator {
+    private client;
+    private visionEngine;
+    private kb;
+    private config;
+    constructor(config?: ConsensusConfig);
+    /**
+     * Initialize the validator (lazy - only when needed)
+     */
+    private initialize;
+    /**
+     * Run full consensus validation
+     */
+    validate(html: string, screenshots: Buffer[], rulesQAResults: QAResults, presentationType: PresentationType, title: string): Promise<ConsensusResult>;
+    /**
+     * Run all expert agents in parallel
+     */
+    private runExpertAgents;
+    /**
+     * Filter agents relevant to presentation type
+     */
+    private filterAgentsForType;
+    /**
+     * Run a single expert agent assessment
+     */
+    private runSingleAgent;
+    /**
+     * Build context for agent assessment
+     */
+    private buildAgentContext;
+    /**
+     * Sample screenshots evenly
+     */
+    private sampleScreenshots;
+    /**
+     * Calculate rules-based score
+     */
+    private calculateRulesScore;
+    private calculateVisualSubscore;
+    private calculateContentSubscore;
+    /**
+     * Calculate final consensus from all validators
+     */
+    private calculateConsensus;
+    /**
+     * Generate human-readable verdict
+     */
+    private generateVerdict;
+    /**
+     * Calculate standard deviation
+     */
+    private calculateStdDev;
+    /**
+     * Convert consensus result to QA issues format
+     */
+    toQAIssues(result: ConsensusResult): QAIssue[];
+}
+/**
+ * Get or create the ConsensusValidator singleton
+ */
+declare function getConsensusValidator(config?: ConsensusConfig): ConsensusValidator;
+/**
+ * Create a new ConsensusValidator instance (non-singleton)
+ */
+declare function createConsensusValidator(config?: ConsensusConfig): ConsensusValidator;
+
 /**
  * Presentation Type Detector
  *
@@ -1477,6 +2072,11 @@ declare class RevealJsGenerator {
      * Basic HTML minification.
      */
     private minifyHtml;
+    /**
+     * Get theme variables based on presentation type.
+     * Returns color scheme and typography for each type.
+     */
+    private getTypeThemeVars;
 }
 
 /**
@@ -1509,7 +2109,7 @@ declare class PowerPointGenerator {
      */
     private addSlide;
     /**
-     * Add title slide.
+     * Add title slide with professional gradient background.
      */
     private addTitleSlide;
     /**
@@ -1525,13 +2125,17 @@ declare class PowerPointGenerator {
      */
     private addQuoteSlide;
     /**
-     * Add bullet points slide.
+     * Add bullet points slide with professional styling.
      */
     private addBulletSlide;
     /**
-     * Add two-column slide.
+     * Add two-column slide with professional layout.
      */
     private addTwoColumnSlide;
+    /**
+     * Add professional metrics card to slide.
+     */
+    private addMetricsCard;
     /**
      * Add metrics grid slide.
      */
@@ -1738,10 +2342,18 @@ declare class CompositeImageProvider implements ImageProvider {
 }
 /**
  * Create default image provider chain
+ *
+ * Priority order:
+ * 1. Local images (user-provided)
+ * 2. NanoBanana Pro (AI generation, if GOOGLE_AI_API_KEY available)
+ * 3. Unsplash (if key available)
+ * 4. Placeholder (always available)
  */
 declare function createDefaultImageProvider(options?: {
     localImages?: Record<string, string>;
     unsplashKey?: string;
+    googleAiKey?: string;
+    enableAiGeneration?: boolean;
 }): ImageProvider;
 
 /**
@@ -1874,6 +2486,116 @@ declare class CompositeChartProvider implements ChartProvider {
  */
 declare function createDefaultChartProvider(): CompositeChartProvider;
 
+/**
+ * NanoBanana Pro Image Provider
+ *
+ * AI-powered image generation using Google's Gemini Image models:
+ * - Gemini 2.5 Flash Image ("Nano Banana") - Fast, 1K resolution
+ * - Gemini 3 Pro Image Preview ("Nano Banana Pro") - Professional, up to 4K resolution
+ *
+ * Perfect for generating:
+ * - Hero images for title slides
+ * - Abstract concept visualizations
+ * - Background imagery
+ * - Product/feature illustrations
+ *
+ * @see https://ai.google.dev/gemini-api/docs/image-generation
+ */
+
+/** Model options for NanoBanana image generation */
+type NanoBananaModel = 'gemini-2.5-flash-image' | 'gemini-3-pro-image';
+/** Image size options (Pro only supports 2K and 4K) */
+type ImageSize = '1K' | '2K' | '4K';
+/** Aspect ratio options */
+type AspectRatio = '1:1' | '16:9' | '9:16' | '4:3' | '3:4' | '21:9';
+/** Configuration for NanoBanana provider */
+interface NanoBananaConfig {
+    /** Google AI API key (or set GOOGLE_AI_API_KEY env var) */
+    apiKey?: string;
+    /** Model to use (default: gemini-2.5-flash-image) */
+    model?: NanoBananaModel;
+    /** Default aspect ratio (default: 16:9 for presentations) */
+    aspectRatio?: AspectRatio;
+    /** Image size for Pro model (default: 2K) */
+    imageSize?: ImageSize;
+    /** Style modifiers to append to prompts */
+    styleModifiers?: string[];
+    /** Whether to include text in generated images */
+    allowText?: boolean;
+}
+/**
+ * NanoBanana Pro Image Provider
+ *
+ * Generates AI images using Google's Gemini Image models.
+ * Requires GOOGLE_AI_API_KEY environment variable or apiKey in config.
+ */
+declare class NanoBananaProvider implements ImageProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private aspectRatio;
+    private imageSize;
+    private styleModifiers;
+    private allowText;
+    private baseUrl;
+    constructor(config?: NanoBananaConfig);
+    isAvailable(): Promise<boolean>;
+    getImage(request: ImageRequest): Promise<ImageResult>;
+    getImages(requests: ImageRequest[]): Promise<ImageResult[]>;
+    /**
+     * Build an optimized prompt for presentation imagery
+     */
+    private buildPrompt;
+    /**
+     * Call the Gemini API for image generation
+     */
+    private callGeminiAPI;
+    /**
+     * Extract image result from Gemini response
+     */
+    private extractImageResult;
+    /**
+     * Get a fallback placeholder image
+     */
+    private getFallbackImage;
+    /**
+     * Generate a consistent hash from a string
+     */
+    private hashString;
+    /**
+     * Delay helper for rate limiting
+     */
+    private delay;
+}
+/**
+ * Create a NanoBanana provider with presentation-optimized defaults
+ */
+declare function createNanoBananaProvider(config?: NanoBananaConfig): NanoBananaProvider;
+/**
+ * Create prompt templates from the knowledge base
+ */
+declare const NANOBANANA_PROMPT_TEMPLATES: {
+    /** Hero image for title/section slides */
+    readonly hero: (topic: string) => string;
+    /** Abstract concept visualization */
+    readonly concept: (concept: string) => string;
+    /** Feature/product illustration */
+    readonly feature: (feature: string) => string;
+    /** Background imagery */
+    readonly background: (theme: string) => string;
+    /** Data/metrics visualization enhancement */
+    readonly data: (metric: string) => string;
+    /** Team/people representation (abstract) */
+    readonly team: (context: string) => string;
+    /** Process/workflow visualization */
+    readonly process: (process: string) => string;
+};
+type PromptTemplate = keyof typeof NANOBANANA_PROMPT_TEMPLATES;
+/**
+ * Get a pre-built prompt from templates
+ */
+declare function getNanoBananaPrompt(template: PromptTemplate, value: string): string;
+
 /**
  * Knowledge Base - RuVector Expert Principles Loader
  *
@@ -1980,60 +2702,1062 @@ declare class KnowledgeBase {
 declare function getKnowledgeBase(): KnowledgeBase;
 
 /**
- * Claude Presentation Master
- *
- * Generate world-class presentations using expert methodologies from
- * Duarte, Reynolds, Gallo, and Anderson. Enforces rigorous quality
- * standards through real visual validation.
+ * KnowledgeOrchestrator - The Central Brain (Optimized v2.0)
  *
- * @packageDocumentation
- * @module claude-presentation-master
- * @author Stuart Kerr <stuart@isovision.ai>
- * @license MIT
- */
-
-/**
- * Generate a presentation from content.
+ * THIS IS THE HEART OF THE APPLICATION.
  *
- * @example
- * ```typescript
- * import { generate } from '@isovision/claude-presentation-master';
+ * Every single decision in the presentation engine flows through this orchestrator.
+ * It queries the RuVector knowledge base via KnowledgeService typed methods.
  *
- * const result = await generate({
- *   content: '# My Presentation\n\n...',
- *   contentType: 'markdown',
- *   mode: 'keynote',
- *   format: ['html', 'pptx'],
- *   qaThreshold: 95,
- *   title: 'My Amazing Presentation'
- * });
+ * DESIGN PRINCIPLE: The RuVector KB IS the application.
+ * This orchestrator simply executes what the KB dictates.
  *
- * console.log(`Score: ${result.score}/100`);
- * ```
+ * KEY OPTIMIZATION (v2.0):
+ * - Uses KnowledgeService typed methods instead of raw property access
+ * - Memory-resident KB (loaded once, cached forever)
+ * - Optional logging (no console spam by default)
+ * - 95/100 KB utilization target
  *
- * @param config - Presentation configuration
- * @returns Presentation result with outputs, QA results, and score
- * @throws {ValidationError} If input validation fails
- * @throws {QAFailureError} If QA score is below threshold
+ * The knowledge base contains 7,000+ lines of world-class expertise from:
+ * - Nancy Duarte (Sparkline, STAR moments)
+ * - Barbara Minto (Pyramid Principle, MECE, Action Titles)
+ * - Edward Tufte (Data-Ink Ratio, Chartjunk elimination)
+ * - Cole Nussbaumer Knaflic (Storytelling with Data)
+ * - Garr Reynolds (Presentation Zen)
+ * - Carmine Gallo (Talk Like TED)
+ * - Robert Cialdini (Persuasion Psychology)
+ * - Daniel Kahneman (Behavioral Economics)
+ * - Chip & Dan Heath (Made to Stick)
+ * - McKinsey, BCG, Bain (Consulting methodology)
+ * - Cognitive Science (Miller's Law, Chunking, Cognitive Load)
+ * - Gestalt Principles (Proximity, Similarity, Closure, Continuity)
+ * - WCAG Accessibility Standards
+ * - And 30+ more expert methodologies
  */
-declare function generate(config: PresentationConfig): Promise<PresentationResult>;
+
+interface KBQueryLog {
+    timestamp: Date;
+    path: string;
+    query: string;
+    result: any;
+    appliedAs: string;
+}
+interface OrchestratorDecision<T> {
+    value: T;
+    kbPath: string;
+    kbSource: string;
+    reasoning: string;
+}
+interface OrchestratorConfig {
+    verbose?: boolean;
+    logQueries?: boolean;
+}
 /**
- * Validate an existing presentation.
- *
- * @example
- * ```typescript
- * import { validate } from '@isovision/claude-presentation-master';
- * import fs from 'fs';
- *
- * const html = fs.readFileSync('presentation.html', 'utf-8');
- * const result = await validate(html, { mode: 'keynote' });
- *
- * console.log(`Score: ${result.score}/100`);
- * console.log(`Passed: ${result.passed}`);
- * ```
+ * KnowledgeOrchestrator - Routes ALL decisions through the knowledge base
  *
- * @param presentation - HTML string or file buffer
- * @param options - Validation options
+ * Uses KnowledgeService typed methods for reliable access to all 33 KB domains.
+ */
+declare class KnowledgeOrchestrator {
+    private queryLog;
+    private initialized;
+    private config;
+    private kbVersion;
+    constructor(config?: OrchestratorConfig);
+    /**
+     * Initialize the orchestrator by loading the knowledge base
+     */
+    initialize(): Promise<void>;
+    /**
+     * Log a knowledge base query for verification
+     */
+    private log;
+    /**
+     * Safe JSON stringify that handles undefined
+     */
+    private safeStringify;
+    /**
+     * Get the full query log for verification
+     */
+    getQueryLog(): KBQueryLog[];
+    /**
+     * Get query statistics
+     */
+    getQueryStats(): {
+        total: number;
+        byDomain: Record<string, number>;
+    };
+    /**
+     * Print query log summary (only if verbose)
+     */
+    printQuerySummary(): void;
+    /**
+     * Get word limits for a presentation mode
+     * SOURCE: KnowledgeService.getModeRules(mode).characteristics.words_per_slide
+     */
+    getWordLimits(mode: PresentationMode): OrchestratorDecision<{
+        min: number;
+        max: number;
+    }>;
+    /**
+     * Get whitespace requirements
+     * SOURCE: KnowledgeService.getModeRules(mode).characteristics.whitespace
+     */
+    getWhitespaceRequirement(mode: PresentationMode): OrchestratorDecision<number>;
+    /**
+     * Get primary experts for a mode
+     * SOURCE: KnowledgeService.getModeRules(mode).experts
+     */
+    getPrimaryExperts(mode: PresentationMode): OrchestratorDecision<string[]>;
+    /**
+     * Get full mode configuration
+     * SOURCE: KnowledgeService.getModeRules(mode)
+     */
+    getModeConfig(mode: PresentationMode): OrchestratorDecision<any>;
+    /**
+     * Get presentation type configuration
+     * SOURCE: KnowledgeService.getTypeConfig(type)
+     */
+    getTypeConfig(type: PresentationType): OrchestratorDecision<any>;
+    /**
+     * Get type detection signals
+     * SOURCE: KnowledgeService.getTypeDetection()
+     */
+    getTypeDetection(): OrchestratorDecision<any>;
+    /**
+     * Get Miller's Law limit for items
+     * SOURCE: KnowledgeService.getMillersLaw()
+     */
+    getMillersLawLimit(): OrchestratorDecision<number>;
+    /**
+     * Get chunking rules for information grouping
+     * SOURCE: KnowledgeService.getChunkingPrinciples()
+     */
+    getChunkingRules(): OrchestratorDecision<string[]>;
+    /**
+     * Get cognitive load reduction strategies
+     * SOURCE: KnowledgeService.getCognitiveLoadTheory()
+     */
+    getCognitiveLoadRules(): OrchestratorDecision<string[]>;
+    /**
+     * Get attention span guidance
+     * SOURCE: KnowledgeService.getAttentionSpan()
+     */
+    getAttentionSpanGuidance(): OrchestratorDecision<{
+        maxSeconds: number;
+        rules: string[];
+    }>;
+    /**
+     * Get all cognitive science rules
+     * SOURCE: KnowledgeService.getCognitiveRules()
+     */
+    getAllCognitiveRules(): OrchestratorDecision<any>;
+    /**
+     * Get proximity principle for layout
+     * SOURCE: KnowledgeService.getGestaltPrinciple('proximity')
+     */
+    getProximityPrinciple(): OrchestratorDecision<{
+        description: string;
+        application: string[];
+    }>;
+    /**
+     * Get similarity principle for styling
+     * SOURCE: KnowledgeService.getGestaltPrinciple('similarity')
+     */
+    getSimilarityPrinciple(): OrchestratorDecision<{
+        description: string;
+        application: string[];
+    }>;
+    /**
+     * Get all Gestalt principles
+     * SOURCE: KnowledgeService.getGestaltPrinciples()
+     */
+    getAllGestaltPrinciples(): OrchestratorDecision<Record<string, any>>;
+    /**
+     * Get Tufte's data-ink ratio rules
+     * SOURCE: KnowledgeService.getDataVizExpert('edward_tufte')
+     */
+    getTufteDataInkRules(): OrchestratorDecision<string[]>;
+    /**
+     * Get chartjunk to avoid
+     * SOURCE: KnowledgeService.getDataVizExpert('edward_tufte')
+     */
+    getChartjunkToAvoid(): OrchestratorDecision<string[]>;
+    /**
+     * Get Knaflic's 6 key principles
+     * SOURCE: KnowledgeService.getDataVizExpert('cole_nussbaumer_knaflic')
+     */
+    getKnaflicPrinciples(): OrchestratorDecision<Record<string, any>>;
+    /**
+     * Select chart type based on purpose
+     * SOURCE: KnowledgeService.getChartSelectionGuide(purpose)
+     */
+    selectChartType(purpose: 'comparison' | 'composition' | 'distribution' | 'relationship', characteristics: {
+        categoryCount: number;
+        hasTimeSeries: boolean;
+        variableCount: number;
+    }): OrchestratorDecision<string>;
+    /**
+     * Get chart-specific rules
+     * SOURCE: KnowledgeService.getChartRules(chartType)
+     */
+    getChartRules(chartType: string): OrchestratorDecision<any>;
+    /**
+     * Get table styling rules
+     * SOURCE: KnowledgeService.getChartRules('tables')
+     */
+    getTableStylingRules(): OrchestratorDecision<string[]>;
+    /**
+     * Get data label rules
+     * SOURCE: KnowledgeService.getDataLabelRules()
+     */
+    getDataLabelRules(): OrchestratorDecision<any>;
+    /**
+     * Get Barbara Minto's Pyramid Principle
+     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto')
+     */
+    getMintoPyramidPrinciple(): OrchestratorDecision<any>;
+    /**
+     * Get action title requirements
+     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto') + getModeRules('business')
+     */
+    getActionTitleRequirements(): OrchestratorDecision<{
+        rules: string[];
+        examples: any;
+    }>;
+    /**
+     * Get MECE validation rules
+     * SOURCE: KnowledgeService.getExpertPrinciples('barbara_minto')
+     */
+    getMECERules(): OrchestratorDecision<any>;
+    /**
+     * Get Nancy Duarte's principles
+     * SOURCE: KnowledgeService.getExpertPrinciples('nancy_duarte')
+     */
+    getDuartePrinciples(): OrchestratorDecision<any>;
+    /**
+     * Get Glance Test requirements
+     * SOURCE: KnowledgeService.getGlanceTest()
+     */
+    getGlanceTestRequirements(): OrchestratorDecision<{
+        maxSeconds: number;
+        rules: string[];
+    }>;
+    /**
+     * Get Garr Reynolds' principles (Presentation Zen)
+     * SOURCE: KnowledgeService.getExpertPrinciples('garr_reynolds')
+     */
+    getReynoldsPrinciples(): OrchestratorDecision<any>;
+    /**
+     * Get Carmine Gallo's principles (Talk Like TED)
+     * SOURCE: KnowledgeService.getExpertPrinciples('carmine_gallo')
+     */
+    getGalloPrinciples(): OrchestratorDecision<any>;
+    /**
+     * Get Sparkline framework
+     * SOURCE: KnowledgeService.getSparklineFramework()
+     */
+    getSparklineFramework(): OrchestratorDecision<any>;
+    /**
+     * Get SCQA framework
+     * SOURCE: KnowledgeService.getSCQAFramework()
+     */
+    getSCQAFramework(): OrchestratorDecision<any>;
+    /**
+     * Get STAR moment guidance
+     * SOURCE: KnowledgeService.getExpertPrinciples('nancy_duarte')
+     */
+    getSTARMomentGuidance(): OrchestratorDecision<any>;
+    /**
+     * Get all story frameworks
+     * SOURCE: KnowledgeService.getStoryFrameworks()
+     */
+    getAllStoryFrameworks(): OrchestratorDecision<any>;
+    /**
+     * Get Cialdini's persuasion principles
+     * SOURCE: KnowledgeService.getCialdiniPrinciples()
+     */
+    getCialdiniPrinciples(): OrchestratorDecision<any>;
+    /**
+     * Get Kahneman insights
+     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     */
+    getKahnemanInsights(): OrchestratorDecision<any>;
+    /**
+     * Get Heath Brothers' Made to Stick principles
+     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     */
+    getHeathBrothersPrinciples(): OrchestratorDecision<any>;
+    /**
+     * Get all persuasion psychology
+     * SOURCE: KnowledgeService.getPersuasionPsychology()
+     */
+    getAllPersuasionPsychology(): OrchestratorDecision<any>;
+    /**
+     * Get color contrast requirements
+     * SOURCE: KnowledgeService.getContrastRequirements()
+     */
+    getContrastRequirements(): OrchestratorDecision<any>;
+    /**
+     * Get font size requirements
+     * SOURCE: KnowledgeService.getFontSizeRequirements()
+     */
+    getFontSizeRequirements(): OrchestratorDecision<any>;
+    /**
+     * Get color blindness guidance
+     * SOURCE: KnowledgeService.getColorBlindnessGuidance()
+     */
+    getColorBlindnessGuidance(): OrchestratorDecision<any>;
+    /**
+     * Get all accessibility rules
+     * SOURCE: KnowledgeService.getAccessibilityRules()
+     */
+    getAllAccessibilityRules(): OrchestratorDecision<any>;
+    /**
+     * Get typography rules
+     * SOURCE: KnowledgeService.getTypography()
+     */
+    getTypographyRules(): OrchestratorDecision<any>;
+    /**
+     * Get color system
+     * SOURCE: KnowledgeService.getColorSystem()
+     */
+    getColorSystem(): OrchestratorDecision<any>;
+    /**
+     * Get spacing system
+     * SOURCE: KnowledgeService.getSpacingSystem()
+     */
+    getSpacingSystem(): OrchestratorDecision<any>;
+    /**
+     * Get layout rules
+     * SOURCE: KnowledgeService.getLayoutSystem()
+     */
+    getLayoutRules(mode: PresentationMode): OrchestratorDecision<any>;
+    /**
+     * Get complete design system
+     * SOURCE: KnowledgeService.getDesignSystem()
+     */
+    getFullDesignSystem(): OrchestratorDecision<any>;
+    /**
+     * Get Harvey balls guidance
+     * SOURCE: KnowledgeService.getHarveyBalls()
+     */
+    getHarveyBallsGuidance(): OrchestratorDecision<any>;
+    /**
+     * Get traffic light guidance
+     * SOURCE: KnowledgeService.getTrafficLights()
+     */
+    getTrafficLightGuidance(): OrchestratorDecision<any>;
+    /**
+     * Get icon usage guidance
+     * SOURCE: KnowledgeService.getIconGuidance()
+     */
+    getIconGuidance(): OrchestratorDecision<any>;
+    /**
+     * Get all consulting visuals
+     * SOURCE: KnowledgeService.getConsultingVisuals()
+     */
+    getAllConsultingVisuals(): OrchestratorDecision<any>;
+    /**
+     * Get signal-to-noise ratio requirements
+     * SOURCE: KnowledgeService.getSignalToNoise()
+     */
+    getSignalToNoiseRequirements(): OrchestratorDecision<any>;
+    /**
+     * Get one-idea-per-slide requirements
+     * SOURCE: KnowledgeService.getOneIdeaPerSlide()
+     */
+    getOneIdeaRequirements(): OrchestratorDecision<any>;
+    /**
+     * Get scoring weights
+     * SOURCE: KnowledgeService.getScoringWeights()
+     */
+    getScoringWeights(): OrchestratorDecision<any>;
+    /**
+     * Get all quality metrics
+     * SOURCE: KnowledgeService.getQualityMetrics()
+     */
+    getAllQualityMetrics(): OrchestratorDecision<any>;
+    /**
+     * Get anti-patterns to avoid
+     * SOURCE: KnowledgeService.getAntiPatterns()
+     */
+    getAntiPatterns(): OrchestratorDecision<any>;
+    /**
+     * Get visual anti-patterns
+     * SOURCE: KnowledgeService.getVisualAntiPatterns()
+     */
+    getVisualAntiPatterns(): OrchestratorDecision<any[]>;
+    /**
+     * Get content anti-patterns
+     * SOURCE: KnowledgeService.getContentAntiPatterns()
+     */
+    getContentAntiPatterns(): OrchestratorDecision<any[]>;
+    /**
+     * Get slide templates for mode
+     * SOURCE: KnowledgeService.getAllSlideTemplates()
+     */
+    getSlideTemplates(mode: PresentationMode): OrchestratorDecision<any>;
+    /**
+     * Get specific slide template
+     * SOURCE: KnowledgeService.getSlideTemplate(templateType)
+     */
+    getSlideTemplate(templateType: string): OrchestratorDecision<any>;
+    /**
+     * Get data integrity requirements
+     * SOURCE: KnowledgeService.getDataIntegrity()
+     */
+    getDataIntegrityRules(): OrchestratorDecision<any>;
+    /**
+     * Get source documentation requirements
+     * SOURCE: KnowledgeService.getSourceDocumentation()
+     */
+    getSourceDocumentationRules(): OrchestratorDecision<any>;
+    /**
+     * Get verification checklist
+     * SOURCE: KnowledgeService.getVerificationChecklist()
+     */
+    getVerificationChecklist(): OrchestratorDecision<any>;
+    /**
+     * Get HTML output configuration
+     * SOURCE: KnowledgeService.getHtmlConfig()
+     */
+    getHtmlConfig(): OrchestratorDecision<any>;
+    /**
+     * Get PPTX output configuration
+     * SOURCE: KnowledgeService.getPptxConfig()
+     */
+    getPptxConfig(): OrchestratorDecision<any>;
+    /**
+     * Get PPTX generation rules
+     * SOURCE: KnowledgeService.getPptxGeneration()
+     */
+    getPptxGenerationRules(): OrchestratorDecision<any>;
+    /**
+     * Get ALL rules applicable to slide creation
+     * This is the master method that aggregates all relevant KB sections
+     */
+    getSlideCreationRules(mode: PresentationMode, type: PresentationType): Promise<{
+        wordLimits: OrchestratorDecision<{
+            min: number;
+            max: number;
+        }>;
+        millerLimit: OrchestratorDecision<number>;
+        glanceTest: OrchestratorDecision<{
+            maxSeconds: number;
+            rules: string[];
+        }>;
+        actionTitles: OrchestratorDecision<{
+            rules: string[];
+            examples: any;
+        }>;
+        tufteRules: OrchestratorDecision<string[]>;
+        chartjunk: OrchestratorDecision<string[]>;
+        gestalt: OrchestratorDecision<Record<string, any>>;
+        accessibility: {
+            contrast: OrchestratorDecision<any>;
+            fonts: OrchestratorDecision<any>;
+        };
+        antiPatterns: OrchestratorDecision<any>;
+    }>;
+    /**
+     * Get ALL narrative/persuasion rules
+     */
+    getNarrativeRules(): Promise<{
+        sparkline: OrchestratorDecision<any>;
+        scqa: OrchestratorDecision<any>;
+        starMoment: OrchestratorDecision<any>;
+        cialdini: OrchestratorDecision<any>;
+        kahneman: OrchestratorDecision<any>;
+        heath: OrchestratorDecision<any>;
+    }>;
+    /**
+     * Search the knowledge base by keyword
+     * SOURCE: KnowledgeService.search(keyword)
+     */
+    searchKB(keyword: string): OrchestratorDecision<any[]>;
+    /**
+     * Get KB version and metadata
+     */
+    getKBMetadata(): OrchestratorDecision<any>;
+}
+declare function getKnowledgeOrchestrator(config?: OrchestratorConfig): KnowledgeOrchestrator;
+/**
+ * Create a new orchestrator instance (useful for testing with different configs)
+ */
+declare function createKnowledgeOrchestrator(config?: OrchestratorConfig): KnowledgeOrchestrator;
+
+/**
+ * NarrativeAnalyzer - Story Structure Analysis Engine
+ *
+ * THIS MODULE ANALYZES AND ENFORCES NARRATIVE STRUCTURE.
+ *
+ * ALL decisions flow through the KnowledgeOrchestrator - NO hardcoding.
+ *
+ * Implements expert frameworks from:
+ * - Nancy Duarte (Sparkline: What Is / What Could Be, STAR moments)
+ * - Barbara Minto (SCQA: Situation, Complication, Question, Answer)
+ * - Cole Nussbaumer Knaflic (Story structure: Beginning, Middle, End)
+ * - Carmine Gallo (Rule of Three, Emotional Connection)
+ * - Chris Anderson (One Idea, Gift Giving)
+ *
+ * The knowledge base IS the brain. This code is just plumbing.
+ */
+
+type SparklineStage = 'what_is' | 'what_could_be' | 'contrast' | 'star_moment' | 'new_bliss' | 'unknown';
+type SCQAStage = 'situation' | 'complication' | 'question' | 'answer' | 'unknown';
+type EmotionalPosition = 'opening_hook' | 'rising_tension' | 'climax' | 'resolution' | 'call_to_action';
+interface SectionNarrativeAnalysis {
+    section: ExtractedSection;
+    sparklineStage: SparklineStage;
+    scqaStage: SCQAStage;
+    emotionalPosition: EmotionalPosition;
+    emotionalIntensity: number;
+    isSTARCandidate: boolean;
+    narrativeFunction: string;
+    kbSources: string[];
+}
+interface PresentationNarrativeAnalysis {
+    sections: SectionNarrativeAnalysis[];
+    sparklineFlow: SparklineStage[];
+    hasProperSparkline: boolean;
+    sparklineScore: number;
+    scqaFlow: SCQAStage[];
+    hasProperSCQA: boolean;
+    scqaScore: number;
+    starMomentIndex: number | null;
+    starMomentContent: string | null;
+    emotionalArc: EmotionalPosition[];
+    emotionalScore: number;
+    overallNarrativeScore: number;
+    recommendations: string[];
+    kbQueriesUsed: number;
+}
+/**
+ * NarrativeAnalyzer - Analyzes and enforces story structure
+ */
+declare class NarrativeAnalyzer {
+    private orchestrator;
+    private sparklineKB;
+    private scqaKB;
+    private starMomentKB;
+    private knaflicKB;
+    private galloKB;
+    private andersonKB;
+    private queryCount;
+    private initialized;
+    constructor();
+    /**
+     * Initialize by loading all narrative frameworks from KB
+     * OPTIMIZATION: Only initialize once - cached data is reused
+     */
+    initialize(): Promise<void>;
+    /**
+     * Analyze the narrative structure of content
+     */
+    analyzeNarrative(analysis: ContentAnalysis, mode: PresentationMode): Promise<PresentationNarrativeAnalysis>;
+    /**
+     * Analyze a single section's narrative position
+     */
+    private analyzeSection;
+    /**
+     * Classify content into Sparkline stage
+     * Based on KB: story_frameworks.sparkline
+     */
+    private classifySparklineStage;
+    /**
+     * Classify content into SCQA stage
+     * Based on KB: story_frameworks.scqa, experts.barbara_minto.scqa_framework
+     */
+    private classifySCQAStage;
+    /**
+     * Classify emotional position and intensity
+     * Based on KB: persuasion_psychology, experts.nancy_duarte.core_principles
+     */
+    private classifyEmotionalPosition;
+    /**
+     * Check if section is a STAR moment candidate
+     * Based on KB: experts.nancy_duarte.core_teachings.star_moment
+     */
+    private isSTARMomentCandidate;
+    /**
+     * Determine the narrative function of a section
+     */
+    private determineNarrativeFunction;
+    /**
+     * Find the best STAR moment in the presentation
+     */
+    private findSTARMoment;
+    /**
+     * Score the Sparkline flow
+     * Based on KB: story_frameworks.sparkline.stages
+     */
+    private scoreSparklineFlow;
+    /**
+     * Score the SCQA flow
+     * Based on KB: story_frameworks.scqa, experts.barbara_minto
+     */
+    private scoreSCQAFlow;
+    /**
+     * Score the emotional arc
+     * Based on KB: persuasion_psychology, experts.nancy_duarte
+     */
+    private scoreEmotionalArc;
+    /**
+     * Generate recommendations for improving narrative
+     */
+    private generateRecommendations;
+    /**
+     * Get recommended Sparkline structure for a presentation
+     * Based on KB: story_frameworks.sparkline
+     */
+    getRecommendedSparklineStructure(slideCount: number): SparklineStage[];
+    /**
+     * Get recommended SCQA structure based on mode
+     * Based on KB: story_frameworks.scqa, experts.barbara_minto
+     */
+    getRecommendedSCQAStructure(slideCount: number, mode: PresentationMode): SCQAStage[];
+    /**
+     * Get total KB queries made
+     */
+    getQueryCount(): number;
+}
+declare function getNarrativeAnalyzer(): NarrativeAnalyzer;
+
+/**
+ * ExpertValidator - Validates Slides Against ALL Expert Methodologies
+ *
+ * THIS MODULE VALIDATES OUTPUT AGAINST THE COMPLETE KNOWLEDGE BASE.
+ *
+ * ALL validation rules come from the KB - NO hardcoded thresholds.
+ *
+ * Validates against 40+ expert methodologies including:
+ *
+ * DATA VISUALIZATION:
+ * - Edward Tufte (Data-Ink Ratio, Chartjunk elimination)
+ * - Cole Nussbaumer Knaflic (Storytelling with Data)
+ * - Scott Berinato (Good Charts)
+ *
+ * PRESENTATION DESIGN:
+ * - Nancy Duarte (Glance Test, STAR moments, Sparkline)
+ * - Garr Reynolds (Signal-to-Noise, Presentation Zen)
+ * - Carmine Gallo (Rule of Three, 18 minutes)
+ * - Chris Anderson (One Idea, Dead Laptop Test)
+ * - Guy Kawasaki (10/20/30 Rule)
+ *
+ * BUSINESS COMMUNICATION:
+ * - Barbara Minto (Pyramid Principle, MECE, Action Titles)
+ * - McKinsey/BCG/Bain (Consulting standards)
+ * - Analyst Academy (SCQA Framework)
+ *
+ * COGNITIVE SCIENCE:
+ * - George Miller (7±2 items)
+ * - John Sweller (Cognitive Load Theory)
+ * - Gestalt Psychology (Proximity, Similarity, etc.)
+ *
+ * PERSUASION:
+ * - Robert Cialdini (6 Principles of Influence)
+ * - Daniel Kahneman (System 1/2)
+ * - Chip & Dan Heath (Made to Stick - SUCCESs)
+ *
+ * ACCESSIBILITY:
+ * - WCAG 2.1 Standards
+ *
+ * The knowledge base IS the brain. This code is just plumbing.
+ */
+
+interface ValidationCheck {
+    expert: string;
+    principle: string;
+    kbPath: string;
+    passed: boolean;
+    score: number;
+    message: string;
+    remediation?: string | undefined;
+}
+interface SlideValidation {
+    slideIndex: number;
+    slideTitle: string;
+    checks: ValidationCheck[];
+    overallScore: number;
+    passed: boolean;
+    criticalFailures: string[];
+}
+interface PresentationValidation {
+    slides: SlideValidation[];
+    overallScore: number;
+    passed: boolean;
+    expertScores: Record<string, number>;
+    categoryScores: {
+        dataVisualization: number;
+        presentationDesign: number;
+        businessCommunication: number;
+        cognitiveScience: number;
+        persuasion: number;
+        accessibility: number;
+    };
+    kbQueriesUsed: number;
+    criticalIssues: string[];
+    recommendations: string[];
+}
+/**
+ * ExpertValidator - Validates against all expert methodologies
+ */
+declare class ExpertValidator {
+    private orchestrator;
+    private queryCount;
+    constructor();
+    /**
+     * Initialize the validator
+     */
+    initialize(): Promise<void>;
+    /**
+     * Validate an entire presentation
+     */
+    validatePresentation(slides: Slide[], mode: PresentationMode): Promise<PresentationValidation>;
+    /**
+     * Validate a single slide against all expert principles
+     */
+    private validateSlide;
+    /**
+     * Validate Tufte's Data-Ink Ratio
+     * KB: data_visualization_experts.edward_tufte.core_principles.data_ink_ratio
+     */
+    private validateTufteDataInk;
+    /**
+     * Validate Tufte's Chartjunk elimination
+     * KB: data_visualization_experts.edward_tufte.core_principles.chartjunk
+     */
+    private validateTufteChartjunk;
+    /**
+     * Validate Knaflic's principles
+     * KB: data_visualization_experts.cole_nussbaumer_knaflic.six_key_principles
+     */
+    private validateKnaflicPrinciples;
+    /**
+     * Validate Duarte's Glance Test
+     * KB: quality_metrics.glance_test, experts.nancy_duarte
+     */
+    private validateDuarteGlanceTest;
+    /**
+     * Validate Reynolds' Signal-to-Noise ratio
+     * KB: experts.garr_reynolds.core_principles.signal_to_noise
+     */
+    private validateReynoldsSignalNoise;
+    /**
+     * Validate Gallo's Rule of Three
+     * KB: experts.carmine_gallo.core_principles.rule_of_three
+     */
+    private validateGalloRuleOfThree;
+    /**
+     * Validate Anderson's One Idea principle
+     * KB: experts.chris_anderson.core_principles.one_idea
+     */
+    private validateAndersonOneIdea;
+    /**
+     * Validate Minto's Action Titles
+     * KB: experts.barbara_minto, presentation_modes.business
+     */
+    private validateMintoActionTitles;
+    /**
+     * Validate Minto's MECE principle
+     * KB: experts.barbara_minto.mece_principle
+     */
+    private validateMintoMECE;
+    /**
+     * Validate Horizontal Logic (titles tell the story)
+     * KB: data_visualization_experts.cole_nussbaumer_knaflic.horizontal_vertical_logic
+     */
+    private validateHorizontalLogic;
+    /**
+     * Validate Miller's Law (7±2 items)
+     * KB: cognitive_science.millers_law
+     */
+    private validateMillersLaw;
+    /**
+     * Validate Cognitive Load
+     * KB: cognitive_science.cognitive_load_theory
+     */
+    private validateCognitiveLoad;
+    /**
+     * Validate Gestalt Proximity principle
+     * KB: gestalt_principles.proximity
+     */
+    private validateGestaltProximity;
+    /**
+     * Validate word count
+     * KB: presentation_modes.[mode].characteristics.words_per_slide
+     */
+    private validateWordCount;
+    /**
+     * Validate accessibility basics
+     * KB: accessibility
+     */
+    private validateAccessibility;
+    /**
+     * Get all text content from a slide
+     */
+    private getSlideContent;
+    /**
+     * Count words in a slide
+     */
+    private countWords;
+    /**
+     * Calculate scores by expert
+     */
+    private calculateExpertScores;
+    /**
+     * Calculate category scores
+     */
+    private calculateCategoryScores;
+    private avgScore;
+    /**
+     * Aggregate critical issues across all slides
+     */
+    private aggregateCriticalIssues;
+    /**
+     * Generate recommendations based on validation results
+     */
+    private generateRecommendations;
+    /**
+     * Get query count
+     */
+    getQueryCount(): number;
+}
+declare function getExpertValidator(): ExpertValidator;
+
+/**
+ * PersuasionEngine - Applies Persuasion Psychology to Presentations
+ *
+ * THIS MODULE ENHANCES PRESENTATIONS WITH PSYCHOLOGICAL PERSUASION.
+ *
+ * ALL decisions flow through the KnowledgeOrchestrator - NO hardcoding.
+ *
+ * Implements frameworks from:
+ *
+ * ROBERT CIALDINI - 6 Principles of Influence:
+ * - Reciprocity: Give value first
+ * - Commitment/Consistency: Build on prior agreements
+ * - Social Proof: Show what others are doing
+ * - Authority: Cite credible experts
+ * - Liking: Create rapport and common ground
+ * - Scarcity: Highlight limited opportunities
+ *
+ * DANIEL KAHNEMAN - Dual Process Theory:
+ * - System 1: Fast, intuitive, emotional
+ * - System 2: Slow, deliberate, rational
+ * - Cognitive biases and heuristics
+ *
+ * CHIP & DAN HEATH - Made to Stick (SUCCESs):
+ * - Simple: Find the core
+ * - Unexpected: Break patterns
+ * - Concrete: Use specific examples
+ * - Credible: Cite proof
+ * - Emotional: Appeal to feelings
+ * - Stories: Use narrative
+ *
+ * ARISTOTLE - Rhetoric:
+ * - Ethos: Credibility
+ * - Pathos: Emotion
+ * - Logos: Logic
+ *
+ * The knowledge base IS the brain. This code is just plumbing.
+ */
+
+type CialdiniPrinciple = 'reciprocity' | 'commitment_consistency' | 'social_proof' | 'authority' | 'liking' | 'scarcity';
+type KahnemanSystem = 'system_1' | 'system_2';
+type HeathPrinciple = 'simple' | 'unexpected' | 'concrete' | 'credible' | 'emotional' | 'stories';
+type AristotleAppeal = 'ethos' | 'pathos' | 'logos';
+interface PersuasionOpportunity {
+    principle: CialdiniPrinciple | HeathPrinciple | AristotleAppeal;
+    source: string;
+    kbPath: string;
+    location: 'title' | 'subtitle' | 'bullet' | 'content';
+    originalText: string;
+    enhancedText: string;
+    reasoning: string;
+    confidence: number;
+}
+interface SectionPersuasionAnalysis {
+    section: ExtractedSection;
+    cialdiniOpportunities: Map<CialdiniPrinciple, PersuasionOpportunity[]>;
+    heathAlignment: Map<HeathPrinciple, number>;
+    kahnemanTarget: KahnemanSystem;
+    aristotleBalance: Record<AristotleAppeal, number>;
+    overallPersuasivenessScore: number;
+    recommendations: string[];
+}
+interface PresentationPersuasionAnalysis {
+    sections: SectionPersuasionAnalysis[];
+    cialdiniUsage: Record<CialdiniPrinciple, number>;
+    heathScore: number;
+    kahnemanBalance: {
+        system1: number;
+        system2: number;
+    };
+    aristotleBalance: Record<AristotleAppeal, number>;
+    overallPersuasivenessScore: number;
+    topOpportunities: PersuasionOpportunity[];
+    kbQueriesUsed: number;
+}
+/**
+ * PersuasionEngine - Applies persuasion psychology
+ */
+declare class PersuasionEngine {
+    private orchestrator;
+    private cialdiniKB;
+    private kahnemanKB;
+    private heathKB;
+    private queryCount;
+    private initialized;
+    constructor();
+    /**
+     * Initialize by loading all persuasion frameworks from KB
+     * OPTIMIZATION: Only initialize once - cached data is reused
+     */
+    initialize(): Promise<void>;
+    /**
+     * Analyze content for persuasion opportunities
+     */
+    analyzePersuasion(sections: ExtractedSection[], mode: PresentationMode): Promise<PresentationPersuasionAnalysis>;
+    /**
+     * Analyze a single section for persuasion
+     */
+    private analyzeSection;
+    /**
+     * Find Cialdini principle opportunities
+     * KB: persuasion_psychology.cialdini_principles
+     */
+    private findCialdiniOpportunities;
+    /**
+     * Analyze Heath Brothers' SUCCESs alignment
+     * KB: persuasion_psychology.heath_brothers
+     */
+    private analyzeHeathAlignment;
+    /**
+     * Determine Kahneman System target
+     * KB: persuasion_psychology.kahneman_systems
+     */
+    private determineKahnemanTarget;
+    /**
+     * Analyze Aristotle's rhetorical balance
+     * KB: persuasion_psychology.aristotle
+     */
+    private analyzeAristotleBalance;
+    /**
+     * Calculate section persuasiveness score
+     */
+    private calculateSectionPersuasiveness;
+    /**
+     * Generate recommendations for a section
+     */
+    private generateSectionRecommendations;
+    /**
+     * Aggregate Cialdini usage across sections
+     */
+    private aggregateCialdiniUsage;
+    /**
+     * Calculate overall Heath SUCCESs score
+     */
+    private calculateHeathScore;
+    /**
+     * Calculate Kahneman balance
+     */
+    private calculateKahnemanBalance;
+    /**
+     * Calculate Aristotle balance across presentation
+     */
+    private calculateAristotleBalance;
+    /**
+     * Calculate overall persuasiveness score
+     */
+    private calculateOverallPersuasiveness;
+    /**
+     * Find top persuasion opportunities
+     */
+    private findTopOpportunities;
+    /**
+     * Get suggested persuasion enhancements for a slide
+     * Returns specific text suggestions based on KB principles
+     */
+    getSlideEnhancements(slide: Slide, mode: PresentationMode): Promise<{
+        enhancedTitle?: string | undefined;
+        enhancedBullets?: string[] | undefined;
+        persuasionTechniques: string[];
+        kbReferences: string[];
+    }>;
+    /**
+     * Get power words from KB
+     * KB: persuasion_psychology.power_words
+     */
+    getPowerWords(): Promise<{
+        urgency: string[];
+        exclusivity: string[];
+        emotion: string[];
+        authority: string[];
+        kbPath: string;
+    }>;
+    /**
+     * Get query count
+     */
+    getQueryCount(): number;
+}
+declare function getPersuasionEngine(): PersuasionEngine;
+
+/**
+ * Claude Presentation Master
+ *
+ * Generate world-class presentations using expert methodologies from
+ * Duarte, Reynolds, Gallo, and Anderson. Enforces rigorous quality
+ * standards through real visual validation.
+ *
+ * @packageDocumentation
+ * @module claude-presentation-master
+ * @author Stuart Kerr <stuart@isovision.ai>
+ * @license MIT
+ */
+
+/**
+ * Generate a presentation from content.
+ *
+ * @example
+ * ```typescript
+ * import { generate } from '@isovision/claude-presentation-master';
+ *
+ * const result = await generate({
+ *   content: '# My Presentation\n\n...',
+ *   contentType: 'markdown',
+ *   mode: 'keynote',
+ *   format: ['html', 'pptx'],
+ *   qaThreshold: 95,
+ *   title: 'My Amazing Presentation'
+ * });
+ *
+ * console.log(`Score: ${result.score}/100`);
+ * ```
+ *
+ * @param config - Presentation configuration
+ * @returns Presentation result with outputs, QA results, and score
+ * @throws {ValidationError} If input validation fails
+ * @throws {QAFailureError} If QA score is below threshold
+ */
+declare function generate(config: PresentationConfig): Promise<PresentationResult>;
+/**
+ * Validate an existing presentation.
+ *
+ * @example
+ * ```typescript
+ * import { validate } from '@isovision/claude-presentation-master';
+ * import fs from 'fs';
+ *
+ * const html = fs.readFileSync('presentation.html', 'utf-8');
+ * const result = await validate(html, { mode: 'keynote' });
+ *
+ * console.log(`Score: ${result.score}/100`);
+ * console.log(`Passed: ${result.passed}`);
+ * ```
+ *
+ * @param presentation - HTML string or file buffer
+ * @param options - Validation options
  * @returns QA validation results
  */
 declare function validate(presentation: string | Buffer, options?: {
@@ -2046,9 +3770,16 @@ declare function validate(presentation: string | Buffer, options?: {
 /**
  * Get the version of the package.
  */
-declare const VERSION = "2.0.0";
+declare const VERSION = "3.0.1";
+
 /**
  * Default export for convenience.
+ *
+ * Now includes Knowledge-Driven Orchestration components:
+ * - getKnowledgeOrchestrator: Central brain that routes ALL decisions through KB
+ * - getNarrativeAnalyzer: Duarte Sparkline, STAR moments, SCQA analysis
+ * - getExpertValidator: Validates against 40+ expert methodologies
+ * - getPersuasionEngine: Cialdini, Kahneman, Heath Brothers
  */
 declare const _default: {
     generate: typeof generate;
@@ -2058,6 +3789,10 @@ declare const _default: {
     PPTXValidator: typeof PPTXValidator;
     AccessibilityValidator: typeof AccessibilityValidator;
     VERSION: string;
+    getKnowledgeOrchestrator: typeof getKnowledgeOrchestrator;
+    getNarrativeAnalyzer: typeof getNarrativeAnalyzer;
+    getExpertValidator: typeof getExpertValidator;
+    getPersuasionEngine: typeof getPersuasionEngine;
 };
 
-export { type AccessibilityResults, AccessibilityValidator, AutoRemediation, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, CompositeChartProvider, CompositeImageProvider, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContentTransform, type ContrastIssue, type ExecutionStrategy, type ExpertQAResults, type ExpertValidation, type FontSizeIssue, type GlanceTestResult, HTMLLayoutValidator, HallucinationDetector, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, KnowledgeBase, LocalImageProvider, MermaidProvider, type MetricData, type OneIdeaResult, type OutputFormat, PPTXValidator, PRESENTATION_TYPE_RULES, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationResult, type PresentationType, type PresentationTypeRules, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStructure, ScoreCalculator, type SignalNoiseResult, type Slide, type SlideBlueprint, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideVisualScore, type SparklineStructure, StrategyFactory, TemplateEngine, TemplateNotFoundError, type ThemeName, TypeDetector, UnsplashImageProvider, VERSION, ValidationError, type VisualQAResults, createDefaultChartProvider, createDefaultImageProvider, _default as default, generate, getKnowledgeBase, validate };
+export { type AccessibilityResults, AccessibilityValidator, type AgentAssessment, type AristotleAppeal, type AspectRatio, AutoRemediation, type ChartData, type ChartDataset, ChartJsProvider, type ChartProvider, type ChartRequest, type ChartResult, type ChartType, type CialdiniPrinciple, type ComparisonData, CompositeChartProvider, CompositeImageProvider, type ConsensusConfig, type ConsensusResult, ConsensusValidator, type ContentAnalysis, ContentAnalyzer, type ContentQAResults, type ContentTransform, type ContrastIssue, type EmotionalPosition, type ExecutionStrategy, type ExpertAgent, type ExpertQAResults, type ExpertValidation, ExpertValidator, type ExtractedConcept$1 as ExtractedConcept, type ExtractedDataPoint, type ExtractedSection, type FinancialSummary, type FontSizeIssue, type GlanceTestResult, HTMLLayoutValidator, HallucinationDetector, type HeathPrinciple, type ImageData, type ImageProvider, type ImageRequest, type ImageResult, type ImageSize, type KBQueryLog, type KahnemanSystem, KnowledgeBase, KnowledgeOrchestrator, LocalImageProvider, MermaidProvider, type MetricData, NANOBANANA_PROMPT_TEMPLATES, type NanoBananaConfig, type NanoBananaModel, NanoBananaProvider, NarrativeAnalyzer, type OneIdeaResult, type OrchestratorConfig, type OrchestratorDecision, type OutputFormat, PPTXValidator, PRESENTATION_TYPE_RULES, type ParsedTable, PersuasionEngine, type PersuasionOpportunity, PlaceholderImageProvider, PowerPointGenerator, type PresentationConfig, PresentationEngine, type PresentationMetadata, type PresentationMode, type PresentationNarrativeAnalysis, type PresentationPersuasionAnalysis, type PresentationResult, type PresentationType, type PresentationTypeRules, type PresentationValidation, type PresentationVisionAnalysis, type PromptTemplate, QAEngine, QAFailureError, type QAIssue, type QAResults, QuickChartProvider, RevealJsGenerator, type SCQAStage, type SCQAStructure, ScoreCalculator, type SectionNarrativeAnalysis, type SectionPersuasionAnalysis, type SemanticCompletenessResult$1 as SemanticCompletenessResult, SemanticCompletenessValidator, type SignalNoiseResult, type Slide, type SlideBlueprint, type SlideContentScore, type SlideData, SlideFactory, type SlideType, type SlideValidation, type SlideVisionAnalysis, type SlideVisualScore, type SparklineStage, type SparklineStructure, StrategyFactory, TemplateEngine, TemplateNotFoundError, type ThemeName, TypeDetector, UnsplashImageProvider, VERSION, type ValidationCheck, ValidationError, type VisionQAConfig, VisionQAEngine, type VisionQAResults, type VisionSlideAnalysis, type VisualQAResults, createConsensusValidator, createDefaultChartProvider, createDefaultImageProvider, createKnowledgeOrchestrator, createNanoBananaProvider, createVisionQAEngine, _default as default, generate, getConsensusValidator, getExpertValidator, getKnowledgeBase, getKnowledgeOrchestrator, getNanoBananaPrompt, getNarrativeAnalyzer, getPersuasionEngine, getVisionQAEngine, validate };