@felkot/think-mcp 1.1.0

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

@@ -0,0 +1,39 @@
+/**
+ * BurstService - Validation and processing for burst thinking sessions
+ * Stateless service - validates input and returns prepared data for commit
+ */
+import type { BurstThought, BurstConsolidation, BurstMetrics, ThoughtRecord } from '../types/thought.types.js';
+/** Burst validation limits */
+export declare const BURST_LIMITS: {
+    maxThoughts: number;
+    minThoughts: number;
+    maxThoughtLength: number;
+    minThoughtLength: number;
+    maxStagnationScore: number;
+    minAvgEntropy: number;
+    minAvgConfidence: number;
+};
+/** Validation result from burst service */
+export interface BurstValidationResult {
+    passed: boolean;
+    errors: string[];
+    warnings: string[];
+    metrics: BurstMetrics;
+    /** Sorted thoughts ready for commit (only if passed) */
+    sortedThoughts?: BurstThought[];
+}
+export declare class BurstService {
+    /**
+     * Validate burst thinking session
+     * Returns validation result with prepared data for commit
+     */
+    validate(goal: string, thoughts: BurstThought[], consolidation?: BurstConsolidation): BurstValidationResult;
+    /**
+     * Validate consolidation data
+     */
+    private validateConsolidation;
+    /**
+     * Convert BurstThought to ThoughtRecord
+     */
+    toThoughtRecord(t: BurstThought, totalThoughts: number, sessionId: string): ThoughtRecord;
+}

package/dist/services/burst.service.js

@@ -0,0 +1,215 @@
+/**
+ * BurstService - Validation and processing for burst thinking sessions
+ * Stateless service - validates input and returns prepared data for commit
+ */
+import { calculateWordEntropy, calculateJaccardSimilarity } from '../utils/index.js';
+/** Burst validation limits */
+export const BURST_LIMITS = {
+    maxThoughts: 30,
+    minThoughts: 1,
+    maxThoughtLength: 2000, // Increased for deep architecture
+    minThoughtLength: 10, // Synced with thresholds.ts (was 50)
+    maxStagnationScore: 0.8, // Relaxed (was 0.6) - allow repetitive boilerplate
+    minAvgEntropy: 0.2, // Relaxed (was 0.25)
+    minAvgConfidence: 4,
+};
+export class BurstService {
+    /**
+     * Validate burst thinking session
+     * Returns validation result with prepared data for commit
+     */
+    validate(goal, thoughts, consolidation) {
+        const errors = [];
+        const warnings = [];
+        // === PHASE 1: Basic Validation ===
+        if (!goal || goal.trim().length < 10) {
+            errors.push('Goal is required and must be at least 10 characters');
+        }
+        if (!thoughts || thoughts.length === 0) {
+            errors.push('At least 1 thought is required');
+        }
+        else if (thoughts.length > BURST_LIMITS.maxThoughts) {
+            errors.push(`Too many thoughts: ${thoughts.length} > ${BURST_LIMITS.maxThoughts} max`);
+        }
+        // Early exit if basic validation fails
+        if (errors.length > 0) {
+            return {
+                passed: false,
+                errors,
+                warnings,
+                metrics: { avgConfidence: 0, avgEntropy: 0, avgLength: 0, stagnationScore: 0, thoughtCount: 0 },
+            };
+        }
+        // === PHASE 2: Sequence Validation ===
+        const sortedThoughts = [...thoughts].sort((a, b) => a.thoughtNumber - b.thoughtNumber);
+        for (let i = 0; i < sortedThoughts.length; i++) {
+            const expected = i + 1;
+            const actual = sortedThoughts[i].thoughtNumber;
+            if (actual !== expected && !sortedThoughts[i].isRevision) {
+                errors.push(`Sequence break: expected thought #${expected}, got #${actual}`);
+                break;
+            }
+        }
+        // Check for duplicate thought numbers (excluding revisions)
+        const nonRevisionNumbers = thoughts.filter(t => !t.isRevision).map(t => t.thoughtNumber);
+        const duplicates = nonRevisionNumbers.filter((n, i) => nonRevisionNumbers.indexOf(n) !== i);
+        if (duplicates.length > 0) {
+            errors.push(`Duplicate thought numbers: ${[...new Set(duplicates)].join(', ')}`);
+        }
+        // === PHASE 3: Content Quality Validation ===
+        let totalLength = 0;
+        let totalEntropy = 0;
+        let totalConfidence = 0;
+        let confidenceCount = 0;
+        for (const t of thoughts) {
+            if (t.thought.length < BURST_LIMITS.minThoughtLength) {
+                errors.push(`#${t.thoughtNumber} too short: ${t.thought.length} < ${BURST_LIMITS.minThoughtLength}`);
+            }
+            if (t.thought.length > BURST_LIMITS.maxThoughtLength) {
+                warnings.push(`#${t.thoughtNumber} truncated: ${t.thought.length} > ${BURST_LIMITS.maxThoughtLength}`);
+            }
+            totalLength += Math.min(t.thought.length, BURST_LIMITS.maxThoughtLength);
+            totalEntropy += calculateWordEntropy(t.thought);
+            if (t.confidence !== undefined) {
+                totalConfidence += t.confidence;
+                confidenceCount++;
+            }
+            // Validate revision targets
+            if (t.isRevision && t.revisesThought !== undefined) {
+                const targetExists = thoughts.some(other => other.thoughtNumber === t.revisesThought);
+                if (!targetExists) {
+                    errors.push(`Revision #${t.thoughtNumber} targets non-existent #${t.revisesThought}`);
+                }
+            }
+            // Validate branch sources
+            if (t.branchFromThought !== undefined) {
+                const sourceExists = thoughts.some(other => other.thoughtNumber === t.branchFromThought);
+                if (!sourceExists) {
+                    errors.push(`Branch #${t.thoughtNumber} from non-existent #${t.branchFromThought}`);
+                }
+            }
+        }
+        // === PHASE 4: Stagnation Detection (only if enough thoughts) ===
+        let stagnationScore = 0;
+        if (thoughts.length >= 3) { // v5.0.1: Skip for small batches
+            let totalSimilarity = 0;
+            let comparisons = 0;
+            for (let i = 1; i < thoughts.length; i++) {
+                const similarity = calculateJaccardSimilarity(thoughts[i].thought, thoughts[i - 1].thought);
+                totalSimilarity += similarity;
+                comparisons++;
+            }
+            stagnationScore = comparisons > 0 ? totalSimilarity / comparisons : 0;
+            if (stagnationScore > BURST_LIMITS.maxStagnationScore) {
+                errors.push(`Stagnation: ${(stagnationScore * 100).toFixed(0)}% similarity > ${BURST_LIMITS.maxStagnationScore * 100}%`);
+            }
+        }
+        // === PHASE 5: Calculate Metrics ===
+        const avgLength = thoughts.length > 0 ? totalLength / thoughts.length : 0;
+        const avgEntropy = thoughts.length > 0 ? totalEntropy / thoughts.length : 0;
+        const avgConfidence = confidenceCount > 0 ? totalConfidence / confidenceCount : 0;
+        // v5.0.1: Skip entropy warning for small batches (< 5 thoughts)
+        if (avgEntropy < BURST_LIMITS.minAvgEntropy && thoughts.length >= 5) {
+            warnings.push(`Low diversity: ${avgEntropy.toFixed(2)} < ${BURST_LIMITS.minAvgEntropy}`);
+        }
+        if (avgConfidence < BURST_LIMITS.minAvgConfidence && confidenceCount > 0) {
+            warnings.push(`Low confidence: ${avgConfidence.toFixed(1)} < ${BURST_LIMITS.minAvgConfidence}`);
+        }
+        // === PHASE 6: Consolidation Validation ===
+        if (consolidation) {
+            this.validateConsolidation(consolidation, thoughts, errors, warnings);
+        }
+        const metrics = {
+            avgConfidence: Math.round(avgConfidence * 10) / 10,
+            avgEntropy: Math.round(avgEntropy * 100) / 100,
+            avgLength: Math.round(avgLength),
+            stagnationScore: Math.round(stagnationScore * 100) / 100,
+            thoughtCount: thoughts.length,
+        };
+        return {
+            passed: errors.length === 0,
+            errors,
+            warnings,
+            metrics,
+            sortedThoughts: errors.length === 0 ? sortedThoughts : undefined,
+        };
+    }
+    /**
+     * Validate consolidation data
+     */
+    validateConsolidation(consolidation, thoughts, errors, warnings) {
+        const { winningPath, verdict } = consolidation;
+        // Validate path references
+        const thoughtNumbers = new Set(thoughts.map(t => t.thoughtNumber));
+        const invalidRefs = winningPath.filter(n => !thoughtNumbers.has(n));
+        if (invalidRefs.length > 0) {
+            errors.push(`Invalid winning path references: ${invalidRefs.join(', ')}`);
+        }
+        // Validate path connectivity (WARNING, not ERROR)
+        if (winningPath.length > 1 && invalidRefs.length === 0) {
+            const thoughtMap = new Map(thoughts.map(t => [t.thoughtNumber, t]));
+            const pathGaps = [];
+            for (let i = 1; i < winningPath.length; i++) {
+                const current = winningPath[i];
+                const previous = winningPath[i - 1];
+                const currentThought = thoughtMap.get(current);
+                if (!currentThought)
+                    continue;
+                const validPredecessors = new Set([current - 1]);
+                if (currentThought.branchFromThought)
+                    validPredecessors.add(currentThought.branchFromThought);
+                if (currentThought.isRevision && currentThought.revisesThought) {
+                    validPredecessors.add(currentThought.revisesThought);
+                    validPredecessors.add(currentThought.revisesThought - 1);
+                }
+                if (!validPredecessors.has(previous)) {
+                    pathGaps.push(`#${previous}→#${current}`);
+                }
+            }
+            if (pathGaps.length > 0) {
+                warnings.push(`Path gaps: ${pathGaps.join(', ')}. Use branches or include intermediate thoughts.`);
+            }
+        }
+        // Check for unaddressed blockers
+        if (verdict === 'ready') {
+            for (const num of winningPath) {
+                const thought = thoughts.find(t => t.thoughtNumber === num);
+                if (thought?.extensions) {
+                    const hasBlocker = thought.extensions.some(e => e.impact === 'blocker');
+                    if (hasBlocker) {
+                        const hasRevision = thoughts.some(t => t.isRevision && t.revisesThought === num);
+                        if (!hasRevision) {
+                            errors.push(`Blocker in #${num} unresolved - cannot mark ready`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Convert BurstThought to ThoughtRecord
+     */
+    toThoughtRecord(t, totalThoughts, sessionId) {
+        return {
+            thought: t.thought.substring(0, BURST_LIMITS.maxThoughtLength),
+            thoughtNumber: t.thoughtNumber,
+            totalThoughts,
+            nextThoughtNeeded: t.thoughtNumber < totalThoughts,
+            confidence: t.confidence,
+            subSteps: t.subSteps,
+            alternatives: t.alternatives,
+            isRevision: t.isRevision,
+            revisesThought: t.revisesThought,
+            branchFromThought: t.branchFromThought,
+            branchId: t.branchId,
+            timestamp: Date.now(),
+            sessionId,
+            extensions: t.extensions?.map(e => ({
+                type: e.type,
+                content: e.content,
+                impact: e.impact ?? 'medium',
+                timestamp: new Date().toISOString(),
+            })),
+        };
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * CoachingService - Proactive coaching and lateral thinking triggers
+ * Stateful service - owns recentAdvices for cooldown tracking
+ */
+import type { ThoughtInput, ThoughtRecord } from '../types/thought.types.js';
+export declare class CoachingService {
+    /** Coach cooldown - track recent advices to prevent spam */
+    private recentAdvices;
+    /**
+     * Reset coaching state (call on session reset)
+     */
+    reset(): void;
+    /**
+     * Add advice with cooldown - prevents spam of same advice
+     * Returns true if advice was added, false if on cooldown
+     */
+    addAdviceWithCooldown(advice: string, nudges: string[]): boolean;
+    /**
+     * LATERAL THINKING TRIGGER with escalating pressure
+     * @param sessionThoughts - Current session thoughts
+     * @param branches - Map of branch ID to branch thoughts
+     * @param isFinishing - True if nextThoughtNeeded=false (v5.0.1)
+     */
+    checkLateralThinking(sessionThoughts: ThoughtRecord[], branches: Map<string, ThoughtRecord[]>, isFinishing?: boolean): string | undefined;
+    /**
+     * PROACTIVE COACH - Analyzes thought content and recommends strategic lenses
+     * v5.0.1: Returns undefined if confidence >= 8 (no need for coaching)
+     */
+    generateProactiveCoachAdvice(sessionThoughts: ThoughtRecord[]): string | undefined;
+    /**
+     * PROACTIVE NUDGES - Enhanced coaching based on current thought
+     */
+    generateProactiveNudges(input: ThoughtInput, sessionThoughts: ThoughtRecord[]): string | undefined;
+    /**
+     * PRE-CONSOLIDATION AUDIT - Quality gate before finishing session
+     */
+    performPreConsolidationAudit(sessionThoughts: ThoughtRecord[]): string | undefined;
+}

package/dist/services/coaching.service.js

@@ -0,0 +1,258 @@
+/**
+ * CoachingService - Proactive coaching and lateral thinking triggers
+ * Stateful service - owns recentAdvices for cooldown tracking
+ */
+import { LINEAR_THINKING_THRESHOLD, ESCALATING_PRESSURE_INTERVAL, MAX_THOUGHTS_BUDGET, POLISH_THRESHOLD_CONFIDENCE, INNOVATION_THRESHOLD_THOUGHTS, DEPTH_METRIC_SIMPLE, DEPTH_METRIC_MEDIUM, DEPTH_METRIC_COMPLEX, MIN_THOUGHT_LENGTH, LOW_CONFIDENCE_THRESHOLD, NO_CRITIQUE_THRESHOLD, COACH_COOLDOWN_COUNT, SMART_PRUNING_THRESHOLD, NEAR_LIMIT_CONFIDENCE_THRESHOLD, MIN_ENTROPY_THRESHOLD, } from '../constants/index.js';
+import { OPTIMIZATION_TRIGGERS, UNCERTAINTY_TRIGGERS } from '../constants/index.js';
+import { calculateWordEntropy } from '../utils/index.js';
+export class CoachingService {
+    /** Coach cooldown - track recent advices to prevent spam */
+    recentAdvices = [];
+    /**
+     * Reset coaching state (call on session reset)
+     */
+    reset() {
+        this.recentAdvices = [];
+    }
+    /**
+     * Add advice with cooldown - prevents spam of same advice
+     * Returns true if advice was added, false if on cooldown
+     */
+    addAdviceWithCooldown(advice, nudges) {
+        const adviceKey = advice.substring(0, 30);
+        if (this.recentAdvices.includes(adviceKey)) {
+            return false;
+        }
+        nudges.push(advice);
+        this.recentAdvices.push(adviceKey);
+        if (this.recentAdvices.length > COACH_COOLDOWN_COUNT) {
+            this.recentAdvices.shift();
+        }
+        return true;
+    }
+    /**
+     * LATERAL THINKING TRIGGER with escalating pressure
+     * @param sessionThoughts - Current session thoughts
+     * @param branches - Map of branch ID to branch thoughts
+     * @param isFinishing - True if nextThoughtNeeded=false (v5.0.1)
+     */
+    checkLateralThinking(sessionThoughts, branches, isFinishing = false) {
+        const thoughtCount = sessionThoughts.length;
+        const advices = [];
+        // Self-checklist: remind about subSteps ONLY when finishing session (v5.0.1)
+        if (isFinishing && thoughtCount >= 2) {
+            const prevThought = sessionThoughts[thoughtCount - 2];
+            if (prevThought.subSteps && prevThought.subSteps.length > 0) {
+                advices.push(`📋 SELF-CHECK: #${prevThought.thoughtNumber} had ${prevThought.subSteps.length} sub-steps. All completed?`);
+            }
+        }
+        // Check for forgotten branches
+        if (branches.size > 0 && thoughtCount > 3) {
+            const recentThoughts = sessionThoughts.slice(-3);
+            const recentBranchIds = new Set(recentThoughts.filter((t) => t.branchId).map((t) => t.branchId));
+            for (const branchId of branches.keys()) {
+                if (!recentBranchIds.has(branchId)) {
+                    advices.push(`🌿 FORGOTTEN: Branch "${branchId}" untouched 3+ thoughts. Integrate or close.`);
+                    break;
+                }
+            }
+        }
+        // Check for declining entropy
+        if (thoughtCount >= 3) {
+            const recentThoughts = sessionThoughts.slice(-3);
+            const entropies = recentThoughts.map((t) => calculateWordEntropy(t.thought));
+            const avgEntropy = entropies.reduce((a, b) => a + b, 0) / entropies.length;
+            const isDecreasing = entropies[2] < entropies[1] && entropies[1] < entropies[0];
+            if (avgEntropy < MIN_ENTROPY_THRESHOLD || (isDecreasing && entropies[2] < 0.3)) {
+                advices.push(`📉 ENTROPY: Vocabulary diversity low (${avgEntropy.toFixed(2)}). Rephrase with different concepts.`);
+            }
+        }
+        // Linear thinking check
+        if (thoughtCount >= LINEAR_THINKING_THRESHOLD) {
+            const hasExtensions = sessionThoughts.some((t) => t.extensions && t.extensions.length > 0);
+            const hasBranches = sessionThoughts.some((t) => t.branchFromThought !== undefined);
+            if (!hasExtensions && !hasBranches) {
+                const pressureLevel = Math.floor((thoughtCount - LINEAR_THINKING_THRESHOLD) / ESCALATING_PRESSURE_INTERVAL) + 1;
+                if (pressureLevel === 1) {
+                    advices.push('💡 LINEAR: Consider quickExtension:critique or think_diverge.');
+                }
+                else if (pressureLevel === 2) {
+                    advices.push('⚠️ LINEAR: STRONGLY use quickExtension:assumption_testing.');
+                }
+                else {
+                    advices.push(`🚨 CRITICAL: ${thoughtCount} thoughts, ZERO lateral. STOP and critique.`);
+                }
+            }
+        }
+        // Complexity Budget
+        if (thoughtCount >= MAX_THOUGHTS_BUDGET) {
+            const overBudget = thoughtCount - MAX_THOUGHTS_BUDGET;
+            if (overBudget === 0) {
+                advices.push(`💰 BUDGET: ${MAX_THOUGHTS_BUDGET} thoughts. Consolidate.`);
+            }
+            else if (overBudget <= 3) {
+                advices.push(`⚠️ OVER BUDGET: ${thoughtCount} thoughts. Consolidate NOW.`);
+            }
+            else {
+                advices.push(`🚨 PARALYSIS: ${thoughtCount} thoughts. STOP. Consolidate immediately.`);
+            }
+        }
+        // Proactive coach advice
+        const coachAdvice = this.generateProactiveCoachAdvice(sessionThoughts);
+        if (coachAdvice) {
+            advices.push(coachAdvice);
+        }
+        return advices.length > 0 ? advices.join('\n') : undefined;
+    }
+    /**
+     * PROACTIVE COACH - Analyzes thought content and recommends strategic lenses
+     * v5.0.1: Returns undefined if confidence >= 8 (no need for coaching)
+     */
+    generateProactiveCoachAdvice(sessionThoughts) {
+        if (sessionThoughts.length === 0)
+            return undefined;
+        const lastThought = sessionThoughts[sessionThoughts.length - 1];
+        // v5.0.1: Skip coaching if high confidence - user knows what they're doing
+        if (lastThought.confidence && lastThought.confidence >= 8) {
+            return undefined;
+        }
+        const allContent = sessionThoughts.map((t) => t.thought.toLowerCase()).join(' ');
+        const lastContent = lastThought.thought.toLowerCase();
+        const existingExtensions = new Set();
+        sessionThoughts.forEach((t) => {
+            t.extensions?.forEach((e) => existingExtensions.add(e.type));
+        });
+        // OPTIMIZATION recommendation
+        if (!existingExtensions.has('optimization')) {
+            const hasOptimizationTrigger = OPTIMIZATION_TRIGGERS.some((trigger) => lastContent.includes(trigger) || allContent.includes(trigger));
+            if (hasOptimizationTrigger) {
+                return '🎯 COACH: TODO/perf detected. Use quickExtension:optimization';
+            }
+        }
+        // ASSUMPTION TESTING recommendation
+        if (!existingExtensions.has('assumption_testing')) {
+            const uncertaintyCount = UNCERTAINTY_TRIGGERS.filter((trigger) => lastContent.includes(trigger)).length;
+            if (uncertaintyCount >= 2) {
+                return '🎯 COACH: Uncertain language. Use quickExtension:assumption_testing';
+            }
+        }
+        // POLISH recommendation
+        if (!existingExtensions.has('polish')) {
+            const isNearEnd = lastThought.thoughtNumber >= lastThought.totalThoughts - 1;
+            const hasHighConfidence = lastThought.confidence && lastThought.confidence >= POLISH_THRESHOLD_CONFIDENCE;
+            if (isNearEnd && hasHighConfidence) {
+                return '🎯 COACH: High confidence. Use quickExtension:polish';
+            }
+        }
+        // INNOVATION recommendation
+        if (!existingExtensions.has('innovation') && sessionThoughts.length >= INNOVATION_THRESHOLD_THOUGHTS) {
+            const hasBranches = sessionThoughts.some((t) => t.branchFromThought !== undefined);
+            if (!hasBranches) {
+                return '🎯 COACH: Long session. Use quickExtension:innovation';
+            }
+        }
+        return undefined;
+    }
+    /**
+     * PROACTIVE NUDGES - Enhanced coaching based on current thought
+     */
+    generateProactiveNudges(input, sessionThoughts) {
+        const nudges = [];
+        // Short thought detection
+        if (input.thought.length < MIN_THOUGHT_LENGTH && input.nextThoughtNeeded) {
+            this.addAdviceWithCooldown(`⚠️ SHORT: ${input.thought.length} chars. Expand.`, nudges);
+        }
+        // Low confidence nudge
+        if (input.confidence && input.confidence < LOW_CONFIDENCE_THRESHOLD) {
+            this.addAdviceWithCooldown(`💡 LOW CONFIDENCE (${input.confidence}/10): STOP. Do not proceed linearly. Use think_diverge to explore 3 alternatives.`, nudges);
+        }
+        // Missing critique check
+        if (sessionThoughts.length >= NO_CRITIQUE_THRESHOLD) {
+            const hasCritique = sessionThoughts.some((t) => t.extensions?.some((e) => e.type === 'critique'));
+            if (!hasCritique) {
+                this.addAdviceWithCooldown(`🧐 NO CRITIQUE: ${sessionThoughts.length} thoughts. Use quickExtension:critique`, nudges);
+            }
+        }
+        // Smart pruning reminder
+        if (sessionThoughts.length >= SMART_PRUNING_THRESHOLD) {
+            this.addAdviceWithCooldown(`🧹 LONG (${sessionThoughts.length} thoughts): Auto-pruning. Consolidate soon.`, nudges);
+        }
+        // Near-limit warning
+        if (input.thoughtNumber >= input.totalThoughts - 1 &&
+            input.confidence &&
+            input.confidence < NEAR_LIMIT_CONFIDENCE_THRESHOLD) {
+            this.addAdviceWithCooldown(`⚠️ NEAR LIMIT: ${input.thoughtNumber}/${input.totalThoughts}, confidence ${input.confidence}/10.`, nudges);
+        }
+        // Context7 Integration (v6.0)
+        // If thought contains technical keywords but no Context7 context, prompt for it
+        const techKeywords = ['react', 'prisma', 'api', 'auth', 'database', 'deploy'];
+        const hasTechKeyword = techKeywords.some(k => input.thought.toLowerCase().includes(k));
+        // Simple heuristic: if talking tech but confidence < 8, suggest docs
+        if (hasTechKeyword && input.confidence && input.confidence < 8) {
+            // Check if we haven't already nudged about docs recently is handled by cooldown
+            this.addAdviceWithCooldown(`📚 DOCS: Technical topic detected with <8 confidence. Use 'context7' to check official docs.`, nudges);
+        }
+        return nudges.length > 0 ? nudges.join('\n') : undefined;
+    }
+    /**
+     * PRE-CONSOLIDATION AUDIT - Quality gate before finishing session
+     */
+    performPreConsolidationAudit(sessionThoughts) {
+        if (sessionThoughts.length === 0)
+            return undefined;
+        const auditWarnings = [];
+        // SUBSTEPS COMPLETION CHECK
+        const allSubSteps = [];
+        sessionThoughts.forEach((t) => {
+            if (t.subSteps && t.subSteps.length > 0) {
+                allSubSteps.push({ thoughtNum: t.thoughtNumber, steps: t.subSteps });
+            }
+        });
+        if (allSubSteps.length > 0) {
+            const totalSteps = allSubSteps.reduce((sum, s) => sum + s.steps.length, 0);
+            const thoughtsWithSteps = allSubSteps.map((s) => `#${s.thoughtNum}`).join(', ');
+            auditWarnings.push(`📋 SUBSTEPS: ${totalSteps} defined in ${thoughtsWithSteps}. Verify completion.`);
+        }
+        // DEPTH METRIC CHECK
+        const avgLength = sessionThoughts.reduce((sum, t) => sum + t.thought.length, 0) / sessionThoughts.length;
+        const thoughtCount = sessionThoughts.length;
+        let requiredDepth;
+        let complexityLevel;
+        if (thoughtCount <= 5) {
+            requiredDepth = DEPTH_METRIC_SIMPLE;
+            complexityLevel = 'simple';
+        }
+        else if (thoughtCount <= 10) {
+            requiredDepth = DEPTH_METRIC_MEDIUM;
+            complexityLevel = 'medium';
+        }
+        else {
+            requiredDepth = DEPTH_METRIC_COMPLEX;
+            complexityLevel = 'complex';
+        }
+        if (avgLength < requiredDepth) {
+            auditWarnings.push(`🔬 DEPTH: ${Math.round(avgLength)} chars < ${requiredDepth} for ${complexityLevel} task.`);
+        }
+        // BLOCKER GATE CHECK
+        const unresolvedBlockers = [];
+        sessionThoughts.forEach((t) => {
+            if (t.extensions) {
+                const hasBlocker = t.extensions.some((e) => e.impact === 'blocker' || (e.impact === 'high' && e.type === 'critique'));
+                if (hasBlocker) {
+                    const hasRevision = sessionThoughts.some((rev) => rev.isRevision && rev.revisesThought === t.thoughtNumber);
+                    if (!hasRevision) {
+                        unresolvedBlockers.push(t.thoughtNumber);
+                    }
+                }
+            }
+        });
+        if (unresolvedBlockers.length > 0) {
+            auditWarnings.push(`🛑 BLOCKERS: #${unresolvedBlockers.join(', ')} unresolved.`);
+        }
+        if (auditWarnings.length > 0) {
+            auditWarnings.unshift('⚡ PRE-CONSOLIDATION AUDIT:');
+            auditWarnings.push('💡 Address items or call think_done.');
+        }
+        return auditWarnings.length > 0 ? auditWarnings.join('\n') : undefined;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * ConsolidateService - Meta-cognitive audit for thinking sessions
+ * Stateless service - receives data as parameters
+ */
+import type { ThoughtRecord, ConsolidateInput, ConsolidateResult } from '../types/thought.types.js';
+export declare class ConsolidateService {
+    private validationService;
+    /**
+     * Consolidate and verify the thinking process (meta-cognitive audit)
+     * Forces model to synthesize, cross-check, and find contradictions
+     * @param input - Consolidation input with winningPath, summary, verdict
+     * @param sessionThoughts - Current session thoughts
+     * @param onDeadEnd - Callback to record dead end when verdict is needs_more_work
+     * @param onSuccess - Callback to save insight when verdict is ready and can proceed (v4.1.0)
+     */
+    consolidate(input: ConsolidateInput, sessionThoughts: ThoughtRecord[], onDeadEnd?: (path: number[], reason: string) => void, onSuccess?: (path: number[], summary: string) => void): ConsolidateResult;
+}