pikakit 1.0.18 → 1.0.20

package/lib/agent-cli/lib/knowledge.js

@@ -0,0 +1,358 @@
+/**
+ * Knowledge Storage v6.0 - Unified Schema
+ * 
+ * Single source of truth for all lessons in PikaKit AutoLearn system.
+ * Consolidates legacy lessons-learned.yaml, mistakes.yaml, and improvements.yaml
+ * 
+ * @version 6.0.0
+ * @author PikaKit
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const KNOWLEDGE_DIR = path.join(process.cwd(), '.agent', 'knowledge');
+const KNOWLEDGE_FILE = path.join(KNOWLEDGE_DIR, 'knowledge.yaml');
+
+// Legacy files (for backward compatibility)
+const LEGACY_FILES = {
+    lessonsLearned: path.join(KNOWLEDGE_DIR, 'lessons-learned.yaml'),
+    mistakes: path.join(KNOWLEDGE_DIR, 'mistakes.yaml'),
+    improvements: path.join(KNOWLEDGE_DIR, 'improvements.yaml')
+};
+
+// ============================================================================
+// SCHEMA DEFINITION
+// ============================================================================
+
+/**
+ * @typedef {Object} Lesson
+ * @property {string} id - Unique identifier (LESSON-XXX)
+ * @property {string} type - Type: 'mistake' | 'improvement' | 'pattern'
+ * @property {string} pattern - Regex pattern to match
+ * @property {string} message - Human-readable explanation
+ * @property {string} severity - 'ERROR' | 'WARNING' | 'INFO'
+ * @property {string} intent - 'prevent' | 'optimize' | 'inform'
+ * @property {number} confidence - 0.0 to 1.0
+ * @property {string} maturity - 'learning' | 'stable'
+ * @property {number} hitCount - Number of times pattern was matched
+ * @property {string|null} lastHit - ISO8601 timestamp of last match
+ * @property {string[]} excludePaths - Glob patterns for excluded paths
+ * @property {string[]} tags - Category tags
+ * @property {Object|null} autoFix - Auto-fix configuration
+ */
+
+/**
+ * @typedef {Object} KnowledgeBase
+ * @property {number} version - Schema version (6.0)
+ * @property {string} createdAt - ISO8601 creation timestamp
+ * @property {string} updatedAt - ISO8601 last update timestamp
+ * @property {Lesson[]} lessons - Array of lessons
+ */
+
+/**
+ * Create empty knowledge base with v6 schema
+ * @returns {KnowledgeBase}
+ */
+export function createEmptyKnowledge() {
+    return {
+        version: 6.0,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        lessons: []
+    };
+}
+
+// ============================================================================
+// LOADING
+// ============================================================================
+
+/**
+ * Load knowledge base with automatic version detection
+ * Priority: v6 (knowledge.yaml) > v4 (mistakes + improvements) > v3 (lessons-learned)
+ * 
+ * @returns {KnowledgeBase}
+ */
+export function loadKnowledge() {
+    try {
+        // Priority 1: v6 unified format
+        if (fs.existsSync(KNOWLEDGE_FILE)) {
+            const content = fs.readFileSync(KNOWLEDGE_FILE, 'utf8');
+            const data = yaml.load(content) || createEmptyKnowledge();
+            return data;
+        }
+
+        // Priority 2: v4 cognitive format (mistakes + improvements)
+        const hasV4 = fs.existsSync(LEGACY_FILES.mistakes) ||
+            fs.existsSync(LEGACY_FILES.improvements);
+
+        if (hasV4) {
+            return loadV4Legacy();
+        }
+
+        // Priority 3: v3 legacy format
+        if (fs.existsSync(LEGACY_FILES.lessonsLearned)) {
+            return loadV3Legacy();
+        }
+
+        // No data - return empty
+        return createEmptyKnowledge();
+
+    } catch (error) {
+        console.error('[knowledge] Error loading:', error.message);
+        return createEmptyKnowledge();
+    }
+}
+
+/**
+ * Load from v4 legacy files (mistakes.yaml + improvements.yaml)
+ * @returns {KnowledgeBase}
+ */
+function loadV4Legacy() {
+    const knowledge = createEmptyKnowledge();
+
+    // Load mistakes
+    if (fs.existsSync(LEGACY_FILES.mistakes)) {
+        try {
+            const data = yaml.load(fs.readFileSync(LEGACY_FILES.mistakes, 'utf8'));
+            const mistakes = (data.mistakes || []).map(m => ({
+                id: m.id,
+                type: 'mistake',
+                pattern: m.pattern,
+                message: m.message,
+                severity: m.severity || 'WARNING',
+                intent: 'prevent',
+                confidence: m.cognitive?.confidence || 0.5,
+                maturity: m.cognitive?.maturity || 'learning',
+                hitCount: m.hitCount || 0,
+                lastHit: m.lastHit || null,
+                excludePaths: m.excludePaths || [],
+                tags: m.tags || [],
+                autoFix: m.autoFix || null
+            }));
+            knowledge.lessons.push(...mistakes);
+        } catch (e) {
+            console.error('[knowledge] Error loading mistakes.yaml:', e.message);
+        }
+    }
+
+    // Load improvements
+    if (fs.existsSync(LEGACY_FILES.improvements)) {
+        try {
+            const data = yaml.load(fs.readFileSync(LEGACY_FILES.improvements, 'utf8'));
+            const improvements = (data.improvements || []).map(i => ({
+                id: i.id,
+                type: 'improvement',
+                pattern: i.pattern,
+                message: i.message,
+                severity: 'INFO',
+                intent: 'optimize',
+                confidence: i.cognitive?.confidence || 0.5,
+                maturity: i.cognitive?.maturity || 'learning',
+                hitCount: i.hitCount || i.appliedCount || 0,
+                lastHit: i.lastHit || i.lastApplied || null,
+                excludePaths: i.excludePaths || [],
+                tags: i.tags || [],
+                autoFix: null
+            }));
+            knowledge.lessons.push(...improvements);
+        } catch (e) {
+            console.error('[knowledge] Error loading improvements.yaml:', e.message);
+        }
+    }
+
+    return knowledge;
+}
+
+/**
+ * Load from v3 legacy file (lessons-learned.yaml)
+ * @returns {KnowledgeBase}
+ */
+function loadV3Legacy() {
+    const knowledge = createEmptyKnowledge();
+
+    try {
+        const data = yaml.load(fs.readFileSync(LEGACY_FILES.lessonsLearned, 'utf8'));
+        const lessons = (data.lessons || []).map(l => ({
+            id: l.id,
+            type: l.severity === 'ERROR' ? 'mistake' : 'pattern',
+            pattern: l.pattern,
+            message: l.message,
+            severity: l.severity || 'WARNING',
+            intent: l.severity === 'ERROR' ? 'prevent' : 'inform',
+            confidence: l.hitCount > 10 ? 0.9 : 0.5,
+            maturity: l.hitCount > 10 ? 'stable' : 'learning',
+            hitCount: l.hitCount || 0,
+            lastHit: l.lastHit || null,
+            excludePaths: [],
+            tags: [l.category || 'general'],
+            autoFix: null
+        }));
+        knowledge.lessons.push(...lessons);
+    } catch (e) {
+        console.error('[knowledge] Error loading lessons-learned.yaml:', e.message);
+    }
+
+    return knowledge;
+}
+
+// ============================================================================
+// SAVING
+// ============================================================================
+
+/**
+ * Save knowledge base to unified format
+ * @param {KnowledgeBase} knowledge
+ */
+export function saveKnowledge(knowledge) {
+    try {
+        // Ensure directory exists
+        if (!fs.existsSync(KNOWLEDGE_DIR)) {
+            fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+        }
+
+        // Update timestamp
+        knowledge.updatedAt = new Date().toISOString();
+        knowledge.version = 6.0;
+
+        // Write to file
+        const yamlContent = yaml.dump(knowledge, {
+            lineWidth: -1,
+            quotingType: '"',
+            forceQuotes: false
+        });
+
+        fs.writeFileSync(KNOWLEDGE_FILE, yamlContent, 'utf8');
+
+        return true;
+    } catch (error) {
+        console.error('[knowledge] Error saving:', error.message);
+        return false;
+    }
+}
+
+// ============================================================================
+// OPERATIONS
+// ============================================================================
+
+/**
+ * Add a new lesson
+ * @param {Lesson} lesson
+ * @returns {boolean}
+ */
+export function addLesson(lesson) {
+    const knowledge = loadKnowledge();
+
+    // Check for duplicate ID
+    if (knowledge.lessons.some(l => l.id === lesson.id)) {
+        console.warn(`[knowledge] Lesson ${lesson.id} already exists`);
+        return false;
+    }
+
+    knowledge.lessons.push(lesson);
+    return saveKnowledge(knowledge);
+}
+
+/**
+ * Update an existing lesson
+ * @param {string} id
+ * @param {Partial<Lesson>} updates
+ * @returns {boolean}
+ */
+export function updateLesson(id, updates) {
+    const knowledge = loadKnowledge();
+    const index = knowledge.lessons.findIndex(l => l.id === id);
+
+    if (index === -1) {
+        console.warn(`[knowledge] Lesson ${id} not found`);
+        return false;
+    }
+
+    knowledge.lessons[index] = { ...knowledge.lessons[index], ...updates };
+    return saveKnowledge(knowledge);
+}
+
+/**
+ * Remove a lesson
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function removeLesson(id) {
+    const knowledge = loadKnowledge();
+    const initialLength = knowledge.lessons.length;
+    knowledge.lessons = knowledge.lessons.filter(l => l.id !== id);
+
+    if (knowledge.lessons.length === initialLength) {
+        console.warn(`[knowledge] Lesson ${id} not found`);
+        return false;
+    }
+
+    return saveKnowledge(knowledge);
+}
+
+/**
+ * Get lessons by type
+ * @param {'mistake' | 'improvement' | 'pattern'} type
+ * @returns {Lesson[]}
+ */
+export function getLessonsByType(type) {
+    const knowledge = loadKnowledge();
+    return knowledge.lessons.filter(l => l.type === type);
+}
+
+/**
+ * Get total lesson count
+ * @returns {number}
+ */
+export function getLessonCount() {
+    const knowledge = loadKnowledge();
+    return knowledge.lessons.length;
+}
+
+/**
+ * Record a hit on a lesson
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function recordHit(id) {
+    const knowledge = loadKnowledge();
+    const lesson = knowledge.lessons.find(l => l.id === id);
+
+    if (!lesson) {
+        return false;
+    }
+
+    lesson.hitCount = (lesson.hitCount || 0) + 1;
+    lesson.lastHit = new Date().toISOString();
+
+    // Auto-update maturity based on hits
+    if (lesson.hitCount >= 10) {
+        lesson.maturity = 'stable';
+        lesson.confidence = Math.min(0.95, lesson.confidence + 0.05);
+    }
+
+    return saveKnowledge(knowledge);
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+export default {
+    loadKnowledge,
+    saveKnowledge,
+    addLesson,
+    updateLesson,
+    removeLesson,
+    getLessonsByType,
+    getLessonCount,
+    recordHit,
+    createEmptyKnowledge,
+    KNOWLEDGE_FILE,
+    LEGACY_FILES
+};

package/lib/agent-cli/lib/migrate-to-v6.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+/**
+ * Migration Script: v3/v4 → v6
+ * 
+ * Migrates legacy knowledge files to unified knowledge.yaml format.
+ * 
+ * Source files:
+ * - lessons-learned.yaml (v3)
+ * - mistakes.yaml (v4)
+ * - improvements.yaml (v4)
+ * 
+ * Target:
+ * - knowledge.yaml (v6)
+ * 
+ * Usage:
+ *   node migrate-to-v6.js
+ *   node migrate-to-v6.js --dry-run
+ * 
+ * @version 6.0.0
+ * @author PikaKit
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const KNOWLEDGE_DIR = path.join(process.cwd(), '.agent', 'knowledge');
+const BACKUP_DIR = path.join(KNOWLEDGE_DIR, 'backup');
+
+const FILES = {
+    lessonsLearned: path.join(KNOWLEDGE_DIR, 'lessons-learned.yaml'),
+    mistakes: path.join(KNOWLEDGE_DIR, 'mistakes.yaml'),
+    improvements: path.join(KNOWLEDGE_DIR, 'improvements.yaml'),
+    knowledge: path.join(KNOWLEDGE_DIR, 'knowledge.yaml')
+};
+
+const isDryRun = process.argv.includes('--dry-run');
+
+// ============================================================================
+// LOGGING
+// ============================================================================
+
+const log = {
+    info: (msg) => console.log(`  ℹ️  ${msg}`),
+    success: (msg) => console.log(`  ✅ ${msg}`),
+    warning: (msg) => console.log(`  ⚠️  ${msg}`),
+    error: (msg) => console.log(`  ❌ ${msg}`),
+    step: (n, msg) => console.log(`\n📌 Step ${n}: ${msg}`)
+};
+
+// ============================================================================
+// BACKUP
+// ============================================================================
+
+function backupFiles() {
+    log.step(1, 'Backing up existing files');
+
+    if (!fs.existsSync(BACKUP_DIR)) {
+        fs.mkdirSync(BACKUP_DIR, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    let backedUp = 0;
+
+    for (const [name, filepath] of Object.entries(FILES)) {
+        if (name === 'knowledge') continue; // Don't backup target
+
+        if (fs.existsSync(filepath)) {
+            const backupPath = path.join(BACKUP_DIR, `${path.basename(filepath)}.${timestamp}.bak`);
+
+            if (!isDryRun) {
+                fs.copyFileSync(filepath, backupPath);
+            }
+
+            log.success(`Backed up ${path.basename(filepath)}`);
+            backedUp++;
+        }
+    }
+
+    if (backedUp === 0) {
+        log.warning('No files to backup');
+    }
+
+    return true;
+}
+
+// ============================================================================
+// LOADING LEGACY DATA
+// ============================================================================
+
+function loadLegacyData() {
+    log.step(2, 'Loading legacy data');
+
+    const lessons = [];
+    const stats = { v3: 0, v4Mistakes: 0, v4Improvements: 0 };
+
+    // Load v3 lessons-learned.yaml
+    if (fs.existsSync(FILES.lessonsLearned)) {
+        try {
+            const data = yaml.load(fs.readFileSync(FILES.lessonsLearned, 'utf8'));
+            const v3Lessons = (data.lessons || []).map(l => ({
+                id: l.id,
+                type: l.severity === 'ERROR' ? 'mistake' : 'pattern',
+                pattern: l.pattern,
+                message: l.message,
+                severity: l.severity || 'WARNING',
+                intent: l.severity === 'ERROR' ? 'prevent' : 'inform',
+                confidence: l.hitCount > 10 ? 0.9 : 0.5,
+                maturity: l.hitCount > 10 ? 'stable' : 'learning',
+                hitCount: l.hitCount || 0,
+                lastHit: l.lastHit || null,
+                excludePaths: [],
+                tags: [l.category || 'general'],
+                autoFix: null,
+                _source: 'lessons-learned.yaml'
+            }));
+            lessons.push(...v3Lessons);
+            stats.v3 = v3Lessons.length;
+            log.success(`Loaded ${v3Lessons.length} lesson(s) from lessons-learned.yaml`);
+        } catch (e) {
+            log.error(`Failed to load lessons-learned.yaml: ${e.message}`);
+        }
+    } else {
+        log.info('lessons-learned.yaml not found, skipping');
+    }
+
+    // Load v4 mistakes.yaml
+    if (fs.existsSync(FILES.mistakes)) {
+        try {
+            const data = yaml.load(fs.readFileSync(FILES.mistakes, 'utf8'));
+            const mistakes = (data.mistakes || []).map(m => ({
+                id: m.id,
+                type: 'mistake',
+                pattern: m.pattern,
+                message: m.message,
+                severity: m.severity || 'WARNING',
+                intent: 'prevent',
+                confidence: m.cognitive?.confidence || 0.5,
+                maturity: m.cognitive?.maturity || 'learning',
+                hitCount: m.hitCount || 0,
+                lastHit: m.lastHit || null,
+                excludePaths: m.excludePaths || [],
+                tags: m.tags || [],
+                autoFix: m.autoFix || null,
+                _source: 'mistakes.yaml'
+            }));
+            lessons.push(...mistakes);
+            stats.v4Mistakes = mistakes.length;
+            log.success(`Loaded ${mistakes.length} mistake(s) from mistakes.yaml`);
+        } catch (e) {
+            log.error(`Failed to load mistakes.yaml: ${e.message}`);
+        }
+    } else {
+        log.info('mistakes.yaml not found, skipping');
+    }
+
+    // Load v4 improvements.yaml
+    if (fs.existsSync(FILES.improvements)) {
+        try {
+            const data = yaml.load(fs.readFileSync(FILES.improvements, 'utf8'));
+            const improvements = (data.improvements || []).map(i => ({
+                id: i.id,
+                type: 'improvement',
+                pattern: i.pattern,
+                message: i.message,
+                severity: 'INFO',
+                intent: 'optimize',
+                confidence: i.cognitive?.confidence || 0.5,
+                maturity: i.cognitive?.maturity || 'learning',
+                hitCount: i.hitCount || i.appliedCount || 0,
+                lastHit: i.lastHit || i.lastApplied || null,
+                excludePaths: i.excludePaths || [],
+                tags: i.tags || [],
+                autoFix: null,
+                _source: 'improvements.yaml'
+            }));
+            lessons.push(...improvements);
+            stats.v4Improvements = improvements.length;
+            log.success(`Loaded ${improvements.length} improvement(s) from improvements.yaml`);
+        } catch (e) {
+            log.error(`Failed to load improvements.yaml: ${e.message}`);
+        }
+    } else {
+        log.info('improvements.yaml not found, skipping');
+    }
+
+    return { lessons, stats };
+}
+
+// ============================================================================
+// DEDUPLICATION
+// ============================================================================
+
+function deduplicateLessons(lessons) {
+    log.step(3, 'Deduplicating lessons');
+
+    const seen = new Map();
+    const duplicates = [];
+
+    for (const lesson of lessons) {
+        // Check by pattern (primary dedup key)
+        if (seen.has(lesson.pattern)) {
+            const existing = seen.get(lesson.pattern);
+            duplicates.push({
+                kept: existing.id,
+                removed: lesson.id,
+                pattern: lesson.pattern
+            });
+            // Keep the one with more hits
+            if (lesson.hitCount > existing.hitCount) {
+                seen.set(lesson.pattern, lesson);
+            }
+        } else {
+            seen.set(lesson.pattern, lesson);
+        }
+    }
+
+    const deduped = Array.from(seen.values());
+
+    if (duplicates.length > 0) {
+        log.warning(`Found ${duplicates.length} duplicate(s), keeping highest hitCount`);
+        duplicates.forEach(d => {
+            log.info(`  Merged ${d.removed} into ${d.kept}`);
+        });
+    } else {
+        log.success('No duplicates found');
+    }
+
+    return deduped;
+}
+
+// ============================================================================
+// RENUMBER IDS
+// ============================================================================
+
+function renumberLessons(lessons) {
+    log.step(4, 'Renumbering lesson IDs');
+
+    return lessons.map((lesson, index) => {
+        // Remove internal _source field
+        const { _source, ...cleanLesson } = lesson;
+
+        // Assign new sequential ID
+        cleanLesson.id = `LESSON-${String(index + 1).padStart(3, '0')}`;
+
+        return cleanLesson;
+    });
+}
+
+// ============================================================================
+// SAVE
+// ============================================================================
+
+function saveKnowledge(lessons) {
+    log.step(5, 'Saving unified knowledge.yaml');
+
+    const knowledge = {
+        version: 6.0,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        lessons
+    };
+
+    const yamlContent = yaml.dump(knowledge, {
+        lineWidth: -1,
+        quotingType: '"',
+        forceQuotes: false
+    });
+
+    if (isDryRun) {
+        log.info('[DRY RUN] Would write to knowledge.yaml');
+        console.log('\n--- Preview of knowledge.yaml ---');
+        console.log(yamlContent.slice(0, 1000) + (yamlContent.length > 1000 ? '\n...' : ''));
+    } else {
+        fs.writeFileSync(FILES.knowledge, yamlContent, 'utf8');
+        log.success(`Saved ${lessons.length} lesson(s) to knowledge.yaml`);
+    }
+
+    return true;
+}
+
+// ============================================================================
+// VERIFY
+// ============================================================================
+
+function verifyMigration(expectedCount) {
+    log.step(6, 'Verifying migration');
+
+    if (isDryRun) {
+        log.info('[DRY RUN] Skipping verification');
+        return true;
+    }
+
+    if (!fs.existsSync(FILES.knowledge)) {
+        log.error('knowledge.yaml not created');
+        return false;
+    }
+
+    const data = yaml.load(fs.readFileSync(FILES.knowledge, 'utf8'));
+    const actualCount = data.lessons?.length || 0;
+
+    if (actualCount !== expectedCount) {
+        log.error(`Count mismatch: expected ${expectedCount}, got ${actualCount}`);
+        return false;
+    }
+
+    log.success(`Verified: ${actualCount} lessons in knowledge.yaml`);
+    log.success(`Version: ${data.version}`);
+
+    return true;
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main() {
+    console.log('\n🔄 Knowledge Storage Migration: v3/v4 → v6');
+    console.log('='.repeat(50));
+
+    if (isDryRun) {
+        console.log('🔍 DRY RUN MODE - No changes will be made\n');
+    }
+
+    // Step 1: Backup
+    backupFiles();
+
+    // Step 2: Load legacy data
+    const { lessons, stats } = loadLegacyData();
+
+    if (lessons.length === 0) {
+        log.warning('No lessons found to migrate');
+        console.log('\n✅ Migration complete (nothing to migrate)');
+        return;
+    }
+
+    // Step 3: Deduplicate
+    const deduped = deduplicateLessons(lessons);
+
+    // Step 4: Renumber
+    const renumbered = renumberLessons(deduped);
+
+    // Step 5: Save
+    saveKnowledge(renumbered);
+
+    // Step 6: Verify
+    const verified = verifyMigration(renumbered.length);
+
+    // Summary
+    console.log('\n' + '='.repeat(50));
+    console.log('📊 Migration Summary');
+    console.log('='.repeat(50));
+    console.log(`  Source files:`);
+    console.log(`    - lessons-learned.yaml: ${stats.v3} lesson(s)`);
+    console.log(`    - mistakes.yaml: ${stats.v4Mistakes} mistake(s)`);
+    console.log(`    - improvements.yaml: ${stats.v4Improvements} improvement(s)`);
+    console.log(`  Total loaded: ${lessons.length}`);
+    console.log(`  After dedup: ${deduped.length}`);
+    console.log(`  Final count: ${renumbered.length}`);
+    console.log(`  Verified: ${verified ? '✅ Yes' : '❌ No'}`);
+
+    if (isDryRun) {
+        console.log('\n🔍 This was a dry run. Run without --dry-run to apply changes.');
+    } else {
+        console.log('\n✅ Migration complete!');
+        console.log('📁 Backup files saved to: .agent/knowledge/backup/');
+    }
+}
+
+main().catch(e => {
+    log.error(`Migration failed: ${e.message}`);
+    process.exit(1);
+});

package/lib/agent-cli/lib/recall.js

@@ -23,6 +23,7 @@ import pretty from "./ui/pretty.js";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { checkEvolutionThreshold, queueEvolutionSignal } from "./evolution-signal.js";
+import { loadKnowledge as loadKnowledgeV6, saveKnowledge as saveKnowledgeV6 } from "./knowledge.js";
 
 // ============================================================================
 // PERCEPTION LAYER - Cognitive Enhancements
@@ -142,66 +143,25 @@ function createCognitiveLesson(rawLesson) {
 // ============================================================================
 
 /**
- * Load knowledge base from YAML file
- * Supports both v3.x (lessons-learned.yaml) and v4.x (cognitive lessons)
+ * Load knowledge base from unified v6 format
+ * With backward compatibility for v3.x and v4.x
  * @returns {{ lessons: Array<{ id: string, pattern: string, message: string, severity: string, hitCount?: number, lastHit?: string }>, version?: number }}
  */
 export function loadKnowledge() {
     try {
-        // Check for v4.x cognitive structure first
-        const mistakesPath = path.join(KNOWLEDGE_DIR, 'mistakes.yaml');
-        const improvementsPath = path.join(KNOWLEDGE_DIR, 'improvements.yaml');
-
-        const hasV4 = fs.existsSync(mistakesPath) || fs.existsSync(improvementsPath);
-
-        if (hasV4) {
-            // v4.x: Load cognitive lessons and flatten for scanning
-            const mistakes = fs.existsSync(mistakesPath)
-                ? yaml.load(fs.readFileSync(mistakesPath, 'utf8'))
-                : { mistakes: [] };
-            const improvements = fs.existsSync(improvementsPath)
-                ? yaml.load(fs.readFileSync(improvementsPath, 'utf8'))
-                : { improvements: [] };
-
-            // Flatten and apply cognitive transformation
-            const rawLessons = [
-                ...(mistakes.mistakes || []).map(m => ({
-                    id: m.id,
-                    pattern: m.pattern,
-                    message: m.message,
-                    severity: m.severity || 'WARNING',
-                    hitCount: m.hitCount || 0,
-                    lastHit: m.lastHit,
-                    excludePaths: m.excludePaths,
-                    tags: m.tags,
-                    autoFix: m.autoFix, // Preserve autoFix for Fix All
-                    type: 'mistake', // Mark for tracking
-                })),
-                ...(improvements.improvements || []).map(i => ({
-                    id: i.id,
-                    pattern: i.pattern,
-                    message: i.message,
-                    severity: 'INFO', // Improvements are informational
-                    hitCount: i.appliedCount || 0,
-                    lastHit: i.lastApplied,
-                    excludePaths: i.excludePaths, // PRESERVE excludePaths!
-                    tags: i.tags,
-                    type: 'improvement', // Mark for tracking
-                }))
-            ];
-
-            // Apply cognitive transformation to create agent-level lessons
-            const lessons = rawLessons.map(createCognitiveLesson);
-
-            return { lessons, version: 4.0 };
-        }
+        // Use unified v6 loader (handles all versions internally)
+        const knowledge = loadKnowledgeV6();
+
+        // Transform lessons for cognitive processing
+        const lessons = knowledge.lessons.map(lesson => {
+            // Apply cognitive transformation if not already present
+            if (!lesson.cognitive) {
+                return createCognitiveLesson(lesson);
+            }
+            return lesson;
+        });
 
-        // Fallback to v3.x
-        if (!fs.existsSync(LESSONS_PATH)) {
-            return { lessons: [], version: 1 };
-        }
-        const content = fs.readFileSync(LESSONS_PATH, "utf8");
-        return yaml.load(content) || { lessons: [], version: 1 };
+        return { lessons, version: knowledge.version || 6.0 };
     } catch (error) {
         if (DEBUG) console.error("Error loading knowledge:", error.message);
         return { lessons: [], version: 1 };
@@ -209,48 +169,20 @@ export function loadKnowledge() {
 }
 
 /**
- * Save knowledge base to YAML file
- * Supports both v3.x and v4.x formats
+ * Save knowledge base to unified v6 format
  * @param {{ lessons: Array, version?: number }} data
  */
 export function saveKnowledge(data) {
     try {
-        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
-
-        // v4.x: Save to mistakes.yaml and improvements.yaml
-        if (data.version === 4.0) {
-            const mistakes = data.lessons.filter(l => l.type === 'mistake').map(m => {
-                const { type, ...rest } = m; // Remove type field
-                return rest;
-            });
-            const improvements = data.lessons.filter(l => l.type === 'improvement').map(i => {
-                const { type, severity, ...rest } = i; // Remove type and severity
-                return {
-                    ...rest,
-                    excludePaths: i.excludePaths || [], // PRESERVE excludePaths explicitly
-                    appliedCount: rest.hitCount,
-                    lastApplied: rest.lastHit,
-                };
-            });
-
-            // Save mistakes
-            if (mistakes.length > 0) {
-                const mistakesPath = path.join(KNOWLEDGE_DIR, 'mistakes.yaml');
-                const mistakesData = yaml.dump({ version: 4.0, mistakes }, { lineWidth: -1 });
-                fs.writeFileSync(mistakesPath, mistakesData, 'utf8');
-            }
+        // Convert to v6 format
+        const knowledge = {
+            version: 6.0,
+            createdAt: data.createdAt || new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            lessons: data.lessons
+        };
 
-            // Save improvements
-            if (improvements.length > 0) {
-                const improvementsPath = path.join(KNOWLEDGE_DIR, 'improvements.yaml');
-                const improvementsData = yaml.dump({ version: 4.0, improvements }, { lineWidth: -1 });
-                fs.writeFileSync(improvementsPath, improvementsData, 'utf8');
-            }
-        } else {
-            // v3.x: Save to lessons-learned.yaml
-            const str = yaml.dump(data, { lineWidth: -1 });
-            fs.writeFileSync(LESSONS_PATH, str, "utf8");
-        }
+        saveKnowledgeV6(knowledge);
     } catch (error) {
         console.error("❌ Failed to save knowledge base:", error.message);
     }

package/lib/agent-cli/scripts/dashboard-server.js

@@ -42,8 +42,21 @@ const projectRoot = findProjectRoot();
 const dashboardPath = path.join(__dirname, '..', 'dashboard');
 const knowledgeDir = path.join(projectRoot, '.agent', 'knowledge');
 
-// Read lessons count from YAML files (same source as CLI)
+// Read lessons count - prioritize v6 format
 function getLessonsCount() {
+    // Priority 1: v6 unified format
+    const knowledgePath = path.join(knowledgeDir, 'knowledge.yaml');
+    if (fs.existsSync(knowledgePath)) {
+        try {
+            const content = fs.readFileSync(knowledgePath, 'utf-8');
+            const data = yaml.load(content);
+            return data.lessons?.length || 0;
+        } catch (e) {
+            // Fall through to legacy
+        }
+    }
+
+    // Priority 2: Legacy files
     let count = 0;
     const files = ['lessons-learned.yaml', 'mistakes.yaml', 'improvements.yaml'];
 
@@ -52,7 +65,6 @@ function getLessonsCount() {
         if (fs.existsSync(filePath)) {
             try {
                 const content = fs.readFileSync(filePath, 'utf-8');
-                // Simple YAML parsing - count items in lessons/mistakes/improvements arrays
                 const matches = content.match(/^\s*-\s+id:/gm);
                 if (matches) count += matches.length;
             } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikakit",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
   "license": "MIT",
   "author": "pikakit <pikakit@gmail.com>",

package/lib/agent-cli/lib/migrate-to-v4.js

@@ -1,322 +0,0 @@
-#!/usr/bin/env node
-/**
- * Migration Script: v3.x → v4.x Cognitive Lesson Engine
- * 
- * This script:
- * 1. Backs up current lessons-learned.yaml
- * 2. Classifies lessons into mistakes vs improvements
- * 3. Generates mistakes.yaml and improvements.yaml
- * 4. Preserves all existing data
- */
-
-import fs from 'fs';
-import path from 'path';
-import yaml from 'js-yaml';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = path.join(__dirname, '../../..');
-const KNOWLEDGE_DIR = path.join(PROJECT_ROOT, '.agent/knowledge');
-const LESSONS_PATH = path.join(KNOWLEDGE_DIR, 'lessons-learned.yaml');
-const BACKUP_DIR = path.join(KNOWLEDGE_DIR, '_migration_backup');
-const MISTAKES_PATH = path.join(KNOWLEDGE_DIR, 'mistakes.yaml');
-const IMPROVEMENTS_PATH = path.join(KNOWLEDGE_DIR, 'improvements.yaml');
-
-// ============================================================================
-// STEP 1: Backup Current Data
-// ============================================================================
-
-function backupCurrentLessons() {
-    console.log('📦 Step 1: Backing up current lessons...');
-
-    if (!fs.existsSync(LESSONS_PATH)) {
-        console.log('⚠️  No lessons-learned.yaml found, skipping backup');
-        return null;
-    }
-
-    // Create backup directory
-    fs.mkdirSync(BACKUP_DIR, { recursive: true });
-
-    // Backup with timestamp
-    const timestamp = new Date().toISOString().replace(/:/g, '-');
-    const backupPath = path.join(BACKUP_DIR, `lessons-learned_${timestamp}.yaml`);
-
-    fs.copyFileSync(LESSONS_PATH, backupPath);
-    console.log(`✅ Backup created: ${backupPath}`);
-
-    // Load and return data
-    const content = fs.readFileSync(LESSONS_PATH, 'utf8');
-    return yaml.load(content);
-}
-
-// ============================================================================
-// STEP 2: Classification Logic
-// ============================================================================
-
-/**
- * Auto-classify lesson as mistake or improvement
- * Conservative: default to mistake (safer assumption)
- */
-function classifyLesson(lesson) {
-    const message = lesson.message.toLowerCase();
-
-    // Keywords that indicate improvement/best practice
-    const improvementKeywords = [
-        'use ', 'always use', 'prefer ', 'should use',
-        'best practice', 'recommended', 'instead use',
-        'better to', 'proper way', 'correct approach'
-    ];
-
-    // Keywords that indicate mistake/anti-pattern
-    const mistakeKeywords = [
-        'never', 'avoid', 'don\'t', 'do not', 'incorrect',
-        'wrong', 'bad', 'conflicts', 'causes', 'breaks'
-    ];
-
-    const hasMistakeKeyword = mistakeKeywords.some(kw => message.includes(kw));
-    const hasImprovementKeyword = improvementKeywords.some(kw => message.includes(kw));
-
-    // Both keywords present - need manual review
-    if (hasMistakeKeyword && hasImprovementKeyword) {
-        return 'mixed';
-    }
-
-    // Clear improvement
-    if (hasImprovementKeyword && !hasMistakeKeyword) {
-        return 'improvement';
-    }
-
-    // Default: mistake (conservative)
-    return 'mistake';
-}
-
-/**
- * Extract tags from lesson data
- * Tags used for grouping into Cognitive Lessons
- */
-function extractTags(lesson) {
-    const tags = new Set();
-
-    // Add category as tag
-    if (lesson.category) {
-        tags.add(lesson.category);
-    }
-
-    // Extract from pattern
-    const pattern = lesson.pattern.toLowerCase();
-    if (pattern.includes('select')) tags.add('cli-navigation');
-    if (pattern.includes('menu')) tags.add('ux');
-    if (pattern.includes('rename') || pattern.includes('move') || pattern.includes('rebrand')) {
-        tags.add('file-safety');
-        tags.add('rebranding');
-    }
-    if (pattern.includes('import')) tags.add('imports');
-    if (pattern.includes('recursive')) tags.add('architecture');
-
-    // Extract from message
-    const message = lesson.message.toLowerCase();
-    if (message.includes('esc')) tags.add('cli-navigation');
-    if (message.includes('clack')) tags.add('clack-framework');
-    if (message.includes('menu')) tags.add('ux');
-    if (message.includes('security')) tags.add('security');
-    if (message.includes('performance')) tags.add('performance');
-
-    return Array.from(tags);
-}
-
-/**
- * Split mixed lessons into mistake + improvement
- */
-function splitMixedLesson(lesson) {
-    const message = lesson.message;
-
-    // Try to extract both parts
-    // Pattern: "NEVER X. Use Y instead"
-    const neverMatch = message.match(/(NEVER|Don't|Avoid)\s+([^.]+)\./i);
-    const useMatch = message.match(/(Use|Always use|Instead use)\s+([^.]+)/i);
-
-    const mistake = {
-        ...lesson,
-        id: lesson.id.replace('LEARN', 'MISTAKE'),
-        title: neverMatch ? neverMatch[0] : message.split('.')[0],
-        message: neverMatch ? neverMatch[0] : message.split('.')[0],
-    };
-
-    let improvement = null;
-    if (useMatch) {
-        improvement = {
-            id: lesson.id.replace('LEARN', 'IMPROVE'),
-            title: useMatch[0],
-            message: useMatch[0],
-            pattern: lesson.pattern,
-            priority: lesson.severity === 'ERROR' ? 'HIGH' : 'MEDIUM',
-            tags: extractTags(lesson),
-            added: lesson.addedAt,
-            appliedCount: 0,
-        };
-    }
-
-    return { mistake, improvement };
-}
-
-// ============================================================================
-// STEP 3: Migration Logic
-// ============================================================================
-
-function migrateToV4(oldData) {
-    console.log('\n🔄 Step 2: Classifying lessons...');
-
-    const mistakes = [];
-    const improvements = [];
-    const needsReview = [];
-
-    oldData.lessons.forEach((lesson, index) => {
-        const classification = classifyLesson(lesson);
-        const tags = extractTags(lesson);
-
-        console.log(`  ${lesson.id}: ${classification} (tags: ${tags.join(', ')})`);
-
-        if (classification === 'mistake') {
-            mistakes.push({
-                id: lesson.id.replace('LEARN', 'MISTAKE'),
-                title: lesson.message.split('.')[0], // First sentence as title
-                pattern: lesson.pattern,
-                message: lesson.message,
-                severity: lesson.severity,
-                tags,
-                context: lesson.category,
-                hitCount: lesson.hitCount || 0,
-                lastHit: lesson.lastHit,
-                added: lesson.addedAt,
-                source: lesson.source,
-                excludePaths: lesson.excludePaths || [],
-            });
-        } else if (classification === 'improvement') {
-            improvements.push({
-                id: lesson.id.replace('LEARN', 'IMPROVE'),
-                title: lesson.message.split('.')[0],
-                pattern: lesson.pattern,
-                message: lesson.message,
-                priority: lesson.severity === 'ERROR' ? 'HIGH' : 'MEDIUM',
-                tags,
-                added: lesson.addedAt,
-                appliedCount: lesson.hitCount || 0,
-                lastApplied: lesson.lastHit,
-                source: lesson.source,
-            });
-        } else {
-            // Mixed - split into both
-            const { mistake, improvement } = splitMixedLesson(lesson);
-            mistakes.push({
-                ...mistake,
-                severity: lesson.severity,
-                tags,
-                hitCount: lesson.hitCount || 0,
-                lastHit: lesson.lastHit,
-                added: lesson.addedAt,
-                source: lesson.source,
-                excludePaths: lesson.excludePaths || [],
-            });
-
-            if (improvement) {
-                improvements.push({
-                    ...improvement,
-                    source: lesson.source,
-                });
-            }
-
-            needsReview.push({
-                ...lesson,
-                reason: 'Mixed mistake + improvement keywords, auto-split but needs verification',
-            });
-        }
-    });
-
-    console.log(`\n✅ Classification complete:`);
-    console.log(`   ${mistakes.length} mistakes`);
-    console.log(`   ${improvements.length} improvements`);
-    console.log(`   ${needsReview.length} need manual review`);
-
-    return { mistakes, improvements, needsReview };
-}
-
-// ============================================================================
-// STEP 4: Save New Files
-// ============================================================================
-
-function saveYAML(filename, data) {
-    const filepath = path.join(KNOWLEDGE_DIR, filename);
-    const yamlStr = yaml.dump(data, {
-        lineWidth: -1,
-        noRefs: true,
-        sortKeys: false,
-    });
-    fs.writeFileSync(filepath, yamlStr, 'utf8');
-    console.log(`✅ Created: ${filename}`);
-}
-
-function saveNewStructure(result) {
-    console.log('\n📝 Step 3: Creating new data files...');
-
-    // Save mistakes
-    saveYAML('mistakes.yaml', {
-        version: 4.0,
-        mistakes: result.mistakes,
-    });
-
-    // Save improvements
-    saveYAML('improvements.yaml', {
-        version: 4.0,
-        improvements: result.improvements,
-    });
-
-    // Save review queue if needed
-    if (result.needsReview.length > 0) {
-        saveYAML('_needs_review.yaml', {
-            note: 'These lessons contained both mistake and improvement keywords and were auto-split. Please review.',
-            items: result.needsReview,
-        });
-        console.log(`⚠️  ${result.needsReview.length} items saved to _needs_review.yaml`);
-    }
-}
-
-// ============================================================================
-// MAIN MIGRATION
-// ============================================================================
-
-async function main() {
-    console.log('🧠 Cognitive Lesson Engine v4.x Migration\n');
-    console.log('This script will transform your lessons into the new architecture.');
-    console.log('All existing data will be preserved in backups.\n');
-
-    try {
-        // Step 1: Backup
-        const oldData = backupCurrentLessons();
-
-        if (!oldData || !oldData.lessons || oldData.lessons.length === 0) {
-            console.log('❌ No lessons found to migrate.');
-            return;
-        }
-
-        // Step 2: Classify
-        const result = migrateToV4(oldData);
-
-        // Step 3: Save
-        saveNewStructure(result);
-
-        // Step 4: Summary
-        console.log('\n🎉 Migration complete!');
-        console.log('\nNext steps:');
-        console.log('  1. Review _needs_review.yaml (if exists)');
-        console.log('  2. Test with: node packages/cli/lib/ui/index.js');
-        console.log('  3. Original file preserved in _migration_backup/');
-        console.log('\n✅ You can now use the Cognitive Lesson Engine!');
-
-    } catch (error) {
-        console.error('\n❌ Migration failed:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-main();