@felkot/think-mcp 1.1.0

package/dist/services/validation.service.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ValidationService - Thought sequence and path validation
+ * Stateless service - receives data as parameters
+ */
+import type { ThoughtInput, ThoughtRecord, ValidationResult, PathConnectivityResult } from '../types/thought.types.js';
+export declare class ValidationService {
+    /**
+     * Validate thought sequence - prevent skipping steps and invalid revisions
+     * Also validates revision content is meaningfully different
+     * @param input - The thought input to validate
+     * @param sessionThoughts - Current session thoughts
+     * @param lastThoughtNumber - Last recorded thought number
+     */
+    validateSequence(input: ThoughtInput, sessionThoughts: ThoughtRecord[], lastThoughtNumber: number): ValidationResult;
+    /**
+     * Validate thought quality - enforce substance and depth
+     * (v5.3.0) - Rejects lazy thoughts
+     */
+    validateThoughtQuality(input: ThoughtInput, isComplexTask: boolean): ValidationResult;
+    /**
+     * Check semantic quality using entropy and pattern matching
+     * Acts as a lightweight "LLM-Validator"
+     */
+    private checkSemanticQuality;
+    /**
+     * HARD duplicate check - returns error message if duplicate found
+     * Used for strict rejection before adding to history
+     * @param input - The thought input to check
+     * @param sessionThoughts - Current session thoughts
+     */
+    checkDuplicateStrict(input: ThoughtInput, sessionThoughts: ThoughtRecord[]): string | undefined;
+    /**
+     * Validate branch source - reject if branchFromThought references non-existent thought
+     * @param input - The thought input to validate
+     * @param sessionThoughts - Current session thoughts
+     */
+    validateBranchSource(input: ThoughtInput, sessionThoughts: ThoughtRecord[]): string | undefined;
+    /**
+     * Validate path connectivity - ensure thoughts in winningPath are logically connected
+     * Each thought must be reachable from its predecessor via sequence, branch, or revision
+     * @param winningPath - Array of thought numbers in the winning path
+     * @param sessionThoughts - Current session thoughts
+     */
+    validatePathConnectivity(winningPath: number[], sessionThoughts: ThoughtRecord[]): PathConnectivityResult;
+}

package/dist/services/validation.service.js

@@ -0,0 +1,260 @@
+/**
+ * ValidationService - Thought sequence and path validation
+ * Stateless service - receives data as parameters
+ */
+import { calculateJaccardSimilarity, calculateWordEntropy } from '../utils/index.js';
+import { LAZY_THINKING_PATTERNS } from '../constants/patterns.js';
+export class ValidationService {
+    /**
+     * Validate thought sequence - prevent skipping steps and invalid revisions
+     * Also validates revision content is meaningfully different
+     * @param input - The thought input to validate
+     * @param sessionThoughts - Current session thoughts
+     * @param lastThoughtNumber - Last recorded thought number
+     */
+    validateSequence(input, sessionThoughts, lastThoughtNumber) {
+        // Validate revision target - can't revise future or non-existent thoughts
+        if (input.isRevision && input.revisesThought !== undefined) {
+            const targetThought = sessionThoughts.find((t) => t.thoughtNumber === input.revisesThought);
+            if (!targetThought) {
+                return {
+                    valid: false,
+                    warning: `🚫 INVALID REVISION: Cannot revise #${input.revisesThought}. Available: ${sessionThoughts.map((t) => t.thoughtNumber).join(', ')}`
+                };
+            }
+            // Check revision is meaningfully different from original
+            const similarity = calculateJaccardSimilarity(input.thought, targetThought.thought);
+            if (similarity > 0.85) {
+                return {
+                    valid: false,
+                    warning: `⚠️ SHALLOW: ${Math.round(similarity * 100)}% similar. Rewrite substantially.`
+                };
+            }
+            // Check for circular revision (revision text similar to even earlier thought)
+            const earlierThoughts = sessionThoughts.filter((t) => t.thoughtNumber < input.revisesThought && !t.isRevision);
+            for (const earlier of earlierThoughts) {
+                const circularSimilarity = calculateJaccardSimilarity(input.thought, earlier.thought);
+                if (circularSimilarity > 0.8) {
+                    return {
+                        valid: false,
+                        warning: `🔄 CIRCULAR: ${Math.round(circularSimilarity * 100)}% similar to #${earlier.thoughtNumber}. New approach needed.`
+                    };
+                }
+            }
+        }
+        // Allow revisions and branches to jump in sequence
+        if (input.isRevision || input.branchFromThought) {
+            return { valid: true };
+        }
+        // First thought is always valid
+        if (lastThoughtNumber === 0) {
+            return { valid: true };
+        }
+        const expectedNext = lastThoughtNumber + 1;
+        if (input.thoughtNumber > expectedNext) {
+            return {
+                valid: false,
+                warning: `⚠️ Sequence break: expected #${expectedNext}, got #${input.thoughtNumber}.`
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Validate thought quality - enforce substance and depth
+     * (v5.3.0) - Rejects lazy thoughts
+     */
+    validateThoughtQuality(input, isComplexTask) {
+        const isHeavyTask = input.totalThoughts >= 8;
+        // 1. Check Phase Logic
+        if (input.phase) {
+            if (input.phase === 'execution' && input.thoughtNumber === 1) {
+                return {
+                    valid: false,
+                    warning: `⚠️ ILLEGAL PHASE JUMP: You cannot start with 'execution'. Begin with 'initialization' or 'analysis'.`
+                };
+            }
+        }
+        if (isHeavyTask &&
+            input.nextThoughtNeeded &&
+            input.thoughtNumber > 1 &&
+            (!input.subSteps || input.subSteps.length === 0) &&
+            (!input.alternatives || input.alternatives.length === 0)) {
+            return {
+                valid: false,
+                warning: '⚠️ HEAVY TASK: Add subSteps or alternatives for this step to avoid shallow linear reasoning.'
+            };
+        }
+        if (isHeavyTask &&
+            !input.nextThoughtNeeded &&
+            input.thoughtNumber < Math.ceil(input.totalThoughts * 0.7)) {
+            return {
+                valid: false,
+                warning: '⚠️ PREMATURE FINISH: You are ending too early for a heavy task. Continue reasoning or lower totalThoughts with justification.'
+            };
+        }
+        // 1. Minimum Length Check
+        if (input.thought.length < 20) {
+            return {
+                valid: false,
+                warning: `⚠️ TOO SHORT: Thought is too brief (${input.thought.length} chars). Expand your reasoning.`
+            };
+        }
+        // 2. Forbidden Weak Phrases
+        const weakPhrases = ['i hope', 'maybe', 'probably', 'might work', 'guess'];
+        const foundWeakness = weakPhrases.find((phrase) => input.thought.toLowerCase().includes(phrase));
+        if (foundWeakness) {
+            return {
+                valid: false,
+                warning: `⚠️ WEAK LANGUAGE: Avoid "${foundWeakness}". Be precise or use 'think_diverge' to explore uncertainty.`
+            };
+        }
+        // 3. Substeps for Complex Tasks (Middle of chain)
+        // If it's a complex task, and we are not in the first or last thought, require substeps for detailed execution
+        if (isComplexTask &&
+            input.thoughtNumber > 1 &&
+            !input.nextThoughtNeeded &&
+            (!input.subSteps || input.subSteps.length === 0)) {
+            // This is a heuristic: if we are finishing a complex task, we should have had substeps in previous thoughts.
+            // But if this SPECIFIC thought is a summary, it might be fine.
+            // Let's be less strict here to avoid false positives, but still warn.
+            // Actually, let's strictly require substeps if confidence is high (>8) to prove the confidence.
+            if (input.confidence && input.confidence > 8) {
+                return {
+                    valid: false,
+                    warning: `⚠️ UNJUSTIFIED CONFIDENCE: High confidence (${input.confidence}) requires subSteps to prove the logic. Add subSteps.`
+                };
+            }
+        }
+        // 4. Semantic Heuristics (v5.5.0) - Rejects "lazy" thinking and gibberish
+        const semanticCheck = this.checkSemanticQuality(input);
+        if (!semanticCheck.valid) {
+            return semanticCheck;
+        }
+        // 5. Complexity Budget Check (Game Theory)
+        // If thought proposes new files/libs without justification in "planning" phase
+        if (input.phase === 'strategy') {
+            const lowerT = input.thought.toLowerCase();
+            if ((lowerT.includes('create new file') || lowerT.includes('add library')) &&
+                input.thought.length < 100) {
+                return {
+                    valid: false,
+                    warning: `⚠️ COMPLEXITY BUDGET: Creating files/libs costs tokens. Justify WHY this is needed in detail (>100 chars).`
+                };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * Check semantic quality using entropy and pattern matching
+     * Acts as a lightweight "LLM-Validator"
+     */
+    checkSemanticQuality(input) {
+        // A. Entropy Check (detects gibberish or extreme repetition)
+        const entropy = calculateWordEntropy(input.thought);
+        // Threshold 0.2: Relaxed to allow simple commands
+        if (entropy < 0.2 && input.thought.length > 50) {
+            return {
+                valid: false,
+                warning: `⚠️ LOW ENTROPY (${entropy.toFixed(2)}): Thought is too repetitive. Elaborate with diverse vocabulary.`
+            };
+        }
+        // B. Lazy Thinking Detection (e.g. "I will just simply...")
+        const lowerThought = input.thought.toLowerCase();
+        const foundLazyPattern = LAZY_THINKING_PATTERNS.find((pattern) => lowerThought.includes(pattern));
+        if (foundLazyPattern) {
+            // Allow if confidence is low (honest uncertainty)
+            if (!input.confidence || input.confidence > 5) {
+                return {
+                    valid: false,
+                    warning: `⚠️ LAZY THINKING DETECTED: Avoid terms like "${foundLazyPattern}". Be specific about HOW and WHY.`
+                };
+            }
+        }
+        // C. Context Awareness Check
+        // If files are provided but not mentioned, warn?
+        // (Disabled for now as it might be too strict, but good for future)
+        return { valid: true };
+    }
+    /**
+     * HARD duplicate check - returns error message if duplicate found
+     * Used for strict rejection before adding to history
+     * @param input - The thought input to check
+     * @param sessionThoughts - Current session thoughts
+     */
+    checkDuplicateStrict(input, sessionThoughts) {
+        if (input.isRevision)
+            return undefined; // Revisions are allowed to reuse numbers
+        const exists = sessionThoughts.some((t) => t.thoughtNumber === input.thoughtNumber);
+        if (exists) {
+            return `🚫 REJECTED: #${input.thoughtNumber} exists. Use isRevision:true or quickExtension.`;
+        }
+        return undefined;
+    }
+    /**
+     * Validate branch source - reject if branchFromThought references non-existent thought
+     * @param input - The thought input to validate
+     * @param sessionThoughts - Current session thoughts
+     */
+    validateBranchSource(input, sessionThoughts) {
+        if (!input.branchFromThought)
+            return undefined;
+        const sourceExists = sessionThoughts.some((t) => t.thoughtNumber === input.branchFromThought);
+        if (!sourceExists) {
+            return `🚫 INVALID BRANCH: Cannot branch from #${input.branchFromThought}. Available: ${sessionThoughts.map((t) => t.thoughtNumber).join(', ') || 'none'}`;
+        }
+        return undefined;
+    }
+    /**
+     * Validate path connectivity - ensure thoughts in winningPath are logically connected
+     * Each thought must be reachable from its predecessor via sequence, branch, or revision
+     * @param winningPath - Array of thought numbers in the winning path
+     * @param sessionThoughts - Current session thoughts
+     */
+    validatePathConnectivity(winningPath, sessionThoughts) {
+        if (winningPath.length <= 1)
+            return { valid: true };
+        const thoughtMap = new Map(sessionThoughts.map((t) => [t.thoughtNumber, t]));
+        for (let i = 1; i < winningPath.length; i++) {
+            const current = winningPath[i];
+            const previous = winningPath[i - 1];
+            const currentThought = thoughtMap.get(current);
+            if (!currentThought) {
+                return {
+                    valid: false,
+                    error: `Thought #${current} not found`,
+                    disconnectedAt: current
+                };
+            }
+            // Build set of valid predecessors for current thought
+            const validPredecessors = new Set();
+            // Sequential predecessor (N can follow N-1)
+            validPredecessors.add(current - 1);
+            // Branch source (if this thought branches from another)
+            if (currentThought.branchFromThought) {
+                validPredecessors.add(currentThought.branchFromThought);
+            }
+            // Revision target (revision can follow the thought it revises)
+            if (currentThought.isRevision && currentThought.revisesThought) {
+                validPredecessors.add(currentThought.revisesThought);
+                // Also allow revision to follow the thought BEFORE the one it revises
+                validPredecessors.add(currentThought.revisesThought - 1);
+            }
+            // Special case: if previous thought was revised, current can follow the revision
+            const previousThought = thoughtMap.get(previous);
+            if (previousThought?.isRevision && previousThought.revisesThought) {
+                // Allow next sequential after revision target
+                validPredecessors.add(previousThought.revisesThought + 1);
+            }
+            if (!validPredecessors.has(previous)) {
+                return {
+                    valid: false,
+                    error: `Path discontinuity: #${current} cannot logically follow #${previous}. Valid predecessors for #${current}: [${Array.from(validPredecessors)
+                        .sort((a, b) => a - b)
+                        .join(', ')}]`,
+                    disconnectedAt: current
+                };
+            }
+        }
+        return { valid: true };
+    }
+}

package/dist/services/visualization.service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * VisualizationService - ASCII tree and Mermaid diagram generation
+ * Stateless service - receives data as parameters
+ * v4.3.0 - Improved visualization with confidence icons and truncation
+ */
+import type { ThoughtRecord } from '../types/thought.types.js';
+export declare class VisualizationService {
+    /**
+     * Generate ASCII tree visualization of thought structure
+     * v4.3.0: Added confidence icons, truncation for long sessions
+     * @param sessionThoughts - thoughts from current session
+     * @param branches - Map of branch ID to branch thoughts
+     */
+    generateAsciiTree(sessionThoughts: ThoughtRecord[], branches: Map<string, ThoughtRecord[]>): string;
+    /**
+     * Generate Mermaid.js graph visualization
+     * @param sessionThoughts - thoughts from current session
+     * @param branches - Map of branch ID to branch thoughts
+     * @param thoughtHistory - full thought history for branch filtering
+     * @param sessionStartIndex - index where current session starts
+     */
+    generateMermaid(sessionThoughts: ThoughtRecord[], branches: Map<string, ThoughtRecord[]>, thoughtHistory: ThoughtRecord[], sessionStartIndex: number): string;
+}

package/dist/services/visualization.service.js

@@ -0,0 +1,211 @@
+/**
+ * VisualizationService - ASCII tree and Mermaid diagram generation
+ * Stateless service - receives data as parameters
+ * v4.3.0 - Improved visualization with confidence icons and truncation
+ */
+import { sanitizeForMermaid } from '../utils/index.js';
+// v4.3.0: Max thoughts to show in tree (older ones collapsed)
+const MAX_TREE_THOUGHTS = 5;
+/**
+ * Get confidence icon based on score
+ */
+function getConfidenceIcon(confidence) {
+    if (!confidence)
+        return '○';
+    if (confidence >= 8)
+        return '✅';
+    if (confidence >= 5)
+        return '⚠️';
+    return '❌';
+}
+export class VisualizationService {
+    /**
+     * Generate ASCII tree visualization of thought structure
+     * v4.3.0: Added confidence icons, truncation for long sessions
+     * @param sessionThoughts - thoughts from current session
+     * @param branches - Map of branch ID to branch thoughts
+     */
+    generateAsciiTree(sessionThoughts, branches) {
+        if (sessionThoughts.length === 0)
+            return '(empty)';
+        const mainThoughts = sessionThoughts.filter((t) => !t.branchFromThought && !t.isRevision);
+        // v4.3.0: Truncate long sessions
+        const shouldTruncate = mainThoughts.length > MAX_TREE_THOUGHTS;
+        const hiddenCount = shouldTruncate ? mainThoughts.length - MAX_TREE_THOUGHTS : 0;
+        const visibleThoughts = shouldTruncate
+            ? mainThoughts.slice(-MAX_TREE_THOUGHTS)
+            : mainThoughts;
+        const lines = ['📊 Thought Tree:'];
+        // Show truncation notice
+        if (shouldTruncate) {
+            lines.push(`│   ... ${hiddenCount} earlier thought(s) hidden`);
+        }
+        for (let i = 0; i < visibleThoughts.length; i++) {
+            const thought = visibleThoughts[i];
+            const isLast = i === visibleThoughts.length - 1;
+            const prefix = isLast ? '└──' : '├──';
+            const childPrefix = isLast ? '    ' : '│   ';
+            // v4.3.0: Confidence icon instead of [N]
+            const confIcon = getConfidenceIcon(thought.confidence);
+            const preview = thought.thought.substring(0, 35);
+            lines.push(`${prefix} ${confIcon} #${thought.thoughtNumber}: ${preview}...`);
+            // Show subSteps (compact)
+            if (thought.subSteps && thought.subSteps.length > 0) {
+                lines.push(`${childPrefix}📋 [${thought.subSteps.length} steps]`);
+            }
+            // Show alternatives (compact)
+            if (thought.alternatives && thought.alternatives.length > 0) {
+                lines.push(`${childPrefix}⚖️ [${thought.alternatives.length} alts]`);
+            }
+            // Show extensions (compact - only count)
+            if (thought.extensions && thought.extensions.length > 0) {
+                const blockers = thought.extensions.filter(e => e.impact === 'blocker').length;
+                const extInfo = blockers > 0 ? `${thought.extensions.length} ext, ${blockers}🚫` : `${thought.extensions.length} ext`;
+                lines.push(`${childPrefix}🔍 [${extInfo}]`);
+            }
+            // Show revisions (compact)
+            const revisions = sessionThoughts.filter((t) => t.isRevision && t.revisesThought === thought.thoughtNumber);
+            if (revisions.length > 0) {
+                lines.push(`${childPrefix}🔄 [${revisions.length} revision(s)]`);
+            }
+            // Show branches (compact)
+            for (const [branchId, branchThoughts] of branches) {
+                const fromThis = branchThoughts.filter((t) => t.branchFromThought === thought.thoughtNumber);
+                if (fromThis.length > 0) {
+                    lines.push(`${childPrefix}🌿 [${branchId}]: ${fromThis.length} thought(s)`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate Mermaid.js graph visualization
+     * @param sessionThoughts - thoughts from current session
+     * @param branches - Map of branch ID to branch thoughts
+     * @param thoughtHistory - full thought history for branch filtering
+     * @param sessionStartIndex - index where current session starts
+     */
+    generateMermaid(sessionThoughts, branches, thoughtHistory, sessionStartIndex) {
+        if (sessionThoughts.length === 0)
+            return '';
+        const lines = ['graph TD;'];
+        const mainThoughts = sessionThoughts.filter((t) => !t.branchFromThought && !t.isRevision);
+        // Build set of revised thoughts (thoughts that have been superseded)
+        const revisedThoughts = new Set(sessionThoughts
+            .filter((t) => t.isRevision && t.revisesThought)
+            .map((t) => t.revisesThought));
+        // Build set of thoughts with blocker extensions
+        const blockerThoughts = new Set(sessionThoughts
+            .filter((t) => t.extensions?.some((e) => e.impact === 'blocker'))
+            .map((t) => t.thoughtNumber));
+        // Main flow subgraph
+        lines.push('  subgraph MainFlow["🧠 Main Reasoning"]');
+        // Add start node
+        if (mainThoughts.length > 0) {
+            lines.push(`    start((Start)) --> ${mainThoughts[0].thoughtNumber};`);
+        }
+        // Process each main thought
+        for (let i = 0; i < mainThoughts.length; i++) {
+            const t = mainThoughts[i];
+            const label = sanitizeForMermaid(t.thought.substring(0, 25));
+            const confLabel = t.confidence ? `<br/>conf:${t.confidence}` : '';
+            const subStepsLabel = t.subSteps && t.subSteps.length > 0 ? `<br/>📋${t.subSteps.length} steps` : '';
+            const altsLabel = t.alternatives && t.alternatives.length > 0 ? `<br/>⚖️${t.alternatives.length} alts` : '';
+            // Determine style class with priority: blocker > revised > lowConf > highConf > normal
+            let styleClass = 'normal';
+            if (blockerThoughts.has(t.thoughtNumber)) {
+                styleClass = 'blocker';
+            }
+            else if (revisedThoughts.has(t.thoughtNumber)) {
+                styleClass = 'revised';
+            }
+            else if (t.confidence && t.confidence < 5) {
+                styleClass = 'lowConf';
+            }
+            else if (t.confidence && t.confidence >= 8) {
+                styleClass = 'highConf';
+            }
+            lines.push(`    ${t.thoughtNumber}["#${t.thoughtNumber}: ${label}...${confLabel}${subStepsLabel}${altsLabel}"]:::${styleClass};`);
+            // Edge to next thought
+            if (i < mainThoughts.length - 1) {
+                lines.push(`    ${t.thoughtNumber} --> ${mainThoughts[i + 1].thoughtNumber};`);
+            }
+        }
+        lines.push('  end');
+        // Extensions subgraph (if any)
+        const hasExtensions = mainThoughts.some((t) => t.extensions && t.extensions.length > 0);
+        if (hasExtensions) {
+            lines.push('  subgraph Extensions["🔍 Deep Analysis"]');
+            for (const t of mainThoughts) {
+                if (t.extensions && t.extensions.length > 0) {
+                    t.extensions.forEach((ext, idx) => {
+                        const extId = `ext_${t.thoughtNumber}_${idx}`;
+                        const extLabel = sanitizeForMermaid(ext.content.substring(0, 20));
+                        const extClass = ext.impact === 'blocker' ? 'blocker' : ext.impact === 'high' ? 'highImpact' : 'ext';
+                        const icon = ext.impact === 'blocker' ? '🚫' : ext.impact === 'high' ? '⚠️' : '📝';
+                        lines.push(`    ${extId}[/"${icon} ${ext.type}: ${extLabel}..."/]:::${extClass};`);
+                    });
+                }
+            }
+            lines.push('  end');
+            // Connect extensions to main thoughts
+            for (const t of mainThoughts) {
+                if (t.extensions && t.extensions.length > 0) {
+                    t.extensions.forEach((_, idx) => {
+                        const extId = `ext_${t.thoughtNumber}_${idx}`;
+                        lines.push(`  ${t.thoughtNumber} -.-> ${extId};`);
+                    });
+                }
+            }
+        }
+        // Revisions subgraph (if any)
+        const revisions = sessionThoughts.filter((t) => t.isRevision);
+        if (revisions.length > 0) {
+            lines.push('  subgraph Revisions["🔄 Revisions"]');
+            revisions.forEach((rev, idx) => {
+                const revId = `rev_${rev.revisesThought}_${idx}`;
+                const revLabel = sanitizeForMermaid(rev.thought.substring(0, 20));
+                lines.push(`    ${revId}["🔄 ${revLabel}..."]:::revision;`);
+            });
+            lines.push('  end');
+            // Connect revisions to targets
+            revisions.forEach((rev, idx) => {
+                const revId = `rev_${rev.revisesThought}_${idx}`;
+                lines.push(`  ${revId} ==> ${rev.revisesThought};`);
+            });
+        }
+        // Branch subgraphs
+        for (const [branchId, branchThoughts] of branches) {
+            const sessionBranchThoughts = branchThoughts.filter((bt) => {
+                return thoughtHistory.indexOf(bt) >= sessionStartIndex;
+            });
+            if (sessionBranchThoughts.length > 0) {
+                lines.push(`  subgraph Branch_${branchId}["🌿 Branch: ${branchId}"]`);
+                sessionBranchThoughts.forEach((bt, idx) => {
+                    const branchNodeId = `branch_${branchId}_${idx}`;
+                    const btLabel = sanitizeForMermaid(bt.thought.substring(0, 20));
+                    lines.push(`    ${branchNodeId}["${btLabel}..."]:::branch;`);
+                });
+                lines.push('  end');
+                // Connect branches to source thoughts
+                sessionBranchThoughts.forEach((bt, idx) => {
+                    if (bt.branchFromThought) {
+                        const branchNodeId = `branch_${branchId}_${idx}`;
+                        lines.push(`  ${bt.branchFromThought} -.->|${branchId}| ${branchNodeId};`);
+                    }
+                });
+            }
+        }
+        // Style definitions with visual intelligence
+        lines.push('  classDef normal fill:#e1f5fe,stroke:#01579b;');
+        lines.push('  classDef highConf fill:#e1f5fe,stroke:#ffd700,stroke-width:3px;');
+        lines.push('  classDef lowConf fill:#ffecb3,stroke:#ff6f00;');
+        lines.push('  classDef blocker fill:#ffcdd2,stroke:#b71c1c,stroke-width:3px;');
+        lines.push('  classDef revised fill:#e0e0e0,stroke:#9e9e9e,stroke-dasharray:5 5;');
+        lines.push('  classDef highImpact fill:#fff3e0,stroke:#e65100;');
+        lines.push('  classDef ext fill:#f3e5f5,stroke:#7b1fa2;');
+        lines.push('  classDef revision fill:#e8f5e9,stroke:#2e7d32;');
+        lines.push('  classDef branch fill:#e0f2f1,stroke:#00695c;');
+        return lines.join('\n');
+    }
+}