genesis-ai-cli 7.4.5

package/dist/src/daemon/dream-mode.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * Genesis 6.0 - Dream Mode
+ *
+ * Offline consolidation and creative synthesis during "sleep".
+ *
+ * Based on sleep neuroscience research:
+ * - Light Sleep (N1/N2): Initial memory processing
+ * - Deep Sleep (N3/SWS): Memory consolidation (episodic → semantic)
+ * - REM Sleep: Creative synthesis, pattern integration
+ *
+ * References:
+ * - Walker, M. (2017). Why We Sleep
+ * - Born, J. (2010). Slow-wave sleep and memory
+ * - Stickgold, R. (2005). Sleep-dependent memory consolidation
+ *
+ * Usage:
+ * ```typescript
+ * import { createDreamService } from './daemon/dream-mode.js';
+ *
+ * const dream = createDreamService({
+ *   minDreamDurationMs: 60000, // 1 minute
+ *   maxDreamDurationMs: 600000, // 10 minutes
+ * });
+ *
+ * // Start a dream session
+ * const session = await dream.startDream();
+ *
+ * // Wait for completion
+ * const results = await dream.waitForWake();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DreamService = void 0;
+exports.createDreamService = createDreamService;
+const crypto_1 = require("crypto");
+const types_js_1 = require("./types.js");
+class DreamService {
+    config;
+    context;
+    currentSession = null;
+    metrics;
+    eventHandlers = new Set();
+    wakeResolvers = [];
+    inactivityTimer = null;
+    lastActivity = new Date();
+    constructor(config = {}, context = {}) {
+        this.config = { ...types_js_1.DEFAULT_DAEMON_CONFIG.dream, ...config };
+        this.context = context;
+        this.metrics = {
+            totalDreamTime: 0,
+            dreamCycles: 0,
+            avgCycleDuration: 0,
+            consolidationRate: 0,
+            patternExtractionRate: 0,
+            lastDreamAt: null,
+            nextScheduledDream: null,
+        };
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    setContext(context) {
+        this.context = { ...this.context, ...context };
+    }
+    startAutoTrigger() {
+        if (!this.config.autoTrigger)
+            return;
+        this.resetInactivityTimer();
+    }
+    stopAutoTrigger() {
+        if (this.inactivityTimer) {
+            clearTimeout(this.inactivityTimer);
+            this.inactivityTimer = null;
+        }
+    }
+    recordActivity() {
+        this.lastActivity = new Date();
+        this.resetInactivityTimer();
+    }
+    resetInactivityTimer() {
+        if (this.inactivityTimer) {
+            clearTimeout(this.inactivityTimer);
+        }
+        if (this.config.autoTrigger && !this.isDreaming()) {
+            this.inactivityTimer = setTimeout(() => this.startDream(), this.config.inactivityThresholdMs);
+            this.metrics.nextScheduledDream = new Date(Date.now() + this.config.inactivityThresholdMs);
+        }
+    }
+    // ============================================================================
+    // Dream Session
+    // ============================================================================
+    isDreaming() {
+        return this.currentSession !== null && !this.currentSession.endedAt;
+    }
+    async startDream(options = {}) {
+        if (this.isDreaming()) {
+            throw new Error('Already dreaming');
+        }
+        const duration = options.duration ||
+            this.config.minDreamDurationMs +
+                Math.random() * (this.config.maxDreamDurationMs - this.config.minDreamDurationMs);
+        const session = {
+            id: (0, crypto_1.randomUUID)(),
+            startedAt: new Date(),
+            phase: 'light',
+            phaseHistory: [{
+                    phase: 'light',
+                    enteredAt: new Date(),
+                }],
+            interrupted: false,
+        };
+        this.currentSession = session;
+        this.emit({ type: 'dream_started', session });
+        this.log(`Dream started (${Math.round(duration / 1000)}s)`);
+        // Run the dream cycle
+        this.runDreamCycle(session, duration);
+        return session;
+    }
+    async interruptDream(reason) {
+        if (!this.currentSession)
+            return null;
+        this.currentSession.interrupted = true;
+        this.currentSession.interruptReason = reason;
+        this.emit({ type: 'dream_interrupted', session: this.currentSession });
+        this.log(`Dream interrupted: ${reason}`, 'warn');
+        // Return partial results
+        return this.currentSession.results || this.createEmptyResults();
+    }
+    waitForWake() {
+        if (!this.isDreaming()) {
+            return Promise.resolve(this.currentSession?.results || this.createEmptyResults());
+        }
+        return new Promise((resolve) => {
+            this.wakeResolvers.push(resolve);
+        });
+    }
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    // ============================================================================
+    // Dream Cycle
+    // ============================================================================
+    async runDreamCycle(session, totalDuration) {
+        const startTime = Date.now();
+        const results = this.createEmptyResults();
+        // Calculate phase durations
+        const lightDuration = totalDuration * this.config.lightSleepRatio;
+        const deepDuration = totalDuration * this.config.deepSleepRatio;
+        const remDuration = totalDuration * this.config.remSleepRatio;
+        try {
+            // Light sleep phase
+            await this.runPhase(session, 'light', lightDuration, results);
+            if (session.interrupted)
+                return this.finishDream(session, results);
+            // Deep sleep phase (consolidation)
+            await this.runPhase(session, 'deep', deepDuration, results);
+            if (session.interrupted)
+                return this.finishDream(session, results);
+            // REM phase (creativity)
+            await this.runPhase(session, 'rem', remDuration, results);
+            if (session.interrupted)
+                return this.finishDream(session, results);
+            // Wake phase
+            await this.runPhase(session, 'wake', 1000, results);
+        }
+        catch (err) {
+            this.log(`Dream cycle error: ${err}`, 'error');
+        }
+        this.finishDream(session, results);
+    }
+    async runPhase(session, phase, duration, results) {
+        // Transition phase
+        this.transitionPhase(session, phase);
+        const phaseStart = Date.now();
+        const phaseEnd = phaseStart + duration;
+        switch (phase) {
+            case 'light':
+                await this.lightSleepPhase(results, duration);
+                break;
+            case 'deep':
+                await this.deepSleepPhase(results, duration);
+                break;
+            case 'rem':
+                await this.remSleepPhase(results, duration);
+                break;
+            case 'wake':
+                await this.wakePhase(results);
+                break;
+        }
+        // Wait remaining duration
+        const elapsed = Date.now() - phaseStart;
+        if (elapsed < duration && !session.interrupted) {
+            await this.sleep(duration - elapsed);
+        }
+    }
+    transitionPhase(session, newPhase) {
+        // Close previous phase
+        const lastPhase = session.phaseHistory[session.phaseHistory.length - 1];
+        if (lastPhase && !lastPhase.exitedAt) {
+            lastPhase.exitedAt = new Date();
+        }
+        // Start new phase
+        session.phase = newPhase;
+        session.phaseHistory.push({
+            phase: newPhase,
+            enteredAt: new Date(),
+        });
+        this.emit({ type: 'phase_changed', session, data: { phase: newPhase } });
+        this.log(`Dream phase: ${newPhase}`, 'debug');
+    }
+    // ============================================================================
+    // Phase Implementations
+    // ============================================================================
+    async lightSleepPhase(results, duration) {
+        // Light sleep: Initial processing, prepare for consolidation
+        // Energy restoration begins
+        if (this.context.rechargeEnergy) {
+            this.context.rechargeEnergy(0.05); // Small recharge
+        }
+        // Count episodes to process
+        if (this.context.getEpisodicMemories) {
+            const episodes = this.context.getEpisodicMemories();
+            results.episodesProcessed = episodes.filter((e) => !e.consolidated).length;
+        }
+    }
+    async deepSleepPhase(results, duration) {
+        // Deep sleep: Memory consolidation (episodic → semantic)
+        // This is where the heavy processing happens
+        if (!this.context.getEpisodicMemories || !this.context.consolidateMemory) {
+            return;
+        }
+        const episodes = this.context.getEpisodicMemories()
+            .filter((e) => !e.consolidated)
+            .sort((a, b) => b.importance - a.importance);
+        // Process episodes in batches
+        const batchSize = 10;
+        const batches = Math.ceil(episodes.length / batchSize);
+        const timePerBatch = duration / (batches || 1);
+        for (let i = 0; i < batches && !this.currentSession?.interrupted; i++) {
+            const batch = episodes.slice(i * batchSize, (i + 1) * batchSize);
+            for (const episode of batch) {
+                try {
+                    const result = await this.context.consolidateMemory(episode.id);
+                    if (result) {
+                        results.memoriesConsolidated++;
+                        this.emit({ type: 'consolidation_done', data: { episode, result } });
+                    }
+                }
+                catch (err) {
+                    this.log(`Consolidation error: ${err}`, 'error');
+                }
+            }
+            // Pattern extraction from related episodes
+            if (this.context.extractPattern && batch.length >= this.config.patternExtractionThreshold) {
+                const relatedGroups = this.groupByTags(batch);
+                for (const [tag, group] of relatedGroups) {
+                    if (group.length >= this.config.patternExtractionThreshold) {
+                        try {
+                            const pattern = await this.context.extractPattern(group.map((e) => e.id));
+                            if (pattern && pattern.confidence > 0.5) {
+                                results.patternsExtracted++;
+                                this.emit({ type: 'pattern_extracted', data: pattern });
+                            }
+                        }
+                        catch (err) {
+                            this.log(`Pattern extraction error: ${err}`, 'error');
+                        }
+                    }
+                }
+            }
+            await this.sleep(timePerBatch);
+        }
+        // Energy restoration during deep sleep
+        if (this.context.rechargeEnergy) {
+            this.context.rechargeEnergy(0.2); // Significant recharge
+        }
+        // Skill reinforcement
+        if (this.context.getProceduralMemories && this.context.reinforceSkill) {
+            const skills = this.context.getProceduralMemories()
+                .filter((s) => s.successRate > 0.5)
+                .sort((a, b) => a.successRate - b.successRate)
+                .slice(0, 5);
+            for (const skill of skills) {
+                if (await this.context.reinforceSkill(skill.id)) {
+                    results.skillsReinforced++;
+                }
+            }
+        }
+    }
+    async remSleepPhase(results, duration) {
+        // REM sleep: Creative synthesis, novel associations
+        // This is where new ideas emerge from combining memories
+        if (!this.context.getSemanticMemories) {
+            return;
+        }
+        const concepts = this.context.getSemanticMemories();
+        // Generate novel associations (simplified creative process)
+        const associations = this.generateNovelAssociations(concepts.map((c) => c.concept), this.config.creativityTemperature);
+        results.newAssociations = associations.length;
+        results.novelIdeas = associations.slice(0, 5); // Keep top 5
+        // Energy boost from REM
+        if (this.context.rechargeEnergy) {
+            this.context.rechargeEnergy(0.1);
+        }
+        // Memory forgetting (weak memories fade during sleep)
+        if (this.context.getEpisodicMemories && this.context.forgetMemory) {
+            const episodes = this.context.getEpisodicMemories();
+            const toForget = episodes
+                .filter((e) => e.importance < 0.2)
+                .slice(0, Math.floor(episodes.length * 0.1)); // Forget up to 10%
+            for (const episode of toForget) {
+                if (this.context.forgetMemory(episode.id)) {
+                    results.memoriesForgotten++;
+                }
+            }
+        }
+    }
+    async wakePhase(results) {
+        // Wake: Health check and invariant verification
+        if (this.context.checkInvariants) {
+            const allSatisfied = await this.context.checkInvariants();
+            results.invariantsChecked++;
+            if (!allSatisfied && this.context.repairState) {
+                results.stateRepairs = await this.context.repairState();
+            }
+        }
+        // Final energy boost
+        if (this.context.rechargeEnergy) {
+            this.context.rechargeEnergy(0.05);
+        }
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    groupByTags(episodes) {
+        const groups = new Map();
+        for (const episode of episodes) {
+            for (const tag of episode.tags) {
+                const group = groups.get(tag) || [];
+                group.push(episode);
+                groups.set(tag, group);
+            }
+        }
+        return groups;
+    }
+    generateNovelAssociations(concepts, temperature) {
+        // Simplified creative association generator
+        // In a real implementation, this would use embeddings and semantic similarity
+        const associations = [];
+        const numAssociations = Math.floor(concepts.length * temperature);
+        for (let i = 0; i < numAssociations && i < concepts.length - 1; i++) {
+            const idx1 = Math.floor(Math.random() * concepts.length);
+            let idx2 = Math.floor(Math.random() * concepts.length);
+            while (idx2 === idx1) {
+                idx2 = Math.floor(Math.random() * concepts.length);
+            }
+            const concept1 = concepts[idx1];
+            const concept2 = concepts[idx2];
+            // Generate a hypothetical association
+            associations.push(`${concept1} relates to ${concept2}`);
+        }
+        return associations;
+    }
+    createEmptyResults() {
+        return {
+            episodesProcessed: 0,
+            memoriesConsolidated: 0,
+            patternsExtracted: 0,
+            skillsReinforced: 0,
+            memoriesForgotten: 0,
+            newAssociations: 0,
+            novelIdeas: [],
+            stateRepairs: 0,
+            invariantsChecked: 0,
+        };
+    }
+    finishDream(session, results) {
+        session.endedAt = new Date();
+        session.results = results;
+        // Close last phase
+        const lastPhase = session.phaseHistory[session.phaseHistory.length - 1];
+        if (lastPhase && !lastPhase.exitedAt) {
+            lastPhase.exitedAt = session.endedAt;
+        }
+        // Update metrics
+        const duration = session.endedAt.getTime() - session.startedAt.getTime();
+        this.metrics.totalDreamTime += duration;
+        this.metrics.dreamCycles++;
+        this.metrics.avgCycleDuration =
+            (this.metrics.avgCycleDuration * (this.metrics.dreamCycles - 1) + duration) /
+                this.metrics.dreamCycles;
+        this.metrics.lastDreamAt = session.endedAt;
+        // Calculate rates
+        const durationHours = duration / (1000 * 60 * 60);
+        if (durationHours > 0) {
+            this.metrics.consolidationRate = results.memoriesConsolidated / durationHours;
+        }
+        this.metrics.patternExtractionRate = results.patternsExtracted / Math.max(1, this.metrics.dreamCycles);
+        this.log(`Dream completed: ${results.memoriesConsolidated} consolidated, ` +
+            `${results.patternsExtracted} patterns, ${results.skillsReinforced} skills`);
+        this.emit({ type: 'dream_completed', session });
+        // Notify waiters
+        for (const resolve of this.wakeResolvers) {
+            resolve(results);
+        }
+        this.wakeResolvers = [];
+        // Reset inactivity timer for next dream
+        this.resetInactivityTimer();
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    // ============================================================================
+    // Events
+    // ============================================================================
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('Dream event handler error:', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Logging
+    // ============================================================================
+    log(message, level = 'info') {
+        if (this.context.log) {
+            this.context.log(message, level);
+        }
+        else {
+            const prefix = '[Dream]';
+            switch (level) {
+                case 'debug':
+                    if (process.env.LOG_LEVEL === 'debug')
+                        console.log(`${prefix} ${message}`);
+                    break;
+                case 'info':
+                    console.log(`${prefix} ${message}`);
+                    break;
+                case 'warn':
+                    console.warn(`${prefix} ${message}`);
+                    break;
+                case 'error':
+                    console.error(`${prefix} ${message}`);
+                    break;
+            }
+        }
+    }
+}
+exports.DreamService = DreamService;
+// ============================================================================
+// Factory
+// ============================================================================
+function createDreamService(config, context) {
+    return new DreamService(config, context);
+}

package/dist/src/daemon/index.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Genesis 6.0 - Daemon Module
+ *
+ * Unified daemon for background task scheduling, self-maintenance, and dream mode.
+ *
+ * This module provides:
+ * - Scheduler: Background task execution with priorities and retries
+ * - Maintenance: Self-repair and health monitoring
+ * - Dream Mode: Offline memory consolidation and creative synthesis
+ *
+ * Usage:
+ * ```typescript
+ * import { createDaemon } from './daemon/index.js';
+ * import { createMemorySystem } from './memory/index.js';
+ *
+ * const memory = createMemorySystem();
+ * const daemon = createDaemon({ memory });
+ *
+ * // Start the daemon
+ * daemon.start();
+ *
+ * // Schedule a custom task
+ * daemon.schedule({
+ *   name: 'my-task',
+ *   schedule: { type: 'interval', intervalMs: 60000 },
+ *   handler: async (ctx) => {
+ *     ctx.logger.info('Running my task');
+ *     return { success: true, duration: 100 };
+ *   },
+ * });
+ *
+ * // Trigger a dream session
+ * await daemon.dream();
+ *
+ * // Check status
+ * console.log(daemon.status());
+ *
+ * // Stop the daemon
+ * daemon.stop();
+ * ```
+ */
+export * from './types.js';
+export { Scheduler, createScheduler, type SchedulerConfig } from './scheduler.js';
+export { MaintenanceService, createMaintenanceService, type MaintenanceContext } from './maintenance.js';
+export { DreamService, createDreamService, type DreamContext } from './dream-mode.js';
+import { DaemonConfig, DaemonState, DaemonStatus, DaemonEventHandler, ScheduledTask, CreateTaskOptions, MaintenanceReport, DreamResults } from './types.js';
+import { Scheduler } from './scheduler.js';
+import { MaintenanceService } from './maintenance.js';
+import { DreamService } from './dream-mode.js';
+export interface DaemonDependencies {
+    memory?: {
+        episodic: {
+            getAll: () => Array<{
+                id: string;
+                content: {
+                    what: string;
+                };
+                importance: number;
+                tags: string[];
+                consolidated: boolean;
+            }>;
+            runForgetting: () => {
+                forgotten: number;
+            };
+        };
+        semantic: {
+            getAll: () => Array<{
+                id: string;
+                concept: string;
+                confidence: number;
+            }>;
+        };
+        procedural: {
+            getAll: () => Array<{
+                id: string;
+                name: string;
+                successRate: number;
+            }>;
+        };
+        consolidation: {
+            sleep: () => Promise<{
+                consolidated: number;
+            }>;
+        };
+        getStats: () => {
+            total: number;
+            episodic: {
+                total: number;
+            };
+            semantic: {
+                total: number;
+            };
+            procedural: {
+                total: number;
+            };
+        };
+    };
+    kernel?: {
+        checkAgentHealth: () => Promise<Array<{
+            id: string;
+            healthy: boolean;
+            latency?: number;
+        }>>;
+        checkInvariants: () => Promise<Array<{
+            id: string;
+            satisfied: boolean;
+            message?: string;
+        }>>;
+        repairInvariant: (id: string) => Promise<boolean>;
+        getState: () => {
+            state: string;
+            energy: number;
+        };
+        rechargeEnergy: (amount: number) => void;
+        resetState: () => void;
+    };
+    log?: (message: string, level?: 'debug' | 'info' | 'warn' | 'error') => void;
+}
+export declare class Daemon {
+    private config;
+    private state;
+    private startedAt;
+    private errors;
+    private eventHandlers;
+    private heartbeatTimer;
+    readonly scheduler: Scheduler;
+    readonly maintenance: MaintenanceService;
+    readonly dreamService: DreamService;
+    private deps;
+    constructor(deps?: DaemonDependencies, config?: Partial<DaemonConfig>);
+    start(): void;
+    stop(): void;
+    restart(): void;
+    getState(): DaemonState;
+    isRunning(): boolean;
+    schedule(options: CreateTaskOptions): ScheduledTask;
+    cancelTask(taskId: string): boolean;
+    triggerTask(taskId: string): boolean;
+    getTasks(): ScheduledTask[];
+    runMaintenance(): Promise<MaintenanceReport>;
+    getMaintenanceIssues(): import("./types.js").MaintenanceIssue[];
+    dream(options?: {
+        duration?: number;
+    }): Promise<DreamResults>;
+    interruptDream(reason: string): Promise<DreamResults | null>;
+    isDreaming(): boolean;
+    getDreamMetrics(): import("./types.js").DreamMetrics;
+    recordActivity(): void;
+    status(): DaemonStatus;
+    on(handler: DaemonEventHandler): () => void;
+    private emit;
+    private heartbeat;
+    private setupEventForwarding;
+    private setupDefaultTasks;
+    private buildMaintenanceContext;
+    private buildDreamContext;
+    private log;
+    private recordError;
+}
+export declare function createDaemon(deps?: DaemonDependencies, config?: Partial<DaemonConfig>): Daemon;
+export declare function getDaemon(deps?: DaemonDependencies, config?: Partial<DaemonConfig>): Daemon;
+export declare function resetDaemon(): void;