🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
Checkpoint: File edits
rUv9de737571047
diff --git a/v3/@claude-flow/memory/src/learning-bridge.test.ts b/v3/@claude-flow/memory/src/learning-bridge.test.tsnew file mode 100644index 0000000000..86a8be5728--- /dev/null+++ b/v3/@claude-flow/memory/src/learning-bridge.test.ts@@ -0,0 +1,841 @@+/**+ * Tests for LearningBridge+ *+ * TDD London School (mock-first) tests for the bridge that connects+ * AutoMemoryBridge insights to the NeuralLearningSystem.+ */++import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';+import type { IMemoryBackend, MemoryEntry, MemoryEntryUpdate } from './types.js';+import type { MemoryInsight } from './auto-memory-bridge.js';++// ===== Mock Neural System =====++const mockNeuralSystem = {+ initialize: vi.fn().mockResolvedValue(undefined),+ beginTask: vi.fn().mockReturnValue('traj-1'),+ recordStep: vi.fn(),+ completeTask: vi.fn().mockResolvedValue(undefined),+ findPatterns: vi.fn().mockResolvedValue([]),+ cleanup: vi.fn().mockResolvedValue(undefined),+};++// Control whether the dynamic import succeeds+let neuralImportShouldFail = false;++vi.mock('@claude-flow/neural', () => {+ if (neuralImportShouldFail) {+ throw new Error('Module not found: @claude-flow/neural');+ }+ return {+ NeuralLearningSystem: vi.fn().mockImplementation(() => mockNeuralSystem),+ };+});++// Import AFTER mocking so the dynamic import inside the class picks up the mock+import { LearningBridge } from './learning-bridge.js';+import type {+ LearningBridgeConfig,+ LearningStats,+ ConsolidateResult,+ PatternMatch,+} from './learning-bridge.js';++// ===== Mock Backend =====++function createMockBackend(): IMemoryBackend & { storedEntries: MemoryEntry[] } {+ const storedEntries: MemoryEntry[] = [];++ return {+ storedEntries,+ initialize: vi.fn().mockResolvedValue(undefined),+ shutdown: vi.fn().mockResolvedValue(undefined),+ store: vi.fn().mockImplementation(async (entry: MemoryEntry) => {+ storedEntries.push(entry);+ }),+ get: vi.fn().mockResolvedValue(null),+ getByKey: vi.fn().mockResolvedValue(null),+ update: vi.fn().mockImplementation(async (id: string, update: MemoryEntryUpdate) => {+ const entry = storedEntries.find(e => e.id === id);+ if (!entry) return null;+ if (update.metadata) entry.metadata = { ...entry.metadata, ...update.metadata };+ return entry;+ }),+ delete: vi.fn().mockResolvedValue(true),+ query: vi.fn().mockResolvedValue([]),+ search: vi.fn().mockResolvedValue([]),+ bulkInsert: vi.fn().mockResolvedValue(undefined),+ bulkDelete: vi.fn().mockResolvedValue(0),+ count: vi.fn().mockResolvedValue(0),+ listNamespaces: vi.fn().mockResolvedValue([]),+ clearNamespace: vi.fn().mockResolvedValue(0),+ getStats: vi.fn().mockResolvedValue({+ totalEntries: 0,+ entriesByNamespace: {},+ entriesByType: {},+ memoryUsage: 0,+ avgQueryTime: 0,+ avgSearchTime: 0,+ }),+ healthCheck: vi.fn().mockResolvedValue({+ status: 'healthy',+ components: {+ storage: { status: 'healthy', latency: 0 },+ index: { status: 'healthy', latency: 0 },+ cache: { status: 'healthy', latency: 0 },+ },+ timestamp: Date.now(),+ issues: [],+ recommendations: [],+ }),+ };+}++// ===== Test Fixtures =====++function createTestInsight(overrides: Partial<MemoryInsight> = {}): MemoryInsight {+ return {+ category: 'debugging',+ summary: 'HNSW index requires initialization before search',+ source: 'agent:tester',+ confidence: 0.95,+ ...overrides,+ };+}++function createTestEntry(overrides: Partial<MemoryEntry> = {}): MemoryEntry {+ const now = Date.now();+ return {+ id: 'entry-1',+ key: 'insight:debugging:12345:0',+ content: 'HNSW index requires initialization',+ type: 'semantic',+ namespace: 'learnings',+ tags: ['insight', 'debugging'],+ metadata: { confidence: 0.8, category: 'debugging' },+ accessLevel: 'private',+ createdAt: now,+ updatedAt: now,+ version: 1,+ references: [],+ accessCount: 0,+ lastAccessedAt: now,+ ...overrides,+ };+}++// ===== Tests =====++describe('LearningBridge', () => {+ let bridge: LearningBridge;+ let backend: ReturnType<typeof createMockBackend>;++ beforeEach(() => {+ vi.clearAllMocks();+ neuralImportShouldFail = false;+ mockNeuralSystem.beginTask.mockReturnValue('traj-1');+ mockNeuralSystem.findPatterns.mockResolvedValue([]);++ backend = createMockBackend();+ bridge = new LearningBridge(backend);+ });++ afterEach(() => {+ bridge.destroy();+ });++ // ===== constructor =====++ describe('constructor', () => {+ it('should create with default config', () => {+ const stats = bridge.getStats();+ expect(stats.totalTrajectories).toBe(0);+ expect(stats.neuralAvailable).toBe(false);+ });++ it('should create with custom config', () => {+ const custom = new LearningBridge(backend, {+ sonaMode: 'research',+ confidenceDecayRate: 0.01,+ accessBoostAmount: 0.05,+ maxConfidence: 0.9,+ minConfidence: 0.2,+ ewcLambda: 5000,+ consolidationThreshold: 20,+ });++ const stats = custom.getStats();+ expect(stats.totalTrajectories).toBe(0);+ custom.destroy();+ });++ it('should respect enabled=false', async () => {+ const disabled = new LearningBridge(backend, { enabled: false });+ const insight = createTestInsight();++ await disabled.onInsightRecorded(insight, 'entry-1');++ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();+ expect(disabled.getStats().totalTrajectories).toBe(0);+ disabled.destroy();+ });+ });++ // ===== onInsightRecorded =====++ describe('onInsightRecorded', () => {+ it('should store trajectory when neural available', async () => {+ const insight = createTestInsight();+ await bridge.onInsightRecorded(insight, 'entry-1');++ expect(mockNeuralSystem.beginTask).toHaveBeenCalledWith(insight.summary, 'general');+ expect(mockNeuralSystem.recordStep).toHaveBeenCalledWith('traj-1', expect.objectContaining({+ action: 'record:debugging',+ reward: 0.95,+ }));+ expect(bridge.getStats().totalTrajectories).toBe(1);+ });++ it('should emit insight:learning-started event', async () => {+ const handler = vi.fn();+ bridge.on('insight:learning-started', handler);++ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ expect(handler).toHaveBeenCalledWith({+ entryId: 'entry-1',+ category: 'debugging',+ });+ });++ it('should no-op when disabled', async () => {+ const disabled = new LearningBridge(backend, { enabled: false });++ await disabled.onInsightRecorded(createTestInsight(), 'entry-1');++ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();+ disabled.destroy();+ });++ it('should no-op when destroyed', async () => {+ bridge.destroy();++ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();+ });++ it('should handle neural unavailable gracefully', async () => {+ neuralImportShouldFail = true;+ const safeBridge = new LearningBridge(backend);+ const handler = vi.fn();+ safeBridge.on('insight:learning-started', handler);++ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-1');++ // Event should still be emitted even without neural+ expect(handler).toHaveBeenCalled();+ expect(safeBridge.getStats().neuralAvailable).toBe(false);+ safeBridge.destroy();+ });++ it('should pass hash embedding as stateEmbedding', async () => {+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ const stepArg = mockNeuralSystem.recordStep.mock.calls[0][1];+ expect(stepArg.stateEmbedding).toBeInstanceOf(Float32Array);+ expect(stepArg.stateEmbedding.length).toBe(768);+ });++ it('should create unique trajectory per entry', async () => {+ mockNeuralSystem.beginTask+ .mockReturnValueOnce('traj-1')+ .mockReturnValueOnce('traj-2');++ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ await bridge.onInsightRecorded(+ createTestInsight({ summary: 'Second insight' }),+ 'entry-2',+ );++ expect(bridge.getStats().totalTrajectories).toBe(2);+ expect(bridge.getStats().activeTrajectories).toBe(2);+ });++ it('should survive beginTask throwing', async () => {+ mockNeuralSystem.beginTask.mockImplementationOnce(() => {+ throw new Error('Neural failure');+ });++ const handler = vi.fn();+ bridge.on('insight:learning-started', handler);++ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ // Should still emit event+ expect(handler).toHaveBeenCalled();+ });+ });++ // ===== onInsightAccessed =====++ describe('onInsightAccessed', () => {+ it('should boost confidence by accessBoostAmount', async () => {+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ expect(backend.update).toHaveBeenCalledWith('entry-1', {+ metadata: expect.objectContaining({ confidence: 0.53 }),+ });+ });++ it('should cap confidence at maxConfidence', async () => {+ const entry = createTestEntry({ metadata: { confidence: 0.99 } });+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ const updateCall = (backend.update as any).mock.calls[0];+ expect(updateCall[1].metadata.confidence).toBeLessThanOrEqual(1.0);+ });++ it('should handle missing entry gracefully', async () => {+ (backend.get as any).mockResolvedValueOnce(null);++ // Should not throw+ await bridge.onInsightAccessed('nonexistent');++ expect(backend.update).not.toHaveBeenCalled();+ });++ it('should emit insight:accessed event', async () => {+ const entry = createTestEntry({ metadata: { confidence: 0.7 } });+ (backend.get as any).mockResolvedValueOnce(entry);++ const handler = vi.fn();+ bridge.on('insight:accessed', handler);++ await bridge.onInsightAccessed('entry-1');++ expect(handler).toHaveBeenCalledWith({+ entryId: 'entry-1',+ newConfidence: expect.any(Number),+ });+ });++ it('should update entry metadata in backend', async () => {+ const entry = createTestEntry({+ metadata: { confidence: 0.6, category: 'debugging', extra: 'preserved' },+ });+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ const updateCall = (backend.update as any).mock.calls[0][1];+ // Original metadata should be preserved alongside the updated confidence+ expect(updateCall.metadata.category).toBe('debugging');+ expect(updateCall.metadata.extra).toBe('preserved');+ expect(updateCall.metadata.confidence).toBeCloseTo(0.63, 5);+ });++ it('should record neural step when trajectory exists', async () => {+ // First create a trajectory+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ vi.clearAllMocks();++ const entry = createTestEntry();+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ expect(mockNeuralSystem.recordStep).toHaveBeenCalledWith('traj-1', {+ action: 'access',+ reward: 0.03,+ });+ });++ it('should not record neural step without trajectory', async () => {+ const entry = createTestEntry();+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ // recordStep may have been called during initNeural on first method call,+ // but not for this access since no trajectory exists for this entry+ expect(mockNeuralSystem.recordStep).not.toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ action: 'access' }),+ );+ });++ it('should use default 0.5 confidence when metadata lacks it', async () => {+ const entry = createTestEntry({ metadata: {} });+ (backend.get as any).mockResolvedValueOnce(entry);++ await bridge.onInsightAccessed('entry-1');++ const updateCall = (backend.update as any).mock.calls[0][1];+ expect(updateCall.metadata.confidence).toBeCloseTo(0.53, 5);+ });++ it('should no-op when disabled', async () => {+ const disabled = new LearningBridge(backend, { enabled: false });++ await disabled.onInsightAccessed('entry-1');++ expect(backend.get).not.toHaveBeenCalled();+ disabled.destroy();+ });++ it('should track boost stats', async () => {+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });+ (backend.get as any).mockResolvedValue(entry);++ await bridge.onInsightAccessed('entry-1');+ await bridge.onInsightAccessed('entry-1');++ const stats = bridge.getStats();+ expect(stats.avgConfidenceBoost).toBeCloseTo(0.03, 5);+ });+ });++ // ===== consolidate =====++ describe('consolidate', () => {+ it('should complete active trajectories', async () => {+ // Create enough trajectories to meet the threshold (default 10)+ for (let i = 0; i < 10; i++) {+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);+ await bridge.onInsightRecorded(+ createTestInsight({ summary: `Insight ${i}` }),+ `entry-${i}`,+ );+ }++ const result = await bridge.consolidate();++ expect(result.trajectoriesCompleted).toBe(10);+ expect(result.patternsLearned).toBe(10);+ expect(result.durationMs).toBeGreaterThanOrEqual(0);+ });++ it('should return early when below threshold', async () => {+ // Only create 2 trajectories, below default threshold of 10+ mockNeuralSystem.beginTask.mockReturnValueOnce('traj-1');+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ const result = await bridge.consolidate();++ expect(result.trajectoriesCompleted).toBe(0);+ expect(mockNeuralSystem.completeTask).not.toHaveBeenCalled();+ });++ it('should return early when neural unavailable', async () => {+ neuralImportShouldFail = true;+ const safeBridge = new LearningBridge(backend);++ const result = await safeBridge.consolidate();++ expect(result.trajectoriesCompleted).toBe(0);+ safeBridge.destroy();+ });++ it('should clear completed trajectories', async () => {+ for (let i = 0; i < 10; i++) {+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);+ await bridge.onInsightRecorded(+ createTestInsight({ summary: `Insight ${i}` }),+ `entry-${i}`,+ );+ }++ expect(bridge.getStats().activeTrajectories).toBe(10);++ await bridge.consolidate();++ expect(bridge.getStats().activeTrajectories).toBe(0);+ });++ it('should emit consolidation:completed event', async () => {+ for (let i = 0; i < 10; i++) {+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);+ await bridge.onInsightRecorded(+ createTestInsight({ summary: `Insight ${i}` }),+ `entry-${i}`,+ );+ }++ const handler = vi.fn();+ bridge.on('consolidation:completed', handler);++ await bridge.consolidate();++ expect(handler).toHaveBeenCalledWith(expect.objectContaining({+ trajectoriesCompleted: 10,+ patternsLearned: 10,+ }));+ });++ it('should track stats correctly', async () => {+ for (let i = 0; i < 10; i++) {+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);+ await bridge.onInsightRecorded(+ createTestInsight({ summary: `Insight ${i}` }),+ `entry-${i}`,+ );+ }++ await bridge.consolidate();++ const stats = bridge.getStats();+ expect(stats.completedTrajectories).toBe(10);+ expect(stats.totalConsolidations).toBe(1);+ });++ it('should handle completeTask failure for individual trajectories', async () => {+ for (let i = 0; i < 10; i++) {+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);+ await bridge.onInsightRecorded(+ createTestInsight({ summary: `Insight ${i}` }),+ `entry-${i}`,+ );+ }++ // Fail on 3rd trajectory+ let callCount = 0;+ mockNeuralSystem.completeTask.mockImplementation(async () => {+ callCount++;+ if (callCount === 3) throw new Error('Neural failure');+ });++ const result = await bridge.consolidate();++ // 9 should succeed, 1 fails+ expect(result.trajectoriesCompleted).toBe(9);+ });++ it('should respect custom consolidationThreshold', async () => {+ const customBridge = new LearningBridge(backend, { consolidationThreshold: 2 });++ mockNeuralSystem.beginTask.mockReturnValueOnce('traj-1').mockReturnValueOnce('traj-2');+ await customBridge.onInsightRecorded(createTestInsight(), 'e-1');+ await customBridge.onInsightRecorded(createTestInsight({ summary: 'Second' }), 'e-2');++ const result = await customBridge.consolidate();++ expect(result.trajectoriesCompleted).toBe(2);+ customBridge.destroy();+ });+ });++ // ===== decayConfidences =====++ describe('decayConfidences', () => {+ it('should decay entries older than 1 hour', async () => {+ const twoHoursAgo = Date.now() - 2 * 3_600_000;+ const entry = createTestEntry({+ id: 'old-entry',+ updatedAt: twoHoursAgo,+ metadata: { confidence: 0.9 },+ });+ (backend.query as any).mockResolvedValueOnce([entry]);++ const count = await bridge.decayConfidences('learnings');++ expect(count).toBe(1);+ expect(backend.update).toHaveBeenCalledWith('old-entry', {+ metadata: expect.objectContaining({+ confidence: expect.any(Number),+ }),+ });++ const newConf = (backend.update as any).mock.calls[0][1].metadata.confidence;+ // 0.9 - (0.005 * 2) = 0.89+ expect(newConf).toBeCloseTo(0.89, 2);+ });++ it('should respect minConfidence floor', async () => {+ const longAgo = Date.now() - 200 * 3_600_000; // 200 hours ago+ const entry = createTestEntry({+ id: 'ancient-entry',+ updatedAt: longAgo,+ metadata: { confidence: 0.5 },+ });+ (backend.query as any).mockResolvedValueOnce([entry]);++ await bridge.decayConfidences('learnings');++ const newConf = (backend.update as any).mock.calls[0][1].metadata.confidence;+ expect(newConf).toBeGreaterThanOrEqual(0.1);+ });++ it('should skip recent entries', async () => {+ const entry = createTestEntry({+ id: 'recent-entry',+ updatedAt: Date.now() - 30 * 60_000, // 30 minutes ago+ metadata: { confidence: 0.8 },+ });+ (backend.query as any).mockResolvedValueOnce([entry]);++ const count = await bridge.decayConfidences('learnings');++ expect(count).toBe(0);+ expect(backend.update).not.toHaveBeenCalled();+ });++ it('should return count of decayed entries', async () => {+ const twoHoursAgo = Date.now() - 2 * 3_600_000;+ const entries = [+ createTestEntry({ id: 'e1', updatedAt: twoHoursAgo, metadata: { confidence: 0.9 } }),+ createTestEntry({ id: 'e2', updatedAt: twoHoursAgo, metadata: { confidence: 0.7 } }),+ createTestEntry({ id: 'e3', updatedAt: Date.now(), metadata: { confidence: 0.5 } }), // recent+ ];+ (backend.query as any).mockResolvedValueOnce(entries);++ const count = await bridge.decayConfidences('learnings');++ expect(count).toBe(2);+ });++ it('should handle empty namespace', async () => {+ (backend.query as any).mockResolvedValueOnce([]);++ const count = await bridge.decayConfidences('empty-ns');++ expect(count).toBe(0);+ });++ it('should handle query failure gracefully', async () => {+ (backend.query as any).mockRejectedValueOnce(new Error('DB error'));++ const count = await bridge.decayConfidences('broken');++ expect(count).toBe(0);+ });++ it('should track total decays in stats', async () => {+ const old = Date.now() - 5 * 3_600_000;+ (backend.query as any).mockResolvedValueOnce([+ createTestEntry({ id: 'e1', updatedAt: old, metadata: { confidence: 0.9 } }),+ ]);++ await bridge.decayConfidences('learnings');++ expect(bridge.getStats().totalDecays).toBe(1);+ });+ });++ // ===== findSimilarPatterns =====++ describe('findSimilarPatterns', () => {+ it('should return patterns when neural available', async () => {+ mockNeuralSystem.findPatterns.mockResolvedValueOnce([+ { content: 'Pattern A', similarity: 0.9, category: 'debugging', confidence: 0.8 },+ { content: 'Pattern B', similarity: 0.7, category: 'performance', confidence: 0.6 },+ ]);++ const patterns = await bridge.findSimilarPatterns('test query');++ expect(patterns).toHaveLength(2);+ expect(patterns[0].content).toBe('Pattern A');+ expect(patterns[0].similarity).toBe(0.9);+ expect(patterns[1].category).toBe('performance');+ });++ it('should return empty when neural unavailable', async () => {+ neuralImportShouldFail = true;+ const safeBridge = new LearningBridge(backend);++ const patterns = await safeBridge.findSimilarPatterns('test');++ expect(patterns).toHaveLength(0);+ safeBridge.destroy();+ });++ it('should map results to PatternMatch format', async () => {+ mockNeuralSystem.findPatterns.mockResolvedValueOnce([+ { data: 'Raw data', score: 0.85, reward: 0.7 },+ ]);++ const patterns = await bridge.findSimilarPatterns('test');++ expect(patterns).toHaveLength(1);+ expect(patterns[0].content).toBe('Raw data');+ expect(patterns[0].similarity).toBe(0.85);+ expect(patterns[0].confidence).toBe(0.7);+ expect(patterns[0].category).toBe('unknown');+ });++ it('should pass k parameter to neural', async () => {+ await bridge.findSimilarPatterns('test', 3);++ expect(mockNeuralSystem.findPatterns).toHaveBeenCalledWith(+ expect.any(Float32Array),+ 3,+ );+ });++ it('should handle findPatterns throwing', async () => {+ mockNeuralSystem.findPatterns.mockRejectedValueOnce(new Error('Neural error'));++ const patterns = await bridge.findSimilarPatterns('test');++ expect(patterns).toHaveLength(0);+ });++ it('should handle non-array result from findPatterns', async () => {+ mockNeuralSystem.findPatterns.mockResolvedValueOnce(null);++ const patterns = await bridge.findSimilarPatterns('test');++ expect(patterns).toHaveLength(0);+ });+ });++ // ===== getStats =====++ describe('getStats', () => {+ it('should return correct initial stats', () => {+ const stats = bridge.getStats();++ expect(stats.totalTrajectories).toBe(0);+ expect(stats.completedTrajectories).toBe(0);+ expect(stats.activeTrajectories).toBe(0);+ expect(stats.totalConsolidations).toBe(0);+ expect(stats.totalDecays).toBe(0);+ expect(stats.avgConfidenceBoost).toBe(0);+ });++ it('should reflect operations in stats', async () => {+ // Record an insight to get a trajectory+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ let stats = bridge.getStats();+ expect(stats.totalTrajectories).toBe(1);+ expect(stats.activeTrajectories).toBe(1);+ expect(stats.neuralAvailable).toBe(true);++ // Access to get boost stats+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });+ (backend.get as any).mockResolvedValueOnce(entry);+ await bridge.onInsightAccessed('entry-1');++ stats = bridge.getStats();+ expect(stats.avgConfidenceBoost).toBeCloseTo(0.03, 5);+ });++ it('should show neuralAvailable=false before init', () => {+ const fresh = new LearningBridge(backend);+ expect(fresh.getStats().neuralAvailable).toBe(false);+ fresh.destroy();+ });+ });++ // ===== destroy =====++ describe('destroy', () => {+ it('should set destroyed state', async () => {+ bridge.destroy();++ // Subsequent operations should no-op+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();+ });++ it('should clear trajectories', async () => {+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ expect(bridge.getStats().activeTrajectories).toBe(1);++ bridge.destroy();++ expect(bridge.getStats().activeTrajectories).toBe(0);+ });++ it('should make subsequent onInsightRecorded no-op', async () => {+ bridge.destroy();++ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');++ expect(bridge.getStats().totalTrajectories).toBe(0);+ });++ it('should make subsequent onInsightAccessed no-op', async () => {+ bridge.destroy();++ await bridge.onInsightAccessed('entry-1');++ expect(backend.get).not.toHaveBeenCalled();+ });++ it('should make subsequent consolidate no-op', async () => {+ bridge.destroy();++ const result = await bridge.consolidate();++ expect(result.trajectoriesCompleted).toBe(0);+ });++ it('should make subsequent decayConfidences no-op', async () => {+ bridge.destroy();++ const count = await bridge.decayConfidences('learnings');++ expect(count).toBe(0);+ });++ it('should make subsequent findSimilarPatterns no-op', async () => {+ bridge.destroy();++ const patterns = await bridge.findSimilarPatterns('test');++ expect(patterns).toHaveLength(0);+ });++ it('should call neural cleanup if available', async () => {+ // Trigger neural init+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ vi.clearAllMocks();++ bridge.destroy();++ expect(mockNeuralSystem.cleanup).toHaveBeenCalled();+ });++ it('should remove all event listeners', () => {+ bridge.on('insight:learning-started', () => {});+ bridge.on('consolidation:completed', () => {});++ bridge.destroy();++ expect(bridge.listenerCount('insight:learning-started')).toBe(0);+ expect(bridge.listenerCount('consolidation:completed')).toBe(0);+ });+ });++ // ===== Neural init caching =====++ describe('neural initialization', () => {+ it('should only attempt neural import once', async () => {+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');+ await bridge.onInsightRecorded(createTestInsight({ summary: 'Second' }), 'entry-2');++ // NeuralLearningSystem constructor should only be called once+ const neuralMod = await import('@claude-flow/neural');+ expect(neuralMod.NeuralLearningSystem).toHaveBeenCalledTimes(1);+ });++ it('should cache failed init and not retry', async () => {+ neuralImportShouldFail = true;+ const safeBridge = new LearningBridge(backend);++ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-1');+ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-2');++ // Both calls should complete without error+ expect(safeBridge.getStats().neuralAvailable).toBe(false);+ safeBridge.destroy();+ });+ });+});