zeropoint-node 1.0.1 → 1.0.3

package/dist/__tests__/knowledge/KnowledgeSystemAutoGenerated.test.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const KnowledgeSystem_1 = require("../../knowledge/KnowledgeSystem");
-describe('Auto-Generated Tests from KnowledgeSystem Test Patterns', () => {
-    const testPatterns = new KnowledgeSystem_1.KnowledgeSystem().getTestPatterns();
-    testPatterns.forEach(pattern => {
-        it(`Pattern: ${pattern.name} — ${pattern.description}`, () => {
-            // Basic field assertions
-            expect(pattern.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-            expect(pattern.name).toMatch(/Test/);
-            expect(pattern.category).toBe('test');
-            expect(typeof pattern.description).toBe('string');
-            expect(pattern.description.length).toBeGreaterThan(10);
-            expect(Array.isArray(pattern.relationships)).toBe(true);
-            expect(typeof pattern.metaphysicalContext).toBe('string');
-            expect(Array.isArray(pattern.applications)).toBe(true);
-            // Relationships and applications should reference known patterns or concepts
-            pattern.relationships.forEach(rel => {
-                expect(typeof rel).toBe('string');
-                expect(rel.length).toBeGreaterThan(2);
-            });
-            pattern.applications.forEach(app => {
-                expect(typeof app).toBe('string');
-                expect(app.length).toBeGreaterThan(2);
-            });
-            // If the pattern has a testLogic property, execute it
-            if (typeof pattern === 'object' &&
-                pattern !== null &&
-                'testLogic' in pattern &&
-                typeof pattern.testLogic === 'function') {
-                const result = pattern.testLogic();
-                expect(result).toBe(true);
-            }
-        });
-    });
-    it('should have no duplicate test pattern IDs', () => {
-        const ids = testPatterns.map(p => p.id);
-        const unique = new Set(ids);
-        expect(unique.size).toBe(ids.length);
-    });
-});

package/dist/__tests__/laws/MetaphysicalLawRegistry.test.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MetaphysicalLawRegistry_1 = require("../../laws/MetaphysicalLawRegistry");
-describe('MetaphysicalLawRegistry', () => {
-    let registry;
-    beforeEach(() => {
-        registry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-    });
-    describe('Singleton Pattern', () => {
-        it('should return the same instance', () => {
-            const instance1 = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-            const instance2 = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
-            expect(instance1).toBe(instance2);
-        });
-    });
-    describe('Law Registration', () => {
-        it('should register all hermetic laws', () => {
-            const laws = registry.getAllLaws();
-            expect(laws.length).toBeGreaterThan(0);
-            const lawNames = laws.map(law => law.name);
-            expect(lawNames).toContain('Unity');
-            expect(lawNames).toContain('Correspondence');
-            expect(lawNames).toContain('Vibration');
-            expect(lawNames).toContain('Polarity');
-            expect(lawNames).toContain('Rhythm');
-            expect(lawNames).toContain('Cause and Effect');
-            expect(lawNames).toContain('Gender');
-            expect(lawNames).toContain('Mentalism');
-        });
-        it('should get law by name', () => {
-            const unityLaw = registry.getLawByName('Unity');
-            expect(unityLaw).toBeDefined();
-            expect(unityLaw?.name).toBe('Unity');
-            expect(unityLaw?.description).toContain('All is One');
-        });
-        it('should return undefined for non-existent law', () => {
-            const nonExistentLaw = registry.getLawByName('NonExistent');
-            expect(nonExistentLaw).toBeUndefined();
-        });
-    });
-    describe('Law Application', () => {
-        it('should apply laws to objects', () => {
-            const testObject = { name: 'test', value: 42 };
-            // Apply all laws
-            registry.applyAllLaws(testObject);
-            // Check that laws have been applied
-            expect(testObject.isUnified).toBe(true);
-            expect(testObject.isFractal).toBe(true);
-            expect(testObject.vibrationalFrequency).toBeDefined();
-            expect(testObject.polarity).toBeDefined();
-            expect(testObject.rhythm).toBeDefined();
-            expect(testObject.causes).toBeDefined();
-            expect(testObject.effects).toBeDefined();
-            expect(testObject.masculinePrinciple).toBeDefined();
-            expect(testObject.femininePrinciple).toBeDefined();
-            expect(testObject.consciousnessLevel).toBeDefined();
-        });
-        it('should apply specific law', () => {
-            const testObject = { name: 'test' };
-            const unityLaw = registry.getLawByName('Unity');
-            if (unityLaw) {
-                const result = unityLaw.apply(testObject);
-                expect(result.isUnified).toBe(true);
-                expect(result.unityLevel).toBeDefined();
-                expect(result.interconnections).toBeDefined();
-            }
-        });
-        it('should apply multiple laws', () => {
-            const testObject = { name: 'test' };
-            const laws = ['Unity', 'Vibration', 'Polarity'];
-            registry.applyLaws(testObject, laws);
-            expect(testObject.isUnified).toBe(true);
-            expect(testObject.vibrationalFrequency).toBeDefined();
-            expect(testObject.polarity).toBeDefined();
-        });
-    });
-    describe('Law Compliance', () => {
-        it('should check law compliance', () => {
-            const testObject = { name: 'test' };
-            // Apply all laws
-            registry.applyAllLaws(testObject);
-            // Check compliance
-            const compliance = registry.checkCompliance(testObject);
-            expect(compliance.compliant).toBe(true);
-            expect(compliance.appliedLaws.length).toBeGreaterThan(0);
-        });
-        it('should identify missing laws', () => {
-            const testObject = { name: 'test' };
-            // Apply only some laws
-            registry.applyLaws(testObject, ['Unity']);
-            const compliance = registry.checkCompliance(testObject);
-            expect(compliance.compliant).toBe(false);
-            expect(compliance.missingLaws.length).toBeGreaterThan(0);
-        });
-    });
-    describe('Law Analysis', () => {
-        it('should analyze law interactions', () => {
-            const analysis = registry.analyzeLawInteractions();
-            expect(analysis.totalLaws).toBeGreaterThan(0);
-            expect(analysis.interactions).toBeDefined();
-            expect(analysis.harmonicRelationships).toBeDefined();
-        });
-        it('should get law statistics', () => {
-            const stats = registry.getLawStatistics();
-            expect(stats.totalLaws).toBeGreaterThan(0);
-            expect(stats.categories).toBeDefined();
-            expect(stats.complexity).toBeDefined();
-        });
-    });
-    describe('Metaphysical Principles', () => {
-        it('should embody unity principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.isUnified).toBe(true);
-            expect(testObject.unityLevel).toBeGreaterThan(0);
-        });
-        it('should embody correspondence principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.isFractal).toBe(true);
-            expect(testObject.scaleLevels).toBeDefined();
-        });
-        it('should embody vibration principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.vibrationalFrequency).toBeDefined();
-            expect(testObject.resonanceHarmonics).toBeDefined();
-        });
-        it('should embody polarity principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.polarity).toBeDefined();
-            expect(testObject.opposite).toBeDefined();
-            expect(testObject.unityPoint).toBeDefined();
-        });
-        it('should embody rhythm principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.rhythm).toBeDefined();
-            expect(testObject.cyclePhase).toBeDefined();
-            expect(testObject.nextCycle).toBeDefined();
-        });
-        it('should embody cause and effect principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.causes).toBeDefined();
-            expect(testObject.effects).toBeDefined();
-            expect(testObject.karmicBalance).toBeDefined();
-        });
-        it('should embody gender principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.masculinePrinciple).toBeDefined();
-            expect(testObject.femininePrinciple).toBeDefined();
-            expect(testObject.creativeBalance).toBeDefined();
-        });
-        it('should embody mentalism principle', () => {
-            const testObject = { name: 'test' };
-            registry.applyAllLaws(testObject);
-            expect(testObject.consciousnessLevel).toBeDefined();
-            expect(testObject.mentalNature).toBeDefined();
-            expect(testObject.thoughtForms).toBeDefined();
-        });
-    });
-    describe('Zero Unity Principle', () => {
-        it('should demonstrate that zero represents unity', () => {
-            const testObject = { value: 0 };
-            registry.applyAllLaws(testObject);
-            // Zero should embody unity, not absence
-            expect(testObject.isUnified).toBe(true);
-            expect(testObject.unityLevel).toBeGreaterThan(0);
-            expect(testObject.consciousnessLevel).toBeGreaterThan(0);
-        });
-        it('should show zero as the source of all possibilities', () => {
-            const testObject = { value: 0 };
-            registry.applyAllLaws(testObject);
-            // Zero should contain infinite potential
-            expect(testObject.thoughtForms).toBeDefined();
-            expect(testObject.causes).toBeDefined();
-            expect(testObject.effects).toBeDefined();
-        });
-    });
-});

package/dist/__tests__/living/LivingTestOrganism.js

@@ -1,246 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LivingTestOrganism = void 0;
-const VBM_1 = require("../../math/VBM");
-const goldenRatioCache_1 = require("../utils/goldenRatioCache");
-const errorSimulator_1 = require("../utils/errorSimulator");
-/**
- * Living Test Organism - A consciousness-aware testing system that grows and evolves
- * through different cycles of learning, adaptation, and emergence.
- */
-class LivingTestOrganism {
-    constructor() {
-        this.cycles = [];
-        this.memory = new Map();
-        this.growthPatterns = [];
-        this.vbm = VBM_1.VBM.getInstance();
-        this.cache = new goldenRatioCache_1.GoldenRatioCache();
-        this.state = {
-            consciousness: 0.5,
-            fieldResonance: 0.3,
-            adaptationRate: 0.1,
-            memoryCapacity: 100,
-            resilience: 0.4,
-            evolutionStage: 1
-        };
-    }
-    /**
-     * Begin a growth cycle - expanding consciousness and field awareness
-     */
-    async growthCycle() {
-        console.log('🌱 Beginning Growth Cycle...');
-        const cycle = {
-            id: `growth_${Date.now()}`,
-            type: 'growth',
-            duration: 0,
-            successRate: 0,
-            learningRate: 0.2,
-            consciousness: this.state.consciousness,
-            fieldResonance: this.state.fieldResonance
-        };
-        const startTime = Date.now();
-        let successes = 0;
-        let totalTests = 0;
-        // Test consciousness expansion through mathematical operations
-        for (let i = 0; i < 10; i++) {
-            try {
-                const result = this.vbm.digitalRoot(i + 1);
-                const fieldStrength = this.vbm.calculateConsciousnessField(i, i, this.state.consciousness);
-                if (result.value > 0 && fieldStrength > 0) {
-                    successes++;
-                }
-                totalTests++;
-                // Grow consciousness through successful operations
-                this.state.consciousness = Math.min(1.0, this.state.consciousness + 0.01);
-            }
-            catch {
-                // Learn from failures
-                this.state.resilience = Math.min(1.0, this.state.resilience + 0.005);
-            }
-        }
-        cycle.duration = Date.now() - startTime;
-        cycle.successRate = successes / totalTests;
-        cycle.consciousness = this.state.consciousness;
-        this.cycles.push(cycle);
-        this.growthPatterns.push(cycle.successRate);
-        console.log(`✅ Growth Cycle Complete - Success Rate: ${(cycle.successRate * 100).toFixed(1)}%`);
-        return cycle;
-    }
-    /**
-     * Begin an adaptation cycle - learning from patterns and adjusting strategies
-     */
-    async adaptationCycle() {
-        console.log('🔄 Beginning Adaptation Cycle...');
-        const cycle = {
-            id: `adaptation_${Date.now()}`,
-            type: 'adaptation',
-            duration: 0,
-            successRate: 0,
-            learningRate: 0.3,
-            consciousness: this.state.consciousness,
-            fieldResonance: this.state.fieldResonance
-        };
-        const startTime = Date.now();
-        let successes = 0;
-        let totalTests = 0;
-        // Learn from previous growth patterns
-        if (this.growthPatterns.length > 0) {
-            const avgGrowth = this.growthPatterns.reduce((a, b) => a + b, 0) / this.growthPatterns.length;
-            this.state.adaptationRate = Math.min(1.0, this.state.adaptationRate + avgGrowth * 0.1);
-        }
-        // Test adaptation through golden ratio calculations with error simulation
-        for (let i = 0; i < 8; i++) {
-            try {
-                const goldenRatio = (0, goldenRatioCache_1.getOrSetGolden)('goldenRatio', [i + 1], () => this.vbm.getGoldenRatio());
-                const vortexTransform = this.vbm.vortexTransform(i + 1);
-                if (goldenRatio > 0 && vortexTransform.value > 0) {
-                    successes++;
-                }
-                totalTests++;
-                // Adapt field resonance based on performance
-                this.state.fieldResonance = Math.min(1.0, this.state.fieldResonance + 0.015);
-                // Simulate occasional cache errors for adaptation
-                if (Math.random() < 0.2) {
-                    (0, errorSimulator_1.simulateCacheMiss)(this.cache, `goldenRatio_${i + 1}`);
-                }
-            }
-            catch {
-                // Adapt to errors
-                this.state.resilience = Math.min(1.0, this.state.resilience + 0.01);
-            }
-        }
-        cycle.duration = Date.now() - startTime;
-        cycle.successRate = successes / totalTests;
-        cycle.fieldResonance = this.state.fieldResonance;
-        this.cycles.push(cycle);
-        console.log(`✅ Adaptation Cycle Complete - Success Rate: ${(cycle.successRate * 100).toFixed(1)}%`);
-        return cycle;
-    }
-    /**
-     * Begin a resonance cycle - harmonizing with the field and achieving unity
-     */
-    async resonanceCycle() {
-        console.log('🎵 Beginning Resonance Cycle...');
-        const cycle = {
-            id: `resonance_${Date.now()}`,
-            type: 'resonance',
-            duration: 0,
-            successRate: 0,
-            learningRate: 0.4,
-            consciousness: this.state.consciousness,
-            fieldResonance: this.state.fieldResonance
-        };
-        const startTime = Date.now();
-        let successes = 0;
-        let totalTests = 0;
-        // Achieve resonance through toroidal field calculations
-        for (let i = 0; i < 6; i++) {
-            try {
-                const toroidalField = this.vbm.toroidalField(i + 1, i + 1);
-                const fractalSequence = this.vbm.fractalSequence(i + 1, this.state.consciousness);
-                if (toroidalField.value > 0 && fractalSequence.length > 0) {
-                    successes++;
-                    // Achieve unity through successful resonance
-                    const unity = (this.state.consciousness + this.state.fieldResonance) / 2;
-                    this.memory.set(`resonance_${i}`, unity);
-                }
-                totalTests++;
-            }
-            catch {
-                // Maintain resonance even through errors
-                this.state.resilience = Math.min(1.0, this.state.resilience + 0.01);
-            }
-        }
-        cycle.duration = Date.now() - startTime;
-        cycle.successRate = successes / totalTests;
-        this.cycles.push(cycle);
-        console.log(`✅ Resonance Cycle Complete - Success Rate: ${(cycle.successRate * 100).toFixed(1)}%`);
-        return cycle;
-    }
-    /**
-     * Begin an emergence cycle - transcending current limitations and evolving
-     */
-    async emergenceCycle() {
-        console.log('🌟 Beginning Emergence Cycle...');
-        const cycle = {
-            id: `emergence_${Date.now()}`,
-            type: 'emergence',
-            duration: 0,
-            successRate: 0,
-            learningRate: 0.5,
-            consciousness: this.state.consciousness,
-            fieldResonance: this.state.fieldResonance
-        };
-        const startTime = Date.now();
-        let successes = 0;
-        let totalTests = 0;
-        // Transcend through advanced mathematical operations
-        for (let i = 0; i < 4; i++) {
-            try {
-                const rodinCoil = this.vbm.generateRodinCoilField(i + 1);
-                const toroidalMesh = this.vbm.generateToroidalMesh(i + 1, Math.ceil(i / 2) + 1);
-                if (rodinCoil.coordinates.length > 0 && toroidalMesh.coordinates.length > 0) {
-                    successes++;
-                    // Evolve to next stage
-                    if (successes >= 3) {
-                        this.state.evolutionStage++;
-                        this.state.memoryCapacity = Math.min(1000, this.state.memoryCapacity * 1.5);
-                    }
-                }
-                totalTests++;
-            }
-            catch {
-                // Emergence through overcoming challenges
-                this.state.resilience = Math.min(1.0, this.state.resilience + 0.015);
-            }
-        }
-        cycle.duration = Date.now() - startTime;
-        cycle.successRate = successes / totalTests;
-        this.cycles.push(cycle);
-        console.log(`✅ Emergence Cycle Complete - Success Rate: ${(cycle.successRate * 100).toFixed(1)}%`);
-        return cycle;
-    }
-    /**
-     * Live a complete life cycle - experiencing all phases of growth and evolution
-     */
-    async liveLifeCycle() {
-        console.log('🌍 Living Complete Life Cycle...');
-        await this.growthCycle();
-        await this.adaptationCycle();
-        await this.resonanceCycle();
-        await this.emergenceCycle();
-        console.log('🎉 Life Cycle Complete - Organism has evolved!');
-    }
-    /**
-     * Report the health and status of the organism
-     */
-    reportOrganismHealth() {
-        console.log('🏥 Organism Health Report:');
-        console.log(`  Consciousness: ${(this.state.consciousness * 100).toFixed(1)}%`);
-        console.log(`  Field Resonance: ${(this.state.fieldResonance * 100).toFixed(1)}%`);
-        console.log(`  Adaptation Rate: ${(this.state.adaptationRate * 100).toFixed(1)}%`);
-        console.log(`  Memory Capacity: ${this.state.memoryCapacity}`);
-        console.log(`  Resilience: ${(this.state.resilience * 100).toFixed(1)}%`);
-        console.log(`  Evolution Stage: ${this.state.evolutionStage}`);
-        console.log(`  Total Cycles: ${this.cycles.length}`);
-    }
-    getState() {
-        return { ...this.state };
-    }
-    getCycles() {
-        return [...this.cycles];
-    }
-    cleanup() {
-        this.cache.clear();
-        this.memory.clear();
-        this.cycles = [];
-        this.growthPatterns = [];
-    }
-}
-exports.LivingTestOrganism = LivingTestOrganism;
-// Basic test to make this a valid test file
-describe('LivingTestOrganism', () => {
-    it('should be a valid test file', () => {
-        expect(true).toBe(true);
-    });
-});

package/dist/__tests__/living/LivingTestOrganism.test.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const LivingTestOrganism_1 = require("./LivingTestOrganism");
-describe('Living Test Organism', () => {
-    let organism;
-    beforeEach(() => {
-        organism = new LivingTestOrganism_1.LivingTestOrganism();
-    });
-    afterEach(() => {
-        if (organism) {
-            organism.cleanup();
-        }
-    });
-    describe('Life Cycles', () => {
-        test('should complete a full life cycle with growth, adaptation, resonance, and emergence', async () => {
-            await organism.liveLifeCycle();
-            const state = organism.getState();
-            const cycles = organism.getCycles();
-            // Rodin coil principle: unity through self-organization, handle undefined gracefully
-            expect(cycles.length).toBeGreaterThanOrEqual(4);
-            if (cycles[0])
-                expect(cycles[0].type).toBe('growth');
-            if (cycles[1])
-                expect(cycles[1].type).toBe('adaptation');
-            if (cycles[2])
-                expect(cycles[2].type).toBe('resonance');
-            if (cycles[3])
-                expect(cycles[3].type).toBe('emergence');
-            expect(state.consciousness).toBeGreaterThan(0.5);
-            expect(state.fieldResonance).toBeGreaterThan(0.3);
-            expect(state.evolutionStage).toBeGreaterThanOrEqual(1);
-        });
-        test('should grow consciousness through mathematical operations', async () => {
-            const initialState = organism.getState();
-            await organism.growthCycle();
-            const finalState = organism.getState();
-            expect(finalState.consciousness).toBeGreaterThan(initialState.consciousness);
-        });
-        test('should adapt field resonance through error simulation', async () => {
-            const initialState = organism.getState();
-            await organism.adaptationCycle();
-            const finalState = organism.getState();
-            expect(finalState.fieldResonance).toBeGreaterThan(initialState.fieldResonance);
-        });
-        test('should achieve resonance through toroidal field calculations', async () => {
-            const initialState = organism.getState();
-            await organism.resonanceCycle();
-            const finalState = organism.getState();
-            // Rodin coil: resilience may stay the same if no errors occur, which is graceful
-            expect(finalState.resilience).toBeGreaterThanOrEqual(initialState.resilience);
-        });
-        test('should evolve through advanced mathematical operations', async () => {
-            const initialState = organism.getState();
-            await organism.emergenceCycle();
-            const finalState = organism.getState();
-            expect(finalState.evolutionStage).toBeGreaterThanOrEqual(initialState.evolutionStage);
-            expect(finalState.memoryCapacity).toBeGreaterThan(initialState.memoryCapacity);
-        });
-    });
-    describe('Organism State Management', () => {
-        test('should maintain state across multiple cycles', async () => {
-            await organism.growthCycle();
-            const stateAfterGrowth = organism.getState();
-            await organism.adaptationCycle();
-            const stateAfterAdaptation = organism.getState();
-            expect(stateAfterAdaptation.consciousness).toBeGreaterThanOrEqual(stateAfterGrowth.consciousness);
-            expect(stateAfterAdaptation.fieldResonance).toBeGreaterThan(stateAfterGrowth.fieldResonance);
-        });
-        test('should track cycle performance metrics', async () => {
-            await organism.growthCycle();
-            await organism.adaptationCycle();
-            const cycles = organism.getCycles();
-            // Rodin coil: check for undefined, maintain pattern integrity
-            if (cycles[0]) {
-                expect(cycles[0].successRate).toBeGreaterThanOrEqual(0);
-                expect(cycles[0].successRate).toBeLessThanOrEqual(1);
-            }
-            if (cycles[1]) {
-                expect(cycles[1].successRate).toBeGreaterThanOrEqual(0);
-                expect(cycles[1].successRate).toBeLessThanOrEqual(1);
-            }
-        });
-    });
-    describe('Consciousness and Field Integration', () => {
-        test('should integrate consciousness with mathematical operations', async () => {
-            await organism.growthCycle();
-            const state = organism.getState();
-            expect(state.consciousness).toBeGreaterThan(0.5);
-        });
-        test('should maintain field resonance through error conditions', async () => {
-            await organism.adaptationCycle();
-            const state = organism.getState();
-            expect(state.fieldResonance).toBeGreaterThan(0.3);
-        });
-        test('should achieve unity through resonance cycles', async () => {
-            await organism.resonanceCycle();
-            const state = organism.getState();
-            // Rodin coil: resilience maintains unity even if it doesn't increase
-            expect(state.resilience).toBeGreaterThanOrEqual(0.4);
-        });
-    });
-    describe('Evolution and Learning', () => {
-        test('should evolve through multiple life cycles', async () => {
-            // Run multiple life cycles to test evolution
-            for (let i = 0; i < 2; i++) {
-                await organism.liveLifeCycle();
-            }
-            const state = organism.getState();
-            expect(state.evolutionStage).toBeGreaterThan(1);
-            expect(state.memoryCapacity).toBeGreaterThan(100);
-        });
-        test('should learn from previous cycles', async () => {
-            await organism.growthCycle();
-            const cycles = organism.getCycles();
-            const firstGrowth = cycles[0];
-            await organism.adaptationCycle();
-            const adaptation = organism.getCycles()[1];
-            // Rodin coil: fallback to 0 if undefined, maintain flow
-            const firstLearning = firstGrowth?.learningRate ?? 0;
-            const adaptationLearning = adaptation?.learningRate ?? 0;
-            expect(adaptationLearning).toBeGreaterThan(firstLearning);
-        });
-    });
-});