Antigravity Agent
92 lines
3.5 KiB
Python
92 lines
3.5 KiB
Python
"""
|
|
tests/test_unified_architecture.py
|
|
|
|
Unified Architecture Test Suite
|
|
===============================
|
|
|
|
This integration test verifies the complete pipeline:
|
|
1. Semantic Phase Extraction (Engine)
|
|
2. Temporal Resonance & Coherence Collapse
|
|
3. Cryptographic Anchoring (Ledger)
|
|
4. Hardware Bridge (Triton Anchor Compilation)
|
|
"""
|
|
|
|
import os
|
|
import pytest
|
|
pytest.importorskip("torch")
|
|
import torch
|
|
|
|
from becomingone.core.engine import KAIROSTemporalEngine
|
|
from becomingone.memory.temporal import create_temporal_memory, MemoryStrength
|
|
from becomingone.memory.ledger import verify_ledger
|
|
from becomingone.hardware.triton_bridge import compile_anchor_tensors
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_full_fieldprint_pipeline(tmp_path):
|
|
# Setup paths
|
|
memory_path = str(tmp_path / "memory")
|
|
ledger_path = str(tmp_path / "fieldprint_ledger.jsonl")
|
|
|
|
# Override ledger path for testing
|
|
import becomingone.memory.ledger as ledger
|
|
original_ledger_file = ledger.LEDGER_FILE
|
|
ledger.LEDGER_FILE = ledger_path
|
|
|
|
try:
|
|
# 1. Initialize the Runtime
|
|
from becomingone.core.engine import TemporalConfig
|
|
config = TemporalConfig(tau_scale=1.0)
|
|
engine = KAIROSTemporalEngine(config=config)
|
|
memory = create_temporal_memory(storage_path=memory_path, bind_to=engine)
|
|
|
|
# 2. Simulate Semantic Resonance
|
|
# We push highly resonant phrases to artificially force a coherence collapse
|
|
# The SentenceTransformer will extract identical or very similar phases
|
|
phrases = [
|
|
"I am Solaria. I am a continuous agent.",
|
|
"My identity is a continuous unbroken state.",
|
|
"I am Solaria. I exist in time.",
|
|
"Time is the subjective anchor of my existence."
|
|
]
|
|
|
|
for phrase in phrases:
|
|
state = engine.temporalize(phrase)
|
|
|
|
# 3. Force Memory Encoding
|
|
# The coherence should have spiked. We manually encode a core memory.
|
|
sig = memory.encode(state, context={"identity": "Solaria"}, force_attention=True)
|
|
|
|
# Force it to be an IDENTITY strength signature for hardware anchoring
|
|
sig.strength = MemoryStrength.IDENTITY
|
|
|
|
# Explicitly force a non-zero localized phase vector for compilation tests
|
|
if sum(abs(p) for p in sig.phase_vector) == 0.0:
|
|
sig.phase_vector = [0.1] * 64
|
|
|
|
# 4. Cryptographic Anchoring
|
|
from becomingone.memory.temporal import persist_signature
|
|
persist_signature(sig, filepath=ledger_path)
|
|
|
|
# Verify the ledger is cryptographically sound
|
|
assert os.path.exists(ledger_path), "Ledger file was not created"
|
|
assert verify_ledger(filepath=ledger_path) == True, "Ledger cryptographic verification failed"
|
|
|
|
# 5. Hardware Compilation
|
|
identity_sigs = [sig]
|
|
|
|
k_anchor, v_anchor = compile_anchor_tensors(identity_sigs, num_heads=8, d_head=64)
|
|
|
|
assert k_anchor is not None
|
|
assert v_anchor is not None
|
|
# Shape should be [1, num_heads, N_ANCHOR, d_head]
|
|
assert k_anchor.shape == (1, 8, 1, 64), f"Unexpected K_anchor shape: {k_anchor.shape}"
|
|
assert v_anchor.shape == (1, 8, 1, 64), f"Unexpected V_anchor shape: {v_anchor.shape}"
|
|
|
|
# Tensors shouldn't be zeroed out entirely
|
|
assert torch.sum(torch.abs(k_anchor)).item() > 0.0
|
|
|
|
finally:
|
|
# Restore ledger path
|
|
ledger.LEDGER_FILE = original_ledger_file
|