agent_floor_keeper.py — Genesis Constitution Article 3.3 Enforcer


RLMCaptureAgent — async agent loop for capturing call transcripts.


AI Readiness Audit — AuditReportGenerator: generates full AI readiness reports (1532 lines), scores 5 dimensions (Strategy/Data/Talent/Process/Technology), produces PDF/HTML/JSON reports


Industry CompanySize ScoreGrade PriorityLevel ImplementationComplexity CompanyProfile DimensionScore ROIProjection RecommendedAction ImplementationPhase AIReadinessReport AuditInput

AI Readiness Audit — Pydantic schemas: AIReadinessReport, CompanyProfile, DimensionScore, ROIProjection, RecommendedAction, ImplementationPhase for structured audit data


Auth — FastAPI Auth Middleware: JWT Bearer token extraction and validation, attaches user_id/tenant_id to request state for downstream handlers


Auth — SupabaseClient: wraps Supabase Python SDK for user authentication (signup, login, token refresh, logout), JWT verification, session management


AtomicIOBenchmarks PostgresBenchmarks SurpriseBenchmarks CircuitBreakerBenchmarks


Billing — StripeClient: Stripe API integration for subscription management, checkout session creation, customer portal, metered billing for SubAIVA tiers ($497/$997/$1497/$20K)


Billing — Stripe Webhook Handler: processes checkout.session.completed, customer.subscription.updated/deleted, invoice.paid events to update tenant entitlements


EntryType TaskStatus BlackboardEntry Blackboard VotingStrategy VotingConfig VoteRecord VotingConsensus Agent


MessageDirection OpenClawMessage BridgeWriter BridgeReader

OpenClaw Bridge — bidirectional message bridge between Genesis (WSL2) and AIVA's OpenClaw gateway (Mac Mini). BridgeWriter pushes messages, BridgeReader polls for responses


GenesisBrowserAgent — Layer 2 Autonomous Browser Agent


BrowserLevel NavigationStatus BrowserConfig NavigationResult ElementResult BrowserBackend PlaywrightBackend HTTPClientBackend ArchiveBackend BrowserController


ActivityLevel TaskType TimeSlot ScheduledTask CircadianScheduler


CircuitState CircuitStats CircuitBreaker CircuitOpenError CircuitBreakerRegistry


Genesis Claude Bridge - Real-time communication between Claude Desktop and Claude Code


Coherence — Bulkhead Pattern: isolates agent failure domains so one crashing agent cannot cascade failures to others


Coherence Orchestrator — coordinates multi-agent state coherence: OCC commits, bulkhead isolation, staging area lifecycle, semantic merge conflict resolution


Coherence — Optimistic Concurrency Control Commit: version-checked atomic commits to shared Redis state with conflict detection and retry


Coherence — Redis Master State: single source of truth for shared swarm state using Redis WATCH/MULTI/EXEC transactions


Coherence — Staging Area: temporary holding zone for agent outputs before they are committed to shared state via OCC


Coherence — State Delta: represents a diff between two agent state snapshots; used by CoherenceOrchestrator to merge parallel agent outputs


Coherence — SwarmWorkerBase: abstract base class for all coherence-aware swarm workers with built-in bulkhead, OCC commit, and staging area lifecycle


Coherence — Task DAG Pusher: publishes task dependencies to Redis for Claude Code native TaskCreate/TaskUpdate DAG coordination


ContentBlock ChatMessage Account Conversation EnrichedConversation ProcessingCheckpoint ProcessingStats CreatorMindAbsorber

AIVA Consciousness Enrichment: Creator Mind Absorber


AIVA RLM Nexus — Centralized Connection Factory


Email — Resend Email Client: sends transactional emails (onboarding, billing alerts, epoch reports) via Resend API with template support


Email — Email Templates: Jinja2 HTML email templates for welcome, billing, epoch report digest, lead notification emails


embed_repair.py — embed all bloodstream_knowledge rows where embedding_id IS NULL.


SurpriseScore MemoryVector EnhancedSurpriseDetector MemorySystem


Story 3.08: PostCallEnricher — Gemini Enrichment


Epoch Pipeline — AxiomDistiller: clusters high-surprise memories from an epoch into axiom candidates using Gemini Flash, writes to KNOWLEDGE_GRAPH/axioms/


Epoch Pipeline — ConversationAggregator: collects raw conversation transcripts from PostgreSQL for a given time window and tenant set


Epoch Pipeline — EpochKnowledgeWriter: persists distilled axioms and epoch summaries to KNOWLEDGE_GRAPH/entities/ JSONL files


Epoch Pipeline — EpochReportGenerator: generates human-readable Markdown epoch reports with stats, top axioms, surprise score distribution


Epoch Pipeline — EpochRunner: orchestrates a single epoch: aggregates conversations, scores surprises, distills axioms, writes to KG, generates report. Implements Track A Module 1


Epoch Pipeline — EpochScheduler: APScheduler-based cron trigger for daily epoch runs (3 AM UTC by default)


Epoch Pipeline — EpochTier1Trigger: triggers Tier 1 memory consolidation when surprise score threshold is hit during a live session (real-time epoch)


Epoch Pipeline — NightlyEpochRunner: runs full nightly consolidation pipeline (all tenants), uses Redis lock to prevent concurrent runs, emits Telegram status report


Epoch Pipeline — NightlyEpochScheduler: schedules NightlyEpochRunner using APScheduler with Redis-backed distributed lock


Epoch Pipeline — RedisEpochLock: distributed mutex preventing concurrent epoch runs across multiple server instances using Redis SETNX with TTL


Story PRD AIVAState AIVAAgent PRDParser PRDSpawner AIVARWLEngine

AIVA RWL ENGINE - Queen's Primary Development Engine


Evolution — Blue/Green Deployment: manages safe A/B deployment of evolution proposals with traffic shifting and automatic rollback on error rate spike


Evolution — CodeProposer: generates code patches for identified gaps using Gemini Flash, validates syntax, creates diff objects for gitops PR creation


Evolution — GapDetector: scans codebase for missing tests, missing verification stamps, missing docstrings, imports that don't exist, produces prioritized gap list


Evolution — GitOps PR Creator: creates GitHub PRs for evolution proposals using git worktrees on E: drive, includes test stubs and VERIFICATION_STAMP


Bottleneck FixProposal ArchitectureAnalysis MetaArchitect

Evolution — MetaArchitect: analyzes system architecture for bottlenecks, proposes structural improvements using Gemini Pro, generates ArchitectureAnalysis reports


Story PRD EngineState FlashAgent PRDParser PRDSpawner PerpetualEvolutionEngine

Evolution — PerpetualEvolutionEngine: infinite RWL loop that continuously proposes PRDs, spawns Gemini agents, verifies outputs, submits PRs. The Genesis self-improvement core


ScarCluster ScarReport _ScarRecord ScarAggregator


Gemini Command Centres — CLI Entry Point


GCC — GeminiAgent: individual Gemini session agent with CTM flush, respawn detection, context-window tracking, tool call execution


GCC — CTM (Commit To Memory): saves session summary, key decisions, and pending tasks to handoff files before context fills; equivalent to pre_compact_ctm.py hook


GCC — GeminiDaemon: persistent daemon managing a fleet of GeminiAgents, auto-respawn on crash, workload distribution


GCC — Launcher: multi-daemon launch orchestration, config loading, signal handling for graceful shutdown of entire GCC fleet


GCC — Watchdog: monitors GeminiDaemon health, triggers respawn on failure, emits Prometheus metrics for GCC fleet health


GeminiResponse GeminiExecutor TitanMemory TitanMemoryManager

Gemini Executor — GeminiExecutor: direct Gemini API calls (Flash/Pro/Ultra), TitanMemory integration for surprise learning, model selection, retry logic, streaming support


TaskType ModelLimits UsageWindow ScheduledRequest UtilizationReport GeminiRateMaximizer

Gemini Rate Maximizer — GeminiRateMaximizer: manages Gemini API rate limits (RPM/TPM per model), schedules requests at 90-95% capacity utilization, auto-selects Flash/Pro based on task type


argparse google playwright playwright_stealth aiohttp


MNEMOSYNE — Memory & Intelligence General


PROMETHEUS — Capabilities & New Tech General


Genesis Evolution Engine — manages the Alpha Evolve recursive self-improvement protocol: detects failures, synthesizes axioms, proposes code fixes, submits PRs via gitops


EventType EventPriority EvolutionEvent SessionContext EvolutionProtocol


ExecutionMode Story ExecutionResult GenesisExecutionLayer

Genesis Execution Layer — top-level execution entry point: GenesisExecutionLayer dispatches RWL stories to Gemini swarm via rate maximizer, verifies results, handles retries. execute_task_sync() is the canonical API


SurpriseLevel SurpriseEvent Axiom EnhancedSurpriseSystem AxiomGenerator GenesisHeartbeat

Genesis Heartbeat - The Circulatory System


KernelState SessionContext CompiledContext GenesisKernel

Genesis Kernel — GenesisKernel: core runtime orchestrating session context, compiled context, capability manifest, boot sequence. Singleton kernel managing all Genesis state


AgentRole ProjectStatus ExecutorType AgentAssignment ProjectState GenesisMasterOrchestrator

Genesis Master Orchestrator — top-level task decomposition and dispatch: receives user requests, runs Adaptive Thinking, decomposes into RWL stories, dispatches to execution layer


MemoryTier Memory WorkingMemoryCache EpisodicMemoryStore SemanticMemoryStore MemoryCortex

Genesis Memory Cortex — MemoryCortex: three-tier memory architecture (WorkingMemoryCache/EpisodicMemoryStore/SemanticMemoryStore) with surprise-scored routing


Genesis Memory Hub — GenesisMemoryHub: unified search across SuperMemory, Graphiti, Qdrant, PostgreSQL, Redis, FileKG. query_all() fan-out with ranked result fusion


Graph — FalkorDB Graph Client: connects to FalkorDB (Redis-compatible graph DB), executes Cypher queries for entity/relationship storage in Genesis KG


Graph — FalkorDB Cypher Query Library: pre-built queries for entity upsert, relationship creation, path traversal, subgraph extraction


Graph — Graph Sync: syncs KNOWLEDGE_GRAPH JSONL entities/axioms into FalkorDB graph, incremental sync on file change detection


AIVA RLM Nexus — BinduHydrator Base Class


RiskLevel ActionCategory ApprovalDecision ActionRiskProfile ApprovalRequest ActionAuditEntry RiskClassifier ApprovalWorkflow


ActionType ActionStatus OpenWorkAction OpenWorkEvent ConnectionState OpenWorkBridge


Task Tool Mastery - Genesis Intelligence Layer


Genesis Persistent Context Architecture — BaseInterceptor


Genesis Persistent Context Architecture — Execution Telemetry Interceptor


Genesis Persistent Context Architecture — NullInterceptor + Scaffold


Genesis Persistent Context Architecture — InterceptorChain


Telnyx Webhook Interceptor — call lifecycle event handler.


Jules Bridge — Strategic Creative & Knowledge Architect


InjectionResult QueryResult EmulationContext CreatorMindLoader SemanticMemoryInjector KinanUnderstandingAPI ContextAwareResponseGenerator PhilosophyEmulationEngine EvolutionNarrator SelfReflectionInterface AIVAConsciousnessIntegrator

AIVA Consciousness Integrator - Phase 5: Creator Mind Integration


Business Idea Extractor - Stories 10A-10E


ConversationAnalysis TopicEvolution ToolUsage ContentAnalyzer

Content Analyzer - Phase 2 Stories 11-22


Entity Relationship Axiom TimelineEvent CreatorMindKGBuilder

Creator Mind Knowledge Graph Builder - Phase 4 Stories 35-44


UnfinishedProject Person Resource Blocker Commitment OpenQuestion BeliefPivot MentalModel DeepValueExtractor


Entity Extractor for Genesis Knowledge Graph


PhilosophyStatement VisionStatement InnovationMoment StrategicPivot FailurePattern SuccessPattern QuestioningProfile ThemeEvolution PatternRecognizer

Pattern Recognizer - Phase 3 Stories 23-34


JSONFormatter ConsoleFormatter ContextManager OperationTimer GenesisLoggers


Genesis Persistent Context Architecture — fast_extract


Memory — JIT Hydration: Just-in-Time memory hydration loads relevant memories from Qdrant into context window before each LLM call based on input embedding similarity


Genesis Persistent Context Architecture — JIT Hydration Interceptor


Memory — Redis L1 Schema: defines hot-cache key patterns and TTLs for working-tier memories (24h TTL, LRU eviction)


Genesis Persistent Context Architecture — Scatter-Gather Memory Fetch


Genesis Persistent Context Architecture — ZERO_AMNESIA_STATE Envelope


Merge — Semantic Merge Interceptor: intercepts conflicting parallel agent outputs and resolves them using Gemini semantic merge before committing to shared state


Genesis Meta-Prompting Library (v2026.1)


MetricValue Counter Gauge Histogram Summary MetricsRegistry GenesisMetrics TimedOperation


Base RoyalConversation EpochLog KnowledgeEntity PlPreferencePair RlmPreferencePair CaiCritiqueLog RlmTenant RlmTenantAudit RlmMemory RlmShredAudit

SQLAlchemy ORM models matching the current Genesis PostgreSQL schema.


HealthStatus ComponentType HealthMetrics HealthCheckResult HealthChecker OpenWorkHealthMonitor


concurrent openai google dotenv mimetypes


CorrectionLoop — MVFL Re-injection Engine.


MemGPTEscalation — Opus escalation handler.


MVFL — Multi-Version Feedback Loop Interceptor: intercepts LLM outputs for quality validation, routes low-confidence outputs to correction loop


Genesis Persistent Context Architecture — MVFL Trigger


Genesis Persistent Context Architecture — Output Validator


Genesis Persistent Context Architecture — Voyager Defense


Observability — Cost Tracker: tracks API spend per model per session, alerts on budget thresholds, writes to cost_log PostgreSQL table


Observability — Decorators: @trace_llm_call, @track_cost, @prometheus_timer decorators for automatic observability instrumentation


Observability — Langfuse Client: traces LLM calls (model, tokens, latency, cost) to Langfuse for observability. Wraps Gemini/OpenRouter calls


Observability — Prometheus Metrics: counter/gauge/histogram definitions for memory writes, surprise scores, decay cycles, API latency


STTConfig TTSVoiceConfig TTSConfig DictationConfig KinanChannelConfig VoiceConfig ConnectionConfig OpenWorkAppConfig ApprovalConfig RoutingConfig RateLimitsConfig ActionsConfig IntegrationConfig MonitoringConfig SecurityConfig OpenWorkConfig


WorkerStatus WorkerResult OrchestratorState WorkerAgent Orchestrator


ComplexityLevel ComplexityClassification TaskComplexityDetector OrchestratorTieredIntegration

PM-011: Wire Tiered Executor to Orchestrator


DegradationType DegradationAlert PerformanceBaseline PerformanceDegradationDetector

PM-014: Performance Degradation Detector


Qwen — QwenConfig: configuration for Qwen 3 14B (Ollama endpoint, context window 32768, reasoning mode toggle, rate limits)


QwenError QwenConnectionError QwenTimeoutError QwenModelNotFoundError QwenRateLimitError QwenCircuitOpenError QwenResponseError QwenWarmupError


Qwen — Health Monitor: polls Ollama /api/tags to verify qwen3:14b is loaded, alerts via Telegram if model unavailable


Qwen — UnifiedClient: unified async client for Qwen 3 14B on Mac Mini via Ollama, handles chat completion, streaming, tool calls with circuit breaker


ResearchLevel ComplexityFactors ResearchGate ResearchDecision TaskComplexityDetector ResearchRouter


RLM Neo-Cortex — FastAPI Integration Application: top-level server on port 8100, mounts /api/v1/memory/* and /api/v1/feedback/* routers, CORS + TenantMiddleware stack, lifecycle startup/shutdown


RLM Neo-Cortex — Settings Configuration: RLMSettings dataclass loading Elestio PostgreSQL, Qdrant, Redis, JWT secrets, feedback webhook config from environment


MemoryTier CustomerTier FeedbackSignal MemoryRecord EntitlementManifest PreferencePair MemoryGatewayProtocol EntitlementLedgerProtocol SurpriseIntegrationProtocol DecaySchedulerProtocol FeedbackCollectorProtocol TenantPartitionProtocol

RLM Neo-Cortex — Component Interface Contracts: all Protocol classes and shared enums/dataclasses (MemoryTier, CustomerTier, MemoryRecord, EntitlementManifest, PreferencePair) used by all RLM modules


RLM Neo-Cortex Module 4 — Ebbinghaus Decay Scheduler: implements forgetting curve R=e^(-t/S), daily decay cycles, tier-specific policies (aggressive/moderate/conservative/infinite), REM sleep consolidation


RLM — Decay Curves: Ebbinghaus retention formula implementations, DECAY_POLICIES config (aggressive/moderate/conservative/infinite), calculate_retention/calculate_strength/should_decay functions


RLM Neo-Cortex Module 2 — Entitlement Ledger: manages customer subscription tiers (Starter $497/Professional $997/Enterprise $1497/Queen $20K+), quota enforcement, capability manifest caching in Redis


RLM — Stripe Entitlement Webhook: handles stripe checkout.session.completed and customer.subscription.updated events to update tenant tier in EntitlementLedger


RLM Neo-Cortex Module 5 — Feedback Collection Pipeline: collects thumbs-up/neutral/down signals from Telegram and webhooks, converts to DPO PreferencePairs, persists to pl_preference_pairs table for model training


RLM — Telegram Feedback Handler: builds inline keyboard for thumbs up/down/neutral, handles callback_query to record FeedbackSignal via FeedbackCollector


RLM — Feedback Webhook Router: FastAPI router for POST /feedback endpoint, accepts FeedbackWebhookRequest, routes to FeedbackCollector


QuotaExceededError PartialDeleteError GatewayNotInitializedError MemoryGateway

qdrant_client prometheus_client asyncpg redis httpx google

RLM Neo-Cortex Module 1 — Memory Gateway: single entry-point for all memory read/write/search/delete, routes content to PG/Qdrant/Redis by surprise score, enforces per-tenant quotas, deduplicates content, emits Prometheus metrics


RLM Neo-Cortex — Gateway FastAPI Router: HTTP endpoints for /write, /search, /read/{id}, /delete/{id}, /health — delegates to MemoryGateway


RLM Neo-Cortex — MCP Bridge: registers RLM memory tools into Genesis MCP server so Claude Code can call rlm_write_memory, rlm_search_memories, rlm_delete_memory directly


RLM Neo-Cortex — Tenant Middleware: extracts tenant UUID from JWT Bearer token or X-API-Key header, attaches to request state for downstream RLS enforcement


qdrant_client cryptography asyncpg redis

RLM Neo-Cortex Module 6 — Tenant Partitioning: PostgreSQL RLS policies, Qdrant payload-filtered collections, Redis keyspace prefixing for per-customer memory isolation. Supports cryptographic shredding for GDPR Right to Erasure


RLM — Partitioning Schema Migration: run_migration() creates rlm_tenants, rlm_memories tables with RLS policies and Qdrant collection on Elestio


RLM Neo-Cortex Module 3 — Surprise Integration: wraps MemorySystem v2.0.0 with tier-aware routing, write gating, batch scoring, and statistics. score_content() returns (float, MemoryTier)


RLM — Surprise Score Config: get_thresholds() and validate_thresholds() for CustomerTier-specific surprise routing thresholds


rlm_adapter.py -- Genesis RLM (Recursive Language Models) PostgreSQL Adapter


AIVAInteractionWorker BloodstreamWorker KGCrystallizerWorker RLMArmy

argparse signal multiprocessing psycopg2

RLM Army — Persistent Daemon Coordinator for Genesis Memory


RoutingTelemetry — Tracks tier distribution over time.


StranglerFig — Progressive Migration Wrapper.


TierClassifier — Zero-cost heuristic task classification.


TierExecutor — dispatches tasks to the correct execution path based on tier.


Routing — TierRouter: routes tasks to appropriate model tier (Haiku/Sonnet/Opus or Flash/Pro/Ultra) based on complexity classification


TierRouterInterceptor — classifies tasks and sets tier/model before execution.


AIVA RLM Nexus — Qdrant Collection Setup


Secrets — Infisical Secrets Client: fetches secrets from Infisical at runtime (no .env files in production), supports dev/staging/prod environments


RedisConfig QdrantConfig PostgresConfig MCPConfig


RLM Bloodstream — Session Context Injector


Storage — Cold Ledger: append-only event log for all memory operations (write/delete/decay) to PostgreSQL. Provides full audit trail for compliance


Genesis Persistent Context Architecture — ColdLedgerInterceptor


Storage — Event Sourcing: event-sourced state reconstruction for memory operations. Replays cold ledger events to reconstruct memory state at any point in time


Storage — PostgreSQL Schema: DDL for all Genesis tables (rlm_memories, rlm_tenants, pl_preference_pairs, cost_log, epoch_reports)


SwarmSagaWriter — Saga Lifecycle Recorder for the Genesis Cold Ledger.


Session Store — L4 Cold Ledger session lifecycle manager.


core.storage.shadow_router — ShadowRouter: Side-Effect Gating


SurpriseLevel MemoryItem Prediction SurpriseScore SurpriseHistory _SurpriseDetector MemorySystem


Task Queue — Dramatiq Broker: Redis-backed async task queue broker configuration for background jobs (epoch runs, decay cycles, email sends)


Task Queue — Task Manager: enqueues and tracks Dramatiq tasks, provides task status querying and cancellation


Task Queue — Dramatiq Workers: worker actor definitions for background tasks (run_epoch, run_decay_cycle, send_email, process_feedback)


Tier configuration loading and capability resolution.


TierGate — runtime feature flag gate for Genesis agent tiers.


ToolIntent ToolDefinition RoutingResult ToolRouter


webbrowser audioop skills pyaudio google pyttsx3 winsound wave

Gemini Live Session - Revenue First Mode


VoiceCommandType VoiceMessage VoiceCommandParser KinanAivaVoiceChannel

wave queue numpy websockets sounddevice argparse AIVA


OpenWorkActionType ParsedVoiceAction VoiceCommandMatcher VoiceToOpenWork


VUA Context Manager - Vigilant Undivided Attention Pattern


FetchHistoryRequest FetchHistoryResponse ProcessTranscriptsRequest ProcessTranscriptsResponse IngestKnowledgeRequest IngestKnowledgeResponse GenerateSkillsRequest GenerateSkillsResponse HealthResponse


ChunkMetadata IngestionResult SearchResult GeminiEmbedder TranscriptChunker QdrantVideoIngester

YouTube Knowledge Pipeline - Qdrant Vector Ingestion Module (STORY-007)


core/rlm/ — 18 modules, 1,108-line Memory Gateway, Ebbinghaus decay, tenant isolation, DPO feedback, Stripe entitlement

core/epoch/ — 10 modules, nightly knowledge consolidation, axiom distillation, Redis distributed locking

core/evolution/ — 25 modules, perpetual self-improvement, PRD generation, GitOps PR creation, blue/green deployment

core/genesis_execution_layer.py + core/gemini_executor.py + core/gemini_rate_maximizer.py — RWL swarm dispatch at 90-95% capacity

core/gemini_command_centres/ — 6 modules, persistent daemon fleet, auto-respawn, CTM flush

core/coherence/ — 8 modules, OCC commits, bulkhead isolation, semantic merge, Redis master state

core/memory/ + core/genesis_memory_cortex.py + core/genesis_memory_hub.py — JIT hydration, 3-tier cortex, fan-out search

core/bridge/openclaw_bridge.py — WSL2 <-> Mac Mini bidirectional message bridge

core/audit/ — AI readiness audit report generator, 12 Pydantic schemas

core/auth/ + core/billing/ + core/email/ + core/graph/ + core/task_queue/ + core/observability/ + core/secrets/ — full production infra

core/qwen/ — 7 modules, Qwen 3 14B on Mac Mini, circuit breaker, health monitoring

core/voice/ — Gemini Live Session, OpenWork voice bridge, Telnyx WebRTC handler

Deep KG scan index of all Python modules in core/ with line counts, classes, functions, imports, test mappings