genesis-ai-cli 7.4.5

package/dist/src/active-inference/integration.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Genesis 6.1 - Active Inference Integration
+ *
+ * Connects Active Inference to Kernel and Daemon for real autonomous operation.
+ *
+ * This module:
+ * - Bridges observations from Kernel state (energy, task status, agents)
+ * - Connects actions to Kernel operations (submit tasks, manage energy)
+ * - Registers Active Inference as a daemon scheduled task
+ *
+ * Usage:
+ * ```typescript
+ * import { integrateActiveInference } from './active-inference/integration.js';
+ * import { getKernel } from './kernel/index.js';
+ * import { getDaemon } from './daemon/index.js';
+ *
+ * const kernel = getKernel();
+ * const daemon = getDaemon();
+ *
+ * // Connect everything
+ * const aiLoop = integrateActiveInference(kernel, daemon, {
+ *   enableDaemonTask: true,
+ *   cycleInterval: 5000,
+ * });
+ *
+ * // Or run manually
+ * await aiLoop.run(100);
+ * ```
+ */
+import { AutonomousLoop } from './autonomous-loop.js';
+import { ObservationGatherer, KernelState, PhiState, SensorResult, WorldModelState } from './observations.js';
+import type { Kernel } from '../kernel/index.js';
+import type { Daemon } from '../daemon/index.js';
+export interface IntegrationConfig {
+    cycleInterval: number;
+    maxCycles: number;
+    enableDaemonTask: boolean;
+    daemonTaskInterval: number;
+    daemonTaskPriority: 'low' | 'normal' | 'high' | 'critical';
+    stopOnDormant: boolean;
+    stopOnError: boolean;
+    verbose: boolean;
+}
+export declare const DEFAULT_INTEGRATION_CONFIG: IntegrationConfig;
+/**
+ * Creates an observation gatherer connected to Kernel state
+ */
+export declare function createKernelObservationBridge(kernel: Kernel): ObservationGatherer;
+/**
+ * Registers action executors that connect to Kernel operations
+ */
+export declare function registerKernelActions(kernel: Kernel): void;
+/**
+ * Registers Active Inference as a daemon scheduled task
+ */
+export declare function registerDaemonTask(daemon: Daemon, loop: AutonomousLoop, config: IntegrationConfig): void;
+/**
+ * Integrates Active Inference with Kernel and Daemon
+ *
+ * @param kernel - The Genesis Kernel instance
+ * @param daemon - The Genesis Daemon instance (optional)
+ * @param config - Integration configuration
+ * @returns Configured AutonomousLoop
+ */
+export declare function integrateActiveInference(kernel: Kernel, daemon?: Daemon, config?: Partial<IntegrationConfig>): AutonomousLoop;
+export interface IntegratedSystem {
+    kernel: Kernel;
+    daemon: Daemon;
+    loop: AutonomousLoop;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    status: () => {
+        kernel: ReturnType<Kernel['getStatus']>;
+        daemon: ReturnType<Daemon['status']>;
+        inference: {
+            running: boolean;
+            cycles: number;
+            beliefs: ReturnType<AutonomousLoop['getMostLikelyState']>;
+        };
+    };
+}
+/**
+ * Create a fully integrated autonomous system
+ */
+export declare function createIntegratedSystem(config?: Partial<IntegrationConfig>): Promise<IntegratedSystem>;
+export interface MCPObservationConfig {
+    verbose: boolean;
+}
+/**
+ * Creates observation sources backed by real MCP calls
+ *
+ * Maps MCPs to observations:
+ * - memory.read_graph → energy (from entity state) + worldModel coherence
+ * - brave-search → tool perception (latency, success)
+ * - gemini → phi state (from search activity)
+ */
+export declare function createMCPObservationBridge(config?: Partial<MCPObservationConfig>): Promise<{
+    kernelState: () => KernelState;
+    phiState: () => PhiState;
+    sensorResult: () => Promise<SensorResult>;
+    worldModelState: () => WorldModelState;
+    lastMCPResults: () => {
+        memory: any;
+        search: any;
+        latencies: Record<string, number>;
+    };
+}>;
+/**
+ * Create Active Inference loop with real MCP observations
+ */
+export declare function createMCPInferenceLoop(config?: Partial<IntegrationConfig & MCPObservationConfig>): Promise<{
+    loop: AutonomousLoop;
+    mcpBridge: Awaited<ReturnType<typeof createMCPObservationBridge>>;
+}>;