aiden-runtime 3.16.0

package/dist/core/dreamEngine.js

@@ -0,0 +1,334 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDream = runDream;
+exports.checkAndRunDream = checkAndRunDream;
+// core/dreamEngine.ts — Background memory consolidation.
+// Runs when: time since last dream >= 24h AND 5+ new sessions AND no lock.
+// 4-phase: Orient → Gather → Consolidate → Prune.
+// Restricted to read-only bash + write to workspace/memory/ only.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const auxiliaryClient_1 = require("./auxiliaryClient");
+const auditTrail_1 = require("./auditTrail");
+const LOCK_FILE = path_1.default.join(process.cwd(), 'workspace', 'dream.lock');
+const MEMORY_DIR = path_1.default.join(process.cwd(), 'workspace', 'memory');
+const SESSIONS_DIR = path_1.default.join(process.cwd(), 'workspace', 'sessions');
+const INDEX_PATH = path_1.default.join(MEMORY_DIR, 'MEMORY_INDEX.md');
+const GATE_HOURS = 24; // hours since last dream
+const GATE_SESSIONS = 5; // new sessions required
+function acquireLock() {
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(LOCK_FILE), { recursive: true });
+        if (fs_1.default.existsSync(LOCK_FILE)) {
+            // Check if the lock holder is still alive
+            const raw = JSON.parse(fs_1.default.readFileSync(LOCK_FILE, 'utf-8'));
+            const alive = isPidAlive(raw.pid);
+            if (alive) {
+                console.log(`[DreamEngine] Lock held by PID ${raw.pid} — skipping`);
+                return false;
+            }
+            // PID is dead — steal the lock
+            console.log(`[DreamEngine] Stale lock (PID ${raw.pid} dead) — stealing`);
+        }
+        const data = { pid: process.pid, startedAt: new Date().toISOString() };
+        fs_1.default.writeFileSync(LOCK_FILE, JSON.stringify(data));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseLock(prevMtime) {
+    try {
+        if (prevMtime !== undefined) {
+            // Update mtime to now (marks lastConsolidatedAt)
+            const now = Date.now() / 1000;
+            fs_1.default.utimesSync(LOCK_FILE, now, now);
+        }
+        else {
+            // On failure — restore prev mtime or just remove
+            fs_1.default.unlinkSync(LOCK_FILE);
+        }
+    }
+    catch { }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getLockMtime() {
+    try {
+        if (!fs_1.default.existsSync(LOCK_FILE))
+            return 0;
+        return fs_1.default.statSync(LOCK_FILE).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+// ── Gate checks ───────────────────────────────────────────────
+function checkTimeGate(lockMtime) {
+    if (lockMtime === 0)
+        return true; // never run
+    const hoursSince = (Date.now() - lockMtime) / (1000 * 60 * 60);
+    return hoursSince >= GATE_HOURS;
+}
+function checkSessionGate(lockMtime) {
+    try {
+        if (!fs_1.default.existsSync(SESSIONS_DIR))
+            return false;
+        const cutoff = lockMtime || 0;
+        const newSessions = fs_1.default.readdirSync(SESSIONS_DIR)
+            .filter(f => f.endsWith('.md'))
+            .filter(f => {
+            try {
+                return fs_1.default.statSync(path_1.default.join(SESSIONS_DIR, f)).mtimeMs > cutoff;
+            }
+            catch {
+                return false;
+            }
+        });
+        return newSessions.length >= GATE_SESSIONS;
+    }
+    catch {
+        return false;
+    }
+}
+function allGatesPass() {
+    const lockMtime = getLockMtime();
+    return checkTimeGate(lockMtime) && checkSessionGate(lockMtime);
+}
+// ── Dream phases ──────────────────────────────────────────────
+async function phaseOrient() {
+    // List memory dir, read index, get overview
+    try {
+        const indexContent = fs_1.default.existsSync(INDEX_PATH)
+            ? fs_1.default.readFileSync(INDEX_PATH, 'utf-8')
+            : '(empty)';
+        const memFiles = fs_1.default.existsSync(MEMORY_DIR)
+            ? fs_1.default.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.md') && f !== 'MEMORY_INDEX.md')
+            : [];
+        return `MEMORY DIRECTORY (${memFiles.length} files):\n${memFiles.join('\n')}\n\nCURRENT INDEX:\n${indexContent.slice(0, 2000)}`;
+    }
+    catch {
+        return '(unable to read memory directory)';
+    }
+}
+async function phaseGather(lockMtime) {
+    // Scan recent session transcripts for signal
+    try {
+        if (!fs_1.default.existsSync(SESSIONS_DIR))
+            return '(no sessions)';
+        const recentSessions = fs_1.default.readdirSync(SESSIONS_DIR)
+            .filter(f => f.endsWith('.md'))
+            .filter(f => {
+            try {
+                return fs_1.default.statSync(path_1.default.join(SESSIONS_DIR, f)).mtimeMs > lockMtime;
+            }
+            catch {
+                return false;
+            }
+        })
+            .slice(0, 10);
+        if (recentSessions.length === 0)
+            return '(no new sessions)';
+        const excerpts = recentSessions.map(f => {
+            try {
+                const content = fs_1.default.readFileSync(path_1.default.join(SESSIONS_DIR, f), 'utf-8');
+                return `=== ${f} ===\n${content.slice(0, 800)}`;
+            }
+            catch {
+                return `=== ${f} === (unreadable)`;
+            }
+        });
+        return excerpts.join('\n\n');
+    }
+    catch {
+        return '(unable to gather sessions)';
+    }
+}
+async function phaseConsolidate(orientData, gatherData) {
+    const prompt = `You are the DevOS Dream Engine performing memory consolidation.
+
+CURRENT MEMORY STATE:
+${orientData}
+
+RECENT SESSION SIGNALS:
+${gatherData}
+
+Your job: identify facts from the sessions that should be preserved in long-term memory.
+
+For each memory to write/update, output JSON:
+[
+  {
+    "filename": "type_descriptor.md (e.g. user_coding_style.md, project_api_structure.md)",
+    "title": "Short descriptive title",
+    "type": "user_preference|project_fact|tool_pattern|learned_behavior",
+    "content": "Concise actionable content. 2-6 sentences. Convert relative dates to absolute (e.g. 'last week' → '2026-03-25').",
+    "summary": "One-line summary"
+  }
+]
+
+Rules:
+- Merge with existing rather than create duplicates
+- Focus on patterns, not one-off events
+- Absolute dates only
+- Output ONLY valid JSON array`;
+    try {
+        const raw = await auxiliaryClient_1.auxiliaryClient.complete(prompt, { task: 'dream', maxTokens: 500 });
+        if (!raw)
+            return { filesUpdated: 0 };
+        const jsonMatch = raw.replace(/```json\s*/g, '').replace(/```\s*/g, '').match(/\[[\s\S]*\]/);
+        if (!jsonMatch)
+            return { filesUpdated: 0 };
+        const items = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(items))
+            return { filesUpdated: 0 };
+        let filesUpdated = 0;
+        const now = new Date().toISOString().split('T')[0];
+        for (const item of items) {
+            if (!item.filename || !item.content)
+                continue;
+            const filePath = path_1.default.join(MEMORY_DIR, item.filename);
+            let created = now;
+            if (fs_1.default.existsSync(filePath)) {
+                try {
+                    const existing = fs_1.default.readFileSync(filePath, 'utf-8');
+                    const m = existing.match(/^created:\s*(.+)$/m);
+                    if (m)
+                        created = m[1].trim();
+                }
+                catch { }
+            }
+            const fileContent = `---
+title: ${item.title}
+type: ${item.type}
+created: ${created}
+updated: ${now}
+---
+
+${item.content.trim()}
+`;
+            try {
+                fs_1.default.writeFileSync(filePath, fileContent, 'utf-8');
+                filesUpdated++;
+            }
+            catch { }
+        }
+        return { filesUpdated };
+    }
+    catch (e) {
+        console.error('[DreamEngine] Consolidate phase failed:', e.message);
+        return { filesUpdated: 0 };
+    }
+}
+async function phasePrune(filesUpdated) {
+    // Rebuild MEMORY_INDEX.md — max 100 entries
+    try {
+        if (!fs_1.default.existsSync(MEMORY_DIR))
+            return;
+        const files = fs_1.default.readdirSync(MEMORY_DIR)
+            .filter(f => f.endsWith('.md') && f !== 'MEMORY_INDEX.md')
+            .map(f => {
+            try {
+                const content = fs_1.default.readFileSync(path_1.default.join(MEMORY_DIR, f), 'utf-8');
+                const titleM = content.match(/^title:\s*(.+)$/m);
+                const sumM = content.match(/---\n+([\s\S]+?)(?:\n\n|$)/);
+                const title = titleM ? titleM[1].trim() : f.replace('.md', '');
+                const summary = sumM
+                    ? sumM[1].trim().replace(/\n/g, ' ').slice(0, 80)
+                    : '';
+                return `- [${title}](${f}) — ${summary}`;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((l) => l !== null)
+            .slice(0, 100);
+        fs_1.default.writeFileSync(INDEX_PATH, files.join('\n') + '\n', 'utf-8');
+        console.log(`[DreamEngine] Pruned index to ${files.length} entries (${filesUpdated} files updated)`);
+    }
+    catch (e) {
+        console.error('[DreamEngine] Prune phase failed:', e.message);
+    }
+}
+// ── Main dream runner ─────────────────────────────────────────
+async function runDream() {
+    if (!allGatesPass()) {
+        console.log('[DreamEngine] Gates not met — skipping');
+        return;
+    }
+    const prevMtime = getLockMtime();
+    if (!acquireLock())
+        return;
+    const traceId = `dream_${Date.now()}`;
+    console.log('[DreamEngine] Dream starting...');
+    let sessionsReviewed = 0;
+    let filesUpdated = 0;
+    try {
+        fs_1.default.mkdirSync(MEMORY_DIR, { recursive: true });
+        // Phase 1: Orient
+        console.log('[DreamEngine] Phase 1: Orient');
+        const orientData = await phaseOrient();
+        // Phase 2: Gather
+        console.log('[DreamEngine] Phase 2: Gather');
+        const gatherData = await phaseGather(prevMtime);
+        sessionsReviewed = (gatherData.match(/=== .+\.md ===/g) || []).length;
+        // Phase 3: Consolidate
+        console.log('[DreamEngine] Phase 3: Consolidate');
+        const result = await phaseConsolidate(orientData, gatherData);
+        filesUpdated = result.filesUpdated;
+        // Phase 4: Prune
+        console.log('[DreamEngine] Phase 4: Prune');
+        await phasePrune(filesUpdated);
+        // Update lock mtime = lastConsolidatedAt
+        releaseLock(prevMtime);
+        // Log to AuditTrail
+        try {
+            auditTrail_1.auditTrail.record({
+                action: 'system',
+                tool: 'dream_completed',
+                input: JSON.stringify({ traceId }),
+                output: JSON.stringify({ filesUpdated, sessionsReviewed }),
+                durationMs: 0,
+                success: true,
+                traceId,
+            });
+        }
+        catch { }
+        console.log(`[DreamEngine] Dream complete — ${filesUpdated} files updated, ${sessionsReviewed} sessions reviewed`);
+    }
+    catch (e) {
+        console.error('[DreamEngine] Dream failed:', e.message);
+        // Roll back lock mtime
+        try {
+            if (prevMtime > 0) {
+                const t = prevMtime / 1000;
+                fs_1.default.utimesSync(LOCK_FILE, t, t);
+            }
+            else {
+                fs_1.default.unlinkSync(LOCK_FILE);
+            }
+        }
+        catch { }
+    }
+}
+// ── Check and run (called by scheduler) ───────────────────────
+function checkAndRunDream() {
+    if (!allGatesPass())
+        return;
+    runDream().catch(e => console.error('[DreamEngine] Unhandled error:', e.message));
+}

package/dist/core/entityGraph.js

@@ -0,0 +1,169 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityGraph = exports.EntityGraph = void 0;
+// core/entityGraph.ts — Lightweight entity graph that auto-extracts
+// topics, files, tools, and searches from conversation text, and
+// tracks weighted relationships between them.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const GRAPH_PATH = path_1.default.join(process.cwd(), 'workspace', 'entity_graph.json');
+class EntityGraph {
+    constructor() {
+        this.graph = { nodes: [], edges: [] };
+        this.load();
+    }
+    // ── Persistence ───────────────────────────────────────────────
+    load() {
+        try {
+            if (fs_1.default.existsSync(GRAPH_PATH)) {
+                this.graph = JSON.parse(fs_1.default.readFileSync(GRAPH_PATH, 'utf-8'));
+            }
+        }
+        catch { }
+    }
+    save() {
+        try {
+            fs_1.default.mkdirSync(path_1.default.dirname(GRAPH_PATH), { recursive: true });
+            fs_1.default.writeFileSync(GRAPH_PATH, JSON.stringify(this.graph, null, 2));
+        }
+        catch { }
+    }
+    // ── Entity extraction ─────────────────────────────────────────
+    extractAndAdd(text, context) {
+        const extracted = [];
+        // Extract Windows file paths
+        const filePaths = text.match(/[A-Z]:\\[^\s"']+\.[a-z]+/gi) || [];
+        filePaths.forEach(f => extracted.push({ name: f, type: 'file' }));
+        // Extract quoted terms
+        const quoted = text.match(/"([^"]{3,40})"/g)?.map(q => q.replace(/"/g, '')) || [];
+        quoted.forEach(q => extracted.push({ name: q, type: 'concept' }));
+        // Extract capitalized multi-word phrases (likely proper nouns / product names)
+        const phrases = text.match(/\b([A-Z][a-zA-Z]+(?:\s[A-Z][a-zA-Z]+){0,2})\b/g) || [];
+        const skipWords = new Set([
+            'The', 'This', 'That', 'You', 'Your', 'I', 'We', 'It',
+            'In', 'On', 'At', 'To', 'For', 'Of', 'And', 'Or', 'But',
+            'Aiden', 'DevOS', 'Windows', 'Step', 'Phase', 'Task',
+        ]);
+        phrases
+            .filter(p => !skipWords.has(p) && p.length > 3)
+            .slice(0, 10)
+            .forEach(p => extracted.push({ name: p, type: 'topic' }));
+        // Add context entities
+        if (context?.files) {
+            context.files.forEach(f => extracted.push({ name: f, type: 'file' }));
+        }
+        if (context?.tools) {
+            context.tools.forEach(t => extracted.push({ name: t, type: 'tool' }));
+        }
+        if (context?.searchQuery) {
+            extracted.push({ name: context.searchQuery, type: 'search' });
+        }
+        // Upsert all extracted entities as nodes
+        extracted.forEach(({ name, type }) => this.addNode(name, type));
+        // Create edges between co-occurring entities (sliding window of 3)
+        const names = extracted.map(e => e.name);
+        for (let i = 0; i < names.length; i++) {
+            for (let j = i + 1; j < names.length && j < i + 3; j++) {
+                this.addEdge(names[i], names[j], 'related_to');
+            }
+        }
+        // Semantic relationship: search query → files created
+        if (context?.files && context?.searchQuery) {
+            context.files.forEach(f => {
+                this.addEdge(context.searchQuery, f, 'saved_to');
+            });
+        }
+        this.save();
+    }
+    // ── Graph mutation ────────────────────────────────────────────
+    addNode(name, type) {
+        if (!name || name.length < 2 || name.length > 200)
+            return;
+        const existing = this.graph.nodes.find(n => n.name === name);
+        if (existing) {
+            existing.lastSeen = Date.now();
+            existing.frequency++;
+        }
+        else {
+            this.graph.nodes.push({
+                name,
+                type,
+                firstSeen: Date.now(),
+                lastSeen: Date.now(),
+                frequency: 1,
+            });
+        }
+        // Cap node count
+        if (this.graph.nodes.length > 1000) {
+            this.graph.nodes = this.graph.nodes
+                .sort((a, b) => b.frequency - a.frequency)
+                .slice(0, 800);
+        }
+    }
+    addEdge(from, to, relation) {
+        if (from === to)
+            return;
+        const existing = this.graph.edges.find(e => e.from === from && e.to === to && e.relation === relation);
+        if (existing) {
+            existing.weight++;
+            existing.timestamp = Date.now();
+        }
+        else {
+            this.graph.edges.push({ from, to, relation, weight: 1, timestamp: Date.now() });
+        }
+        // Cap edge count
+        if (this.graph.edges.length > 2000) {
+            this.graph.edges = this.graph.edges
+                .sort((a, b) => b.weight - a.weight)
+                .slice(0, 1500);
+        }
+    }
+    // ── Public API ────────────────────────────────────────────────
+    getRelated(entity, maxResults = 5) {
+        const related = this.graph.edges
+            .filter(e => e.from === entity || e.to === entity)
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, maxResults)
+            .map(e => {
+            const other = e.from === entity ? e.to : e.from;
+            return `${other} (${e.relation})`;
+        });
+        return [...new Set(related)];
+    }
+    getFrequent(topN = 10) {
+        return [...this.graph.nodes]
+            .sort((a, b) => b.frequency - a.frequency)
+            .slice(0, topN);
+    }
+    buildContextString(_query) {
+        const frequent = this.getFrequent(5);
+        if (frequent.length === 0)
+            return '';
+        const lines = ['KNOWN ENTITIES:'];
+        frequent.forEach(node => {
+            const related = this.getRelated(node.name, 3);
+            if (related.length > 0) {
+                lines.push(`- ${node.name} (${node.type}) → ${related.join(', ')}`);
+            }
+            else {
+                lines.push(`- ${node.name} (${node.type})`);
+            }
+        });
+        return lines.join('\n');
+    }
+    getStats() {
+        return {
+            nodes: this.graph.nodes.length,
+            edges: this.graph.edges.length,
+        };
+    }
+}
+exports.EntityGraph = EntityGraph;
+exports.entityGraph = new EntityGraph();

package/dist/core/eventBus.js

@@ -0,0 +1,16 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventBus = void 0;
+// core/eventBus.ts — Lightweight in-process event bus.
+// Used by costTracker and aidenIdentity to push updates to
+// any subscriber (e.g. api/server.ts → WebSocket clients).
+const events_1 = require("events");
+class DevOSEventBus extends events_1.EventEmitter {
+}
+exports.eventBus = new DevOSEventBus();
+// Increase listener limit — many subsystems may subscribe
+exports.eventBus.setMaxListeners(50);

package/dist/core/evolutionAnalyzer.js

@@ -0,0 +1,153 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evolutionAnalyzer = void 0;
+// core/evolutionAnalyzer.ts — Self-evolution: tracks execution reports,
+// computes per-skill stats, and decides which skills need attention.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ── File paths ────────────────────────────────────────────────
+const REPORTS_FILE = path.join(process.cwd(), 'workspace', 'evolution-reports.json');
+const STATS_FILE = path.join(process.cwd(), 'workspace', 'evolution-stats.json');
+const HISTORY_FILE = path.join(process.cwd(), 'workspace', 'evolution-history.json');
+// ── Helpers ───────────────────────────────────────────────────
+function readJSON(file, fallback) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJSON(file, data) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+}
+// ── EvolutionAnalyzer ─────────────────────────────────────────
+class EvolutionAnalyzer {
+    /** Store a completed execution report, then re-analyse. */
+    collect(report) {
+        const reports = readJSON(REPORTS_FILE, []);
+        reports.push(report);
+        writeJSON(REPORTS_FILE, reports.slice(-200));
+        this.analyze();
+    }
+    /** Extract per-skill stats from all stored reports. */
+    analyze() {
+        const reports = readJSON(REPORTS_FILE, []);
+        const skillMap = {};
+        for (const report of reports) {
+            for (const step of report.steps) {
+                if (!skillMap[step.skill]) {
+                    skillMap[step.skill] = { runs: 0, successes: 0, times: [], errors: [] };
+                }
+                skillMap[step.skill].runs++;
+                if (step.success)
+                    skillMap[step.skill].successes++;
+                skillMap[step.skill].times.push(step.duration);
+                if (step.error)
+                    skillMap[step.skill].errors.push(step.error);
+            }
+        }
+        const stats = Object.entries(skillMap).map(([skill, data]) => {
+            const successRate = data.successes / data.runs;
+            const avgTime = data.times.reduce((a, b) => a + b, 0) / data.times.length;
+            // Count common errors
+            const errorCount = {};
+            data.errors.forEach(e => { errorCount[e] = (errorCount[e] || 0) + 1; });
+            const commonErrors = Object.entries(errorCount)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([e]) => e);
+            // Decision engine — rules based
+            let decision = 'GOOD';
+            if (data.runs < 3)
+                decision = 'GOOD'; // not enough data
+            else if (successRate < 0.3)
+                decision = 'REPLACE';
+            else if (successRate < 0.6)
+                decision = 'IMPROVE';
+            else if (avgTime > 30000)
+                decision = 'OPTIMIZE';
+            else if (data.runs === 0)
+                decision = 'REMOVE';
+            return {
+                skill,
+                totalRuns: data.runs,
+                successRate,
+                avgTime,
+                commonErrors,
+                decision,
+                lastUpdated: Date.now(),
+            };
+        });
+        writeJSON(STATS_FILE, stats);
+        return stats;
+    }
+    /** Get current stats (from file cache). */
+    getStats() {
+        return readJSON(STATS_FILE, []);
+    }
+    /** Get skills that need attention (not GOOD). */
+    getDecisions() {
+        return this.getStats().filter(s => s.decision !== 'GOOD');
+    }
+    /** Log an evolution event (what changed and measured impact). */
+    recordEvolution(entry) {
+        const history = readJSON(HISTORY_FILE, []);
+        history.push({ ...entry, timestamp: Date.now() });
+        writeJSON(HISTORY_FILE, history.slice(-100));
+    }
+    /** Get full evolution history. */
+    getHistory() {
+        return readJSON(HISTORY_FILE, []);
+    }
+    /** Summary string for devos doctor. */
+    getSummary() {
+        const stats = this.getStats();
+        const decisions = this.getDecisions();
+        const reports = readJSON(REPORTS_FILE, []);
+        const avgSuccess = stats.length
+            ? stats.reduce((a, s) => a + s.successRate, 0) / stats.length
+            : 0;
+        return `${reports.length} executions tracked · ${stats.length} skills · ${decisions.length} need attention · avg success ${Math.round(avgSuccess * 100)}%`;
+    }
+}
+exports.evolutionAnalyzer = new EvolutionAnalyzer();