pikakit 1.0.18 → 1.0.19

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.19",
   "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
   "license": "MIT",
   "author": "pikakit <pikakit@gmail.com>",