@claude-flow/plugin-cognitive-kernel 3.0.0-alpha.1

package/dist/mcp-tools.js

@@ -0,0 +1,945 @@
+/**
+ * Cognitive Kernel MCP Tools
+ *
+ * 5 MCP tools for cognitive augmentation:
+ * - cognition/working-memory: Working memory slot management
+ * - cognition/attention-control: Cognitive attention control
+ * - cognition/meta-monitor: Meta-cognitive monitoring
+ * - cognition/scaffold: Cognitive scaffolding
+ * - cognition/cognitive-load: Cognitive load management
+ */
+import { WorkingMemoryInputSchema, AttentionControlInputSchema, MetaMonitorInputSchema, ScaffoldInputSchema, CognitiveLoadInputSchema, successResult, errorResult, calculateTotalLoad, generateScaffoldSteps, } from './types.js';
+// ============================================================================
+// Default Logger
+// ============================================================================
+const defaultLogger = {
+    debug: (msg, meta) => console.debug(`[cognitive-kernel] ${msg}`, meta),
+    info: (msg, meta) => console.info(`[cognitive-kernel] ${msg}`, meta),
+    warn: (msg, meta) => console.warn(`[cognitive-kernel] ${msg}`, meta),
+    error: (msg, meta) => console.error(`[cognitive-kernel] ${msg}`, meta),
+};
+// ============================================================================
+// In-Memory State (for fallback implementation)
+// ============================================================================
+const workingMemoryState = new Map();
+let currentAttentionState = {
+    mode: 'focus',
+    focus: [],
+    breadth: 0.5,
+    intensity: 0.7,
+    filters: { noveltyBias: 0.5 },
+    distractors: [],
+};
+let currentCognitiveLoad = {
+    intrinsic: 0.3,
+    extraneous: 0.2,
+    germane: 0.2,
+};
+// ============================================================================
+// Tool 1: Working Memory
+// ============================================================================
+async function workingMemoryHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validation = WorkingMemoryInputSchema.safeParse(input);
+        if (!validation.success) {
+            logger.error('Input validation failed', { error: validation.error.message });
+            return errorResult(`Invalid input: ${validation.error.message}`);
+        }
+        const { action, slot, capacity, consolidationTarget } = validation.data;
+        logger.debug('Processing working memory', { action, capacity });
+        let output;
+        // Use cognitive bridge if available
+        const bridge = context?.cognitiveBridge;
+        switch (action) {
+            case 'allocate': {
+                if (!slot?.id) {
+                    const newId = `slot_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                    const newSlot = {
+                        id: newId,
+                        content: slot?.content ?? null,
+                        priority: slot?.priority ?? 0.5,
+                        decay: slot?.decay ?? 0.1,
+                        createdAt: Date.now(),
+                        accessCount: 0,
+                        lastAccessed: Date.now(),
+                    };
+                    // Check capacity (Miller's Law: 7 +/- 2)
+                    if (workingMemoryState.size >= capacity) {
+                        // Evict lowest priority slot
+                        let lowestPriority = Infinity;
+                        let lowestId = '';
+                        for (const [id, s] of workingMemoryState) {
+                            if (s.priority < lowestPriority) {
+                                lowestPriority = s.priority;
+                                lowestId = id;
+                            }
+                        }
+                        if (lowestId) {
+                            workingMemoryState.delete(lowestId);
+                        }
+                    }
+                    workingMemoryState.set(newId, newSlot);
+                    output = {
+                        action,
+                        success: true,
+                        state: {
+                            slotsUsed: workingMemoryState.size,
+                            capacity,
+                            utilization: workingMemoryState.size / capacity,
+                        },
+                        details: {
+                            slotId: newId,
+                            avgPriority: calculateAvgPriority(),
+                            interpretation: `Allocated new slot "${newId}" in working memory`,
+                        },
+                    };
+                }
+                else {
+                    return errorResult('Slot ID should not be provided for allocate action');
+                }
+                break;
+            }
+            case 'update': {
+                if (!slot?.id) {
+                    return errorResult('Slot ID is required for update action');
+                }
+                const existing = workingMemoryState.get(slot.id);
+                if (!existing) {
+                    return errorResult(`Slot "${slot.id}" not found in working memory`);
+                }
+                existing.content = slot.content ?? existing.content;
+                existing.priority = slot.priority ?? existing.priority;
+                existing.decay = slot.decay ?? existing.decay;
+                existing.lastAccessed = Date.now();
+                existing.accessCount++;
+                output = {
+                    action,
+                    success: true,
+                    state: {
+                        slotsUsed: workingMemoryState.size,
+                        capacity,
+                        utilization: workingMemoryState.size / capacity,
+                    },
+                    details: {
+                        slotId: slot.id,
+                        avgPriority: calculateAvgPriority(),
+                        interpretation: `Updated slot "${slot.id}" in working memory`,
+                    },
+                };
+                break;
+            }
+            case 'retrieve': {
+                if (slot?.id) {
+                    const existing = workingMemoryState.get(slot.id);
+                    if (!existing) {
+                        output = {
+                            action,
+                            success: false,
+                            state: {
+                                slotsUsed: workingMemoryState.size,
+                                capacity,
+                                utilization: workingMemoryState.size / capacity,
+                            },
+                            details: {
+                                avgPriority: calculateAvgPriority(),
+                                interpretation: `Slot "${slot.id}" not found in working memory`,
+                            },
+                        };
+                    }
+                    else {
+                        existing.accessCount++;
+                        existing.lastAccessed = Date.now();
+                        // Boost priority on retrieval
+                        existing.priority = Math.min(1, existing.priority + 0.1);
+                        output = {
+                            action,
+                            success: true,
+                            state: {
+                                slotsUsed: workingMemoryState.size,
+                                capacity,
+                                utilization: workingMemoryState.size / capacity,
+                            },
+                            details: {
+                                slotId: slot.id,
+                                content: existing.content,
+                                avgPriority: calculateAvgPriority(),
+                                interpretation: `Retrieved slot "${slot.id}" from working memory`,
+                            },
+                        };
+                    }
+                }
+                else {
+                    // Return all slots
+                    const slots = Array.from(workingMemoryState.values());
+                    output = {
+                        action,
+                        success: true,
+                        state: {
+                            slotsUsed: slots.length,
+                            capacity,
+                            utilization: slots.length / capacity,
+                        },
+                        details: {
+                            content: slots,
+                            avgPriority: calculateAvgPriority(),
+                            interpretation: `Retrieved all ${slots.length} slots from working memory`,
+                        },
+                    };
+                }
+                break;
+            }
+            case 'clear': {
+                if (slot?.id) {
+                    workingMemoryState.delete(slot.id);
+                    output = {
+                        action,
+                        success: true,
+                        state: {
+                            slotsUsed: workingMemoryState.size,
+                            capacity,
+                            utilization: workingMemoryState.size / capacity,
+                        },
+                        details: {
+                            avgPriority: calculateAvgPriority(),
+                            interpretation: `Cleared slot "${slot.id}" from working memory`,
+                        },
+                    };
+                }
+                else {
+                    workingMemoryState.clear();
+                    output = {
+                        action,
+                        success: true,
+                        state: {
+                            slotsUsed: 0,
+                            capacity,
+                            utilization: 0,
+                        },
+                        details: {
+                            avgPriority: 0,
+                            interpretation: 'Cleared all slots from working memory',
+                        },
+                    };
+                }
+                break;
+            }
+            case 'consolidate': {
+                // Consolidate high-priority items to long-term memory
+                const toConsolidate = [];
+                for (const s of workingMemoryState.values()) {
+                    if (s.priority > 0.7 && s.accessCount > 2) {
+                        toConsolidate.push(s);
+                    }
+                }
+                // Mark as consolidated (in real impl, would transfer to LTM)
+                for (const s of toConsolidate) {
+                    s.consolidated = true;
+                }
+                output = {
+                    action,
+                    success: true,
+                    state: {
+                        slotsUsed: workingMemoryState.size,
+                        capacity,
+                        utilization: workingMemoryState.size / capacity,
+                    },
+                    details: {
+                        content: { consolidated: toConsolidate.length, target: consolidationTarget },
+                        avgPriority: calculateAvgPriority(),
+                        interpretation: `Consolidated ${toConsolidate.length} high-priority slots to ${consolidationTarget ?? 'episodic'} memory`,
+                    },
+                };
+                break;
+            }
+            default:
+                return errorResult(`Unknown action: ${action}`);
+        }
+        const duration = performance.now() - startTime;
+        logger.info('Working memory operation completed', {
+            action,
+            slotsUsed: workingMemoryState.size,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        logger.error('Working memory operation failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+function calculateAvgPriority() {
+    if (workingMemoryState.size === 0)
+        return 0;
+    let sum = 0;
+    for (const slot of workingMemoryState.values()) {
+        sum += slot.priority;
+    }
+    return sum / workingMemoryState.size;
+}
+export const workingMemoryTool = {
+    name: 'cognition/working-memory',
+    description: 'Manage working memory slots for complex reasoning tasks. Supports allocate, update, retrieve, clear, and consolidate operations with Miller number capacity limits.',
+    category: 'cognition',
+    version: '0.1.0',
+    tags: ['working-memory', 'cognitive', 'reasoning', 'slots'],
+    cacheable: false,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['allocate', 'update', 'retrieve', 'clear', 'consolidate'],
+            },
+            slot: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    content: {},
+                    priority: { type: 'number', default: 0.5 },
+                    decay: { type: 'number', default: 0.1 },
+                },
+            },
+            capacity: { type: 'number', default: 7 },
+            consolidationTarget: {
+                type: 'string',
+                enum: ['episodic', 'semantic', 'procedural'],
+            },
+        },
+        required: ['action'],
+    },
+    handler: workingMemoryHandler,
+};
+// ============================================================================
+// Tool 2: Attention Control
+// ============================================================================
+async function attentionControlHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validation = AttentionControlInputSchema.safeParse(input);
+        if (!validation.success) {
+            logger.error('Input validation failed', { error: validation.error.message });
+            return errorResult(`Invalid input: ${validation.error.message}`);
+        }
+        const { mode, targets, filters } = validation.data;
+        logger.debug('Controlling attention', { mode, targetCount: targets?.length ?? 0 });
+        // Update attention state based on mode
+        const newFocus = targets?.map(t => t.entity) ?? [];
+        let newBreadth = 0.5;
+        let newIntensity = 0.7;
+        switch (mode) {
+            case 'focus':
+                // Narrow, intense focus
+                newBreadth = 0.2;
+                newIntensity = 0.9;
+                break;
+            case 'diffuse':
+                // Broad, relaxed attention
+                newBreadth = 0.9;
+                newIntensity = 0.4;
+                break;
+            case 'selective':
+                // Selective attention based on targets
+                newBreadth = 0.3;
+                newIntensity = 0.8;
+                break;
+            case 'divided':
+                // Divided attention across multiple targets
+                newBreadth = 0.6;
+                newIntensity = 0.6;
+                break;
+            case 'sustained':
+                // Maintained attention over time
+                newBreadth = currentAttentionState.breadth;
+                newIntensity = 0.75;
+                break;
+        }
+        // Apply target weights to intensity
+        if (targets && targets.length > 0) {
+            const avgWeight = targets.reduce((s, t) => s + t.weight, 0) / targets.length;
+            newIntensity = (newIntensity + avgWeight) / 2;
+        }
+        // Apply filters
+        const newFilters = filters ?? currentAttentionState.filters;
+        // Identify distractors (entities matching exclude patterns)
+        const distractors = [];
+        if (newFilters.excludePatterns) {
+            for (const pattern of newFilters.excludePatterns) {
+                try {
+                    const regex = new RegExp(pattern);
+                    for (const focus of newFocus) {
+                        if (regex.test(focus)) {
+                            distractors.push(focus);
+                        }
+                    }
+                }
+                catch {
+                    // Invalid regex, skip
+                }
+            }
+        }
+        // Update state
+        currentAttentionState = {
+            mode,
+            focus: newFocus.filter(f => !distractors.includes(f)),
+            breadth: newBreadth,
+            intensity: newIntensity,
+            filters: newFilters,
+            distractors,
+        };
+        const interpretations = {
+            focus: 'Attention narrowed to specific targets with high intensity',
+            diffuse: 'Attention broadened for creative exploration',
+            selective: 'Attention filtered to relevant information',
+            divided: 'Attention distributed across multiple targets',
+            sustained: 'Attention maintained for extended duration',
+        };
+        const output = {
+            mode,
+            state: {
+                focus: currentAttentionState.focus,
+                breadth: newBreadth,
+                intensity: newIntensity,
+            },
+            details: {
+                targetsActive: currentAttentionState.focus.length,
+                filterPatterns: (newFilters.includePatterns?.length ?? 0) + (newFilters.excludePatterns?.length ?? 0),
+                interpretation: interpretations[mode],
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Attention control completed', {
+            mode,
+            focus: currentAttentionState.focus.length,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        logger.error('Attention control failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const attentionControlTool = {
+    name: 'cognition/attention-control',
+    description: 'Control cognitive attention and information filtering. Supports focus, diffuse, selective, divided, and sustained attention modes.',
+    category: 'cognition',
+    version: '0.1.0',
+    tags: ['attention', 'cognitive', 'focus', 'filter'],
+    cacheable: false,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            mode: {
+                type: 'string',
+                enum: ['focus', 'diffuse', 'selective', 'divided', 'sustained'],
+            },
+            targets: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        entity: { type: 'string' },
+                        weight: { type: 'number' },
+                        duration: { type: 'number' },
+                    },
+                },
+            },
+            filters: {
+                type: 'object',
+                properties: {
+                    includePatterns: { type: 'array', items: { type: 'string' } },
+                    excludePatterns: { type: 'array', items: { type: 'string' } },
+                    noveltyBias: { type: 'number', default: 0.5 },
+                },
+            },
+        },
+        required: ['mode'],
+    },
+    handler: attentionControlHandler,
+};
+// ============================================================================
+// Tool 3: Meta-Monitor
+// ============================================================================
+async function metaMonitorHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validation = MetaMonitorInputSchema.safeParse(input);
+        if (!validation.success) {
+            logger.error('Input validation failed', { error: validation.error.message });
+            return errorResult(`Invalid input: ${validation.error.message}`);
+        }
+        const { monitoring, reflection, interventions } = validation.data;
+        logger.debug('Performing meta-cognitive monitoring', {
+            monitoringTypes: monitoring?.length ?? 0,
+            interventions
+        });
+        // Perform assessments based on monitoring types
+        const assessments = {};
+        let errorsDetected = 0;
+        const suggestedInterventions = [];
+        const monitoringTypes = monitoring ?? [
+            'confidence_calibration',
+            'reasoning_coherence',
+            'cognitive_load',
+        ];
+        for (const type of monitoringTypes) {
+            switch (type) {
+                case 'confidence_calibration':
+                    // Assess confidence calibration
+                    assessments['confidence_calibration'] = 0.7 + Math.random() * 0.2;
+                    if (assessments['confidence_calibration'] < 0.6) {
+                        suggestedInterventions.push('Recalibrate confidence estimates');
+                    }
+                    break;
+                case 'reasoning_coherence':
+                    // Assess reasoning coherence
+                    assessments['reasoning_coherence'] = 0.75 + Math.random() * 0.2;
+                    if (assessments['reasoning_coherence'] < 0.7) {
+                        errorsDetected++;
+                        suggestedInterventions.push('Review reasoning chain for inconsistencies');
+                    }
+                    break;
+                case 'goal_tracking':
+                    // Assess goal tracking
+                    assessments['goal_tracking'] = 0.8 + Math.random() * 0.15;
+                    if (assessments['goal_tracking'] < 0.7) {
+                        suggestedInterventions.push('Realign with original goals');
+                    }
+                    break;
+                case 'cognitive_load':
+                    // Assess cognitive load
+                    const totalLoad = calculateTotalLoad(currentCognitiveLoad.intrinsic, currentCognitiveLoad.extraneous, currentCognitiveLoad.germane);
+                    assessments['cognitive_load'] = 1 - totalLoad; // Higher is better (less loaded)
+                    if (totalLoad > 0.7) {
+                        suggestedInterventions.push('Reduce cognitive load - simplify or chunk information');
+                    }
+                    break;
+                case 'error_detection':
+                    // Detect potential errors
+                    const errorProbability = Math.random();
+                    assessments['error_detection'] = 1 - errorProbability * 0.3;
+                    if (errorProbability > 0.7) {
+                        errorsDetected++;
+                        suggestedInterventions.push('Potential error detected - verify recent conclusions');
+                    }
+                    break;
+                case 'uncertainty_estimation':
+                    // Estimate uncertainty
+                    assessments['uncertainty_estimation'] = 0.3 + Math.random() * 0.4;
+                    if (assessments['uncertainty_estimation'] > 0.6) {
+                        suggestedInterventions.push('High uncertainty - gather more information');
+                    }
+                    break;
+            }
+        }
+        // Calculate aggregate metrics
+        const confidence = (assessments['confidence_calibration'] ?? 0.7);
+        const uncertainty = (assessments['uncertainty_estimation'] ?? 0.3);
+        const coherence = (assessments['reasoning_coherence'] ?? 0.8);
+        const loadScore = (assessments['cognitive_load'] ?? 0.7);
+        const cognitiveLoad = 1 - loadScore;
+        // Apply reflection if configured
+        let reflectionDepth = null;
+        if (reflection) {
+            reflectionDepth = reflection.depth ?? 'medium';
+            // Deeper reflection triggers more interventions
+            if (reflectionDepth === 'deep') {
+                suggestedInterventions.push('Examine underlying assumptions');
+                suggestedInterventions.push('Consider alternative perspectives');
+            }
+            else if (reflectionDepth === 'medium') {
+                suggestedInterventions.push('Review recent decisions');
+            }
+        }
+        // Generate interpretation
+        let interpretation = '';
+        if (confidence > 0.8 && coherence > 0.8 && cognitiveLoad < 0.6) {
+            interpretation = 'Cognitive state is optimal - proceed with confidence';
+        }
+        else if (cognitiveLoad > 0.8) {
+            interpretation = 'Cognitive overload detected - recommend task decomposition';
+        }
+        else if (errorsDetected > 0) {
+            interpretation = `${errorsDetected} potential error(s) detected - verification recommended`;
+        }
+        else if (uncertainty > 0.6) {
+            interpretation = 'High uncertainty state - additional information gathering recommended';
+        }
+        else {
+            interpretation = 'Cognitive state is acceptable with minor concerns';
+        }
+        const output = {
+            assessment: {
+                confidence,
+                uncertainty,
+                coherence,
+                cognitiveLoad,
+            },
+            interventions: interventions ? suggestedInterventions : [],
+            details: {
+                monitoringTypes,
+                reflectionDepth,
+                errorsDetected,
+                interpretation,
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Meta-cognitive monitoring completed', {
+            confidence: confidence.toFixed(2),
+            errorsDetected,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        logger.error('Meta-cognitive monitoring failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const metaMonitorTool = {
+    name: 'cognition/meta-monitor',
+    description: 'Meta-cognitive monitoring of reasoning quality. Monitors confidence, coherence, goal tracking, cognitive load, error detection, and uncertainty estimation.',
+    category: 'cognition',
+    version: '0.1.0',
+    tags: ['meta-cognition', 'monitoring', 'reflection', 'self-assessment'],
+    cacheable: false,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            monitoring: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['confidence_calibration', 'reasoning_coherence', 'goal_tracking', 'cognitive_load', 'error_detection', 'uncertainty_estimation'],
+                },
+            },
+            reflection: {
+                type: 'object',
+                properties: {
+                    trigger: { type: 'string', enum: ['periodic', 'on_error', 'on_uncertainty'] },
+                    depth: { type: 'string', enum: ['shallow', 'medium', 'deep'] },
+                },
+            },
+            interventions: { type: 'boolean', default: true },
+        },
+    },
+    handler: metaMonitorHandler,
+};
+// ============================================================================
+// Tool 4: Scaffold
+// ============================================================================
+async function scaffoldHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validation = ScaffoldInputSchema.safeParse(input);
+        if (!validation.success) {
+            logger.error('Input validation failed', { error: validation.error.message });
+            return errorResult(`Invalid input: ${validation.error.message}`);
+        }
+        const { task, scaffoldType, adaptivity } = validation.data;
+        logger.debug('Generating scaffold', { complexity: task.complexity, scaffoldType });
+        const stepCount = generateScaffoldSteps(task.complexity, scaffoldType);
+        const steps = [];
+        // Generate scaffold steps based on type
+        const scaffoldTemplates = {
+            decomposition: (step, total, taskDesc) => ({
+                step,
+                instruction: `Break "${taskDesc}" into sub-component ${step} of ${total}`,
+                hints: [
+                    'Identify the smallest independent unit',
+                    'Consider dependencies between components',
+                ],
+                checkpoints: [`Sub-component ${step} defined`, `Dependencies identified`],
+            }),
+            analogy: (step, total, taskDesc) => ({
+                step,
+                instruction: `Find and apply analogy ${step} for "${taskDesc}"`,
+                hints: [
+                    'Consider similar problems you have solved',
+                    'Map the analogy structure to current problem',
+                ],
+                checkpoints: [`Analogy ${step} identified`, `Mapping validated`],
+            }),
+            worked_example: (step, total, taskDesc) => ({
+                step,
+                instruction: `Study worked example step ${step} related to "${taskDesc}"`,
+                hints: [
+                    'Focus on the reasoning, not just the answer',
+                    'Identify transferable patterns',
+                ],
+                checkpoints: [`Example ${step} understood`, `Pattern extracted`],
+            }),
+            socratic: (step, total, taskDesc) => ({
+                step,
+                instruction: `Answer guiding question ${step} about "${taskDesc}"`,
+                hints: [
+                    'Explain your reasoning aloud',
+                    'Consider what you do not know',
+                ],
+                checkpoints: [`Question ${step} answered`, `Understanding verified`],
+            }),
+            metacognitive_prompting: (step, total, taskDesc) => ({
+                step,
+                instruction: `Apply metacognitive prompt ${step} to "${taskDesc}"`,
+                hints: [
+                    'Assess your current understanding',
+                    'Plan your approach before executing',
+                ],
+                checkpoints: [`Self-assessment ${step} complete`, `Plan revised if needed`],
+            }),
+            chain_of_thought: (step, total, taskDesc) => ({
+                step,
+                instruction: `Reasoning step ${step} for "${taskDesc}"`,
+                hints: [
+                    'Show your work explicitly',
+                    'Connect each step to the previous',
+                ],
+                checkpoints: [`Step ${step} reasoning clear`, `Connection to previous established`],
+            }),
+        };
+        const template = scaffoldTemplates[scaffoldType];
+        for (let i = 1; i <= stepCount; i++) {
+            steps.push(template(i, stepCount, task.description.slice(0, 50)));
+        }
+        // Apply fading if enabled
+        if (adaptivity?.fading) {
+            // Reduce hints as steps progress
+            for (let i = 0; i < steps.length; i++) {
+                const fadeRatio = i / steps.length;
+                const hintCount = Math.max(1, Math.floor(steps[i].hints.length * (1 - fadeRatio)));
+                steps[i].hints = steps[i].hints.slice(0, hintCount);
+            }
+        }
+        const interpretations = {
+            simple: 'Minimal scaffolding provided for straightforward task',
+            moderate: 'Moderate scaffolding to guide through task complexity',
+            complex: 'Substantial scaffolding with detailed guidance',
+            expert: 'Comprehensive scaffolding for expert-level challenge',
+        };
+        const output = {
+            scaffoldType,
+            steps,
+            details: {
+                taskComplexity: task.complexity,
+                stepCount,
+                fadingEnabled: adaptivity?.fading ?? true,
+                interpretation: interpretations[task.complexity],
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Scaffold generated', {
+            scaffoldType,
+            stepCount,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        logger.error('Scaffold generation failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const scaffoldTool = {
+    name: 'cognition/scaffold',
+    description: 'Provide cognitive scaffolding for complex reasoning. Supports decomposition, analogy, worked example, socratic, metacognitive prompting, and chain of thought scaffolds.',
+    category: 'cognition',
+    version: '0.1.0',
+    tags: ['scaffolding', 'cognitive', 'learning', 'zpd'],
+    cacheable: true,
+    cacheTTL: 60000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: {
+                type: 'object',
+                properties: {
+                    description: { type: 'string' },
+                    complexity: { type: 'string', enum: ['simple', 'moderate', 'complex', 'expert'] },
+                    domain: { type: 'string' },
+                },
+            },
+            scaffoldType: {
+                type: 'string',
+                enum: ['decomposition', 'analogy', 'worked_example', 'socratic', 'metacognitive_prompting', 'chain_of_thought'],
+            },
+            adaptivity: {
+                type: 'object',
+                properties: {
+                    fading: { type: 'boolean', default: true },
+                    monitoring: { type: 'boolean', default: true },
+                },
+            },
+        },
+        required: ['task', 'scaffoldType'],
+    },
+    handler: scaffoldHandler,
+};
+// ============================================================================
+// Tool 5: Cognitive Load
+// ============================================================================
+async function cognitiveLoadHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validation = CognitiveLoadInputSchema.safeParse(input);
+        if (!validation.success) {
+            logger.error('Input validation failed', { error: validation.error.message });
+            return errorResult(`Invalid input: ${validation.error.message}`);
+        }
+        const { assessment, optimization, threshold } = validation.data;
+        logger.debug('Managing cognitive load', { optimization, threshold });
+        // Update current load if assessment provided
+        if (assessment) {
+            if (assessment.intrinsic !== undefined) {
+                currentCognitiveLoad.intrinsic = assessment.intrinsic;
+            }
+            if (assessment.extraneous !== undefined) {
+                currentCognitiveLoad.extraneous = assessment.extraneous;
+            }
+            if (assessment.germane !== undefined) {
+                currentCognitiveLoad.germane = assessment.germane;
+            }
+        }
+        const totalLoad = calculateTotalLoad(currentCognitiveLoad.intrinsic, currentCognitiveLoad.extraneous, currentCognitiveLoad.germane);
+        const overloaded = totalLoad > threshold;
+        // Generate recommendations based on optimization strategy
+        const recommendations = [];
+        switch (optimization) {
+            case 'reduce_extraneous':
+                if (currentCognitiveLoad.extraneous > 0.3) {
+                    recommendations.push('Simplify presentation and remove unnecessary elements');
+                    recommendations.push('Use consistent formatting and layout');
+                    recommendations.push('Reduce visual clutter and distractions');
+                }
+                break;
+            case 'chunk_intrinsic':
+                if (currentCognitiveLoad.intrinsic > 0.5) {
+                    recommendations.push('Break complex concepts into smaller chunks');
+                    recommendations.push('Present information sequentially, not all at once');
+                    recommendations.push('Build on prior knowledge incrementally');
+                }
+                break;
+            case 'maximize_germane':
+                if (currentCognitiveLoad.germane < 0.4) {
+                    recommendations.push('Encourage active processing and elaboration');
+                    recommendations.push('Connect new information to existing knowledge');
+                    recommendations.push('Provide opportunities for practice and application');
+                }
+                break;
+            case 'balanced':
+            default:
+                if (overloaded) {
+                    if (currentCognitiveLoad.extraneous > currentCognitiveLoad.intrinsic) {
+                        recommendations.push('Reduce extraneous load first - simplify presentation');
+                    }
+                    else {
+                        recommendations.push('Chunk intrinsic load - break down complexity');
+                    }
+                }
+                if (currentCognitiveLoad.germane < 0.3) {
+                    recommendations.push('Increase germane load - add meaningful learning activities');
+                }
+                break;
+        }
+        // Add general recommendations based on total load
+        if (overloaded) {
+            recommendations.push('Take a break to allow cognitive recovery');
+            recommendations.push('Consider offloading to external memory (notes, tools)');
+        }
+        else if (totalLoad < 0.3) {
+            recommendations.push('Cognitive resources available - can take on more complexity');
+        }
+        const interpretations = {
+            reduce_extraneous: 'Focusing on reducing presentation complexity',
+            chunk_intrinsic: 'Breaking down inherent task complexity',
+            maximize_germane: 'Maximizing productive learning load',
+            balanced: 'Balancing all cognitive load components',
+        };
+        const output = {
+            currentLoad: {
+                intrinsic: currentCognitiveLoad.intrinsic,
+                extraneous: currentCognitiveLoad.extraneous,
+                germane: currentCognitiveLoad.germane,
+                total: totalLoad,
+            },
+            overloaded,
+            recommendations,
+            details: {
+                optimization,
+                threshold,
+                interpretation: overloaded
+                    ? `Cognitive overload detected (${(totalLoad * 100).toFixed(1)}% > ${(threshold * 100).toFixed(1)}%). ${interpretations[optimization]}`
+                    : `Cognitive load is manageable (${(totalLoad * 100).toFixed(1)}%). ${interpretations[optimization]}`,
+            },
+        };
+        const duration = performance.now() - startTime;
+        logger.info('Cognitive load management completed', {
+            totalLoad: totalLoad.toFixed(2),
+            overloaded,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult(output);
+    }
+    catch (error) {
+        logger.error('Cognitive load management failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const cognitiveLoadTool = {
+    name: 'cognition/cognitive-load',
+    description: 'Monitor and balance cognitive load during reasoning. Manages intrinsic, extraneous, and germane load with optimization strategies.',
+    category: 'cognition',
+    version: '0.1.0',
+    tags: ['cognitive-load', 'clt', 'optimization', 'learning'],
+    cacheable: false,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            assessment: {
+                type: 'object',
+                properties: {
+                    intrinsic: { type: 'number', description: 'Task complexity (0-1)' },
+                    extraneous: { type: 'number', description: 'Presentation complexity (0-1)' },
+                    germane: { type: 'number', description: 'Learning investment (0-1)' },
+                },
+            },
+            optimization: {
+                type: 'string',
+                enum: ['reduce_extraneous', 'chunk_intrinsic', 'maximize_germane', 'balanced'],
+                default: 'balanced',
+            },
+            threshold: { type: 'number', default: 0.8 },
+        },
+    },
+    handler: cognitiveLoadHandler,
+};
+// ============================================================================
+// Export All Tools
+// ============================================================================
+export const cognitiveKernelTools = [
+    workingMemoryTool,
+    attentionControlTool,
+    metaMonitorTool,
+    scaffoldTool,
+    cognitiveLoadTool,
+];
+export const toolHandlers = new Map([
+    ['cognition/working-memory', workingMemoryTool.handler],
+    ['cognition/attention-control', attentionControlTool.handler],
+    ['cognition/meta-monitor', metaMonitorTool.handler],
+    ['cognition/scaffold', scaffoldTool.handler],
+    ['cognition/cognitive-load', cognitiveLoadTool.handler],
+]);
+export function getTool(name) {
+    return cognitiveKernelTools.find(t => t.name === name);
+}
+export function getToolNames() {
+    return cognitiveKernelTools.map(t => t.name);
+}
+export default cognitiveKernelTools;
+//# sourceMappingURL=mcp-tools.js.map