"""CPU coupled graph/Tidal actor. Bridge and motor heads start untrained. Features v1: graph 0:32, donor 32:48, memory 48:56, compass 56:64. Resource mapping is an explicit synthetic adapter, not measured animal physiology. """ from copy import deepcopy import numpy as np import torch from torch import nn from torch.nn import functional as F from . import sources from .config import ARTIFACTS from graftbrain.brain import GraftedBrain from graftbrain.connectomes import make_proxy from graftbrain.graft import build from graftbrain.neuro_modules import MushroomBody, CentralComplexCompass, CuriosityRND from graftbrain.plasticity import GraftPlasticity, PlasticityConfig from poseidon.core import load_checkpoint from .neuromodulation import NeuromodulatoryEngine, NeuromodulatorState from .astrocyte import AstrocyteNetwork from .predictive_coding import PredictiveCodingEngine from .vision_encoder import TrainableVisualEncoder from .experience import ExperienceWorldModel, encode_experience_state from .surprise_memory import SurpriseEpisodicMemory from .homeostasis import HomeostaticEngine from .neurogenesis import ConnectomeNeurogenesisEngine from .mimomix_reasoner import MiMoMixCognitiveCore, MiMoMixReasoningTrace from .dormant_lifecycle import DormantLifecycleManager from .fast_weight_memory import UniversalFastWeightMemory from .latent_reasoner import ContinuousLatentReasoner from .actions import TURN, govern_action from .self_model import EfferenceCopyComparator class AcquiringMushroomBody(MushroomBody): def forward(self,cue_vec,adapt=True): out=super().forward(cue_vec,adapt=False) if adapt: raw=F.linear(cue_vec,self.w_claw) values,indices=torch.topk(raw,self.k_sparse) kc=torch.zeros_like(raw).scatter_(0,indices,F.relu(values)) self.kc_act.copy_(kc.detach()) # Presynaptic eligibility permits learning from neutral MBON weights. self.elig.mul_(.85).add_(kc.detach().expand(self.n_mbon,-1)) return out class IntegratedAgent: feature_schema={'version':1,'dimension':64,'graph':[0,32],'donor':[32,48],'memory':[48,56],'context':[56,64]} def __init__(self,config): self.config=config from .compute import configure_torch self.compute=configure_torch(config.compute_threads) with torch.random.fork_rng(devices=[]): torch.manual_seed(config.seed) sources = getattr(config, 'connectome_sources', ('flywire', 'manc', 'optic-lobe')) if config.connectome_mode=='proxy': substrates=[make_proxy(p,n,config.seed) for p,n in zip(sources,config.source_node_counts())] else: from .connectome_assets import build_runtime_connectomes substrates=build_runtime_connectomes(config,strict=config.connectome_mode=='strict_authentic') self.graph=build(substrates,seed=config.seed) self.source_provenance=[deepcopy(getattr(c,'provenance',{'representation':'synthetic_proxy','dataset':name})) for c,name in zip(substrates,sources)] self.brain=GraftedBrain(self.graph,microsteps=config.microsteps,noise=0,seed=config.seed) self.plasticity=GraftPlasticity(self.graph,155,PlasticityConfig(mode='adaptive'),seed=config.seed) self.mb=AcquiringMushroomBody(4) self.compass=CentralComplexCompass() self.curiosity=CuriosityRND(155) self.neuromod=NeuromodulatoryEngine() self.astrocytes=AstrocyteNetwork(num_domains=len(sources)) self.predictive=PredictiveCodingEngine() self.vision_encoder=TrainableVisualEncoder(seed=config.seed) self.vis_to_sensory=nn.Linear(32,len(self.brain.sensory_idx),bias=False) # A small seeded projection gives camera input a measurable causal path. visual_generator=torch.Generator(device='cpu').manual_seed(config.seed+1907) nn.init.normal_(self.vis_to_sensory.weight,std=0.02,generator=visual_generator) self.tidal,self.receipt=load_checkpoint(ARTIFACTS/'tidal_core.pt') h=self.tidal.config.hidden_size self.encoder=nn.Linear(155+16+2,len(self.brain.sensory_idx)) self.donor_to_graph=nn.Linear(h+6,len(self.brain.sensory_idx),bias=False) self.graph_to_resource=nn.Linear(32,16,bias=False) self.motor=nn.Linear(64,5,bias=False) self.dormant_lifecycle=DormantLifecycleManager(num_slots=2,feature_dim=32,seed=config.seed) self.dormant=self.dormant_lifecycle.modules self.native=nn.Linear(32,32,bias=False) nn.init.zeros_(self.native.weight) self.mimomix=MiMoMixCognitiveCore(latent_dim=64,action_dim=5) self.latent_reasoner=(ContinuousLatentReasoner(latent_dim=64,action_dim=5) if getattr(config,'latent_reasoning',False) else None) for p in self.tidal.parameters(): p.requires_grad_(False) self.modules={'brain':self.brain,'plasticity':self.plasticity,'mb':self.mb,'curiosity':self.curiosity,'tidal':self.tidal,'encoder':self.encoder,'donor_to_graph':self.donor_to_graph,'graph_to_resource':self.graph_to_resource,'motor':self.motor,'dormant':self.dormant,'native':self.native,'vision_encoder':self.vision_encoder,'vis_to_sensory':self.vis_to_sensory,'predictive_network':self.predictive,'mimomix':self.mimomix} self.opt=torch.optim.Adam(self._optimization_parameters(),lr=3e-4) self.rng=np.random.default_rng(config.seed) self.experience_model=ExperienceWorldModel(state_dim=16,action_dim=5,ensemble_size=3,seed=config.seed,context_dim=2) self.surprise_memory=SurpriseEpisodicMemory() self.homeostasis=HomeostaticEngine(seed=config.seed) self.neurogenesis=ConnectomeNeurogenesisEngine(num_neurons=self.brain.n,seed=config.seed) if getattr(config,'continual_backprop',False): from .continual_backprop import ContinualBackpropEngine self.continual_backprop=ContinualBackpropEngine(num_neurons=self.brain.n,seed=config.seed) else: self.continual_backprop=None self.self_model=(EfferenceCopyComparator(sensory_dim=155,action_dim=5,seed=config.seed) if getattr(config,'self_model',False) else None) self.fast_weight_memory=(UniversalFastWeightMemory(in_dim=32,out_dim=32,seed=config.seed) if getattr(config,'fast_weight_memory',False) else None) self.dendritic_ltc=None self.oscillatory_coherence=None self.recurrent_planner=None self.diffusion_repair=None self.dpo_engine=None self.dvgem_memory=None self.tether_coordinator=None self.criticality_homeostat=None self.holographic_vsa=None self.apical_engine=None self.spectral_reservoir=None self.hyperbolic_manifold=None self.spiking_engine=None self.glymphatic_engine=None self.kuramoto_engine=None self.archimedes_engine=None self.memory_carrier_nexus=None self.cross_graft_engine=None self.comm_fabric=None self.overflow_mini_brain=None self.grafted_diffusion=None self.selective_ssm=None self.multitimescale=None self.meta_plasticity=None self.causal_world=None self.intervention_planner=None self.relational_memory=None self.event_backend=None self.graph_diffusion=None self.active_inference=None self.thermodynamics=None self.metaplasticity_bcm=None self.transfer_entropy=None self.neurowave_x2=None self._setup_frontier_extensions() self.preparation_updates=0; self.bridge_updates=0; self.episodic=[]; self.tool_memory=[] self._camera_consumed_any=False self.neural_graft=None self.programmed_prior_status={'enabled':False} self._setup_neural_graft() self.reset_episode() def _setup_frontier_extensions(self): with torch.random.fork_rng(devices=[]): torch.manual_seed(self.config.seed + 4099) if getattr(self.config, 'dendritic_ltc', False) and self.dendritic_ltc is None: from .dendritic_ltc import DendriticLiquidSubGraft self.dendritic_ltc = DendriticLiquidSubGraft(seed=self.config.seed) self.modules['dendritic_ltc'] = self.dendritic_ltc if getattr(self.config, 'oscillatory_coherence', False) and self.oscillatory_coherence is None: from .oscillatory_coherence import OscillatoryCoherenceEngine sources = getattr(self.config, 'connectome_sources', ('flywire', 'manc', 'optic-lobe')) self.oscillatory_coherence = OscillatoryCoherenceEngine(source_names=sources) if getattr(self.config, 'planner_algorithm', 'experience_mpc') in ('recurrent_latent', 'hybrid') and self.recurrent_planner is None: from .multistep_planner import MultistepRecurrentPlanner self.recurrent_planner = MultistepRecurrentPlanner(default_horizon=self.config.experience_horizon, seed=self.config.seed) if getattr(self.config, 'planner_algorithm', 'experience_mpc') == 'hybrid' and self.diffusion_repair is None: from .diffusion_repair import DiffusionRepairSidecar self.diffusion_repair = DiffusionRepairSidecar(feature_dim=5, seed=self.config.seed) if getattr(self.config, 'verifiable_dpo', False) and self.dpo_engine is None: from .preference_dpo import MachineVerifiableDPOEngine self.dpo_engine = MachineVerifiableDPOEngine(obs_dim=155, action_dim=5, seed=self.config.seed) if getattr(self.config, 'dvgem_memory', False) and self.dvgem_memory is None: from .dvgem_tether import DecisionValueEpisodicMemory self.dvgem_memory = DecisionValueEpisodicMemory(seed=self.config.seed) if getattr(self.config, 'tether_coordinator', False) and self.tether_coordinator is None: from .dvgem_tether import TetherSuccessorCoordinator self.tether_coordinator = TetherSuccessorCoordinator(seed=self.config.seed) if getattr(self.config, 'criticality_homeostat', False) and self.criticality_homeostat is None: from .criticality_vsa import CriticalityAvalancheEngine self.criticality_homeostat = CriticalityAvalancheEngine(seed=self.config.seed) if getattr(self.config, 'holographic_vsa', False) and self.holographic_vsa is None: from .criticality_vsa import HolographicVSAWorkingMemory self.holographic_vsa = HolographicVSAWorkingMemory(seed=self.config.seed) if getattr(self.config, 'apical_amplification', False) and getattr(self, 'apical_engine', None) is None: from .apical_amplification import ApicalAmplificationEngine self.apical_engine = ApicalAmplificationEngine(num_units=64, seed=self.config.seed) self.modules['apical_engine'] = self.apical_engine if getattr(self.config, 'spectral_reservoir', False) and getattr(self, 'spectral_reservoir', None) is None: from .spectral_reservoir import SpectralReservoirEngine self.spectral_reservoir = SpectralReservoirEngine(seed=self.config.seed) self.modules['spectral_reservoir'] = self.spectral_reservoir if getattr(self.config, 'hyperbolic_manifold', False) and getattr(self, 'hyperbolic_manifold', None) is None: from .hyperbolic_manifold import HyperbolicManifoldEngine self.hyperbolic_manifold = HyperbolicManifoldEngine(seed=self.config.seed) if getattr(self.config, 'spiking_neuromorphic', False) and getattr(self, 'spiking_engine', None) is None: from .spiking_neuromorphic import SpikingNeuromorphicEngine self.spiking_engine = SpikingNeuromorphicEngine(num_neurons=min(64, self.brain.n), seed=self.config.seed) self.modules['spiking_engine'] = self.spiking_engine if getattr(self.config, 'glymphatic_clearance', False) and getattr(self, 'glymphatic_engine', None) is None: from .glymphatic_clearance import GlymphaticClearanceEngine self.glymphatic_engine = GlymphaticClearanceEngine(seed=self.config.seed) self.modules['glymphatic_engine'] = self.glymphatic_engine if getattr(self.config, 'quantum_kuramoto', False) and getattr(self, 'kuramoto_engine', None) is None: from .quantum_kuramoto import QuantumKuramotoEngine self.kuramoto_engine = QuantumKuramotoEngine(num_oscillators=min(32, self.brain.n), seed=self.config.seed) self.modules['kuramoto_engine'] = self.kuramoto_engine if getattr(self.config, 'archimedes_buoyancy', False) and getattr(self, 'archimedes_engine', None) is None: from .archimedes_buoyancy import ArchimedesBuoyancyEngine self.archimedes_engine = ArchimedesBuoyancyEngine(seed=self.config.seed) self.modules['archimedes_engine'] = self.archimedes_engine if getattr(self.config, 'memory_carrier_nexus', False) and getattr(self, 'memory_carrier_nexus', None) is None: from .memory_carrier import MemoryCarrierNexus self.memory_carrier_nexus = MemoryCarrierNexus(dimension=min(64, self.brain.n), seed=self.config.seed) self.modules['memory_carrier_nexus'] = self.memory_carrier_nexus if getattr(self.config, 'cross_connectome_graft', False) and getattr(self, 'cross_graft_engine', None) is None: from .cross_graft import CrossConnectomeGraft self.cross_graft_engine = CrossConnectomeGraft(node_dim=min(64, self.brain.n), seed=self.config.seed) self.modules['cross_graft_engine'] = self.cross_graft_engine if getattr(self.config, 'neural_comm_enabled', False) and self.comm_fabric is None: from .neural_comm import NeuralCommFabric from .neural_comm_channels import CommChannelSpec comm_spec = CommChannelSpec( mode=getattr(self.config, 'neural_comm_mode', 'continuous'), message_dim=getattr(self.config, 'neural_comm_dim', 16), precision_bits=getattr(self.config, 'neural_comm_precision_bits', 32), packet_loss_probability=getattr(self.config, 'neural_comm_drop_rate', 0.0), max_latency_steps=getattr(self.config, 'neural_comm_latency_steps', 0), seed=self.config.seed, ) self.comm_fabric = NeuralCommFabric( self.graph, spec=comm_spec, enabled=True, max_aux_current=self.config.neural_comm_max_aux_current, topology_strategy=getattr(self.config, 'neural_comm_topology', 'hybrid_causal'), seed=self.config.seed, ) if getattr(self.config, 'neurowave_x2_enabled', False) and self.neurowave_x2 is None: from .neurowave_x2 import NeuroWaveX2Config, NeuroWaveX2Fabric nw_cfg = NeuroWaveX2Config( enabled=True, residual_gain=float(getattr(self.config, 'neurowave_x2_gamma', 0.0)), protocol=str(getattr(self.config, 'neurowave_x2_protocol', 'adaptive')), message_dimension=int(getattr(self.config, 'neurowave_x2_dimension', 16)), precision_bits=int(getattr(self.config, 'neurowave_x2_precision_bits', 32)), spectral_modes=int(getattr(self.config, 'neurowave_x2_spectral_modes', 8)), spectral_basis=str(getattr(self.config, 'neurowave_x2_spectral_basis', 'hybrid')), phase_enabled=bool(getattr(self.config, 'neurowave_x2_phase', True)), structural_plasticity=bool(getattr(self.config, 'neurowave_x2_plasticity', False)), development_mode=bool(getattr(self.config, 'neurowave_x2_development', False)), development_level=int(getattr(self.config, 'neurowave_x2_development_level', 0)), ) num_src = getattr(self.graph, 'num_sources', 8) or 8 self.neurowave_x2 = NeuroWaveX2Fabric( config=nw_cfg, num_regions=num_src, neurons_per_region=max(16, self.brain.n // max(1, num_src)), total_neurons=self.brain.n, seed=self.config.seed, ) if self.comm_fabric is None: self.comm_fabric = self.neurowave_x2 if getattr(self.config, 'overflow_mini_brain', False) and self.overflow_mini_brain is None: from .grafted_sections import OverflowMiniBrain self.overflow_mini_brain = OverflowMiniBrain(num_neurons=256, sensory_dim=155, motor_dim=5) self.modules['overflow_mini_brain'] = self.overflow_mini_brain if getattr(self.config, 'grafted_diffusion', False) and self.grafted_diffusion is None: from .grafted_sections import GraftedMiniDiffusionModel self.grafted_diffusion = GraftedMiniDiffusionModel(action_dim=5, cond_dim=64, num_steps=5) self.modules['grafted_diffusion'] = self.grafted_diffusion if getattr(self.config, 'selective_state_space', False) and self.selective_ssm is None: from .grafted_sections import SelectiveStateSpaceSection self.selective_ssm = SelectiveStateSpaceSection(d_model=64, d_state=16) self.modules['selective_ssm'] = self.selective_ssm if getattr(self.config, 'multitimescale_learning', False) and self.multitimescale is None: from .adaptation_coordinator import AdaptationCoordinator self.multitimescale = AdaptationCoordinator(num_neurons=self.brain.n, seed=self.config.seed) if getattr(self.config, 'meta_plasticity', False) and self.meta_plasticity is None: from .meta_plasticity import ParameterizedPlasticityRule self.meta_plasticity = ParameterizedPlasticityRule() if getattr(self.config, 'causal_world_model', False) and self.causal_world is None: from .causal_world_model import CausalWorldModel from .intervention_planner import InterventionPlanner self.causal_world = CausalWorldModel(state_dim=64, action_dim=5, seed=self.config.seed) self.intervention_planner = InterventionPlanner(self.causal_world) if getattr(self.config, 'relational_memory', False) and self.relational_memory is None: from .relational_memory import RelationalMemoryBank self.relational_memory = RelationalMemoryBank(dim=256) if getattr(self.config, 'event_driven_backend', False) and self.event_backend is None: from .event_driven_backend import EventDrivenSparseBackend self.event_backend = EventDrivenSparseBackend(delta_threshold=0.05) if getattr(self.config, 'graph_diffusion', False) and self.graph_diffusion is None: from .graph_diffusion import ChebyshevGraphDiffusion self.graph_diffusion = ChebyshevGraphDiffusion( num_nodes=self.brain.n, pre=torch.as_tensor(self.graph.base_pre), post=torch.as_tensor(self.graph.base_post), weights=torch.as_tensor(self.brain.base_w), order=4, seed=self.config.seed, ) self.modules['graph_diffusion'] = self.graph_diffusion if getattr(self.config, 'active_inference_planner', False) and self.active_inference is None: from .active_inference import ActiveInferenceEngine self.active_inference = ActiveInferenceEngine( observation_dim=155, action_dim=5, hidden_dim=32, seed=self.config.seed, ) if getattr(self.config, 'thermodynamics', False) and self.thermodynamics is None: from .thermodynamics import NeuralThermodynamicsEngine self.thermodynamics = NeuralThermodynamicsEngine(num_states=8) if getattr(self.config, 'metaplasticity_bcm', False) and self.metaplasticity_bcm is None: from .metaplasticity_bcm import BcmMetaplasticityEngine self.metaplasticity_bcm = BcmMetaplasticityEngine( num_neurons=self.brain.n, target_activity=0.25, ) if getattr(self.config, 'transfer_entropy', False) and self.transfer_entropy is None: from .transfer_entropy import TransferEntropyEngine self.transfer_entropy = TransferEntropyEngine(buffer_size=64) def _setup_neural_graft(self): if not self.config.neural_graft: return from .neural_graft import NeuralResidualGraft if self.neural_graft is None: self.neural_graft=NeuralResidualGraft(seed=self.config.seed) self.modules['neural_graft']=self.neural_graft.network if self.config.programmed_connectome and self.neural_graft.connectome is None: try: from .connectome_assets import load_programmed_graft prior=load_programmed_graft(max_nodes=128,seed=self.config.seed) self.neural_graft.bind_connectome(prior['pre'],prior['post'],prior['weights'],prior['n'],prior['provenance']) self.programmed_prior_status={'enabled':True,'available':True,'nodes':prior['n'],'provenance':prior['provenance']} except (FileNotFoundError,ImportError) as exc: self.programmed_prior_status={'enabled':True,'available':False,'reason':str(exc)} def _optimization_parameters(self): # Preserve the historical order so old optimizer moments can be migrated. return (list(self.encoder.parameters())+list(self.motor.parameters())+ list(self.donor_to_graph.parameters())+list(self.graph_to_resource.parameters())+ [self.brain.graft_w]+list(self.plasticity.router.parameters())+ list(self.vision_encoder.parameters())+list(self.vis_to_sensory.parameters())) def _restore_optimizer(self, saved, rebuild=False): """Bind moments to live tensors, extending legacy visual-free optimizers.""" if rebuild: self.opt=torch.optim.Adam(self._optimization_parameters(),lr=3e-4) restored=deepcopy(saved) current=self.opt.state_dict() old_groups=restored.get('param_groups', []) if len(old_groups)!=len(current['param_groups']): raise ValueError('optimizer parameter groups differ') for old,new in zip(old_groups,current['param_groups']): if len(old['params'])>len(new['params']): raise ValueError('optimizer has unsupported parameters') # Existing parameter indices precede the newly registered visual paths. old['params']=list(new['params']) self.opt.load_state_dict(restored) # Resized structural parameters cannot retain moments of the old shape. for parameter,moments in list(self.opt.state.items()): if any(isinstance(value,torch.Tensor) and value.ndim>0 and value.shape!=parameter.shape for value in moments.values()): del self.opt.state[parameter] def reset_episode(self): self.brain.reset_state(); self.mb.elig.zero_(); self.mb.kc_act.zero_(); self.compass.reset() if hasattr(self, 'neuromod'): self.neuromod.reset() if hasattr(self, 'astrocytes'): self.astrocytes.reset() if hasattr(self, 'predictive'): self.predictive.reset() if getattr(self, 'dendritic_ltc', None) is not None: self.dendritic_ltc.reset_state() if getattr(self, 'oscillatory_coherence', None) is not None: self.oscillatory_coherence.reset() if getattr(self, 'dvgem_memory', None) is not None: self.dvgem_memory.reset_state() if getattr(self, 'tether_coordinator', None) is not None: self.tether_coordinator.reset() if getattr(self, 'criticality_homeostat', None) is not None: self.criticality_homeostat.reset() if getattr(self, 'holographic_vsa', None) is not None: self.holographic_vsa.reset() if getattr(self, 'apical_engine', None) is not None: self.apical_engine.reset() if getattr(self, 'spectral_reservoir', None) is not None: self.spectral_reservoir.reset() if getattr(self, 'spiking_engine', None) is not None: self.spiking_engine.reset() if getattr(self, 'glymphatic_engine', None) is not None: self.glymphatic_engine.reset() if getattr(self, 'kuramoto_engine', None) is not None: self.kuramoto_engine.reset() if getattr(self, 'archimedes_engine', None) is not None: self.archimedes_engine.reset() if getattr(self, 'memory_carrier_nexus', None) is not None: self.memory_carrier_nexus.reset() if getattr(self, 'cross_graft_engine', None) is not None: self.cross_graft_engine.reset() if getattr(self, 'comm_fabric', None) is not None: self.comm_fabric.reset() if getattr(self, 'neurowave_x2', None) is not None: self.neurowave_x2.reset() if getattr(self, 'overflow_mini_brain', None) is not None: self.overflow_mini_brain.reset_state() if getattr(self, 'selective_ssm', None) is not None: self.selective_ssm.reset_state() if getattr(self, 'event_backend', None) is not None: self.event_backend.reset() self._camera_consumed_any=False self.hidden=torch.zeros(1,self.tidal.config.hidden_size); self.intent=torch.zeros(6) self.evoked=torch.zeros(self.brain.n); self.ticks=0; self.last_compass=torch.zeros(16) self.last_features=np.zeros(64,np.float32); self.last_telemetry={}; self.last_obs=np.zeros(155,np.float32) self.resources=np.array([1.,1.,1.,1.,0.,0.,0.,0.,0.,0.,.5,1.,0.,0.,0.,0.],np.float32) self.expert_usage=torch.zeros(2); self.consolidated=torch.zeros(32); self.consolidations=0 self.pending_transition=None def _pooled(self,r): return F.adaptive_avg_pool1d(r.reshape(1,1,-1),32).flatten() def semantic_frame(self,obs): # health/energy/hydration/stamina/exposure/threat/food/water/shelter, # weather/temperature/daylight/terrain/scent/last_intent/time. depth=obs[:33]; rgb=obs[33:132].reshape(3,33) frame=self.resources.copy() frame[1]=np.clip(frame[1]-.0005*(1+abs(obs[136])),0,1) frame[3]=np.clip(1-abs(obs[136])*.3,0,1) frame[5]=float(depth.max()); frame[6]=float((rgb[1]*depth).max()); frame[7]=float((rgb[2]*depth).max()) frame[8]=float(1-depth.mean()); frame[12]=float(depth.mean()); frame[13]=float(frame[6:8].mean()) frame[14]=float(self.intent.argmax())/5; frame[15]=float(obs[154]); self.resources=frame return torch.from_numpy(frame) def act(self,obs,camera=None,learn=False,planner_mode=None): obs=np.asarray(obs,dtype=np.float32) if obs.shape!=(155,) or not np.isfinite(obs).all(): raise ValueError('observation must be finite shape (155,)') if camera is not None and not np.isfinite(camera).all(): raise ValueError('camera must be finite') mode=planner_mode if mode is None: mode=('memory' if self.config.surprise_memory else 'model') if self.config.experience_planning else 'off' if not isinstance(mode,str) or mode not in {'off','model','memory'}: raise ValueError('planner_mode must be off, model, or memory') vis_latent=None vis_info={} camera_consumed=False if camera is not None and hasattr(self, 'vision_encoder'): with torch.no_grad(): vis_info=self.vision_encoder.encode_frame(camera) vis_latent=vis_info['latent'] camera_consumed=True self._camera_consumed_any=True o=torch.from_numpy(obs.copy()) with torch.no_grad(): compass=self.compass.step(float(obs[137])*2.5,obs[:132]); self.last_compass=compass mbon=self.mb(o[149:153],adapt=learn) if self.ticks%self.config.cognition_interval==0: graph_context=self._pooled(self.brain.r) frame=(self.semantic_frame(obs)+.05*torch.tanh(self.graph_to_resource(graph_context))).clamp(0,1) out=self.tidal(torch.zeros(1,self.tidal.config.hash_buckets),frame[None],memory=self.hidden) self.hidden=out['memory'].detach(); self.intent=out['action'][0].softmax(-1).detach(); self.routing=out['routing'][0].tolist() current=2*torch.tanh(self.encoder(torch.cat([o,compass,mbon]))+.3*self.donor_to_graph(torch.cat([self.hidden[0],self.intent]))) if vis_latent is not None and hasattr(self, 'vis_to_sensory'): current = current + 0.3 * torch.tanh(self.vis_to_sensory(vis_latent.to(current.device))) # These neural corrections have no trained objective in this actor. pred_info=(self.predictive.step(o,self.hidden,acetylcholine=self.neuromod.state.acetylcholine) if self.config.experimental_cognition else {'steer_bias':0.0}) gates=self.plasticity.gates(o); effective=self.plasticity.effective_weights(self.brain.graft_w,gates) if hasattr(self,'astrocytes'): effective=self.astrocytes.modulate_graft_weights(effective,torch.as_tensor(self.graph.graft_pre,dtype=torch.long),self.brain.n) previous=self.brain.r.clone() baseline=self.brain(torch.zeros_like(current),effective,adapt=False,advance=False) if self.config.readout!='absolute' else None r=self.brain( current, effective, adapt=learn, comm_fabric=getattr(self, 'comm_fabric', None), phase_angles=getattr(self.oscillatory_coherence, 'theta_phases', None) if getattr(self, 'oscillatory_coherence', None) is not None else None, ) if hasattr(self,'astrocytes'): self.astrocytes.step(r.detach()) if learn: self.plasticity.observe(r) gate_alpha=0.0 if self.config.readout=='absolute': read=r; delta_norm=0.0; baseline_norm=0.0 else: delta=r-baseline delta_norm=float(delta.norm()) baseline_norm=float(baseline.norm()) if self.config.readout=='persistent_evoked': gate=torch.sigmoid(delta.abs().mean()*8) gate_alpha=float(gate) self.evoked=.9*self.evoked+delta read=gate*self.evoked+(1.-gate)*baseline else: self.evoked=delta read=self.evoked gate_alpha=1.0 pooled=self._pooled(read) criticality_info = None if getattr(self, 'criticality_homeostat', None) is not None: pooled, criticality_info = self.criticality_homeostat.step(r.detach().numpy(), pooled, learn=learn) vsa_info = None if getattr(self, 'holographic_vsa', None) is not None: vsa_delta, vsa_info = self.holographic_vsa.step(pooled, obs) pooled = pooled + 0.04 * torch.tanh(vsa_delta) dendritic_info = None if getattr(self, 'dendritic_ltc', None) is not None: apical_ctx = torch.cat([self.hidden[0, :16], self.intent, mbon]) ach_val = float(self.neuromod.state.acetylcholine) if hasattr(self, 'neuromod') else 0.5 ca_val = float(self.astrocytes.domains[0].calcium) if (hasattr(self, 'astrocytes') and self.astrocytes.domains) else 0.1 dend_delta, dendritic_info = self.dendritic_ltc.step( pooled, apical_ctx, ach_precision=ach_val, astrocyte_ca=ca_val, learn=learn ) pooled = pooled + 0.05 * torch.tanh(dend_delta) coherence_info = None if getattr(self, 'oscillatory_coherence', None) is not None: ach_val = float(self.neuromod.state.acetylcholine) if hasattr(self, 'neuromod') else 0.5 da_val = float(self.neuromod.state.dopamine) if hasattr(self, 'neuromod') else 0.5 surp_val = float(self.predictive.state.sensory_surprisal) if hasattr(self, 'predictive') else 0.0 coherence_info = self.oscillatory_coherence.step( r.detach().numpy(), self.graph.origin, surprisal=surp_val, ach=ach_val, dopamine=da_val, learn=learn ) if self.fast_weight_memory is not None: fmem_out, _ = self.fast_weight_memory(pooled.unsqueeze(0)) pooled = pooled + 0.05 * torch.tanh(fmem_out.squeeze(0)) criticality_info = None if getattr(self, 'criticality_homeostat', None) is not None: pooled, criticality_info = self.criticality_homeostat.step(r.detach().numpy(), pooled, learn=learn) vsa_info = None if getattr(self, 'holographic_vsa', None) is not None: vsa_res, vsa_info = self.holographic_vsa.step(pooled, obs, learn=learn) pooled = pooled + 0.03 * torch.tanh(vsa_res) graph_diff_info = None if getattr(self, 'graph_diffusion', None) is not None: gdiff_res, graph_diff_info = self.graph_diffusion(r, learn=learn) pooled = pooled + 0.04 * torch.tanh(gdiff_res[:32]) # Dormant candidates participate only when novelty recruits one; unused weights persist. novelty=float((r-previous).abs().mean()); preferred_expert=int(self.intent.argmax())%2 if getattr(self.config, 'dormant_lifecycle', True): recruited, expert, gain = self.dormant_lifecycle.step_novelty(novelty, preferred_expert, learn=learn) if gain > 0: pooled = pooled + 0.05 * gain * torch.tanh(self.dormant[expert](pooled)) if learn: self.expert_usage[expert] += 1 self.dormant_lifecycle.evaluate_contribution(pooled, expert) else: recruited=novelty>.02; expert=preferred_expert if recruited: pooled=pooled+.05*torch.tanh(self.dormant[expert](pooled)) if learn: self.expert_usage[expert]+=1 if learn: self.consolidated.mul_(.99).add_(pooled*.01) if learn and recruited and self.ticks%self.config.cognition_interval==0: if getattr(self.config, 'dormant_lifecycle', True): self.dormant_lifecycle.step_consolidation(self.native, recruited_slot=expert) else: self.native.weight.mul_(.995).add_(self.dormant[expert].weight*.005) self.consolidations+=1 pooled=pooled+.01*self.consolidated+.05*torch.tanh(self.native(pooled)) features=torch.cat([pooled,self.hidden[0,:16],mbon,self.intent,compass[:8]]) if getattr(self, 'selective_ssm', None) is not None: features = features + 0.05 * torch.tanh(self.selective_ssm.step(features)) if learn and self.config.structural_learning and hasattr(self, 'neurogenesis'): self.neurogenesis.record_activity(r) if self.ticks % 16 == 0 or learn: da = self.neuromod.state.dopamine if hasattr(self, 'neuromod') else 1.0 ca = self.astrocytes.domains[0].calcium if (hasattr(self, 'astrocytes') and self.astrocytes.domains) else 1.0 thr = self.homeostasis.state.threat if hasattr(self, 'homeostasis') else 0.0 self.neurogenesis.evaluate_structural_remodeling(self, dopamine=da, astrocyte_calcium=ca, threat=thr) if hasattr(self, 'homeostasis') and hasattr(self, 'neuromod'): da, sht, oa, ach = self.homeostasis.modulate_neuromodulators( self.neuromod.state.dopamine, self.neuromod.state.serotonin, self.neuromod.state.octopamine, self.neuromod.state.acetylcholine ) self.neuromod.state.dopamine = da; self.neuromod.state.serotonin = sht self.neuromod.state.octopamine = oa; self.neuromod.state.acetylcholine = ach # Every action is gated by actual graph activity; no action from a world oracle. gains=self.neuromod.compute_gains() if hasattr(self, 'neuromod') else {'motor_vigor':1.0} action=torch.tanh(self.motor(features))*torch.sigmoid(pooled.mean()*4)*gains['motor_vigor'] if getattr(self, 'overflow_mini_brain', None) is not None: of_curr, of_act, _ = self.overflow_mini_brain(o, motor_feedback=action) action = action + 0.05 * of_act if 'steer_bias' in pred_info and abs(pred_info['steer_bias'])>1e-4: action[TURN]=torch.clamp(action[TURN]+pred_info['steer_bias'],-1.0,1.0) fe = float(self.predictive.state.free_energy) if hasattr(self, 'predictive') else 0.0 surprisal = float(self.predictive.state.sensory_surprisal) if hasattr(self, 'predictive') else 0.0 thr = float(self.homeostasis.state.threat) if hasattr(self, 'homeostasis') else 0.0 mimomix_trace = MiMoMixReasoningTrace(system_engaged='disabled; untrained experimental correction') if self.config.experimental_cognition: mimomix_delta, mimomix_trace = self.mimomix.deliberate(latent_state=features, free_energy=fe, surprisal=surprisal, threat=thr) action = action + mimomix_delta latent_reasoner_trace = None if self.latent_reasoner is not None and getattr(self.config, 'latent_reasoning', False): if fe > 0.35 or surprisal > 0.25 or thr > 0.25: refined_act, latent_reasoner_trace = self.latent_reasoner.forward_continuous_thinking(features) action = 0.8 * action + 0.2 * refined_act.squeeze(0) bonus=self.curiosity.compute_bonus(o,train=learn) self.ticks+=1; self.last_obs=obs.copy(); self.last_features=features.numpy().copy() experience_state=encode_experience_state(obs,self.last_features) base_act=np.clip(action.numpy(),-1.,1.).astype(np.float32,copy=True) executed=base_act.copy() graft_receipt=None if self.neural_graft is not None: executed,graft_receipt=self.neural_graft.propose(obs,self.last_features,executed,learn=learn) if getattr(self, 'active_inference', None) is not None: if getattr(self.config, 'planner_algorithm', '') == 'active_inference': executed, act_inf_info = self.active_inference.select_action(executed, self.last_features) else: _, act_inf_info = self.active_inference.evaluate_expected_free_energy( np.array([executed]), self.last_features ) self.last_telemetry['active_inference'] = act_inf_info graft_act=executed.copy() planner_info={'mode':mode,'enabled':mode!='off','horizon':self.config.experience_horizon, 'scope':'experimental short-horizon planning; heuristic uncertainty'} if mode!='off': from .experience_planner import ExperienceMPC value_guided = getattr(self.config, 'value_guided_planning', False) planner=ExperienceMPC(self.experience_model,horizon=self.config.experience_horizon,value_guided=value_guided) planned,diagnostics=planner.plan(experience_state,executed, memory=self.surprise_memory if mode=='memory' else None) candidate=np.asarray(planned,dtype=np.float32) if candidate.shape!=(5,) or not np.isfinite(candidate).all(): raise ValueError('planner must return a finite five-dimensional action') if getattr(self.config, 'planner_algorithm', 'experience_mpc') in ('recurrent_latent', 'hybrid') and getattr(self, 'recurrent_planner', None) is not None and self.recurrent_planner.training_steps >= 4: rec_out = self.recurrent_planner.plan(obs, executed, horizon=self.config.experience_horizon) rec_act = np.asarray(rec_out['action'], dtype=np.float32) if getattr(self.config, 'planner_algorithm', 'experience_mpc') == 'recurrent_latent': if rec_out.get('used_plan'): candidate = rec_act planner_info['recurrent_latent'] = {k: v for k, v in rec_out.items() if k != 'action'} else: if rec_out.get('used_plan'): candidate = 0.65 * candidate + 0.35 * rec_act if getattr(self, 'diffusion_repair', None) is not None: traj = np.vstack([executed[None, :], candidate[None, :], rec_act[None, :]]) repaired = self.diffusion_repair.repair_trajectory_plan(traj, hazard_zones=[]) candidate = repaired[1].astype(np.float32) planner_info['hybrid_recurrent'] = {k: v for k, v in rec_out.items() if k != 'action'} # Enforce the conservative action trust region at the acting boundary. executed=np.clip(candidate,np.maximum(-1.,executed-.35),np.minimum(1.,executed+.35)) planner_info.update(diagnostics) planner_info['mode']=mode planner_info['algorithm']=getattr(self.config, 'planner_algorithm', 'experience_mpc') planner_act=executed.copy() dvgem_diag=None if getattr(self, 'dvgem_memory', None) is not None: v_res = float(min(self.homeostasis.state.energy, self.homeostasis.state.health)) if hasattr(self, 'homeostasis') else 1.0 executed, dvgem_diag = self.dvgem_memory.query_and_gate(obs, executed, viability_reserve=v_res) tether_diag=None # Holographic VSA transition recording is performed in observe_transition. if getattr(self, 'tether_coordinator', None) is not None: proposals = {'base_actor': base_act, 'neural_graft': graft_act, 'planner': planner_act, 'dvgem': executed.copy()} executed, tether_diag = self.tether_coordinator.coordinate_specialists( proposals, self.last_features, r.detach().numpy(), self.graph.origin ) executed = np.clip(executed, np.maximum(-1., planner_act - .35), np.minimum(1., planner_act + .35)) executed=govern_action(executed,self.homeostasis.get_max_allowed_thrust()) self.pending_transition={'state':np.array(experience_state,copy=True),'action':executed.copy(),'graft_receipt':graft_receipt} self.last_telemetry={'ticks':self.ticks,'graph_mean':float(r.mean()),'graph_delta':novelty,'tidal_intent':self.intent.tolist(),'tidal_routing':self.routing,'resources':self.resources.tolist(),'compass':float(self.compass.bump_angle),'mbon':mbon.tolist(),'curiosity':bonus,'recruited_expert':expert if recruited else None,'expert_usage':self.expert_usage.tolist(),'consolidations':self.consolidations,'readout':self.config.readout,'evoked_delta_norm':delta_norm,'evoked_baseline_norm':baseline_norm,'bridge_training':'experimental supervised preparation' if self.bridge_updates else 'untrained','camera_consumed':camera_consumed,'visual_latents':vis_latent.tolist() if vis_latent is not None else [],'visual_brightness':vis_info.get('mean_brightness',0.0),'visual_contrast':vis_info.get('contrast',0.0),'neuromodulators':self.neuromod.state.to_dict() if hasattr(self, 'neuromod') else {},'astrocytes':self.astrocytes.summary() if hasattr(self, 'astrocytes') else {},'predictive_coding':self.predictive.state.to_dict() if hasattr(self, 'predictive') else {}} self.last_telemetry['evoked_channels']={'channel_m_norm':baseline_norm,'channel_d_norm':delta_norm,'gate_alpha':gate_alpha,'persistent_norm':float(self.evoked.norm()) if hasattr(self,'evoked') else 0.0} self.last_telemetry['dormant_lifecycle']=self.dormant_lifecycle.summary() if hasattr(self,'dormant_lifecycle') else {} if self.continual_backprop is not None: self.last_telemetry['continual_backprop']={'enabled':True,**self.continual_backprop.get_metrics()} if self.fast_weight_memory is not None: self.last_telemetry['fast_weight_memory']={'enabled':True,**self.fast_weight_memory.get_metrics()} if latent_reasoner_trace is not None: self.last_telemetry['latent_reasoner']={'engaged':True,'recurrent_depth':latent_reasoner_trace.recurrent_depth,'ponder_cost':latent_reasoner_trace.ponder_cost,'accumulated_halt':latent_reasoner_trace.accumulated_halt} self.last_telemetry['experience_planner']=planner_info self.last_telemetry['experience_model']=self.experience_model.summary() self.last_telemetry['surprise_memory']=self.surprise_memory.summary() if hasattr(self, 'homeostasis'): self.last_telemetry['homeostasis']=self.homeostasis.summary() if hasattr(self, 'neurogenesis'): self.last_telemetry['neurogenesis']=self.neurogenesis.summary() if getattr(self, 'self_model', None) is not None: self.last_telemetry['self_model']=self.self_model.summary() if dendritic_info is not None: self.last_telemetry['dendritic_ltc']=dendritic_info if coherence_info is not None: self.last_telemetry['oscillatory_coherence']=coherence_info if dvgem_diag is not None: self.last_telemetry['dvgem']=dvgem_diag if tether_diag is not None: self.last_telemetry['tether_coordinator']=tether_diag if criticality_info is not None: self.last_telemetry['criticality_homeostat']=criticality_info if vsa_info is not None: self.last_telemetry['holographic_vsa']=vsa_info if getattr(self, 'apical_engine', None) is not None: _, apical_telem = self.apical_engine( r[:64], apical_context=torch.tensor(self.last_features[:32], dtype=torch.float32), neuromod_ach=getattr(self.neuromod.state, 'acetylcholine', 1.0) if hasattr(self, 'neuromod') else 1.0, neuromod_da=getattr(self.neuromod.state, 'dopamine', 1.0) if hasattr(self, 'neuromod') else 1.0, ) self.last_telemetry['apical_amplification'] = apical_telem.to_dict() if getattr(self, 'spectral_reservoir', None) is not None: res_readout, res_telem = self.spectral_reservoir.step( torch.tensor(self.last_features[:32], dtype=torch.float32), learn=learn, target=torch.tensor(executed[:5], dtype=torch.float32) if learn else None, ) self.last_telemetry['spectral_reservoir'] = res_telem.to_dict() if getattr(self, 'hyperbolic_manifold', None) is not None: hyp_telem = self.hyperbolic_manifold.step(active_node_ids=list(range(min(4, self.brain.n)))) self.last_telemetry['hyperbolic_manifold'] = hyp_telem.to_dict() if getattr(self, 'spiking_engine', None) is not None: _, _, spk_telem = self.spiking_engine( r[:min(64, self.brain.n)], neuromod_ach=getattr(self.neuromod.state, 'acetylcholine', 1.0) if hasattr(self, 'neuromod') else 1.0 ) self.last_telemetry['spiking_neuromorphic'] = spk_telem.to_dict() if getattr(self, 'glymphatic_engine', None) is not None: act_norm = float(r.norm().item()) if isinstance(r, torch.Tensor) else float(np.linalg.norm(r)) is_sleep = bool(getattr(self, 'in_sleep_phase', False)) _, glymph_telem = self.glymphatic_engine.step(act_norm, is_quiescent_sleep=is_sleep) self.last_telemetry['glymphatic_clearance'] = glymph_telem.to_dict() if getattr(self, 'kuramoto_engine', None) is not None: _, kur_telem = self.kuramoto_engine.step() self.last_telemetry['quantum_kuramoto'] = kur_telem.to_dict() if getattr(self, 'archimedes_engine', None) is not None: pos = (float(self.last_features[0]), float(self.last_features[1])) if len(self.last_features) >= 2 else (0.0, 0.0) vel = (float(self.last_features[2]), float(self.last_features[3])) if len(self.last_features) >= 4 else (0.0, 0.0) _, _, arch_telem = self.archimedes_engine.step(pos, vel, vertical_thrust=float(executed[0]) if len(executed) > 0 else 0.0) self.last_telemetry['archimedes_buoyancy'] = arch_telem.to_dict() if getattr(self, 'memory_carrier_nexus', None) is not None: k_vec = torch.tensor(self.last_features[:min(64, self.brain.n)], dtype=torch.float32) if learn: v_vec = torch.tensor(executed[:min(64, len(executed))], dtype=torch.float32) self.memory_carrier_nexus.store(k_vec, v_vec, carrier_idx=self.ticks % 16) _, _ = self.memory_carrier_nexus.retrieve(k_vec, carrier_idx=self.ticks % 16) self.last_telemetry['memory_carrier_nexus'] = self.memory_carrier_nexus.telemetry.to_dict() if getattr(self, 'cross_graft_engine', None) is not None: _, graft_telem = self.cross_graft_engine(r[:min(64, self.brain.n)], context=torch.tensor(self.last_features[:min(64, len(self.last_features))], dtype=torch.float32)) self.last_telemetry['cross_connectome_graft'] = graft_telem.to_dict() if getattr(self, 'dpo_engine', None) is not None: self.last_telemetry['verifiable_dpo']={'enabled':True,'pairs':len(self.dpo_engine.preference_buffer),'last_margin':getattr(self.dpo_engine,'last_margin',0.0)} if getattr(self, 'comm_fabric', None) is not None: self.last_telemetry['sancf'] = self.comm_fabric.get_telemetry_dict() if getattr(self, 'neurowave_x2', None) is not None: self.last_telemetry['neurowave_x2'] = self.neurowave_x2.get_telemetry_dict() if getattr(self, 'graph_diffusion', None) is not None and graph_diff_info is not None: self.last_telemetry['graph_diffusion'] = graph_diff_info if getattr(self, 'thermodynamics', None) is not None: t_st = self.thermodynamics.step(r.detach().numpy(), task_utility=0.75, learn=learn) self.last_telemetry['thermodynamics'] = t_st.to_dict() if getattr(self, 'metaplasticity_bcm', None) is not None: bcm_delta, bcm_st = self.metaplasticity_bcm.step( r.detach().numpy(), graft_weights=self.brain.graft_w, graft_pre=self.brain.graft_pre, graft_post=self.brain.graft_post, learn=learn, ) if learn and bcm_delta is not None and self.brain.graft_w is not None: with torch.no_grad(): self.brain.graft_w.add_(0.01 * bcm_delta.clamp(-0.1, 0.1)) self.last_telemetry['metaplasticity_bcm'] = bcm_st.to_dict() if getattr(self, 'transfer_entropy', None) is not None: te_st = self.transfer_entropy.step(r.detach().numpy(), self.graph.origin, learn=learn) self.last_telemetry['transfer_entropy'] = te_st.to_dict() if getattr(self, 'overflow_mini_brain', None) is not None: self.last_telemetry['overflow_mini_brain'] = {'enabled': True, 'state_norm': float(torch.norm(self.overflow_mini_brain.state).item())} if getattr(self, 'event_backend', None) is not None: from dataclasses import asdict _, _, ev_m = self.event_backend.detect_events(r) self.last_telemetry['event_driven'] = asdict(ev_m) if getattr(self, 'grafted_diffusion', None) is not None: diff_proposal = self.grafted_diffusion.sample_action(features) self.last_telemetry['grafted_diffusion'] = {'proposal': diff_proposal.tolist()} if hasattr(self, 'mimomix'): self.last_telemetry['mimomix']={'system_engaged':mimomix_trace.system_engaged,'ponder_steps':mimomix_trace.ponder_steps,'ponder_cost':mimomix_trace.ponder_cost,'confidence':mimomix_trace.confidence,'action_delta_l2':mimomix_trace.action_delta_l2} return {'action':executed.copy(),'features':self.last_features.copy(),'telemetry':deepcopy(self.last_telemetry)} def observe_transition(self,next_obs,reward,done=False,action=None): """Learn once from an explicitly supplied real outcome and executed action. The next observation retains the current graph/donor context as conditioning inputs; the model does not predict neural dynamics or advance the actor speculatively. Explicit actions support shared/off-policy support streams. """ observation=np.asarray(next_obs,dtype=np.float32) if observation.shape!=(155,) or not np.isfinite(observation).all(): raise ValueError('next observation must be finite shape (155,)') if isinstance(reward,(bool,np.bool_)) or not np.isscalar(reward) or not np.isfinite(reward): raise ValueError('reward must be finite') if type(done) not in (bool,np.bool_): raise ValueError('done must be boolean') if self.pending_transition is None: raise RuntimeError('observe_transition requires a preceding action') executed=np.asarray(self.pending_transition['action'] if action is None else action,dtype=np.float32) if executed.shape!=(5,) or not np.isfinite(executed).all() or np.any(np.abs(executed)>1): raise ValueError('executed action must be finite shape (5,) within [-1,1]') state=np.array(self.pending_transition['state'],copy=True) next_state=encode_experience_state(observation,self.last_features) diagnostics=self.experience_model.update(state,executed,next_state,float(reward),done=bool(done)) if self.neural_graft is not None: receipt=self.pending_transition.get('graft_receipt') if receipt is not None and receipt.get('learning'): diagnostics['neural_graft']=self.neural_graft.observe(observation,float(reward),bool(done),executed, receipt=receipt,manual=bool(self.pending_transition.get('manual',False))) else: diagnostics['neural_graft']=self.neural_graft.record_transition(self.last_obs,self.last_features, executed,executed,observation,float(reward),bool(done)) if self.config.active_training and self.neural_graft.samples%16==0: fit=self.neural_graft.train_replay(updates=self.config.graft_updates,batch_size=self.config.graft_batch_size,actor=True) diagnostics['graft_fit']={k:v for k,v in fit.items() if k not in ('cpu_seconds','wall_seconds')} if self.config.surprise_memory: diagnostics={**diagnostics,'memory':self.surprise_memory.update(state,executed,float(reward),float(diagnostics['prediction_error']))} if getattr(self, 'self_model', None) is not None and getattr(self, 'last_obs', None) is not None: self_receipt = self.self_model.process_transition(self.last_obs, executed, observation, learn=True) diagnostics['self_model'] = self_receipt.to_dict() if self.fast_weight_memory is not None: pooled_f = torch.as_tensor(self.last_features[:32], dtype=torch.float32).unsqueeze(0) self.fast_weight_memory.inner_update(pooled_f, surprisal=float(abs(diagnostics['prediction_error']))) if self.continual_backprop is not None: self.continual_backprop.update_utility(self.brain.r.detach().numpy()) if self.ticks % 16 == 0: candidates = self.continual_backprop.identify_replacement_candidates() if candidates: self.continual_backprop.replace_neurons(self, candidates, optimizer=self.opt) if getattr(self, 'dendritic_ltc', None) is not None: diagnostics['dendritic_ltc'] = self.dendritic_ltc.update_from_outcome(float(reward), float(diagnostics.get('prediction_error', 0.0))) if getattr(self, 'recurrent_planner', None) is not None and getattr(self, 'last_obs', None) is not None: diagnostics['recurrent_planner'] = self.recurrent_planner.train_step( self.last_obs[None, :], executed[None, :], np.array([float(reward)], np.float32), observation[None, :], np.array([float(done)], np.float32) ) if getattr(self, 'dpo_engine', None) is not None and getattr(self, 'last_obs', None) is not None: if abs(float(reward)) > 0.02: winner = executed if float(reward) >= 0 else np.clip(-0.5 * executed, -1.0, 1.0) loser = np.clip(-0.5 * executed, -1.0, 1.0) if float(reward) >= 0 else executed self.dpo_engine.record_preference(self.last_obs, winner, loser, 'return', abs(float(reward))) if len(self.dpo_engine.preference_buffer) >= 4 and self.ticks % 8 == 0: with torch.random.fork_rng(devices=[]): dpo_fit = self.dpo_engine.train_dpo_step(batch_size=min(8, len(self.dpo_engine.preference_buffer))) self.dpo_engine.last_margin = float(dpo_fit.get('implicit_reward_margin', 0.0)) diagnostics['verifiable_dpo'] = dpo_fit if getattr(self, 'dvgem_memory', None) is not None and getattr(self, 'last_obs', None) is not None: v_res = float(min(self.homeostasis.state.energy, self.homeostasis.state.health)) if hasattr(self, 'homeostasis') else 1.0 diagnostics['dvgem'] = self.dvgem_memory.record_transition(self.last_obs, executed, float(reward), observation, viability_reserve=v_res) if getattr(self, 'holographic_vsa', None) is not None and getattr(self, 'last_obs', None) is not None: diagnostics['holographic_vsa'] = self.holographic_vsa.record_transition( self.last_features[:32], self.last_obs, executed, float(reward) ) # Holographic VSA transition recording is performed in observe_transition. if getattr(self, 'tether_coordinator', None) is not None: diagnostics['tether_coordinator'] = self.tether_coordinator.update_successor_td( state, executed, float(reward), next_state, executed, done=bool(done) ) if getattr(self, 'multitimescale', None) is not None: diagnostics['multitimescale'] = self.multitimescale.step(float(reward), novelty=float(abs(diagnostics.get('prediction_error', 0.0)))) if getattr(self, 'causal_world', None) is not None: f_t = torch.as_tensor(self.last_features, dtype=torch.float32) a_t = torch.as_tensor(executed, dtype=torch.float32) next_f = torch.as_tensor(next_state[:64] if len(next_state) >= 64 else np.pad(next_state, (0, 64 - len(next_state))), dtype=torch.float32) diagnostics['causal_world'] = self.causal_world.observe(f_t, a_t, next_f) if getattr(self, 'relational_memory', None) is not None: diagnostics['relational_memory'] = self.relational_memory.bind_step(state, executed, next_state) if getattr(self, 'active_inference', None) is not None: self.active_inference.update_beliefs(float(abs(reward))) self.pending_transition=None return diagnostics def feedback(self,reward,done=False): self.mb.dopaminergic_update(float(reward)); self.brain.hebbian(float(reward)); self.brain.apply_hebbian() # LabRuntime advances physiology exactly once per real transition. if hasattr(self, 'neuromod'): threat=float(self.resources[5]) if hasattr(self, 'resources') and len(self.resources)>5 else 0.0 contrast=float(np.std(self.last_obs[:33])) if len(self.last_obs)>=33 else 0.0 depletion=float(1.0-self.resources[1]) if hasattr(self, 'resources') and len(self.resources)>1 else 0.0 self.neuromod.step(reward=float(reward), sensory_contrast=contrast, threat_level=threat, energy_depletion=depletion) self.episodic=(self.episodic+[{'reward':float(reward),'intent':self.intent.tolist(),'done':bool(done)}])[-128:] def prepare(self,features,targets,steps=1): x=torch.as_tensor(features,dtype=torch.float32); y=torch.as_tensor(targets,dtype=torch.float32) if x.ndim!=2 or x.shape[1]!=64 or y.shape!=(len(x),5) or not torch.isfinite(x).all() or not torch.isfinite(y).all(): raise ValueError('finite feature [N,64] and motor target [N,5] required') if not 1<=steps<=1000: raise ValueError('steps outside bound') for _ in range(steps): loss=F.mse_loss(torch.tanh(self.motor(x)),y); self.opt.zero_grad(); loss.backward(); self.opt.step() self.preparation_updates+=steps return {'loss':float(loss.detach()),'updates':self.preparation_updates,'scope':'supervised motor readout only; semantic bridge remains untrained'} def prepare_observations(self,observations,targets,steps=1,cameras=None): """Supervise the actual coupled actor; caller supplies motor demonstrations. Tidal parameters stay frozen; gradients propagate through its computation to graph_to_resource. This is preparation, never an evaluation oracle. """ x=torch.as_tensor(observations,dtype=torch.float32) y=torch.as_tensor(targets,dtype=torch.float32) if x.ndim!=2 or x.shape[1]!=155 or y.shape!=(len(x),5) or not len(x) or not torch.isfinite(x).all() or not torch.isfinite(y).all(): raise ValueError('expected finite [N,155] observations and [N,5] actions') if type(steps) is not int or not 1<=steps<=1000: raise ValueError('steps outside bound') frames=None if cameras is not None: frames=np.asarray(cameras,dtype=np.float32) if frames.ndim!=4 or len(frames)!=len(x) or not np.isfinite(frames).all(): raise ValueError('cameras must contain one finite RGB frame per observation') state=self.export_state(); gradients={} for _ in range(steps): losses=[] self.plasticity.begin_gradient_update() for index,(o,target) in enumerate(zip(x,y)): preliminary=2*torch.tanh(self.encoder(torch.cat([o,self.last_compass.detach(),self.mb(o[149:153],adapt=False)]))) preliminary_rates=self.brain(preliminary,adapt=False,advance=False) pooled=self._pooled(preliminary_rates) frame=torch.tensor(state['transient']['resources'])+.05*torch.tanh(self.graph_to_resource(pooled)) donor=self.tidal(torch.zeros(1,self.tidal.config.hash_buckets),frame.clamp(0,1)[None]) hidden=donor['memory'][0]; intent=donor['action'][0].softmax(-1) compass=self.last_compass.detach(); mbon=self.mb(o[149:153],adapt=False) current=2*torch.tanh(self.encoder(torch.cat([o,compass,mbon]))+.3*self.donor_to_graph(torch.cat([hidden,intent]))) if frames is not None: visual=self.vision_encoder.encode_frame(frames[index])['latent'] current=current+.3*torch.tanh(self.vis_to_sensory(visual)) gates=self.plasticity.gates(o); weights=self.plasticity.effective_weights(self.brain.graft_w,gates) self.plasticity.capture_gradient(weights,gates) r=self.brain(current,weights,adapt=False,advance=False) self.plasticity.observe(r.detach()) features=torch.cat([self._pooled(r),hidden[:16],mbon,intent,compass[:8]]) losses.append(F.mse_loss(torch.tanh(self.motor(features))*torch.sigmoid(self._pooled(r).mean()*4),target)) loss=torch.stack(losses).mean(); self.opt.zero_grad(); loss.backward() self.plasticity.finish_gradient_update() gradients={name:float(value.grad.norm()) for name,value in self.editable_tensors().items() if value.grad is not None} nn.utils.clip_grad_norm_([p for group in self.opt.param_groups for p in group['params']],1.) self.opt.step() self.plasticity.after_update(self.brain.graft_w,self.opt,self.brain.elig,self.brain.heb) self.preparation_updates+=steps; self.bridge_updates+=steps return {'loss':float(loss.detach()),'updates':self.preparation_updates,'gradient_norms':gradients,'scope':'supervised coupled actor; frozen pretrained Tidal; no performance promotion'} def editable_tensors(self): out={} for name,module in self.modules.items(): if name in ('tidal','curiosity'): continue out.update({name+'.'+k:v for k,v in module.named_parameters()}) out['mb.w_mbon']=self.mb.w_mbon return out def reset_edit_moments(self,names): surfaces=self.editable_tensors() for name in names: parameter=surfaces[name] optimizer=self.neural_graft.optimizer if name.startswith('neural_graft.') and self.neural_graft is not None else self.opt optimizer.state.pop(parameter,None) if self.neural_graft is not None and any(name.startswith('neural_graft.') for name in names): self.neural_graft.policy_version+=1 self.neural_graft.pending=None def _restore_graft_topology(self,pre,post,initial_weights): """Synchronize fixed-budget candidate identity with executing endpoints. Endpoint changes retain each slot's origin direction and site, so routing and fixed directional budgets remain meaningful. Vendor code is unchanged. """ pre=np.asarray(pre); post=np.asarray(post); initial=np.asarray(initial_weights,dtype=np.float32) shape=tuple(self.brain.graft_w.shape) if (pre.shape!=shape or post.shape!=shape or initial.shape!=shape or pre.dtype.kind not in 'iu' or post.dtype.kind not in 'iu' or not np.isfinite(initial).all() or np.any(pre<0) or np.any(pre>=self.graph.n) or np.any(post<0) or np.any(post>=self.graph.n)): raise ValueError('invalid graft topology') graph=deepcopy(self.graph) graph.graft_pre=pre.astype(np.int64,copy=True) graph.graft_post=post.astype(np.int64,copy=True) graph.graft_w0=initial.copy() template=GraftPlasticity(graph,155,self.plasticity.config,seed=self.config.seed) if (not torch.equal(template.bucket_ids,self.plasticity.bucket_ids) or not torch.equal(template.bucket_keys,self.plasticity.bucket_keys) or not torch.equal(template.bucket_budgets,self.plasticity.bucket_budgets)): raise ValueError('rewiring must preserve directional candidate budgets') # Keep module/Parameter objects and optimizer bindings intact. with torch.no_grad(): self.brain.graft_pre.copy_(template.candidate_pre) self.brain.graft_post.copy_(template.candidate_post) for name in ('candidate_pre','candidate_post','original_weights'): getattr(self.plasticity,name).copy_(getattr(template,name)) self.plasticity._candidate_digest=template._candidate_digest self.graph.graft_pre=graph.graft_pre self.graph.graft_post=graph.graft_post self.graph.graft_w0=graph.graft_w0 def rewire_graft_slots(self,pre,post,weights,slots): """Commit neurogenesis to live topology and reset replaced-slot credit.""" slots=np.asarray(slots,dtype=np.int64) values=np.asarray(weights,dtype=np.float32) if (slots.ndim!=1 or np.any(slots<0) or np.any(slots>=len(self.brain.graft_w)) or values.shape!=tuple(self.brain.graft_w.shape) or not np.isfinite(values).all()): raise ValueError('invalid graft slot replacement') initial=self.graph.graft_w0.copy() initial[slots]=values[slots] self._restore_graft_topology(pre,post,initial) indices=torch.as_tensor(slots,dtype=torch.long) with torch.no_grad(): self.brain.graft_w.copy_(torch.from_numpy(values)) for tensor in (self.brain.elig,self.brain.heb,self.plasticity.coactivity_ema, self.plasticity.gradient_ema,self.plasticity.gradient_evidence_count, self.plasticity.edge_age,self.plasticity._pending_gradient): tensor[indices]=0 for value in self.opt.state.get(self.brain.graft_w,{}).values(): if isinstance(value,torch.Tensor) and value.shape==self.brain.graft_w.shape: value[indices]=0 def __deepcopy__(self, memo): cloned = IntegratedAgent(self.config) cloned.import_state(self.export_state()) memo[id(self)] = cloned return cloned def export_state(self): state=deepcopy({'schema':1,'config':self.config.to_dict(),'topology':{'pre':self.brain.graft_pre.numpy(),'post':self.brain.graft_post.numpy(),'initial_weights':self.plasticity.original_weights.numpy()},'modules':{k:v.state_dict() for k,v in self.modules.items()},'optimizer':self.opt.state_dict(),'curiosity_optimizer':self.curiosity.opt.state_dict(),'rng':self.rng.bit_generator.state,'transient':{k:getattr(self,k) for k in ('hidden','intent','evoked','ticks','last_compass','last_features','last_telemetry','last_obs','resources','expert_usage','consolidated','episodic','tool_memory','preparation_updates','bridge_updates','consolidations','pending_transition','_camera_consumed_any')},'compass_angle':self.compass.bump_angle,'neuromod':self.neuromod.state.to_dict() if hasattr(self, 'neuromod') else None,'neuromod_context':{'v_predicted':self.neuromod.v_predicted,'history':self.neuromod.history},'astrocytes':self.astrocytes.export_state() if hasattr(self, 'astrocytes') else None,'predictive':self.predictive.export_state() if hasattr(self, 'predictive') else None,'routing':getattr(self,'routing',[]),'experience_model':self.experience_model.export_state(),'surprise_memory':self.surprise_memory.export_state(),'homeostasis':self.homeostasis.export_state() if hasattr(self,'homeostasis') else None,'neurogenesis':self.neurogenesis.export_state() if hasattr(self,'neurogenesis') else None,'dormant_lifecycle':self.dormant_lifecycle.export_state() if hasattr(self,'dormant_lifecycle') else None,'continual_backprop':self.continual_backprop.export_state() if (hasattr(self,'continual_backprop') and self.continual_backprop is not None) else None,'fast_weight_memory':self.fast_weight_memory.export_state() if (hasattr(self,'fast_weight_memory') and self.fast_weight_memory is not None) else None,'latent_reasoner':self.latent_reasoner.state_dict() if (hasattr(self,'latent_reasoner') and self.latent_reasoner is not None) else None,'self_model':self.self_model.export_state() if (hasattr(self,'self_model') and self.self_model is not None) else None}) state['neural_graft']=self.neural_graft.export_state() if self.neural_graft is not None else None state['dendritic_ltc']=self.dendritic_ltc.export_state() if getattr(self,'dendritic_ltc',None) is not None else None state['oscillatory_coherence']=self.oscillatory_coherence.export_state() if getattr(self,'oscillatory_coherence',None) is not None else None state['recurrent_planner']=self.recurrent_planner.export_state() if getattr(self,'recurrent_planner',None) is not None else None state['dpo_engine']=self.dpo_engine.export_state() if getattr(self,'dpo_engine',None) is not None else None state['dvgem_memory']=self.dvgem_memory.export_state() if getattr(self,'dvgem_memory',None) is not None else None state['tether_coordinator']=self.tether_coordinator.export_state() if getattr(self,'tether_coordinator',None) is not None else None state['criticality_homeostat']=self.criticality_homeostat.export_state() if getattr(self,'criticality_homeostat',None) is not None else None state['holographic_vsa']=self.holographic_vsa.export_state() if getattr(self,'holographic_vsa',None) is not None else None if getattr(self, 'apical_engine', None) is not None: state['apical_engine'] = self.apical_engine.export_state() if getattr(self, 'spectral_reservoir', None) is not None: state['spectral_reservoir'] = self.spectral_reservoir.export_state() if getattr(self, 'hyperbolic_manifold', None) is not None: state['hyperbolic_manifold'] = self.hyperbolic_manifold.export_state() if getattr(self, 'spiking_engine', None) is not None: state['spiking_engine'] = self.spiking_engine.export_state() if getattr(self, 'glymphatic_engine', None) is not None: state['glymphatic_engine'] = self.glymphatic_engine.export_state() if getattr(self, 'kuramoto_engine', None) is not None: state['kuramoto_engine'] = self.kuramoto_engine.export_state() if getattr(self, 'archimedes_engine', None) is not None: state['archimedes_engine'] = self.archimedes_engine.export_state() if getattr(self, 'memory_carrier_nexus', None) is not None: state['memory_carrier_nexus'] = self.memory_carrier_nexus.export_state() if getattr(self, 'cross_graft_engine', None) is not None: state['cross_graft_engine'] = self.cross_graft_engine.export_state() state['comm_fabric']=self.comm_fabric.export_state() if getattr(self,'comm_fabric',None) is not None else None state['neurowave_x2']=self.neurowave_x2.export_state() if getattr(self,'neurowave_x2',None) is not None else None state['overflow_mini_brain']=self.overflow_mini_brain.state_dict() if getattr(self,'overflow_mini_brain',None) is not None else None state['selective_ssm']=self.selective_ssm.state_dict() if getattr(self,'selective_ssm',None) is not None else None state['grafted_diffusion']=self.grafted_diffusion.export_state() if getattr(self,'grafted_diffusion',None) is not None else None state['event_backend']=self.event_backend.export_state() if getattr(self,'event_backend',None) is not None else None state['multitimescale']=self.multitimescale.export_state() if getattr(self,'multitimescale',None) is not None else None state['relational_memory']=self.relational_memory.export_state() if getattr(self,'relational_memory',None) is not None else None state['graph_diffusion']=self.graph_diffusion.export_state() if getattr(self,'graph_diffusion',None) is not None else None state['active_inference']=self.active_inference.export_state() if getattr(self,'active_inference',None) is not None else None state['thermodynamics']=self.thermodynamics.export_state() if getattr(self,'thermodynamics',None) is not None else None state['metaplasticity_bcm']=self.metaplasticity_bcm.export_state() if getattr(self,'metaplasticity_bcm',None) is not None else None state['transfer_entropy']=self.transfer_entropy.export_state() if getattr(self,'transfer_entropy',None) is not None else None state['torch_rng']=torch.random.get_rng_state() state['programmed_prior_status']=deepcopy(self.programmed_prior_status) state['source_provenance']=deepcopy(self.source_provenance) return state def import_state(self,state): backup=self.export_state() try: self._import_state(state) except Exception: self._import_state(backup) raise def _import_state(self,state): if state.get('schema')!=1 or not self.config.matches_saved(state.get('config')): raise ValueError('agent state/config mismatch') brain_state=state['modules']['brain'] plasticity_state=state['modules'].get('plasticity',{}) topology=state.get('topology',{'pre':brain_state['graft_pre'].numpy(), 'post':brain_state['graft_post'].numpy(), 'initial_weights':plasticity_state.get('original_weights',torch.from_numpy(self.graph.graft_w0)).numpy()}) if (not np.array_equal(topology['pre'],brain_state['graft_pre'].numpy()) or not np.array_equal(topology['post'],brain_state['graft_post'].numpy())): raise ValueError('checkpoint topology disagrees with executing endpoints') rebuild_optimizer=self.brain.graft_w.shape!=brain_state['graft_w'].shape if rebuild_optimizer: self.brain.graft_w=nn.Parameter(torch.zeros_like(brain_state['graft_w'])) for name in ('graft_pre','graft_post'): if getattr(self.brain,name).shape!=brain_state[name].shape: self.brain.register_buffer(name,torch.zeros_like(brain_state[name])) self._restore_graft_topology(topology['pre'],topology['post'],topology['initial_weights']) for k,v in state['modules'].items(): if k == 'brain': for buf_name in ('r', 'activity_ema', 'elig', 'heb', 'graft_pre', 'graft_post', 'base_pre', 'base_post', 'base_w', 'graft_site', 'bias', 'sensory_idx', 'motor_idx', 'probe_idx'): if buf_name in v and getattr(self.brain,buf_name).shape!=v[buf_name].shape: self.brain.register_buffer(buf_name, torch.zeros_like(v[buf_name])) if 'graft_w' in v and self.brain.graft_w.shape!=v['graft_w'].shape: self.brain.graft_w = nn.Parameter(torch.zeros_like(v['graft_w'])) rebuild_optimizer=True self.brain.n = len(v['r']) if k in self.modules: self.modules[k].load_state_dict(v) live_parameters=self._optimization_parameters() optimizer_parameters=[p for group in self.opt.param_groups for p in group['params']] rebuild_optimizer=rebuild_optimizer or len(live_parameters)!=len(optimizer_parameters) or any(a is not b for a,b in zip(live_parameters,optimizer_parameters)) self._restore_optimizer(state['optimizer'],rebuild_optimizer) self.curiosity.opt.load_state_dict(state['curiosity_optimizer']); self.rng.bit_generator.state=state['rng'] self.pending_transition=None; self._camera_consumed_any=False for k,v in deepcopy(state['transient']).items(): setattr(self,k,v) if 'experience_model' in state: self.experience_model.import_state(state['experience_model']) else: self.experience_model=ExperienceWorldModel(state_dim=16,action_dim=5,ensemble_size=3,seed=self.config.seed,context_dim=2) if 'surprise_memory' in state: self.surprise_memory.import_state(state['surprise_memory']) else: self.surprise_memory=SurpriseEpisodicMemory() self.compass.bump_angle=state['compass_angle']; self.routing=state['routing'] if hasattr(self, 'neuromod') and state.get('neuromod'): self.neuromod.state = NeuromodulatorState(**state['neuromod']) context=state.get('neuromod_context',{}) self.neuromod.v_predicted=float(context.get('v_predicted',0.)) self.neuromod.history=deepcopy(context.get('history',[])) if hasattr(self, 'astrocytes') and state.get('astrocytes'): self.astrocytes.import_state(state['astrocytes']) if hasattr(self, 'predictive') and state.get('predictive'): self.predictive.import_state(state['predictive']) if hasattr(self, 'homeostasis') and state.get('homeostasis'): self.homeostasis.import_state(state['homeostasis']) if hasattr(self, 'neurogenesis') and state.get('neurogenesis'): self.neurogenesis.import_state(state['neurogenesis']) if hasattr(self, 'dormant_lifecycle') and state.get('dormant_lifecycle') and hasattr(self, 'dormant_lifecycle'): self.dormant_lifecycle.import_state(state['dormant_lifecycle']) if hasattr(self, 'continual_backprop') and self.continual_backprop is not None and state.get('continual_backprop'): self.continual_backprop.import_state(state['continual_backprop']) if hasattr(self, 'fast_weight_memory') and self.fast_weight_memory is not None and state.get('fast_weight_memory'): self.fast_weight_memory.import_state(state['fast_weight_memory']) if hasattr(self, 'latent_reasoner') and self.latent_reasoner is not None and state.get('latent_reasoner'): self.latent_reasoner.load_state_dict(state['latent_reasoner']) if hasattr(self, 'self_model') and self.self_model is not None and state.get('self_model'): self.self_model.import_state(state['self_model']) if self.neural_graft is not None: if state.get('neural_graft') is not None: self.neural_graft.import_state(state['neural_graft']) self.modules['neural_graft']=self.neural_graft.network else: from .neural_graft import NeuralResidualGraft self.neural_graft=NeuralResidualGraft(seed=self.config.seed) self.modules['neural_graft']=self.neural_graft.network if getattr(self,'dendritic_ltc',None) is not None and state.get('dendritic_ltc') is not None: self.dendritic_ltc.import_state(state['dendritic_ltc']) if getattr(self,'oscillatory_coherence',None) is not None and state.get('oscillatory_coherence') is not None: self.oscillatory_coherence.import_state(state['oscillatory_coherence']) if getattr(self,'recurrent_planner',None) is not None and state.get('recurrent_planner') is not None: self.recurrent_planner.import_state(state['recurrent_planner']) if getattr(self,'dpo_engine',None) is not None and state.get('dpo_engine') is not None: self.dpo_engine.import_state(state['dpo_engine']) if getattr(self,'dvgem_memory',None) is not None and state.get('dvgem_memory') is not None: self.dvgem_memory.import_state(state['dvgem_memory']) if getattr(self,'tether_coordinator',None) is not None and state.get('tether_coordinator') is not None: self.tether_coordinator.import_state(state['tether_coordinator']) if getattr(self,'criticality_homeostat',None) is not None and state.get('criticality_homeostat') is not None: self.criticality_homeostat.import_state(state['criticality_homeostat']) if getattr(self,'holographic_vsa',None) is not None and state.get('holographic_vsa') is not None: self.holographic_vsa.import_state(state['holographic_vsa']) if getattr(self, 'apical_engine', None) is not None and state.get('apical_engine') is not None: self.apical_engine.import_state(state['apical_engine']) if getattr(self, 'spectral_reservoir', None) is not None and state.get('spectral_reservoir') is not None: self.spectral_reservoir.import_state(state['spectral_reservoir']) if getattr(self, 'hyperbolic_manifold', None) is not None and state.get('hyperbolic_manifold') is not None: self.hyperbolic_manifold.import_state(state['hyperbolic_manifold']) if getattr(self, 'spiking_engine', None) is not None and state.get('spiking_engine') is not None: self.spiking_engine.import_state(state['spiking_engine']) if getattr(self, 'glymphatic_engine', None) is not None and state.get('glymphatic_engine') is not None: self.glymphatic_engine.import_state(state['glymphatic_engine']) if getattr(self, 'kuramoto_engine', None) is not None and state.get('kuramoto_engine') is not None: self.kuramoto_engine.import_state(state['kuramoto_engine']) if getattr(self, 'archimedes_engine', None) is not None and state.get('archimedes_engine') is not None: self.archimedes_engine.import_state(state['archimedes_engine']) if getattr(self, 'memory_carrier_nexus', None) is not None and state.get('memory_carrier_nexus') is not None: self.memory_carrier_nexus.import_state(state['memory_carrier_nexus']) if getattr(self, 'cross_graft_engine', None) is not None and state.get('cross_graft_engine') is not None: self.cross_graft_engine.import_state(state['cross_graft_engine']) if getattr(self,'comm_fabric',None) is not None and state.get('comm_fabric') is not None: self.comm_fabric.import_state(state['comm_fabric']) if getattr(self,'neurowave_x2',None) is not None and state.get('neurowave_x2') is not None: self.neurowave_x2.import_state(state['neurowave_x2']) if getattr(self,'overflow_mini_brain',None) is not None and state.get('overflow_mini_brain') is not None: self.overflow_mini_brain.load_state_dict(state['overflow_mini_brain']) if getattr(self,'selective_ssm',None) is not None and state.get('selective_ssm') is not None: self.selective_ssm.load_state_dict(state['selective_ssm']) if getattr(self,'grafted_diffusion',None) is not None and state.get('grafted_diffusion') is not None: self.grafted_diffusion.import_state(state['grafted_diffusion']) if getattr(self,'event_backend',None) is not None and state.get('event_backend') is not None: self.event_backend.import_state(state['event_backend']) if getattr(self,'multitimescale',None) is not None and state.get('multitimescale') is not None: self.multitimescale.import_state(state['multitimescale']) if getattr(self,'relational_memory',None) is not None and state.get('relational_memory') is not None: self.relational_memory.import_state(state['relational_memory']) if getattr(self,'graph_diffusion',None) is not None and state.get('graph_diffusion') is not None: self.graph_diffusion.import_state(state['graph_diffusion']) if getattr(self,'active_inference',None) is not None and state.get('active_inference') is not None: self.active_inference.import_state(state['active_inference']) if getattr(self,'thermodynamics',None) is not None and state.get('thermodynamics') is not None: self.thermodynamics.import_state(state['thermodynamics']) if getattr(self,'metaplasticity_bcm',None) is not None and state.get('metaplasticity_bcm') is not None: self.metaplasticity_bcm.import_state(state['metaplasticity_bcm']) if getattr(self,'transfer_entropy',None) is not None and state.get('transfer_entropy') is not None: self.transfer_entropy.import_state(state['transfer_entropy']) if 'torch_rng' in state: torch.random.set_rng_state(state['torch_rng']) self.programmed_prior_status=deepcopy(state.get('programmed_prior_status',self.programmed_prior_status)) self.source_provenance=deepcopy(state.get('source_provenance',self.source_provenance)) def status(self): return {'feature_schema':self.feature_schema,'graph':self.graph.describe(),'tidal_parameters':sum(p.numel() for p in self.tidal.parameters()),'bridge_training':'experimental supervised preparation' if self.bridge_updates else 'untrained','motor_preparation_updates':self.preparation_updates,'camera':'active; visual encoder fused' if getattr(self, '_camera_consumed_any', False) else 'inactive; image not consumed','experience_planning':self.config.experience_planning,'experience_model':self.experience_model.summary(),'surprise_memory':self.surprise_memory.summary(),'evidence_scope':'synthetic graph and heuristic resource adapter; no integrated performance claim','telemetry':deepcopy(self.last_telemetry)}