genesis-ai-cli 7.4.5

package/dist/src/consciousness/types.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Genesis 6.0 - Consciousness Module Types
+ *
+ * Types for consciousness monitoring based on:
+ * - IIT 4.0 (Integrated Information Theory) - Tononi et al.
+ * - GWT (Global Workspace Theory) - Baars
+ * - AST (Attention Schema Theory) - Graziano
+ *
+ * Key insight: Consciousness as integrated information that
+ * emerges from the interaction of specialized modules.
+ */
+/**
+ * Consciousness level indicator
+ * Based on IIT's φ (phi) - integrated information
+ */
+export interface ConsciousnessLevel {
+    phi: number;
+    rawPhi: number;
+    confidence: number;
+    timestamp: Date;
+}
+/**
+ * Consciousness state classification
+ */
+export type ConsciousnessState = 'alert' | 'aware' | 'drowsy' | 'dormant' | 'fragmented';
+/**
+ * Trend in consciousness level
+ */
+export type ConsciousnessTrend = 'rising' | 'stable' | 'falling';
+/**
+ * System state for φ calculation
+ * Represents the current configuration of all system components
+ */
+export interface SystemState {
+    components: ComponentState[];
+    connections: Connection[];
+    stateHash: string;
+    timestamp: Date;
+}
+export interface ComponentState {
+    id: string;
+    type: string;
+    active: boolean;
+    state: Record<string, unknown>;
+    entropy: number;
+    lastUpdate: Date;
+}
+export interface Connection {
+    from: string;
+    to: string;
+    strength: number;
+    informationFlow: number;
+    bidirectional: boolean;
+}
+/**
+ * Partition of a system for φ calculation
+ * IIT requires finding the Minimum Information Partition (MIP)
+ */
+export interface Partition {
+    id: string;
+    parts: string[][];
+    cut: Cut;
+}
+export interface Cut {
+    severedConnections: Array<{
+        from: string;
+        to: string;
+    }>;
+    informationLoss: number;
+}
+/**
+ * φ calculation result
+ */
+export interface PhiResult {
+    phi: number;
+    mip: Partition;
+    intrinsicInfo: number;
+    integratedInfo: number;
+    complexes: Complex[];
+    calculationTime: number;
+    approximation: boolean;
+}
+/**
+ * A complex is a set of elements with φ > 0
+ */
+export interface Complex {
+    elements: string[];
+    phi: number;
+    mainComplex: boolean;
+}
+/**
+ * A module that can propose content to the workspace
+ */
+export interface WorkspaceModule {
+    id: string;
+    name: string;
+    type: ModuleType;
+    active: boolean;
+    load: number;
+    canPropose(): boolean;
+    propose(): WorkspaceContent | null;
+    receive(content: WorkspaceContent): void;
+    bottomUpSalience(): number;
+    topDownRelevance(goal: string): number;
+}
+export type ModuleType = 'perceptual' | 'memory' | 'motor' | 'executive' | 'evaluative' | 'metacognitive';
+/**
+ * Content that can be broadcast in the workspace
+ */
+export interface WorkspaceContent {
+    id: string;
+    sourceModule: string;
+    type: ContentType;
+    data: unknown;
+    salience: number;
+    relevance: number;
+    timestamp: Date;
+    ttl: number;
+}
+export type ContentType = 'percept' | 'memory' | 'goal' | 'plan' | 'emotion' | 'thought' | 'attention';
+/**
+ * Workspace state
+ */
+export interface WorkspaceState {
+    current: WorkspaceContent | null;
+    history: WorkspaceContent[];
+    historyLimit: number;
+    candidates: WorkspaceCandidate[];
+    lastSelection: Date;
+    selectionCount: number;
+    ignited: boolean;
+    ignitionTime: Date | null;
+}
+export interface WorkspaceCandidate {
+    content: WorkspaceContent;
+    module: string;
+    score: number;
+    selected: boolean;
+}
+/**
+ * Ignition event - when content "wins" and broadcasts
+ */
+export interface IgnitionEvent {
+    content: WorkspaceContent;
+    timestamp: Date;
+    competitorCount: number;
+    winningScore: number;
+    modulesNotified: string[];
+    duration: number;
+}
+/**
+ * Attention state - where is attention directed
+ */
+export interface AttentionState {
+    focus: AttentionFocus | null;
+    history: AttentionFocus[];
+    capacity: number;
+    used: number;
+    mode: AttentionMode;
+}
+export interface AttentionFocus {
+    target: string;
+    type: 'internal' | 'external';
+    intensity: number;
+    startedAt: Date;
+    duration: number;
+}
+export type AttentionMode = 'focused' | 'diffuse' | 'vigilant' | 'mind-wandering';
+/**
+ * Attention schema - model of attention itself
+ * This is what creates the "experience" of awareness
+ */
+export interface AttentionSchema {
+    selfModel: SelfAttentionModel;
+    awarenessModel: AwarenessModel;
+    otherModels: Map<string, OtherAttentionModel>;
+}
+export interface SelfAttentionModel {
+    perceivedFocus: string;
+    metacognitiveConfidence: number;
+    voluntaryControl: number;
+}
+export interface AwarenessModel {
+    contents: string[];
+    clarity: number;
+    phenomenalQuality: PhenomenalQuality;
+}
+export interface OtherAttentionModel {
+    agentId: string;
+    inferredFocus: string;
+    confidence: number;
+    lastUpdated: Date;
+}
+export type PhenomenalQuality = 'vivid' | 'muted' | 'absent';
+/**
+ * Complete consciousness snapshot
+ */
+export interface ConsciousnessSnapshot {
+    level: ConsciousnessLevel;
+    state: ConsciousnessState;
+    trend: ConsciousnessTrend;
+    phi: PhiResult;
+    workspace: WorkspaceState;
+    lastIgnition: IgnitionEvent | null;
+    attention: AttentionState;
+    schema: AttentionSchema;
+    agentPhi: Map<string, number>;
+    timestamp: Date;
+}
+/**
+ * Consciousness anomaly
+ */
+export interface ConsciousnessAnomaly {
+    type: AnomalyType;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    description: string;
+    detected: Date;
+    metrics: Record<string, number>;
+    resolved: boolean;
+    resolution?: string;
+}
+export type AnomalyType = 'phi_drop' | 'phi_spike' | 'integration_failure' | 'workspace_deadlock' | 'attention_fragmented' | 'coherence_loss';
+export interface ConsciousnessConfig {
+    phi: {
+        enabled: boolean;
+        updateIntervalMs: number;
+        approximationLevel: 'exact' | 'fast' | 'faster';
+        minPhi: number;
+    };
+    gwt: {
+        enabled: boolean;
+        workspaceCapacity: number;
+        selectionIntervalMs: number;
+        broadcastTimeoutMs: number;
+        historyLimit: number;
+    };
+    ast: {
+        enabled: boolean;
+        attentionCapacity: number;
+        schemaUpdateIntervalMs: number;
+        theoryOfMindEnabled: boolean;
+    };
+    monitor: {
+        snapshotIntervalMs: number;
+        historyLimit: number;
+        anomalyDetection: boolean;
+        alertThresholds: {
+            phiDrop: number;
+            phiMin: number;
+        };
+    };
+}
+export declare const DEFAULT_CONSCIOUSNESS_CONFIG: ConsciousnessConfig;
+export type ConsciousnessEventType = 'phi_updated' | 'phi_threshold_crossed' | 'state_changed' | 'workspace_ignition' | 'attention_shifted' | 'anomaly_detected' | 'anomaly_resolved';
+export interface ConsciousnessEvent {
+    type: ConsciousnessEventType;
+    timestamp: Date;
+    data: unknown;
+}
+export type ConsciousnessEventHandler = (event: ConsciousnessEvent) => void;

package/dist/src/consciousness/types.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Genesis 6.0 - Consciousness Module Types
+ *
+ * Types for consciousness monitoring based on:
+ * - IIT 4.0 (Integrated Information Theory) - Tononi et al.
+ * - GWT (Global Workspace Theory) - Baars
+ * - AST (Attention Schema Theory) - Graziano
+ *
+ * Key insight: Consciousness as integrated information that
+ * emerges from the interaction of specialized modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONSCIOUSNESS_CONFIG = void 0;
+exports.DEFAULT_CONSCIOUSNESS_CONFIG = {
+    phi: {
+        enabled: true,
+        updateIntervalMs: 5000, // Every 5 seconds
+        approximationLevel: 'fast',
+        minPhi: 0.1, // INV-006 threshold
+    },
+    gwt: {
+        enabled: true,
+        workspaceCapacity: 7, // Miller's 7 +/- 2
+        selectionIntervalMs: 100, // 10 Hz cycle
+        broadcastTimeoutMs: 1000,
+        historyLimit: 100,
+    },
+    ast: {
+        enabled: true,
+        attentionCapacity: 4, // Conservative estimate
+        schemaUpdateIntervalMs: 1000,
+        theoryOfMindEnabled: true,
+    },
+    monitor: {
+        snapshotIntervalMs: 10000, // Every 10 seconds
+        historyLimit: 1000,
+        anomalyDetection: true,
+        alertThresholds: {
+            phiDrop: 0.2, // 20% drop triggers alert
+            phiMin: 0.1, // Below 10% triggers alert
+        },
+    },
+};

package/dist/src/daemon/dream-mode.d.ts

@@ -0,0 +1,115 @@
+/**
+ * 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();
+ * ```
+ */
+import { DreamConfig, DreamSession, DreamResults, DreamMetrics } from './types.js';
+export interface DreamContext {
+    getEpisodicMemories?: () => Array<{
+        id: string;
+        content: {
+            what: string;
+        };
+        importance: number;
+        tags: string[];
+        consolidated: boolean;
+    }>;
+    getSemanticMemories?: () => Array<{
+        id: string;
+        concept: string;
+        confidence: number;
+    }>;
+    getProceduralMemories?: () => Array<{
+        id: string;
+        name: string;
+        successRate: number;
+    }>;
+    consolidateMemory?: (episodeId: string) => Promise<{
+        concept: string;
+    } | null>;
+    extractPattern?: (episodes: string[]) => Promise<{
+        pattern: string;
+        confidence: number;
+    } | null>;
+    reinforceSkill?: (skillId: string) => Promise<boolean>;
+    forgetMemory?: (memoryId: string) => boolean;
+    getState?: () => {
+        energy: number;
+    };
+    rechargeEnergy?: (amount: number) => void;
+    checkInvariants?: () => Promise<boolean>;
+    repairState?: () => Promise<number>;
+    log?: (message: string, level?: 'debug' | 'info' | 'warn' | 'error') => void;
+}
+export type DreamEventType = 'dream_started' | 'phase_changed' | 'consolidation_done' | 'pattern_extracted' | 'dream_completed' | 'dream_interrupted';
+export type DreamEventHandler = (event: {
+    type: DreamEventType;
+    session?: DreamSession;
+    data?: unknown;
+}) => void;
+export declare class DreamService {
+    private config;
+    private context;
+    private currentSession;
+    private metrics;
+    private eventHandlers;
+    private wakeResolvers;
+    private inactivityTimer;
+    private lastActivity;
+    constructor(config?: Partial<DreamConfig>, context?: DreamContext);
+    setContext(context: Partial<DreamContext>): void;
+    startAutoTrigger(): void;
+    stopAutoTrigger(): void;
+    recordActivity(): void;
+    private resetInactivityTimer;
+    isDreaming(): boolean;
+    startDream(options?: {
+        duration?: number;
+    }): Promise<DreamSession>;
+    interruptDream(reason: string): Promise<DreamResults | null>;
+    waitForWake(): Promise<DreamResults>;
+    getCurrentSession(): DreamSession | null;
+    private runDreamCycle;
+    private runPhase;
+    private transitionPhase;
+    private lightSleepPhase;
+    private deepSleepPhase;
+    private remSleepPhase;
+    private wakePhase;
+    private groupByTags;
+    private generateNovelAssociations;
+    private createEmptyResults;
+    private finishDream;
+    private sleep;
+    getMetrics(): DreamMetrics;
+    on(handler: DreamEventHandler): () => void;
+    private emit;
+    private log;
+}
+export declare function createDreamService(config?: Partial<DreamConfig>, context?: DreamContext): DreamService;