@timmeck/brain 1.0.0

package/tests/fixtures/code-modules/modules.ts

@@ -0,0 +1,83 @@
+export const retryModule = {
+  name: 'retry',
+  language: 'typescript',
+  filePath: 'src/utils/retry.ts',
+  source: `export async function retry<T>(
+  fn: () => Promise<T>,
+  maxAttempts: number = 3,
+  delayMs: number = 1000,
+): Promise<T> {
+  let lastError: Error | undefined;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt < maxAttempts) {
+        await new Promise(r => setTimeout(r, delayMs * attempt));
+      }
+    }
+  }
+  throw lastError;
+}`,
+  description: 'Retry function with exponential backoff',
+};
+
+export const loggerModule = {
+  name: 'logger',
+  language: 'typescript',
+  filePath: 'src/utils/logger.ts',
+  source: `import winston from 'winston';
+
+export function createLogger(name: string, level: string = 'info') {
+  return winston.createLogger({
+    level,
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.printf(({ timestamp, level, message }) =>
+        \`[\${timestamp}] [\${level}] [\${name}] \${message}\`
+      ),
+    ),
+    transports: [new winston.transports.Console()],
+  });
+}`,
+  description: 'Winston logger factory with timestamp formatting',
+};
+
+export const hashModule = {
+  name: 'hash',
+  language: 'python',
+  filePath: 'utils/hash.py',
+  source: `import hashlib
+
+def sha256(data: str) -> str:
+    return hashlib.sha256(data.encode()).hexdigest()
+
+def md5(data: str) -> str:
+    return hashlib.md5(data.encode()).hexdigest()
+`,
+  description: 'Hash utility functions',
+};
+
+export const similarRetryModule = {
+  name: 'retryWithBackoff',
+  language: 'typescript',
+  filePath: 'lib/retry-with-backoff.ts',
+  source: `export async function retryWithBackoff<T>(
+  operation: () => Promise<T>,
+  retries: number = 3,
+  baseDelay: number = 500,
+): Promise<T> {
+  let error: Error | undefined;
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await operation();
+    } catch (e) {
+      error = e instanceof Error ? e : new Error(String(e));
+      await new Promise(r => setTimeout(r, baseDelay * Math.pow(2, i)));
+    }
+  }
+  throw error;
+}`,
+  description: 'Retry with exponential backoff',
+};

package/tests/fixtures/errors/go.ts

@@ -0,0 +1,9 @@
+export const goCompileError = `./main.go:15:2: undefined: fmt.Prinln
+./main.go:20:5: cannot use "hello" (untyped string constant) as int value in assignment`;
+
+export const goPanicError = `goroutine 1 [running]:
+main.main()
+	/app/main.go:12 +0x40
+panic: runtime error: index out of range [5] with length 3`;
+
+export const goTypeError = `./handler.go:25:15: cannot convert result (variable of type string) to type int`;

package/tests/fixtures/errors/node.ts

@@ -0,0 +1,24 @@
+export const nodeTypeError = `TypeError: Cannot read properties of undefined (reading 'map')
+    at UserList (/app/src/components/UserList.tsx:15:23)
+    at renderWithHooks (/app/node_modules/react-dom/cjs/react-dom.development.js:14985:18)
+    at mountIndeterminateComponent (/app/node_modules/react-dom/cjs/react-dom.development.js:17811:13)`;
+
+export const nodeModuleNotFound = `Error: Cannot find module './config'
+Require stack:
+- /app/src/server.ts
+- /app/src/index.ts
+    at Function.Module._resolveFilename (node:internal/modules/cjs/loader:995:15)
+    at Function.Module._load (node:internal/modules/cjs/loader:841:27)`;
+
+export const nodeReferenceError = `ReferenceError: process is not defined
+    at Object.<anonymous> (/app/src/utils/env.ts:3:18)
+    at Module._compile (node:internal/modules/cjs/loader:1234:14)`;
+
+export const nodeSyntaxError = `SyntaxError: Unexpected token '}'
+    at wrapSafe (node:internal/modules/cjs/loader:1278:20)
+    at Module._compile (node:internal/modules/cjs/loader:1320:27)
+    at /app/src/parser.ts:42:5`;
+
+export const nodeEnoent = `Error: ENOENT: no such file or directory, open '/app/data/config.json'
+    at Object.openSync (node:fs:600:3)
+    at Object.readFileSync (node:fs:468:35)`;

package/tests/fixtures/errors/python.ts

@@ -0,0 +1,21 @@
+export const pythonTraceback = `Traceback (most recent call last):
+  File "/app/main.py", line 42, in <module>
+    result = process_data(data)
+  File "/app/processor.py", line 15, in process_data
+    return data["key"]["nested"]
+KeyError: 'nested'`;
+
+export const pythonImportError = `Traceback (most recent call last):
+  File "/app/server.py", line 1, in <module>
+    from flask import Flask
+ModuleNotFoundError: No module named 'flask'`;
+
+export const pythonTypeError = `Traceback (most recent call last):
+  File "/app/calc.py", line 10, in compute
+    return x + y
+TypeError: unsupported operand type(s) for +: 'int' and 'str'`;
+
+export const pythonValueError = `Traceback (most recent call last):
+  File "/app/parser.py", line 25, in parse_int
+    return int(value)
+ValueError: invalid literal for int() with base 10: 'abc'`;

package/tests/fixtures/errors/rust.ts

@@ -0,0 +1,25 @@
+export const rustCompilerError = `error[E0308]: mismatched types
+ --> src/main.rs:10:5
+  |
+9 | fn get_count() -> u32 {
+  |                   --- expected \`u32\` because of return type
+10|     "hello"
+  |     ^^^^^^^ expected \`u32\`, found \`&str\``;
+
+export const rustBorrowError = `error[E0502]: cannot borrow \`v\` as mutable because it is also borrowed as immutable
+ --> src/main.rs:6:5
+  |
+4 |     let first = &v[0];
+  |                  - immutable borrow occurs here
+5 |
+6 |     v.push(4);
+  |     ^^^^^^^^^ mutable borrow occurs here
+7 |
+8 |     println!("{}", first);
+  |                    ----- immutable borrow later used here`;
+
+export const rustLifetimeError = `error[E0106]: missing lifetime specifier
+ --> src/lib.rs:5:16
+  |
+5 | fn longest(x: &str, y: &str) -> &str {
+  |               ----     ----     ^ expected named lifetime parameter`;

package/tests/fixtures/errors/shell.ts

@@ -0,0 +1,15 @@
+export const shellCommandNotFound = `bash: docker-compose: command not found`;
+
+export const shellPermissionDenied = `bash: ./deploy.sh: Permission denied`;
+
+export const npmError = `npm ERR! code ERESOLVE
+npm ERR! ERESOLVE unable to resolve dependency tree
+npm ERR!
+npm ERR! While resolving: my-app@1.0.0
+npm ERR! Found: react@18.2.0
+npm ERR! node_modules/react
+npm ERR!   react@"^18.2.0" from the root project`;
+
+export const buildFailed = `BUILD FAILED in 2.3s
+Error: Module build failed (from ./node_modules/ts-loader/index.js):
+Error: TypeScript compilation failed`;

package/tests/fixtures/solutions/solutions.ts

@@ -0,0 +1,27 @@
+export const solutionFixtures = [
+  {
+    description: 'Add null check before accessing .map() on potentially undefined array',
+    commands: '',
+    codeChange: 'const items = data?.items ?? [];\nconst mapped = items.map(fn);',
+  },
+  {
+    description: 'Install missing module with npm install',
+    commands: 'npm install flask',
+    codeChange: '',
+  },
+  {
+    description: 'Fix type mismatch by converting string to number',
+    commands: '',
+    codeChange: 'return parseInt(value, 10);',
+  },
+  {
+    description: 'Add missing lifetime annotation to function signature',
+    commands: '',
+    codeChange: "fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {",
+  },
+  {
+    description: 'Grant execute permission to script',
+    commands: 'chmod +x deploy.sh',
+    codeChange: '',
+  },
+];

package/tests/helpers/setup-db.ts

@@ -0,0 +1,52 @@
+import Database from 'better-sqlite3';
+import { runMigrations } from '../../src/db/migrations/index.js';
+import { ProjectRepository } from '../../src/db/repositories/project.repository.js';
+import { ErrorRepository } from '../../src/db/repositories/error.repository.js';
+import { SolutionRepository } from '../../src/db/repositories/solution.repository.js';
+import { RuleRepository } from '../../src/db/repositories/rule.repository.js';
+import { AntipatternRepository } from '../../src/db/repositories/antipattern.repository.js';
+import { TerminalRepository } from '../../src/db/repositories/terminal.repository.js';
+import { CodeModuleRepository } from '../../src/db/repositories/code-module.repository.js';
+import { SynapseRepository } from '../../src/db/repositories/synapse.repository.js';
+import { NotificationRepository } from '../../src/db/repositories/notification.repository.js';
+import { InsightRepository } from '../../src/db/repositories/insight.repository.js';
+
+export interface TestDb {
+  db: Database.Database;
+  repos: {
+    project: ProjectRepository;
+    error: ErrorRepository;
+    solution: SolutionRepository;
+    rule: RuleRepository;
+    antipattern: AntipatternRepository;
+    terminal: TerminalRepository;
+    codeModule: CodeModuleRepository;
+    synapse: SynapseRepository;
+    notification: NotificationRepository;
+    insight: InsightRepository;
+  };
+}
+
+export function createTestDb(): TestDb {
+  const db = new Database(':memory:');
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  runMigrations(db);
+
+  return {
+    db,
+    repos: {
+      project: new ProjectRepository(db),
+      error: new ErrorRepository(db),
+      solution: new SolutionRepository(db),
+      rule: new RuleRepository(db),
+      antipattern: new AntipatternRepository(db),
+      terminal: new TerminalRepository(db),
+      codeModule: new CodeModuleRepository(db),
+      synapse: new SynapseRepository(db),
+      notification: new NotificationRepository(db),
+      insight: new InsightRepository(db),
+    },
+  };
+}

package/tests/integration/code-flow.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDb, type TestDb } from '../helpers/setup-db.js';
+import { CodeService } from '../../src/services/code.service.js';
+import { SynapseManager } from '../../src/synapses/synapse-manager.js';
+import { retryModule, hashModule } from '../fixtures/code-modules/modules.js';
+
+const synapsesConfig = {
+  initialWeight: 0.1,
+  learningRate: 0.15,
+  decayHalfLifeDays: 45,
+  pruneThreshold: 0.05,
+  decayAfterDays: 14,
+  maxDepth: 3,
+  minActivationWeight: 0.2,
+};
+
+describe('Code Flow Integration', () => {
+  let testDb: TestDb;
+  let codeService: CodeService;
+
+  beforeEach(() => {
+    testDb = createTestDb();
+    const synapseManager = new SynapseManager(testDb.repos.synapse, synapsesConfig);
+    codeService = new CodeService(testDb.repos.codeModule, testDb.repos.project, synapseManager);
+  });
+
+  it('registers a code module and retrieves it', () => {
+    const result = codeService.analyzeAndRegister({
+      project: 'utils-lib',
+      name: retryModule.name,
+      filePath: retryModule.filePath,
+      language: retryModule.language,
+      source: retryModule.source,
+      description: retryModule.description,
+    });
+
+    expect(result.moduleId).toBeTruthy();
+    expect(result.isNew).toBe(true);
+    expect(result.reusabilityScore).toBeGreaterThan(0);
+
+    const mod = codeService.getById(result.moduleId);
+    expect(mod).toBeTruthy();
+  });
+
+  it('finds reusable modules by query', () => {
+    codeService.analyzeAndRegister({
+      project: 'utils-lib',
+      name: retryModule.name,
+      filePath: retryModule.filePath,
+      language: retryModule.language,
+      source: retryModule.source,
+      description: retryModule.description,
+    });
+
+    const results = codeService.findReusable({ query: 'retry backoff' });
+    // FTS matching may or may not find results
+    expect(results).toBeDefined();
+  });
+
+  it('lists all modules', () => {
+    codeService.analyzeAndRegister({
+      project: 'project-a',
+      name: retryModule.name,
+      filePath: retryModule.filePath,
+      language: retryModule.language,
+      source: retryModule.source,
+    });
+
+    // listModules requires a projectId — project is created with id=1 by analyzeAndRegister
+    const modules = codeService.listModules(1);
+    expect(modules.length).toBe(1);
+  });
+
+  it('detects similar code', () => {
+    codeService.analyzeAndRegister({
+      project: 'project-a',
+      name: retryModule.name,
+      filePath: retryModule.filePath,
+      language: retryModule.language,
+      source: retryModule.source,
+    });
+
+    const similarities = codeService.checkSimilarity(retryModule.source, 'typescript');
+    expect(similarities).toBeDefined();
+  });
+});

package/tests/integration/error-flow.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDb, type TestDb } from '../helpers/setup-db.js';
+import { ErrorService } from '../../src/services/error.service.js';
+import { SolutionService } from '../../src/services/solution.service.js';
+import { SynapseManager } from '../../src/synapses/synapse-manager.js';
+
+const synapsesConfig = {
+  initialWeight: 0.1,
+  learningRate: 0.15,
+  decayHalfLifeDays: 45,
+  pruneThreshold: 0.05,
+  decayAfterDays: 14,
+  maxDepth: 3,
+  minActivationWeight: 0.2,
+};
+
+describe('Error Flow Integration', () => {
+  let testDb: TestDb;
+  let errorService: ErrorService;
+  let solutionService: SolutionService;
+  let synapseManager: SynapseManager;
+
+  beforeEach(() => {
+    testDb = createTestDb();
+    synapseManager = new SynapseManager(testDb.repos.synapse, synapsesConfig);
+    errorService = new ErrorService(testDb.repos.error, testDb.repos.project, synapseManager);
+    solutionService = new SolutionService(testDb.repos.solution, synapseManager);
+  });
+
+  it('reports error and queries it back', () => {
+    const result = errorService.report({
+      project: 'test-project',
+      errorOutput: "TypeError: Cannot read properties of undefined (reading 'map')",
+    });
+    expect(result.errorId).toBeTruthy();
+    expect(result.isNew).toBe(true);
+
+    const errors = errorService.query({ resolved: false });
+    expect(errors.length).toBe(1);
+  });
+
+  it('adds and finds solutions for errors', () => {
+    const errResult = errorService.report({
+      project: 'test-project',
+      errorOutput: "TypeError: Cannot read properties of undefined",
+    });
+
+    const solutionId = solutionService.report({
+      errorId: errResult.errorId,
+      description: 'Add null check before accessing .map()',
+    });
+    expect(solutionId).toBeTruthy();
+
+    const solutions = solutionService.findForError(errResult.errorId);
+    expect(solutions.length).toBeGreaterThanOrEqual(0); // may need error_solution join
+  });
+
+  it('matches similar errors', () => {
+    const first = errorService.report({
+      project: 'project-a',
+      errorOutput: "TypeError: Cannot read properties of undefined (reading 'map')",
+    });
+
+    const second = errorService.report({
+      project: 'project-a',
+      errorOutput: "TypeError: Cannot read properties of undefined (reading 'filter')",
+    });
+
+    const matches = errorService.matchSimilar(second.errorId);
+    expect(matches).toBeDefined();
+  });
+
+  it('creates project on first error report', () => {
+    errorService.report({
+      project: 'new-project',
+      errorOutput: 'Error: something broke',
+    });
+
+    const projects = testDb.repos.project.getAll();
+    expect(projects.length).toBe(1);
+    expect(projects[0].name).toBe('new-project');
+  });
+});

package/tests/integration/ipc-flow.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { encodeMessage, MessageDecoder } from '../../src/ipc/protocol.js';
+import type { IpcMessage } from '../../src/types/ipc.types.js';
+
+describe('IPC Protocol', () => {
+  it('round-trips a request message', () => {
+    const msg: IpcMessage = {
+      id: 'test-123',
+      type: 'request',
+      method: 'error.report',
+      params: { project: 'test', errorOutput: 'Error: something' },
+    };
+
+    const encoded = encodeMessage(msg);
+    const decoder = new MessageDecoder();
+    const decoded = decoder.feed(encoded);
+
+    expect(decoded.length).toBe(1);
+    expect(decoded[0].id).toBe('test-123');
+    expect(decoded[0].type).toBe('request');
+    expect(decoded[0].method).toBe('error.report');
+    expect(decoded[0].params).toEqual(msg.params);
+  });
+
+  it('round-trips a response message', () => {
+    const msg: IpcMessage = {
+      id: 'test-456',
+      type: 'response',
+      result: { errorId: 42, isNew: true },
+    };
+
+    const encoded = encodeMessage(msg);
+    const decoder = new MessageDecoder();
+    const decoded = decoder.feed(encoded);
+
+    expect(decoded.length).toBe(1);
+    expect(decoded[0].result).toEqual({ errorId: 42, isNew: true });
+  });
+
+  it('round-trips an error response', () => {
+    const msg: IpcMessage = {
+      id: 'test-789',
+      type: 'response',
+      error: { code: -1, message: 'Unknown method' },
+    };
+
+    const encoded = encodeMessage(msg);
+    const decoder = new MessageDecoder();
+    const decoded = decoder.feed(encoded);
+
+    expect(decoded[0].error?.code).toBe(-1);
+    expect(decoded[0].error?.message).toBe('Unknown method');
+  });
+
+  it('handles multiple messages in one feed', () => {
+    const msg1: IpcMessage = { id: '1', type: 'request', method: 'a' };
+    const msg2: IpcMessage = { id: '2', type: 'request', method: 'b' };
+
+    const buf = Buffer.concat([encodeMessage(msg1), encodeMessage(msg2)]);
+    const decoder = new MessageDecoder();
+    const decoded = decoder.feed(buf);
+
+    expect(decoded.length).toBe(2);
+    expect(decoded[0].id).toBe('1');
+    expect(decoded[1].id).toBe('2');
+  });
+
+  it('handles partial messages across feeds', () => {
+    const msg: IpcMessage = { id: 'partial', type: 'request', method: 'test' };
+    const encoded = encodeMessage(msg);
+
+    const decoder = new MessageDecoder();
+    // Split buffer in half
+    const mid = Math.floor(encoded.length / 2);
+    const part1 = encoded.subarray(0, mid);
+    const part2 = encoded.subarray(mid);
+
+    const decoded1 = decoder.feed(part1);
+    expect(decoded1.length).toBe(0); // incomplete
+
+    const decoded2 = decoder.feed(part2);
+    expect(decoded2.length).toBe(1);
+    expect(decoded2[0].id).toBe('partial');
+  });
+
+  it('decoder reset clears buffer', () => {
+    const msg: IpcMessage = { id: 'x', type: 'request', method: 'y' };
+    const encoded = encodeMessage(msg);
+    const partial = encoded.subarray(0, 5);
+
+    const decoder = new MessageDecoder();
+    decoder.feed(partial);
+    decoder.reset();
+
+    // After reset, feeding a complete message should work
+    const decoded = decoder.feed(encodeMessage(msg));
+    expect(decoded.length).toBe(1);
+  });
+});
+
+describe('IPC Router', () => {
+  it('routes methods to services', async () => {
+    const { createTestDb } = await import('../helpers/setup-db.js');
+    const { IpcRouter } = await import('../../src/ipc/router.js');
+    const { ErrorService } = await import('../../src/services/error.service.js');
+    const { SolutionService } = await import('../../src/services/solution.service.js');
+    const { TerminalService } = await import('../../src/services/terminal.service.js');
+    const { PreventionService } = await import('../../src/services/prevention.service.js');
+    const { CodeService } = await import('../../src/services/code.service.js');
+    const { SynapseService } = await import('../../src/services/synapse.service.js');
+    const { ResearchService } = await import('../../src/services/research.service.js');
+    const { NotificationService } = await import('../../src/services/notification.service.js');
+    const { AnalyticsService } = await import('../../src/services/analytics.service.js');
+    const { SynapseManager } = await import('../../src/synapses/synapse-manager.js');
+
+    const testDb = createTestDb();
+    const synapsesConfig = {
+      initialWeight: 0.1, learningRate: 0.15, decayHalfLifeDays: 45,
+      pruneThreshold: 0.05, decayAfterDays: 14, maxDepth: 3, minActivationWeight: 0.2,
+    };
+    const sm = new SynapseManager(testDb.repos.synapse, synapsesConfig);
+
+    const services = {
+      error: new ErrorService(testDb.repos.error, testDb.repos.project, sm),
+      solution: new SolutionService(testDb.repos.solution, sm),
+      terminal: new TerminalService(testDb.repos.terminal, 300000),
+      prevention: new PreventionService(testDb.repos.rule, testDb.repos.antipattern, sm),
+      code: new CodeService(testDb.repos.codeModule, testDb.repos.project, sm),
+      synapse: new SynapseService(sm),
+      research: new ResearchService(testDb.repos.insight, testDb.repos.error, sm),
+      notification: new NotificationService(testDb.repos.notification),
+      analytics: new AnalyticsService(
+        testDb.repos.error, testDb.repos.solution, testDb.repos.codeModule,
+        testDb.repos.rule, testDb.repos.antipattern, testDb.repos.insight, sm,
+      ),
+    };
+
+    const router = new IpcRouter(services);
+
+    // Test analytics.summary
+    const summary = router.handle('analytics.summary', {});
+    expect(summary).toBeTruthy();
+
+    // Test synapse.stats
+    const stats = router.handle('synapse.stats', {});
+    expect(stats).toBeTruthy();
+
+    // Test error.report
+    const result = router.handle('error.report', {
+      project: 'test',
+      errorOutput: 'Error: test error',
+    }) as any;
+    expect(result.errorId).toBeTruthy();
+
+    // Test unknown method throws
+    expect(() => router.handle('nonexistent.method', {})).toThrow('Unknown method');
+
+    // Test listMethods
+    const methods = router.listMethods();
+    expect(methods.length).toBeGreaterThan(20);
+    expect(methods).toContain('error.report');
+    expect(methods).toContain('analytics.summary');
+
+    testDb.db.close();
+  });
+});

package/tests/integration/learning-cycle.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDb, type TestDb } from '../helpers/setup-db.js';
+import { LearningEngine } from '../../src/learning/learning-engine.js';
+import { SynapseManager } from '../../src/synapses/synapse-manager.js';
+
+const learningConfig = {
+  intervalMs: 900000,
+  minOccurrences: 3,
+  minSuccessRate: 0.7,
+  minConfidence: 0.6,
+  pruneThreshold: 0.2,
+  maxRejectionRate: 0.5,
+  decayHalfLifeDays: 30,
+};
+
+const synapsesConfig = {
+  initialWeight: 0.1,
+  learningRate: 0.15,
+  decayHalfLifeDays: 45,
+  pruneThreshold: 0.05,
+  decayAfterDays: 14,
+  maxDepth: 3,
+  minActivationWeight: 0.2,
+};
+
+describe('Learning Cycle Integration', () => {
+  let testDb: TestDb;
+  let learningEngine: LearningEngine;
+
+  beforeEach(() => {
+    testDb = createTestDb();
+    const synapseManager = new SynapseManager(testDb.repos.synapse, synapsesConfig);
+
+    learningEngine = new LearningEngine(
+      learningConfig,
+      testDb.repos.error,
+      testDb.repos.solution,
+      testDb.repos.rule,
+      testDb.repos.antipattern,
+      synapseManager,
+    );
+
+    // Seed data
+    testDb.repos.project.create({ name: 'test', path: '/test' } as any);
+    for (let i = 0; i < 5; i++) {
+      testDb.repos.error.create({
+        project_id: 1,
+        terminal_id: null,
+        type: 'TypeError',
+        message: "Cannot read properties of undefined (reading 'map')",
+        fingerprint: 'fp_type_error',
+        raw_output: `TypeError: Cannot read properties of undefined`,
+        context: null,
+        file_path: null,
+        line_number: null,
+        column_number: null,
+      } as any);
+    }
+  });
+
+  it('runs a learning cycle without error', () => {
+    const result = learningEngine.runCycle();
+    expect(result).toBeTruthy();
+    expect(typeof result.newPatterns).toBe('number');
+    expect(typeof result.updatedRules).toBe('number');
+    expect(typeof result.prunedRules).toBe('number');
+    expect(typeof result.duration).toBe('number');
+    expect(result.duration).toBeGreaterThan(0);
+  });
+
+  it('tracks last cycle time', () => {
+    expect(learningEngine.getLastCycleAt()).toBeNull();
+    learningEngine.runCycle();
+    expect(learningEngine.getLastCycleAt()).toBeTruthy();
+  });
+
+  it('start/stop controls scheduling', () => {
+    learningEngine.start();
+    learningEngine.stop();
+    // Should not throw
+  });
+});