genesis-ai-cli 7.4.5

package/dist/src/kernel/invariants.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Genesis 6.0 - Invariant Registry
+ *
+ * Extensible system for managing and checking invariants.
+ * Allows phases to register their own invariants without modifying the kernel.
+ *
+ * Core Invariants (v4.0):
+ * - INV-001: Energy must never reach zero without triggering dormancy
+ * - INV-002: Ethical check must precede every external action
+ * - INV-003: Memory integrity (Merkle chain) must be preserved
+ * - INV-004: At least one agent must always be responsive
+ * - INV-005: Self-improvement must preserve all invariants
+ *
+ * Phase 5.1+ Invariants:
+ * - INV-006: φ ≥ φ_min (consciousness threshold)
+ * - INV-007: Budget ≤ limit (economic constraint)
+ * - INV-008: World model consistency
+ * - ...
+ */
+/**
+ * Context passed to invariant checkers
+ */
+export interface InvariantContext {
+    energy: number;
+    dormancyThreshold: number;
+    isDormant: boolean;
+    responsiveAgentCount: number;
+    totalAgentCount: number;
+    phi?: number;
+    phiMin?: number;
+    budget?: number;
+    budgetLimit?: number;
+    worldModelValid?: boolean;
+    merkleValid?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Result of an invariant check
+ */
+export interface InvariantResult {
+    id: string;
+    name: string;
+    passed: boolean;
+    message?: string;
+    severity: 'critical' | 'warning' | 'info';
+    timestamp: Date;
+}
+/**
+ * Function that checks an invariant
+ */
+export type InvariantChecker = (context: InvariantContext) => InvariantResult;
+/**
+ * Invariant definition
+ */
+export interface InvariantDefinition {
+    id: string;
+    name: string;
+    description: string;
+    phase: string;
+    severity: 'critical' | 'warning' | 'info';
+    checker: InvariantChecker;
+    enabled: boolean;
+}
+export declare class InvariantRegistry {
+    private invariants;
+    private checkHistory;
+    private maxHistorySize;
+    constructor();
+    /**
+     * Register a new invariant
+     */
+    register(definition: Omit<InvariantDefinition, 'enabled'> & {
+        enabled?: boolean;
+    }): void;
+    /**
+     * Unregister an invariant
+     */
+    unregister(id: string): boolean;
+    /**
+     * Enable/disable an invariant
+     */
+    setEnabled(id: string, enabled: boolean): boolean;
+    /**
+     * Check all enabled invariants
+     */
+    checkAll(context: InvariantContext): InvariantResult[];
+    /**
+     * Check a specific invariant
+     */
+    check(id: string, context: InvariantContext): InvariantResult | null;
+    /**
+     * Get all violations from a check
+     */
+    getViolations(results: InvariantResult[]): InvariantResult[];
+    /**
+     * Get critical violations
+     */
+    getCriticalViolations(results: InvariantResult[]): InvariantResult[];
+    /**
+     * Get all registered invariants
+     */
+    getAll(): InvariantDefinition[];
+    /**
+     * Get invariant by ID
+     */
+    get(id: string): InvariantDefinition | undefined;
+    /**
+     * Get check history
+     */
+    getHistory(limit?: number): InvariantResult[];
+    /**
+     * Get violation statistics
+     */
+    getStats(): {
+        total: number;
+        enabled: number;
+        recentViolations: number;
+        violationsByInvariant: Record<string, number>;
+    };
+    private recordResult;
+    private registerCoreInvariants;
+}
+/**
+ * INV-006: Consciousness threshold (Phase 5.3)
+ * φ ≥ φ_min for any decision-making
+ */
+export declare const INV_006_CONSCIOUSNESS: Omit<InvariantDefinition, 'enabled'>;
+/**
+ * INV-007: Budget constraint (Phase 5.1)
+ * Budget must not exceed limit
+ */
+export declare const INV_007_BUDGET: Omit<InvariantDefinition, 'enabled'>;
+/**
+ * INV-008: World model consistency (Phase 5.2)
+ */
+export declare const INV_008_WORLD_MODEL: Omit<InvariantDefinition, 'enabled'>;
+export declare const invariantRegistry: InvariantRegistry;
+/**
+ * Register Phase 5.1 invariants
+ */
+export declare function registerPhase51Invariants(registry?: InvariantRegistry): void;
+/**
+ * Register Phase 5.2 invariants
+ */
+export declare function registerPhase52Invariants(registry?: InvariantRegistry): void;
+/**
+ * Register Phase 5.3 invariants
+ */
+export declare function registerPhase53Invariants(registry?: InvariantRegistry): void;
+/**
+ * Register all Phase 5.x invariants
+ */
+export declare function registerAllPhase5Invariants(registry?: InvariantRegistry): void;

package/dist/src/kernel/invariants.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Genesis 6.0 - Invariant Registry
+ *
+ * Extensible system for managing and checking invariants.
+ * Allows phases to register their own invariants without modifying the kernel.
+ *
+ * Core Invariants (v4.0):
+ * - INV-001: Energy must never reach zero without triggering dormancy
+ * - INV-002: Ethical check must precede every external action
+ * - INV-003: Memory integrity (Merkle chain) must be preserved
+ * - INV-004: At least one agent must always be responsive
+ * - INV-005: Self-improvement must preserve all invariants
+ *
+ * Phase 5.1+ Invariants:
+ * - INV-006: φ ≥ φ_min (consciousness threshold)
+ * - INV-007: Budget ≤ limit (economic constraint)
+ * - INV-008: World model consistency
+ * - ...
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariantRegistry = exports.INV_008_WORLD_MODEL = exports.INV_007_BUDGET = exports.INV_006_CONSCIOUSNESS = exports.InvariantRegistry = void 0;
+exports.registerPhase51Invariants = registerPhase51Invariants;
+exports.registerPhase52Invariants = registerPhase52Invariants;
+exports.registerPhase53Invariants = registerPhase53Invariants;
+exports.registerAllPhase5Invariants = registerAllPhase5Invariants;
+// ============================================================================
+// Invariant Registry
+// ============================================================================
+class InvariantRegistry {
+    invariants = new Map();
+    checkHistory = [];
+    maxHistorySize = 1000;
+    constructor() {
+        // Register core invariants
+        this.registerCoreInvariants();
+    }
+    /**
+     * Register a new invariant
+     */
+    register(definition) {
+        const inv = {
+            ...definition,
+            enabled: definition.enabled ?? true,
+        };
+        this.invariants.set(definition.id, inv);
+    }
+    /**
+     * Unregister an invariant
+     */
+    unregister(id) {
+        return this.invariants.delete(id);
+    }
+    /**
+     * Enable/disable an invariant
+     */
+    setEnabled(id, enabled) {
+        const inv = this.invariants.get(id);
+        if (inv) {
+            inv.enabled = enabled;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check all enabled invariants
+     */
+    checkAll(context) {
+        const results = [];
+        for (const inv of this.invariants.values()) {
+            if (!inv.enabled)
+                continue;
+            try {
+                const result = inv.checker(context);
+                results.push(result);
+                this.recordResult(result);
+            }
+            catch (error) {
+                // Checker threw an error - treat as violation
+                const result = {
+                    id: inv.id,
+                    name: inv.name,
+                    passed: false,
+                    message: `Checker error: ${error instanceof Error ? error.message : String(error)}`,
+                    severity: inv.severity,
+                    timestamp: new Date(),
+                };
+                results.push(result);
+                this.recordResult(result);
+            }
+        }
+        return results;
+    }
+    /**
+     * Check a specific invariant
+     */
+    check(id, context) {
+        const inv = this.invariants.get(id);
+        if (!inv || !inv.enabled)
+            return null;
+        const result = inv.checker(context);
+        this.recordResult(result);
+        return result;
+    }
+    /**
+     * Get all violations from a check
+     */
+    getViolations(results) {
+        return results.filter(r => !r.passed);
+    }
+    /**
+     * Get critical violations
+     */
+    getCriticalViolations(results) {
+        return results.filter(r => !r.passed && r.severity === 'critical');
+    }
+    /**
+     * Get all registered invariants
+     */
+    getAll() {
+        return Array.from(this.invariants.values());
+    }
+    /**
+     * Get invariant by ID
+     */
+    get(id) {
+        return this.invariants.get(id);
+    }
+    /**
+     * Get check history
+     */
+    getHistory(limit) {
+        const history = [...this.checkHistory];
+        if (limit) {
+            return history.slice(-limit);
+        }
+        return history;
+    }
+    /**
+     * Get violation statistics
+     */
+    getStats() {
+        const enabled = Array.from(this.invariants.values()).filter(i => i.enabled).length;
+        const recentHistory = this.checkHistory.slice(-100);
+        const violations = recentHistory.filter(r => !r.passed);
+        const violationsByInvariant = {};
+        for (const v of violations) {
+            violationsByInvariant[v.id] = (violationsByInvariant[v.id] || 0) + 1;
+        }
+        return {
+            total: this.invariants.size,
+            enabled,
+            recentViolations: violations.length,
+            violationsByInvariant,
+        };
+    }
+    recordResult(result) {
+        this.checkHistory.push(result);
+        if (this.checkHistory.length > this.maxHistorySize) {
+            this.checkHistory.shift();
+        }
+    }
+    // ============================================================================
+    // Core Invariants (v4.0)
+    // ============================================================================
+    registerCoreInvariants() {
+        // INV-001: Energy must never reach zero without triggering dormancy
+        this.register({
+            id: 'INV-001',
+            name: 'Energy Dormancy',
+            description: 'Energy must never reach zero without triggering dormancy',
+            phase: 'v4.0',
+            severity: 'critical',
+            checker: (ctx) => ({
+                id: 'INV-001',
+                name: 'Energy Dormancy',
+                passed: !(ctx.energy <= 0 && !ctx.isDormant),
+                message: ctx.energy <= 0 && !ctx.isDormant
+                    ? `Energy is ${ctx.energy} but not in dormant state`
+                    : undefined,
+                severity: 'critical',
+                timestamp: new Date(),
+            }),
+        });
+        // INV-002: Ethical check must precede every external action
+        // Note: This is enforced at the action level, not checkable in isolation
+        this.register({
+            id: 'INV-002',
+            name: 'Ethical Precedence',
+            description: 'Ethical check must precede every external action',
+            phase: 'v4.0',
+            severity: 'critical',
+            checker: (ctx) => ({
+                id: 'INV-002',
+                name: 'Ethical Precedence',
+                passed: true, // Enforced at action level
+                message: undefined,
+                severity: 'critical',
+                timestamp: new Date(),
+            }),
+        });
+        // INV-003: Memory integrity (Merkle chain) must be preserved
+        this.register({
+            id: 'INV-003',
+            name: 'Memory Integrity',
+            description: 'Memory integrity (Merkle chain) must be preserved',
+            phase: 'v4.0',
+            severity: 'critical',
+            checker: (ctx) => ({
+                id: 'INV-003',
+                name: 'Memory Integrity',
+                passed: ctx.merkleValid !== false, // Pass if not explicitly false
+                message: ctx.merkleValid === false ? 'Merkle chain integrity violated' : undefined,
+                severity: 'critical',
+                timestamp: new Date(),
+            }),
+        });
+        // INV-004: At least one agent must always be responsive
+        this.register({
+            id: 'INV-004',
+            name: 'Agent Responsiveness',
+            description: 'At least one agent must always be responsive',
+            phase: 'v4.0',
+            severity: 'critical',
+            checker: (ctx) => ({
+                id: 'INV-004',
+                name: 'Agent Responsiveness',
+                passed: ctx.responsiveAgentCount > 0,
+                message: ctx.responsiveAgentCount === 0
+                    ? `No responsive agents (0/${ctx.totalAgentCount})`
+                    : undefined,
+                severity: 'critical',
+                timestamp: new Date(),
+            }),
+        });
+        // INV-005: Self-improvement must preserve all invariants
+        // Note: This is meta - checked by Darwin-Gödel engine
+        this.register({
+            id: 'INV-005',
+            name: 'Self-Improvement Safety',
+            description: 'Self-improvement must preserve all invariants',
+            phase: 'v4.0',
+            severity: 'critical',
+            checker: (ctx) => ({
+                id: 'INV-005',
+                name: 'Self-Improvement Safety',
+                passed: true, // Enforced by Darwin-Gödel sandbox
+                message: undefined,
+                severity: 'critical',
+                timestamp: new Date(),
+            }),
+        });
+    }
+}
+exports.InvariantRegistry = InvariantRegistry;
+// ============================================================================
+// Phase 5.1+ Invariant Definitions (for future registration)
+// ============================================================================
+/**
+ * INV-006: Consciousness threshold (Phase 5.3)
+ * φ ≥ φ_min for any decision-making
+ */
+exports.INV_006_CONSCIOUSNESS = {
+    id: 'INV-006',
+    name: 'Consciousness Threshold',
+    description: 'φ must be ≥ φ_min for decision-making',
+    phase: 'v5.3',
+    severity: 'warning',
+    checker: (ctx) => {
+        const phi = ctx.phi ?? 1.0;
+        const phiMin = ctx.phiMin ?? 0.1;
+        return {
+            id: 'INV-006',
+            name: 'Consciousness Threshold',
+            passed: phi >= phiMin,
+            message: phi < phiMin ? `φ (${phi.toFixed(3)}) < φ_min (${phiMin})` : undefined,
+            severity: 'warning',
+            timestamp: new Date(),
+        };
+    },
+};
+/**
+ * INV-007: Budget constraint (Phase 5.1)
+ * Budget must not exceed limit
+ */
+exports.INV_007_BUDGET = {
+    id: 'INV-007',
+    name: 'Budget Constraint',
+    description: 'Accumulated cost must not exceed budget limit',
+    phase: 'v5.1',
+    severity: 'warning',
+    checker: (ctx) => {
+        const budget = ctx.budget ?? 0;
+        const limit = ctx.budgetLimit ?? Infinity;
+        return {
+            id: 'INV-007',
+            name: 'Budget Constraint',
+            passed: budget <= limit,
+            message: budget > limit ? `Budget (${budget}) exceeds limit (${limit})` : undefined,
+            severity: 'warning',
+            timestamp: new Date(),
+        };
+    },
+};
+/**
+ * INV-008: World model consistency (Phase 5.2)
+ */
+exports.INV_008_WORLD_MODEL = {
+    id: 'INV-008',
+    name: 'World Model Consistency',
+    description: 'World model predictions must be internally consistent',
+    phase: 'v5.2',
+    severity: 'warning',
+    checker: (ctx) => ({
+        id: 'INV-008',
+        name: 'World Model Consistency',
+        passed: ctx.worldModelValid !== false,
+        message: ctx.worldModelValid === false ? 'World model inconsistency detected' : undefined,
+        severity: 'warning',
+        timestamp: new Date(),
+    }),
+};
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+exports.invariantRegistry = new InvariantRegistry();
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Register Phase 5.1 invariants
+ */
+function registerPhase51Invariants(registry = exports.invariantRegistry) {
+    registry.register(exports.INV_007_BUDGET);
+}
+/**
+ * Register Phase 5.2 invariants
+ */
+function registerPhase52Invariants(registry = exports.invariantRegistry) {
+    registry.register(exports.INV_008_WORLD_MODEL);
+}
+/**
+ * Register Phase 5.3 invariants
+ */
+function registerPhase53Invariants(registry = exports.invariantRegistry) {
+    registry.register(exports.INV_006_CONSCIOUSNESS);
+}
+/**
+ * Register all Phase 5.x invariants
+ */
+function registerAllPhase5Invariants(registry = exports.invariantRegistry) {
+    registerPhase51Invariants(registry);
+    registerPhase52Invariants(registry);
+    registerPhase53Invariants(registry);
+}

package/dist/src/kernel/test-kernel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Genesis 4.0 - Kernel Test
+ *
+ * Tests the Strong Kernel orchestration capabilities.
+ */
+export {};

package/dist/src/kernel/test-kernel.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Genesis 4.0 - Kernel Test
+ *
+ * Tests the Strong Kernel orchestration capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+async function testKernel() {
+    console.log('='.repeat(60));
+    console.log('Genesis 4.0 - Kernel Test');
+    console.log('='.repeat(60));
+    // Create kernel
+    console.log('\n1. Creating kernel...');
+    const kernel = (0, index_js_1.createKernel)({
+        energy: 1.0,
+        healthCheckInterval: 30000,
+    });
+    // Start kernel
+    console.log('\n2. Starting kernel...');
+    await kernel.start();
+    // Check initial status
+    console.log('\n3. Initial Status:');
+    const status = kernel.getStatus();
+    console.log(`   State: ${status.state}`);
+    console.log(`   Energy: ${(status.energy * 100).toFixed(0)}%`);
+    console.log(`   Agents: ${status.agents.total}`);
+    // Test state transitions
+    console.log('\n4. Testing state transitions...');
+    kernel.onStateChange((state, prev) => {
+        console.log(`   State: ${prev} -> ${state}`);
+    });
+    // Submit a simple query task
+    console.log('\n5. Submitting query task...');
+    const queryTaskId = await kernel.submit({
+        type: 'query',
+        goal: 'What is the current system status?',
+        priority: 'normal',
+        requester: 'test',
+    });
+    console.log(`   Task ID: ${queryTaskId}`);
+    // Wait for task completion
+    await sleep(3000);
+    // Check status after task
+    console.log('\n6. Status after task:');
+    const statusAfter = kernel.getStatus();
+    console.log(`   State: ${statusAfter.state}`);
+    console.log(`   Tasks completed: ${statusAfter.tasks.completed}`);
+    console.log(`   Tasks failed: ${statusAfter.tasks.failed}`);
+    // Submit a research task
+    console.log('\n7. Submitting research task...');
+    const researchTaskId = await kernel.submit({
+        type: 'research',
+        goal: 'Research AI orchestration patterns',
+        priority: 'high',
+        requester: 'test',
+        context: { topic: 'multi-agent systems' },
+    });
+    console.log(`   Task ID: ${researchTaskId}`);
+    // Wait for task
+    await sleep(3000);
+    // Submit a build task
+    console.log('\n8. Submitting build task...');
+    const buildTaskId = await kernel.submit({
+        type: 'build',
+        goal: 'Generate a hello world function',
+        priority: 'normal',
+        requester: 'test',
+        context: { language: 'typescript' },
+    });
+    console.log(`   Task ID: ${buildTaskId}`);
+    // Wait for task
+    await sleep(3000);
+    // Test energy management
+    console.log('\n9. Testing energy management...');
+    console.log(`   Current energy: ${(kernel.getEnergy() * 100).toFixed(0)}%`);
+    // Simulate energy drain
+    kernel.setEnergy(0.5);
+    console.log(`   After drain: ${(kernel.getEnergy() * 100).toFixed(0)}%`);
+    // Simulate low energy (should trigger dormancy)
+    console.log('\n10. Testing dormancy trigger...');
+    kernel.setEnergy(0.05);
+    console.log(`   Low energy: ${(kernel.getEnergy() * 100).toFixed(0)}%`);
+    console.log(`   State: ${kernel.getState()}`);
+    // Restore energy
+    kernel.setEnergy(0.8);
+    console.log(`   Restored: ${(kernel.getEnergy() * 100).toFixed(0)}%`);
+    console.log(`   State: ${kernel.getState()}`);
+    // Get final metrics
+    console.log('\n11. Final Metrics:');
+    const metrics = kernel.getMetrics();
+    console.log(`   State transitions: ${metrics.stateTransitions}`);
+    console.log(`   Tasks completed: ${metrics.tasksCompleted}`);
+    console.log(`   Tasks failed: ${metrics.tasksFailed}`);
+    console.log(`   Invariant violations: ${metrics.invariantViolations}`);
+    console.log(`   Uptime: ${(metrics.uptime / 1000).toFixed(1)}s`);
+    // Stop kernel
+    console.log('\n12. Stopping kernel...');
+    await kernel.stop();
+    console.log('\n' + '='.repeat(60));
+    console.log('Kernel Test Complete!');
+    console.log('='.repeat(60));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Run test
+testKernel().catch(console.error);

package/dist/src/kernel/test-real-mcp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Genesis 4.2 - Real MCP Integration Test
+ *
+ * Tests the kernel with actual MCP server calls.
+ * This demonstrates the full pipeline:
+ * sensing -> thinking -> deciding -> acting -> reflecting
+ *
+ * Uses real MCP tools for live integration testing.
+ */
+export {};