
    @i                        d Z ddlZddlZddlZddlZddlZddlmZmZ ddlmZm	Z	m
Z
mZmZ ddlmZmZ ddlmZ ddlmZ ddlZddlZddlmZmZmZ 	 dd	lmZmZmZ d
Z ed      Z	 ddl!m"Z"m#Z# d
Z$	 ddl%m&Z&m'Z' d
Z(	 ddl)m*Z*m+Z+ d
Z,	 ddl-m.Z.m/Z/ d
Z0 G d de      Z1e G d d             Z2 G d d      Z3 G d d      Z4 G d d      Z5 G d d      Z6e7dk(  rCddl8Z8 e6       Z9 e:e8jv                        dk  r e<d        e8jz                  d       e8jv                  d    Z>e>d!k(  r_ e:e8jv                        dkD  rJd"j                  e8jv                  dd       Z@e9j                  e@      ZB e< ej                  eBd#             ye>d$k(  r_ e:e8jv                        dkD  rJd"j                  e8jv                  dd       ZDe9j                  eD      ZF e< ej                  eFd#             ye>d%k(  r e:e8jv                        d&k\  rje8jv                  d   ZGe8jv                  d'   ZHd"j                  e8jv                  d(d       ZIe9j                  eGeHeI      ZF e< ej                  eFd#             ye>d)k(  r+e9j                         ZB e< ej                  eBd#             ye>d*k(  r+e9j                         ZB e< ej                  eBd#             ye>d+k(  r+e9j                         ZN e< ej                  eNd#             y e<d,e>         e8jz                  d        yy# e $ r dZdZY w xY w# e $ r dZ$dZ"Y w xY w# e $ r dZ(dZ&Y w xY w# e $ r
 dZ,dZ*dZ+Y w xY w# e $ r dZ0dZ.Y w xY w)-a  
Genesis Memory Cortex
=====================
World-Leading Multi-Tier Memory System with MCP Integration

Unifies all memory systems into a single intelligent architecture:
- Working Memory (Dragonfly) - Fast session context with vector search
- Episodic Memory (SQLite) - Experiential storage with FTS
- Semantic Memory (Neo4j/MCP) - Conceptual knowledge graphs
- Vector Memory (Weaviate/ChromaDB/Dragonfly) - Multi-backend similarity search

Usage:
    from genesis_memory_cortex import MemoryCortex

    cortex = MemoryCortex()
    cortex.remember("Discovered that parallel execution improves performance by 37%")
    results = cortex.recall("performance optimization")

Vector Backends:
    - Redis (Remote/Shared, HNSW indexing) - Fast working memory
    - Qdrant (Remote, episodic vector store) - Experiential storage
    - SQLite (Local, tempo-spatial events) - Episodic events
    - Weaviate/ChromaDB (Optional multi-backend similarity)
    N)datetime	timedelta)DictListAnyOptionalTuple)	dataclassasdict)Path)Enum)MemorySystem
MemoryItemSurpriseScore)
get_loggerwith_contextOperationTimerTzgenesis.cortexF)GenesisMetricsTimedOperation)get_circuit_breakerCircuitBreaker)get_redis_configRedisConfig)VectorManagerVectorDocumentc                        e Zd ZdZdZdZdZdZy)
MemoryTierz=Memory storage tiers based on importance and access patterns.discardworkingepisodicsemanticN)__name__
__module____qualname____doc__DISCARDWORKINGEPISODICSEMANTIC     3/mnt/e/genesis-system/core/genesis_memory_cortex.pyr   r   V   s    GGGHHr+   r   c                       e Zd ZU dZeed<   eed<   eed<   eed<   eed<   eed<   eed<   d	Ze	e
e      ed
<   d	Ze	e
e      ed<   dZeed<   d	Ze	e   ed<   d	Ze	e   ed<   defdZy	)MemoryzUnified memory representation.idcontenttierscoredomainsource	timestampN	embedding	relationsr   access_countlast_accessedmetadatareturnc                 N    t        |       }| j                  j                  |d<   |S )Nr1   )r   r1   value)selfds     r,   to_dictzMemory.to_dictn   s!    4LIIOO&	r+   )r"   r#   r$   r%   str__annotations__r   floatr6   r   r   r7   r8   intr9   r:   r   r@   r*   r+   r,   r.   r.   ^   s    (GL
LKKN'+IxU$+%)IxS	")L##'M8C='#Hhtn# r+   r.   c                       e Zd ZdZ	 	 dded   defdZddedefd	Z	ded
efdZ
ddeded
ee   fdZddeded
ee   fdZded
efdZd
efdZdded
ee   fdZded
efdZy)WorkingMemoryCacheaV  
    Redis-backed cache for working memory tier.
    Provides real-time continuum across all Genesis agents.

    Credentials loaded from environment or secrets.env file.
    See: secrets_loader.py for configuration.

    Features:
    - Circuit breaker for resilience
    - Structured logging
    - Metrics collection
    - Adaptive TTL
    Nredis_configr   ttl_secondsc                    d| _         || _        d | _        d| _        d | _        t
        rt        rt        ddd      | _        |Mt        rt        rt               }n6t        rt        j                  d       d| _        y t        d       d| _        y |j                  s6t        rt        j                  d	       d| _        y t        d
       d| _        y 	 t        j                  |j                   |j"                  |j$                  |j&                  dd      | _        | j                  j)                          d| _        t        r$t        j                  dd|j                   i       y t        d|j                           y # t*        $ rZ}t        r#t        j-                  ddt/        |      i       nt        d|        t        d       d| _        d | _        Y d }~y d }~ww xY w)Nzgenesis:working_memoryFworking_memory_redis   g      >@)failure_thresholdrecovery_timeoutz+No secrets_loader available, using fallbackzC[!] WorkingMemoryCache: No secrets_loader available, using fallbackz-Redis not configured, operating without cachezE[!] WorkingMemoryCache: Redis not configured, operating without cacheT)hostportpasswordsslsocket_timeoutdecode_responseszConnected to RedisrN   extraz/[OK] WorkingMemoryCache: Connected to Redis at zRedis connection failederrorz$[!] WorkingMemoryCache Redis Error: z;[!] Operating in degraded mode without working memory cache)	namespacettlclient	available_circuitCIRCUIT_AVAILABLEr   SECRETS_AVAILABLEr   loggerwarningprintis_configuredinforedisRedisrN   rO   rP   rQ   ping	ExceptionrV   rA   )r>   rG   rH   es       r,   __init__zWorkingMemoryCache.__init__   s   1 !4/&"#!%DM  %5/1NN#PQ "' _`!& ))KL #DN ]^"DN	++!&&!&&%.. $$ !%DK KK!DN0ARAR8STGHYHYGZ[\ 	6wA>OP<QC@AST"DNDKK	s    BF (F 	G$
AGG$memoryadaptive_ttlc                 0   | j                   r2| j                   j                  st        rt        j                  d       yt	        j
                  |j                               }|r| j                  |      n| j                  }t        j                         }	 | j                  r| j                  j                  | j                   d|j                   ||       | j                   r| j                   j                          t        rct         r]t        j                         |z
  }t         j"                  j%                  ddd       t         j&                  j)                  |ddi       t        r%t        j+                  d	|j                  |d
       yyy# t,        $ rx}| j                   r| j                   j/                  |       t        r.t        j1                  dt3        |      |j                  d       nt5        d|        Y d}~yY d}~yd}~ww xY w)z<Store memory in Redis with adaptive TTL based on importance.z*Circuit breaker open, skipping Redis writeN:r   storer1   oplabelsr1   zMemory stored)r/   rX   rT   zRedis write failedrV   r/   z[!] Redis write failed: )r[   is_availabler^   r_   jsondumpsr@   _calculate_ttlrX   timerY   setexrW   r/   record_successMETRICS_AVAILABLEr   memory_operationsincmemory_latencyobservedebugrf   record_failurerV   rA   r`   )r>   ri   rj   memory_datarX   
start_timedurationrg   s           r,   setzWorkingMemoryCache.set   s    ==!;!;KLjj!12 .:d!!&)txxYY[
	6{{!!~~&a		{3 ==MM002$#yy{Z7H"4488Za@b8c"1199(FT]K^9_LLvyyQT8ULV    	6}},,Q/13q6QWQZQZ9[\0455 ]		6s   C;F 	HA)HHr;   c                    | j                   }t        |d      r|j                  nd}d|dz  z   }h d}t        |d      r|j                  nd}|j	                         |v rdnd}t        |d      r|j
                  nd}t        t        |      d	z  d      }	t        ||z  |z  d
|	z   z        }
t        dt        |
d            S )aB  
        Calculate adaptive TTL based on memory importance.

        Factors:
        - Base TTL (1 hour)
        - Score bonus: High score = longer retention
        - Domain bonus: Certain domains get longer retention
        - Length bonus: More content = likely more important

        Returns TTL in seconds.
        r2         ?g      ?>   axiominsightcriticallearningsecurityr3          ?r0   i     i,  Q )
rX   hasattrr2   r3   lowerr0   minlenrD   max)r>   ri   base_ttlr2   score_multiplierimportant_domainsr3   domain_multiplierr0   length_bonusrX   s              r,   rv   z!WorkingMemoryCache._calculate_ttl   s     88 !( 8c%#+. U")&(";#)<<>5F#FCC %,FI$>&..B3w<$.4 (--0AAQEUVW 3C((r+   	memory_id
extend_ttlc                    | j                   rE| j                   j                  s/t        r(t        r"t        j                  j                  ddi       y| j                  r| j                  rt        j                         }	 | j                   d| }| j                  j                  |      }|rrt        j                  |      }| j                  |      }| j                   d}| j                  j                  ||d      }	|rk| j                  j                  |      }
|
dkD  rKt!        |	d	z  d
      }t#        |
d|dz  z   z        }t!        |d      }| j                  j%                  ||       | j                   r| j                   j'                          t        rt        rt        j                         |z
  }t        j(                  j                  ddi       t        j*                  j                  ddd       t        j,                  j/                  |ddi       |S t        r(t        r"t        j                  j                  ddi       yy# t0        $ ri}| j                   r| j                   j3                  |       t4        r$t4        j7                  dt9        |      |d       nt;        d|        Y d}~yd}~ww xY w)z?Retrieve memory from Redis, optionally extending TTL on access.r1   r   rp   Nrl   :access_countsr   r   g?r   r   r   getrn   zRedis get failedrr   rT   z[!] Redis get failed: )r[   rs   rz   r   cache_missesr|   rZ   rY   rw   rW   r   rt   loads_dict_to_memoryhincrbyrX   r   rD   expirery   
cache_hitsr{   r}   r~   rf   r   r^   rV   rA   r`   )r>   r   r   r   keydatamem_dictri   
access_keyr8   current_ttl	extensionnew_ttlr   rg   s                  r,   r   zWorkingMemoryCache.get	  sA    ==!;!; ^++//	7J/K>>dkkJ(8()5{{s+#zz$/H!11(;F %)NN#3>!BJ#';;#6#6z9a#PL "&*kkooc&:&?(+L3,>(DI&)+Y_9L*M&NG&)'5&9G KK..sG< }}446(^#'99;#;&1155fi=P5Q&88<<Y^cDd<e&55==hPVXaOb=c!M(^&3377	?R7S   8==MM003LL!3SVS\;]L^21#678s    F I ".I 	KAJ??Kquerylimitc                    g }| j                   r	 | j                  j                  | j                   d      D ]  }| j                  j	                  |      }|rXt        j                  |      }|j                         |d   j                         v r |j                  | j                  |             t        |      |k\  s |S  	 |S |S #  Y |S xY w)zSearch working memory keys.:*r0   )rZ   rY   	scan_iterrW   r   rt   r   r   appendr   r   )r>   r   r   resultsr   r   r   s          r,   searchzWorkingMemoryCache.search>  s    >>;;00DNN3C21FG C;;??3/D#'::d#3 ;;=HY,?,E,E,GG#NN4+?+?+IJ7|u,  ws   B.C ?C C Cr?   c                 @    ddl m}  ||d         |d<   t        di |S )z*Helper to restore Memory object from dict.r   )r   r1   r*   )genesis_memory_cortexr   r.   )r>   r?   r   s      r,   r   z"WorkingMemoryCache._dict_to_memoryP  s#    4qy)&	{{r+   c                     | j                   rL	 t        t        | j                  j	                  | j
                   d                  }d|| j                  ddS dddS #  Y 	xY w)zGet cache statistics.r   rc   T)backendsizerH   rZ   fallbackF)r   rZ   )rZ   r   listrY   r   rW   rX   )r>   counts     r,   statszWorkingMemoryCache.statsV  si    >>	D!6!6$..9I7L!MNO&!#'88!%	  &E::s   A
A A"access_thresholdc                    g }| j                   r	 | j                   d}| j                  j                  | j                   d      D ]  }d|v r|j	                  d      d   }t        | j                  j                  ||      xs d      }||k\  sK| j                  j                  |      }|si|j                  | j                  t        j                  |                    	 |S |S # t        $ r Y |S w xY w)z
        Get memories ready for promotion to episodic tier.
        In working memory, we promote based on access count tracked via Redis.
        r   r   rl   r   )rZ   rW   rY   r   splitrD   hgetr   r   r   rt   r   rf   )r>   r   r   r   r   r   r8   r   s           r,   get_promotablez!WorkingMemoryCache.get_promotablee  s    
 >> $/~>
;;00DNN3C21FG SC'3.  #		#r 2I#&t{{'7'7
I'N'SRS#TL#'77#{{s3#NN4+?+?

4@P+QRS w  s   BC* C* 05C* *	C76C7c                     | j                   rU	 | j                  j                  | j                   d|        | j                  j	                  | j                   d|       yy#  Y yxY w)z#Remove a memory from working cache.rl   r   TF)rZ   rY   deleterW   hdelr>   r   s     r,   removezWorkingMemoryCache.remove{  se    >>""dnn%5Qyk#BC  DNN#3>!BIN s   AA# #A')Ni  T)rK   )   )r"   r#   r$   r%   r   rD   rh   r.   boolr   rv   rA   r   r   r   r   r   r   r   r   r*   r+   r,   rF   rF   t   s     @D$(<Xm%< <!<|$6& $6 $6N)V ) )B3S 3d 3hv>N 3jC  DL $ & ;t ;s 4< ,	 	 	r+   rF   c                       e Zd ZdZddedefdZd Zdedefd	Z	dd
ede
dee   fdZdedee   fdZddede
dee   fdZ	 	 ddede
dee   fdZdefdZdefdZdefdZy)EpisodicMemoryStorezg
    SQLite-based episodic memory storage.
    Stores experiential memories with temporal context.
    Ndb_pathuse_postgresc                 N   || _         d | _        |rS	 dd l}|j                  j	                  d       ddlm} ddlm}  |d
i |j                         | _        t        d       y t        d	      # t        $ r,}t        d|        t        d       t        d|       d }~ww xY w)Nr   z%E:\genesis-system\data\genesis-memory)PostgreSQLStore)PostgresConfigz=[OK] EpisodicMemoryStore: PostgreSQL (Elestio) backend activez4[!] CRITICAL FAILURE: PostgreSQL Connection Failed: z7[!] Fall back to SQLite is FORBIDDEN by user directive.z:PostgreSQL connection failed. Strict mode enabled. Error: z6EpisodicMemoryStore must use PostgreSQL in production.r*   )r   pg_storesyspathr   storage.postgresql_storer   elestio_configr   get_connection_paramsr`   rf   ConnectionError
ValueError)r>   r   r   r   r   r   rg   s          r,   rh   zEpisodicMemoryStore.__init__  s    ( h HID9 / Y.2V2V2X YUV UVV  hLQCPQOP%(bcdbe&fgg	hs   AA/ /	B$8'BB$c                 2    | j                   st        d      y)z-Initialize database (PostgreSQL Strict Mode).z+SQLite fallback is disabled in Strict Mode.N)r   r   r>   s    r,   _init_dbzEpisodicMemoryStore._init_db  s      KLL !r+   ri   r;   c           
      f   | j                   st        d      | j                   j                  |j                  |j                  |j
                  r|j
                  j                  d      nd|j                  |j
                  r|j
                  j                  dd      nd      xs |j                  S )z*Store episodic memory (PostgreSQL Strict)..PostgreSQL Store not initialized (Strict Mode)agent_idNsurprise_scoreg        )r0   source_typer   importance_scorer   )	r   r   store_episoder0   r4   r:   r   r2   r/   )r>   ri   s     r,   rm   zEpisodicMemoryStore.store  s    }}"#STT}}**NN8>V__((4T#\\IO6??../?E^a + 
  YY	r+   r   r   c                     | j                   st        d      | j                   j                  ||d      }|D cg c]  }| j                  |       c}S c c}w )z(Search for memories (PostgreSQL Strict).r   active)r   r   statusr   r   search_episodes_episode_to_memory)r>   r   r   episodesrg   s        r,   r   zEpisodicMemoryStore.search  sX    }}"#STT==00 1 

 5==q''*===s   Ar   c                     | j                   st        d      | j                   j                  |      }|r| j                  |      S y)zGet specific memory by ID.r   N)r   r   get_episoder   )r>   r   eps      r,   r   zEpisodicMemoryStore.get  s@    }}"#STT]]&&y1**2..r+   r3   c                     | j                   st        d      | j                   j                  ||      }|D cg c]  }| j                  |       c}S c c}w )zGet memories by domain.r   )r   r   r   )r>   r3   r   r   rg   s        r,   get_by_domainz!EpisodicMemoryStore.get_by_domain  sW    }}"#STT ==00 1 
 5==q''*===   Ascore_thresholdr   c                     | j                   st        d      | j                   j                  |d      }|D cg c]  }| j                  |       c}S c c}w )z!Get memories ready for promotion.r      )min_importancer   r   )r>   r   r   r   rg   s        r,   r   z"EpisodicMemoryStore.get_promotable  sW     }}"#STT==00* 1 
 5==q''*===r   c                      y)zDelete a memory.Nr*   r   s     r,   r   zEpisodicMemoryStore.delete  s    r+   c                 d    | j                   st        d      | j                   j                         S )zGet storage statistics.r   )r   r   	get_statsr   s    r,   r   zEpisodicMemoryStore.stats  s(    }}"#STT}}&&((r+   c                    t        |j                  |j                  t        j                  |j
                  |j                  |j                  xs d|j                  |j                  |j                  d|j                  i
      S )z$Convert PG Episode to Memory object.observationoriginal_id)
r/   r0   r1   r2   r3   r4   r5   r8   r9   r:   )r.   
episode_idr0   r   r(   r   r   
source_ref
created_atconsolidation_countaccessed_at)r>   r   s     r,   r   z&EpisodicMemoryStore._episode_to_memory  se    }}JJ$$%%>>==1Mmm//..#R]]3
 	
r+   )NT)
   )r   )      ?rK   )r"   r#   r$   r%   rA   r   rh   r   r.   rm   rD   r   r   r   r   r   rC   r   r   r   r   r   r*   r+   r,   r   r     s    
W W$ W.MF s 
>C 
> 
>T&\ 
>S Xf%5 
>C 
> 
>T&\ 
> 7;/0
>e 
>),
>59&\
> )t )
 
r+   r   c                   |    e Zd ZdZd Zd Zd ZdedefdZ		 dded	ed
efdZ
defdZd ZdedefdZdedefdZy)SemanticMemoryStorez\
    MCP-based semantic memory storage.
    Integrates with MCP memory knowledge graph.
    c                 D    t        d      | _        | j                          y )Nz/E:\genesis-system\data\semantic_memory_log.json)r   bridge_log_path	_load_logr   s    r,   rh   zSemanticMemoryStore.__init__  s    #$VWr+   c                     g g d| _         | j                  j                         r:	 t        | j                        5 }t	        j
                  |      | _         ddd       yy# 1 sw Y   yxY w# t        $ r Y yw xY w)zLoad pending operations log.entitiesr7   N)pendingr  existsopenrt   loadrf   r>   fs     r,   r  zSemanticMemoryStore._load_log	  st    $&R8&&($../ 01#'99Q<DL0 0 )0 0 s.   A, A A,  A)%A, )A, ,	A87A8c                     t        | j                  d      5 }t        j                  | j                  |d       ddd       y# 1 sw Y   yxY w)zSave pending operations.w   indentN)r  r  rt   dumpr
  r  s     r,   	_save_logzSemanticMemoryStore._save_log  s=    $&&, 	1IIdllAa0	1 	1 	1s   #AAri   r;   c                 p   | j                  |      | j                  |j                        |j                  d|j                  dd|j                   d|j
                   d|j                   g|j                  d}| j                  d   j                  |       | j                          |j                  S )zt
        Queue memory for MCP storage.

        In Claude Code context, these will be synced via MCP tools.
        zScore: z.3fzDomain: zSource: zTimestamp: )name
entityTypeobservationsr   r	  )_generate_entity_name_get_entity_typer3   r0   r2   r4   r5   r/   r
  r   r  )r>   ri   entitys      r,   rm   zSemanticMemoryStore.store  s     ..v6//>&,,s+,6==/*6==/*f../0  
 	Z ''/yyr+   from_memory	to_memoryrelation_typec                 l    |||d}| j                   d   j                  |       | j                          y)z"Queue a relation between memories.fromtorelationTyper7   N)r
  r   r  )r>   r  r  r   relations        r,   add_relationz SemanticMemoryStore.add_relation/  s7      )

 	[!((2r+   c                     | j                   S )zGet pending MCP operations.)r
  r   s    r,   get_pendingzSemanticMemoryStore.get_pending:  s    ||r+   c                 8    g g d| _         | j                          y)z$Clear pending operations after sync.r  N)r
  r  r   s    r,   mark_syncedzSemanticMemoryStore.mark_synced>  s    $&R8r+   c                 &   |j                   j                         dd }dj                  |      dd }t        j                  |j
                  j                               j                         dd }|j                  j                          d| d| dS )	z!Generate entity name from memory.N    2      z: z ())
r0   r   joinhashlibmd5r/   encode	hexdigestr3   title)r>   ri   wordsshortsuffixs        r,   r  z)SemanticMemoryStore._generate_entity_nameC  s    $$&r*$VYY--/0::<Ra@--%%'(5'F81==r+   r3   c                 8    ddddddd}|j                  |d      S )	zMap domain to entity type.r   	discoveryissuedecisionpattern
capability)r   	technicalrV   r>  r?  r@  r   )r   )r>   r3   mappings      r,   r  z$SemanticMemoryStore._get_entity_typeJ  s0     #$" &
 {{6=11r+   N)
relates_to)r"   r#   r$   r%   rh   r  r  r.   rA   rm   r'  r   r)  r+  r  r  r*   r+   r,   r  r    s    
1
F s 0 +7	 	 	$'	T 
>F >s >
2s 
2s 
2r+   r  c                      e Zd ZdZdddddZd defdZ	 	 	 d!d	ed
ededee	   de
de	eef   fdZ	 	 	 d"dededee
   dedee	   f
dZde	eef   fdZdedededee	   fdZde	fdZde	fdZd Zdede
fdZd	edefdZy)#MemoryCortexa  
    Unified Memory Cortex - The Genesis Brain.

    Orchestrates all memory tiers:
    - Working Memory: Fast session cache
    - Episodic Memory: Experiential SQLite storage
    - Semantic Memory: MCP knowledge graph

    Uses surprise-based scoring for tier routing.
    g333333?r   皙?)r   r   r    r!   enable_vectorsc                    t               | _        t               | _        t	               | _        t               | _        d | _        d| _	        |rt        r	 t               | _        ddlm}  || j                        | _        | j                  j                         }t!        |j#                               | _	        | j                  r,|j%                         D cg c]
  \  }}|s	| c}}| _        ng | _        dt,        D ci c]  }|j.                  d c}dd| _        y c c}}w # t(        $ r}g | _        t+        d|        Y d }~Rd }~ww xY wc c}w )NFr   )SynapseLinkerzVector backends unavailable: )memories_processedtier_distributionvector_stores)r   surpriserF   r   r   r    r  r!   vectorsvector_enabledVECTOR_AVAILABLEr   synapse_linkerrI  linkerhealthanyvaluesitems_active_backendsrf   r`   r   r=   r   )r>   rG  rI  rS  kvrg   ts           r,   rh   zMemoryCortex.__init__k  s   $)++-+- #.;,8+DLL9,,.&)&--/&:#&&;A<<>,O41aQQ,OD),.D) #$6@!A!''1*!A

 -P  ;(*%5aS9::; "Bs7   BD& 
D "D &D&  E D& &	E/E		ENr0   r4   r3   r:   
force_tierr;   c                    |i }t         j                  j                  d      rt        d       t	        d      	 ddlm}  |||||xs i       }|j                  }|j                  }| j                  |      }
|r,| j                  r ||d
<   t        d|
 dt        |       d       t        j                         j!                         }| j"                  j%                  |||      }|d   d   }|r|}n| j'                  |      }t)        |
|||||||xs i       }g }|t*        j,                  k(  rn|t*        j.                  k(  r-| j0                  j3                  |       |j5                  d       n|t*        j6                  k(  r^| j8                  j;                  |       |j5                  d       |dk\  r| j<                  j;                  |       |j5                  d       nk|t*        j>                  k(  rX| j8                  j;                  |       | j<                  j;                  |       |j5                  d       |j5                  d       i }| j                  r|t*        j6                  t*        j>                  fv r	 |j@                  |||d}tC        | d      r4| jD                  jG                  |
||      \  }}||d
<   ||d<   ||d
<   ||d<   | jH                  jK                  |
||      }t        d|        |jM                         D ]9  \  }}|dk7  s|s|j5                  d|        | jN                  dxx   dz  cc<   ; 	 | jN                  d xx   dz  cc<   | jN                  d!   |j@                  xx   dz  cc<   |
|j@                  tS        |d"      |d   ||d#S # t        $ r!}	t        d|	        t        d	|	       d}	~	ww xY w# t        $ r&}	t        d|	        tQ        |	      |d<   Y d}	~	d}	~	ww xY w)$zu
        Process and store a memory.
        
        CRITICAL: Checks for SYSTEM_LOCKDOWN before executing.
        Nz+E:/genesis-system/data/SYSTEM_LOCKDOWN.modeu4   ⛔ MEMORY CORTEX REFUSED: System in Cardiac Arrest.z$SYSTEM HALTED: Core Connection Lost.r   )MemoryItemInputr0   r4   r3   r:   u   ⛔ POISON PILL DETECTED: zMemory Reject: r7   u   🕸️ SYNAPSE: Linking z to z nodes.r2   total)r/   r0   r1   r2   r3   r4   r5   r:   working_cacheepisodic_dbg333333?semantic_mcp)r1   r2   r3   r4   rR  
risk_level)doc_idr0   r:   z      VECTOR DEBUG: results=r/   vector_rL  r   z      VECTOR ERROR: rV   rJ  rK  r   )r   r1   r2   score_breakdown	stored_inr5   )*osr   r  r`   r   memory_schemasr]  r0   r7   rf   r   _generate_idrO  r   r   now	isoformatrM  evaluate_route_to_tierr.   r   r&   r'   r   r   r   r(   r    rm   r!   r)   r=   r   rR  link_memoryrN  addrV  r   rA   round)r>   r0   r4   r3   r:   r[  r]  	validatedr7   rg   r   r5   eval_resultr2   r1   ri   rg  vector_resultsvector_metadatalinksriskr   successs                          r,   rememberzMemoryCortex.remember  s    H77>>GHHI!"HII	46'v`h`nlnoI''G!++I %%g.	 ,, &/Xk".ykc)n=MWUVLLN,,.	 mm,,WffEG$W- D&&u-D ^	
 	:%%%Z'''LLV$_-Z(((MM']+|##F+  0Z(((MM'MM']+^, 4J,?,?ATAT+U#U1 JJ"$$	# 4*"&++"9"9)Wf"UKE438OK048OL1,1H[)-1H\*!%!1!1$#, "2 "
 4^4DEF(6(<(<(> 9$GW$7!((77))<=

?3q839 	

'(A-(

&'

3q83 #JJ5!_*73""
 	
E  	4.qc23qc233	4t  1,QC01*-a&w'1s<   .N%  BO O -O %	O.O

O	PO<<Pr   r   tiersuse_vectorsc                    |/t         j                  t         j                  t         j                  g}g }t	               }|r| j
                  r	 | j                  j                  ||      }|D ]  }|j                  |vs|j                  |j                         |j                  |j                  nd}	|j                  d|j                  j                  dd      |j                  |j                  |j                  j                  dd      |j                  j                  dd	      |j                  d
|	|	d        	 t         j                  |v rp| j                   j#                  ||      }|D ]O  }|j                  |vs|j                  |j                         |j                  d|j%                         dd       Q t         j                  |v st         j                  |v rz| j&                  j#                  ||      }|D ]Y  }|j                  |vs|j                  |j                         |j                  d|j%                         |j                  d       [ |j)                  d d       |d| S # t        $ r}
Y d}
~
Hd}
~
ww xY w)z
        Search for relevant memories across all tiers.

        Uses hybrid search: keyword (FTS) + semantic (vectors).
        Returns ranked list of matching memories.
        N)top_kr   vectorr   unknownr2   r3   general)r/   r0   r2   r3   r:   )r1   r4   ri   	relevance
similarityr   rF  )r1   ri   r  r    c                     | d   S )Nr  r*   )xs    r,   <lambda>z%MemoryCortex.recall.<locals>.<lambda>L  s
    1[> r+   T)r   reverse)r   r'   r(   r)   r   rO  rN  unified_searchr/   rp  r2   r   r:   r   r0   rf   r   r   r@   r    sort)r>   r   r   rz  r{  r   seen_idsrt  docr  rg   working_resultsmepisodic_resultss                 r,   recallzMemoryCortex.recall  s7    ='')<)<j>Q>QRE5 4..!%!<!<U%!<!P) CvvX- SVV,25))2GSYYS
$,&)ll&6&6y)&L&)ff+.;;),)9)9'3)G*-,,*:*:8Y*O,/LL' *4*4( 	* &"ll11%?O$ 44x'LL&NN )"#))+%($  %':+>+>%+G#}}33E5A% 44x'LL&NN *"#))+%&WW$  	14@v;  s   0I8 >C I8 8	JJc                    ddd}| j                   j                  d      }|D ]  }|j                  t        j                  k(  sJ d|j                   d       t        j
                  |_        | j                  j                  |       | j                   j                  |j                         |dxx   dz  cc<    | j                  j                  d	d
      }|D ]  }|j                  t        j                  k7  s!|j                  t        j
                  k(  sJ d|j                   d       t        j                  |_        | j                  j                  |       |dxx   dz  cc<    |S )u   
        Run consolidation loop:
        1. Promote working → episodic based on access
        2. Promote episodic → semantic based on score/access
        r   )working_to_episodicepisodic_to_semanticr   )r   zPromotion violation: z -> Episodicr  r   r  rK   )r   r   z -> Semanticr  )r   r   r1   r   r'   r(   r    rm   r   r/   r)   r!   )r>   promoted
promotableri   s       r,   consolidatezMemoryCortex.consolidateO  sS    ,-aH \\00!0D
  	1F;;*"4"44g8Mfkk]Zf6gg4$--FKMM'LL		**+q0+	1 ]]11  2 

 ! 	6F{{j111{{j&9&99l=RSYS^S^R__k;ll9(11##F+/0A50	6 r+   actionexpectedactualc                 "   | j                   j                  ||       | j                   j                  |      }g }|D ]P  }|j                  dd      dkD  s| j	                  d| d| d| ddd	||||d   d
      }|j                  |       R |S )zp
        Reflective learning from action outcomes.

        Stores significant deviations as learnings.
        	deviationr   g?zLearning from 'z': Expected 'z' but got ''reflective_loopr   )r  r  r  r  r^  )rM  r~   reflectr   ry  r   )r>   r  r  r  	learningsr   r   results           r,   r  zMemoryCortex.reflectp  s     	fh/ MM))&1	 ! 	'H||K+c1-fX]8*KX^W__`a,%"($,"(%-k%:		 ' 
 v&	' r+   c           
         | j                   | j                  j                         | j                  j                         t        | j                  j
                  j                  dg             t        | j                  j
                  j                  dg             d| j                  j                         d}| j                  r-d| j                  | j                  j                         d|d<   |S dd	d
|d<   |S )z$Get comprehensive memory statistics.r	  r7   r  )cortexworking_memoryepisodic_memorypending_semantic_syncsurprise_memoryT)enabledactive_backendsrS  vector_backendsFz!No backends available or disabled)r  reason)r   r   r    r   r!   r
  r   rM  r   rO  rW  rN  rS  )r>   r   s     r,   r   zMemoryCortex.get_stats  s     jj"ll002#}}224 5 5 9 9*b IJ !6!6!:!:;!KL&  $}}668	
 #'#8#8,,--/(E#$ 	 !=(E#$
 r+   c                    | j                   j                         }|d   s	|d   sddiS g }|d   r3|d   D cg c]  }|d   |d   |d   d }}|j                  d	|d
       |d   r3|d   D cg c]  }|d   |d   |d   d }}|j                  d|d       d|t        |d         t        |d         dS c c}w c c}w )z{
        Get commands to sync semantic memories to MCP.

        Run the returned commands in Claude Code context.
        r	  r7   r   nothing_to_syncr  r  r  )r  r  r  mcp__memory__create_entities)toolr	  r#  r$  r%  r"  mcp__memory__create_relations)r  r7   pending_sync)r   commandsentity_countrelation_count)r!   r)  r   r   )r>   r
  r  rg   r	  rr7   s          r,   sync_to_mcpzMemoryCortex.sync_to_mcp  s,    --++-z"7;+?/00:
 z*	,  &	o !. 1 ,H ,
 OO6$ 
 ;
 {+	-  &	g !. 1 -I -
 OO7&  % 
 34!'+"67	
 	
+,-s   B:/B?c                 8    | j                   j                          y)z,Mark all pending MCP operations as complete.N)r!   r+  r   s    r,   mark_mcp_syncedzMemoryCortex.mark_mcp_synced  s    !!#r+   r2   c                     || j                   d   k  rt        j                  S || j                   d   k  rt        j                  S || j                   d   k  rt        j                  S t        j
                  S )z%Determine memory tier based on score.r   r   r    )
THRESHOLDSr   r&   r'   r(   r)   )r>   r2   s     r,   rn  zMemoryCortex._route_to_tier  se    4??9--%%%T__Y//%%%T__Z00&&&&&&r+   c                 b    ddl }|j                  d      }t        |j                  ||            S )z$Generate unique memory ID (UUID v5).r   Nz$e2a6d7f8-b3c4-4d5e-8f90-a1b2c3d4e5f6)uuidUUIDrA   uuid5)r>   r0   r  GENESIS_NAMESPACEs       r,   rj  zMemoryCortex._generate_id  s,     II&LM4::/9::r+   r   )claude_coder  NN)r   NT)r"   r#   r$   r%   r  r   rh   rA   r   r   r   r   ry  rD   r   r  r  r  r   r  r  rC   rn  rj  r*   r+   r,   rE  rE  W  s@   	 	J
t 
B 4AEI*.~
 ~
S ~
~
4<TN~
'~
37S>~
@ /1)-#'AC A A:&A A,0JAFT#s(^ Bc S # $t* >4 8(
T (
T$	'E 	'j 	';C ;C ;r+   rE  __main__r  a  
Genesis Memory Cortex - World-Leading AI Memory System
=======================================================

Commands:
  remember "<content>"          Store a new memory
  recall "<query>"              Search for memories
  reflect "<action>" "<exp>" "<actual>"  Learn from outcome
  consolidate                   Run memory consolidation
  sync                          Get MCP sync commands
  stats                         Show memory statistics

Examples:
  python genesis_memory_cortex.py remember "Discovered that caching improves latency by 50%"
  python genesis_memory_cortex.py recall "performance optimization"
  python genesis_memory_cortex.py reflect "Deploy feature" "Smooth rollout" "Had errors"
  python genesis_memory_cortex.py stats
        r   ry  r.  r  r  r  rK   r   r0  r  syncr   zUnknown command: )Or%   rt   r3  rc   rh  r   r   typingr   r   r   r   r	   dataclassesr
   r   pathlibr   enumr   	threadingrw   core.surprise_memoryr   r   r   logging_configr   r   r   LOGGING_AVAILABLEr^   ImportErrormetricsr   r   rz   circuit_breakerr   r   r\   secrets_loaderr   r   r]   r  r   r   rP  r   r.   rF   r   r  rE  r"   r   r  r   argvr`   exitcommandr2  r0   ry  r  ru   r   r  r   r  r  r  r  r  r  r   r   r*   r+   r,   <module>r     s  2     	 ( 3 3 )     I HGG()F
6C<=    *P Pfu
 u
pU2 U2pR; R;l z^F
388}q  	$ 	hhqkG*SXX!2((388AB<()jdjj*+	H	SXX!2!"&--&jdjj+,	I	#chh-1"4!88A;#((12,'..6:jdjj+,	M	!##%jdjj*+	F	##%jdjj*+	G	  "jdjjq)* 	!'+,w y  F  N    K  MsZ   L  )
L0 4
M  ?
M 

M"  	L-,L-0	L=<L= 	MMMM"	M/.M/