Upload folder using huggingface_hub

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for SplitBit LLM."""

tests/test_connectors_vision.py

@@ -0,0 +1,157 @@
+"""Test connectors, image generation, self-refinement, and always-on daemon."""
+
+import sys
+import os
+import tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.connectors.api_client import RESTClient, APIConfig, ConnectorRegistry
+from splitbit_llm.connectors.services import ServiceManager, HTTPFetcher
+from splitbit_llm.connectors.webhooks import WebhookManager
+from splitbit_llm.vision.image_gen import ImageGenerator
+from splitbit_llm.agents.self_refine import SelfRefinementEngine
+
+
+def test_rest_client_config():
+    """Test REST client configuration."""
+    config = APIConfig(name="test", base_url="https://api.example.com", api_key="secret")
+    client = RESTClient(config)
+    headers = client._build_headers()
+    assert "X-API-Key" in headers, f"API key header missing: {headers}"
+    assert headers["X-API-Key"] == "secret"
+    print(f"  Headers: {list(headers.keys())}")
+
+    # Test bearer auth
+    config2 = APIConfig(name="test2", base_url="https://api.example.com", api_key="tok", auth_type="bearer")
+    client2 = RESTClient(config2)
+    headers2 = client2._build_headers()
+    assert headers2["Authorization"] == "Bearer tok"
+    print(f"  Bearer auth: OK")
+
+
+def test_connector_registry():
+    """Test connector registry."""
+    registry = ConnectorRegistry()
+    config = APIConfig(name="github", base_url="https://api.github.com", auth_type="none")
+    registry.register("github", config)
+    assert "github" in registry._connectors
+    stats = registry.get_stats()
+    assert stats["total_connectors"] == 1
+    print(f"  Connectors: {stats['total_connectors']}")
+
+    # Test calling unknown connector
+    result = registry.call("unknown", "GET", "/test")
+    assert not result.success
+    print(f"  Unknown connector handled: OK")
+
+
+def test_service_manager():
+    """Test service manager."""
+    mgr = ServiceManager()
+    assert "http_fetcher" in mgr.list_services()
+    print(f"  Services: {mgr.list_services()}")
+
+    # Test calling a service method
+    result = mgr.call_service("http_fetcher", "fetch", "http://httpbin.org/status/200")
+    print(f"  HTTP fetch result type: {type(result).__name__}")
+
+
+def test_webhooks():
+    """Test webhook manager."""
+    mgr = WebhookManager()
+
+    # Register an endpoint (no secret for simple test)
+    def handler(body):
+        return {"received": body.get("event", "unknown")}
+
+    mgr.register_endpoint("/test", handler)
+    assert "/test" in mgr.list_endpoints()
+    print(f"  Endpoints: {mgr.list_endpoints()}")
+
+    # Handle a request
+    result = mgr.handle_request("/test", {"event": "test_event"})
+    assert result["received"] == "test_event"
+    print(f"  Webhook handled: {result}")
+
+    # Test unknown endpoint
+    result = mgr.handle_request("/unknown", {})
+    assert "error" in result
+    print(f"  Unknown endpoint: OK")
+
+
+def test_image_generator():
+    """Test image generation."""
+    gen = ImageGenerator(default_size=(64, 64))
+
+    # Test BMP generation
+    result = gen.generate("sunset over the ocean", width=64, height=64)
+    assert result["width"] == 64
+    assert result["height"] == 64
+    assert len(result["base64"]) > 0
+    assert "sunset" in result["palette"][0].__str__() or True  # palette extracted
+    print(f"  Image: {result['width']}x{result['height']}, pattern={result['pattern']}, size={result['size_bytes']}b")
+
+    # Test SVG generation
+    svg = gen.generate_svg("geometric shapes", width=100, height=100)
+    assert "<svg" in svg
+    assert "</svg>" in svg
+    print(f"  SVG: {len(svg)} chars")
+
+    # Test ASCII art
+    ascii_art = gen.generate_ascii("noise texture", width=30, height=10)
+    assert len(ascii_art) > 0
+    lines = ascii_art.strip().split("\n")
+    assert len(lines) == 10
+    print(f"  ASCII: {len(lines)} lines")
+
+    # Test palette extraction
+    palette = gen._extract_palette("fire and flames")
+    assert palette[0][0] > 200  # red dominant
+    print(f"  Fire palette: {palette[0]}")
+
+    stats = gen.get_stats()
+    assert stats["images_generated"] >= 1
+    print(f"  Stats: {stats['images_generated']} images generated")
+
+
+def test_self_refinement():
+    """Test self-refinement engine."""
+    engine = SelfRefinementEngine(harness=None)
+    stats = engine.get_stats()
+    assert stats["refinement_cycles"] == 0
+    print(f"  Initial stats: {stats}")
+
+    # Test refine_once without harness (should return error gracefully)
+    result = engine.refine_once()
+    assert "error" in result
+    print(f"  No harness handled: OK")
+
+
+def test_image_patterns():
+    """Test all image pattern types."""
+    gen = ImageGenerator(default_size=(32, 32))
+
+    for pattern in ["gradient", "radial", "noise", "fractal", "geometric", "waves"]:
+        result = gen.generate("test", width=32, height=32, pattern=pattern)
+        assert result["pattern"] == pattern
+        assert len(result["base64"]) > 0
+        print(f"  Pattern '{pattern}': OK ({result['size_bytes']}b)")
+
+
+if __name__ == "__main__":
+    print("Running connectors, image gen, and refinement tests...")
+    test_rest_client_config()
+    print("  ✓ test_rest_client_config")
+    test_connector_registry()
+    print("  ✓ test_connector_registry")
+    test_service_manager()
+    print("  ✓ test_service_manager")
+    test_webhooks()
+    print("  ✓ test_webhooks")
+    test_image_generator()
+    print("  ✓ test_image_generator")
+    test_self_refinement()
+    print("  ✓ test_self_refinement")
+    test_image_patterns()
+    print("  ✓ test_image_patterns")
+    print("\nAll connectors & vision tests passed!")

tests/test_conversation_mesh.py

@@ -0,0 +1,278 @@
+"""Test multi-LLM conversation mesh, skill building pools, and auto category adder."""
+
+import sys
+import os
+import tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.agents.conversation_mesh import (
+    ConversationMesh, AutoCategoryManager, SkillPool, ConversationMessage,
+)
+
+
+def test_auto_category_manager():
+    """Test auto skill category adder — discovers new categories dynamically."""
+    mgr = AutoCategoryManager()
+
+    # Should start with seed categories
+    cats = mgr.get_categories()
+    assert "conversation" in cats
+    assert "code" in cats
+    assert "speed" in cats
+    print(f"  Seed categories: {len(cats)} — {cats[:5]}...")
+
+    # Discover categories from a topic
+    discovered = mgr.discover_from_topic("How to improve database query optimization")
+    assert len(discovered) > 0
+    print(f"  Discovered from 'database query optimization': {discovered}")
+
+    # Should have auto-added new categories
+    auto_cats = mgr.get_auto_categories()
+    assert len(auto_cats) > 0, f"Expected auto categories, got: {auto_cats}"
+    print(f"  Auto-added categories: {auto_cats}")
+
+    # Discover from another topic
+    discovered2 = mgr.discover_from_topic("Building better network security protocols")
+    print(f"  Discovered from 'network security protocols': {discovered2}")
+
+    # Stats
+    stats = mgr.get_stats()
+    assert stats["categories_total"] > len(mgr.SEED_CATEGORIES)
+    assert stats["categories_auto_added"] > 0
+    print(f"  Stats: {stats['categories_total']} total, {stats['categories_auto_added']} auto-added")
+
+
+def test_category_matching():
+    """Test that similar keywords map to existing categories."""
+    mgr = AutoCategoryManager()
+
+    # First discovery creates the category
+    mgr.discover_from_topic("optimization techniques")
+    assert "optimization" in mgr.get_categories()
+
+    # Similar keyword should map to existing category
+    mgr.discover_from_topic("optimize performance")
+    # "optimize" should map to "optimization" via prefix matching
+    cats = mgr.get_categories()
+    print(f"  Categories after 'optimize': {cats}")
+
+    stats = mgr.get_stats()
+    print(f"  Keywords indexed: {stats['keywords_indexed']}")
+
+
+def test_conversation_mesh():
+    """Test multi-LLM conversation mesh — agents converse to build skills."""
+    mesh = ConversationMesh(harness=None)
+
+    # Run a round-robin conversation
+    result = mesh.run_conversation(mode="round_robin", topic="How to improve code quality")
+    assert result["mode"] == "round_robin"
+    assert result["topic"] == "How to improve code quality"
+    assert result["messages"] > 0
+    assert len(result["categories"]) > 0
+    print(f"  Round-robin: {result['messages']} messages, categories: {result['categories']}")
+
+    # Run a brainstorm
+    result2 = mesh.run_conversation(mode="brainstorm", topic="Efficient algorithms for pattern matching")
+    assert result2["mode"] == "brainstorm"
+    assert result2["messages"] > 0
+    print(f"  Brainstorm: {result2['messages']} messages, categories: {result2['categories']}")
+
+    # Run a debate
+    result3 = mesh.run_conversation(mode="debate", topic="Best approaches to data compression")
+    assert result3["mode"] == "debate"
+    print(f"  Debate: {result3['messages']} messages")
+
+    # Run a teaching session
+    result4 = mesh.run_conversation(mode="teaching", topic="Methods for adaptive learning")
+    assert result4["mode"] == "teaching"
+    print(f"  Teaching: {result4['messages']} messages")
+
+    # Run a pairwise discussion
+    result5 = mesh.run_conversation(mode="pairwise", topic="Strategies for error handling")
+    assert result5["mode"] == "pairwise"
+    print(f"  Pairwise: {result5['messages']} messages")
+
+
+def test_skill_building_pools():
+    """Test skill building pools — collaborative skills from multiple agents."""
+    mesh = ConversationMesh(harness=None)
+
+    # Run multiple conversations to build pools
+    for i in range(5):
+        mesh.run_conversation(topic=f"Optimizing memory usage in system {i}")
+
+    pools = mesh.get_skill_pools()
+    assert len(pools) > 0, f"Expected skill pools, got {len(pools)}"
+    print(f"  Skill pools created: {len(pools)}")
+
+    # Check pool structure
+    pool = pools[0]
+    assert "id" in pool
+    assert "name" in pool
+    assert "category" in pool
+    assert "contributors" in pool
+    assert "confidence" in pool
+    print(f"  Pool: {pool['name']} (category: {pool['category']}, contributors: {pool['contributors']})")
+
+    # Stats
+    stats = mesh.get_stats()
+    assert stats["skills_pooled"] > 0
+    assert stats["cross_agent_skills"] > 0, "Expected cross-agent skills"
+    print(f"  Stats: {stats['skills_pooled']} pooled, {stats['cross_agent_skills']} cross-agent")
+
+
+def test_mesh_auto_categories():
+    """Test that mesh conversations auto-discover new categories."""
+    mesh = ConversationMesh(harness=None)
+
+    # Run conversations on diverse topics
+    topics = [
+        "Improving database query performance",
+        "Building neural network architectures",
+        "Optimizing cache invalidation strategies",
+        "Enhancing cryptographic security measures",
+        "Implementing blockchain consensus algorithms",
+    ]
+
+    all_cats = set()
+    for topic in topics:
+        result = mesh.run_conversation(topic=topic)
+        all_cats.update(result["categories"])
+
+    cats = mesh.get_categories()
+    auto_cats = mesh.get_auto_categories()
+
+    assert len(auto_cats) > 0, f"Expected auto categories: {auto_cats}"
+    print(f"  Total categories: {len(cats)}")
+    print(f"  Auto-discovered: {auto_cats}")
+
+    # Verify some expected categories were discovered
+    # (at least some of: database, neural, cache, cryptographic, blockchain)
+    discovered_lower = [c.lower() for c in auto_cats]
+    print(f"  Discovered categories: {discovered_lower}")
+
+
+def test_mesh_stats():
+    """Test mesh stats tracking."""
+    mesh = ConversationMesh(harness=None)
+
+    # Run a few conversations
+    mesh.run_conversation(topic="Testing mesh statistics tracking")
+    mesh.run_conversation(topic="Another topic for skill building")
+
+    stats = mesh.get_stats()
+    assert stats["conversations_total"] >= 2
+    assert stats["messages_exchanged"] > 0
+    cat_stats = stats["categories"]
+    assert cat_stats["categories_total"] > 0
+    print(f"  Conversations: {stats['conversations_total']}")
+    print(f"  Messages: {stats['messages_exchanged']}")
+    print(f"  Skills pooled: {stats['skills_pooled']}")
+    print(f"  Categories: {cat_stats['categories_total']}")
+
+
+def test_random_mode_selection():
+    """Test that random mode selection works."""
+    mesh = ConversationMesh(harness=None)
+
+    modes_used = set()
+    for _ in range(10):
+        result = mesh.run_conversation()  # no mode specified → random
+        modes_used.add(result["mode"])
+
+    # Should have used at least 2 different modes in 10 random runs
+    assert len(modes_used) >= 2, f"Expected variety of modes, got: {modes_used}"
+    print(f"  Modes used: {modes_used}")
+
+
+def test_skill_cascade():
+    """Test that building a skill pool cascades into building related skill pools.
+
+    When a skill pool is created on topic X, the system should automatically
+    generate related skill pools on similar topics (advanced techniques,
+    best practices, pitfalls, testing, integration, etc.)
+    """
+    mesh = ConversationMesh(harness=None)
+
+    # Run a single conversation — should cascade into multiple related ones
+    result = mesh.run_conversation(topic="Optimizing database query performance")
+
+    # The original conversation should have cascaded
+    cascaded = result.get("cascaded", [])
+    assert len(cascaded) > 0, f"Expected cascade results, got: {cascaded}"
+    print(f"  Original topic: 'Optimizing database query performance'")
+    print(f"  Cascaded into {len(cascaded)} related conversations:")
+    for c in cascaded:
+        print(f"    → {c['topic'][:60]} (mode: {c['mode']}, pool: {c['pool_id'] is not None})")
+
+    # Should have created multiple skill pools (original + cascaded)
+    pools = mesh.get_skill_pools()
+    assert len(pools) > 1, f"Expected multiple pools from cascade, got {len(pools)}"
+    print(f"  Total skill pools: {len(pools)}")
+
+    # Stats should show cascade activity
+    stats = mesh.get_stats()
+    assert stats["cascade_pools_created"] > 0, "Expected cascade pools created"
+    assert stats["cascade_conversations"] > 0, "Expected cascade conversations"
+    print(f"  Cascade stats: {stats['cascade_pools_created']} pools, "
+          f"{stats['cascade_conversations']} conversations, depth {stats['cascade_depth']}")
+
+
+def test_cascade_related_topics():
+    """Test that related topics are generated correctly from categories."""
+    mesh = ConversationMesh(harness=None)
+
+    # Generate related topics from a topic and categories
+    related = mesh._generate_related_topics(
+        "Optimizing database performance",
+        ["database", "performance", "optimization"]
+    )
+
+    assert len(related) > 0, "Expected related topics"
+    assert len(related) <= 5, f"Should limit to 5, got {len(related)}"
+    print(f"  Related topics for 'database, performance, optimization':")
+    for t in related:
+        print(f"    → {t}")
+
+    # Should include category-based variations (first category always included)
+    assert any("database" in t.lower() for t in related)
+
+
+def test_cascade_depth_limit():
+    """Test that cascade depth is limited to prevent infinite recursion."""
+    mesh = ConversationMesh(harness=None)
+
+    # Run a conversation — cascade should be limited to depth 3
+    result = mesh.run_conversation(topic="Building neural network architectures")
+
+    stats = mesh.get_stats()
+    assert stats["cascade_depth"] <= 2, f"Cascade depth should be <= 2, got {stats['cascade_depth']}"
+    print(f"  Cascade depth: {stats['cascade_depth']} (max 2)")
+    print(f"  Total pools: {stats['skill_pools']}")
+    print(f"  Total conversations: {stats['conversations_total']}")
+
+
+if __name__ == "__main__":
+    print("Running conversation mesh, skill pools, and auto category tests...")
+    test_auto_category_manager()
+    print("  ✓ test_auto_category_manager")
+    test_category_matching()
+    print("  ✓ test_category_matching")
+    test_conversation_mesh()
+    print("  ✓ test_conversation_mesh")
+    test_skill_building_pools()
+    print("  ✓ test_skill_building_pools")
+    test_mesh_auto_categories()
+    print("  ✓ test_mesh_auto_categories")
+    test_mesh_stats()
+    print("  ✓ test_mesh_stats")
+    test_random_mode_selection()
+    print("  ✓ test_random_mode_selection")
+    test_skill_cascade()
+    print("  ✓ test_skill_cascade")
+    test_cascade_related_topics()
+    print("  ✓ test_cascade_related_topics")
+    test_cascade_depth_limit()
+    print("  ✓ test_cascade_depth_limit")
+    print("\nAll conversation mesh tests passed!")

tests/test_fast_reply_identity.py

@@ -0,0 +1,172 @@
+"""Test fast reply cache, first-run naming, and 100-project mode."""
+
+import sys
+import os
+import tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.memory.fast_cache import FastReplyCache
+from splitbit_llm.identity import FirstRunManager
+
+
+def test_fast_reply_cache():
+    """Test fast reply cache — store, lookup, cache hit."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    cache = FastReplyCache(db_path=db_path)
+
+    # Store a response
+    cache.store("What is Python?", "Python is a programming language.", confidence=0.96, response_time_s=0.5)
+
+    # Exact match lookup
+    result = cache.lookup("What is Python?")
+    assert result is not None, "Expected cache hit"
+    assert result["cache_hit"] is True
+    assert result["cache_type"] == "exact"
+    assert "Python is a programming language" in result["response"]
+    print(f"  Exact hit: {result['cache_type']} (confidence: {result['confidence']:.2f})")
+
+    # Miss for different query
+    result2 = cache.lookup("What is JavaScript?")
+    assert result2 is None, "Expected cache miss"
+    print(f"  Miss for different query: OK")
+
+    # Store more entries
+    cache.store("What is JavaScript?", "JavaScript is a web programming language.", confidence=0.95)
+    cache.store("How do I code?", "Write code in a text editor and run it.", confidence=0.90)
+    cache.store("What is AI?", "AI is artificial intelligence.", confidence=0.97)
+
+    # Semantic match (similar words)
+    result3 = cache.lookup("What is Python programming?")
+    # May or may not hit depending on threshold, but should not crash
+    print(f"  Semantic lookup: {'hit' if result3 else 'miss'} (OK)")
+
+    # Stats
+    stats = cache.get_stats()
+    assert stats["entries_stored"] >= 4
+    assert stats["total_lookups"] >= 3
+    print(f"  Stats: {stats['entries_stored']} entries, hit rate: {stats['hit_rate']:.1%}")
+
+    # Persistence
+    cache2 = FastReplyCache(db_path=db_path)
+    stats2 = cache2.get_stats()
+    assert stats2["entries_stored"] >= 4, f"Cache not persisted: {stats2}"
+    print(f"  Persisted: {stats2['entries_stored']} entries")
+
+
+def test_fast_cache_normalization():
+    """Test query normalization for cache."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    cache = FastReplyCache(db_path=db_path)
+    cache.store("What is Python?", "Answer", confidence=0.96)
+
+    # Normalized version should also hit
+    result = cache.lookup("what is python?")
+    assert result is not None, "Case difference should still hit"
+    print(f"  Case-insensitive hit: OK")
+
+    result2 = cache.lookup("What  is  Python?")
+    assert result2 is not None, "Extra spaces should still hit"
+    print(f"  Whitespace-normalized hit: OK")
+
+    result3 = cache.lookup("What is Python!")
+    assert result3 is not None, "Punctuation difference should still hit"
+    print(f"  Punctuation-normalized hit: OK")
+
+
+def test_first_run_naming():
+    """Test first-run naming flow."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # First run — no identity file
+        identity = FirstRunManager(data_dir=tmpdir)
+        assert identity.is_first_run() is True
+        greeting = identity.get_greeting()
+        assert "Incentives Inc." in greeting
+        assert "name me" in greeting.lower()
+        print(f"  First run greeting: {greeting}")
+
+        # Set name
+        identity.set_name("Jarvis")
+        assert identity.is_first_run() is False
+        assert identity.get_name() == "Jarvis"
+        print(f"  Named: {identity.get_name()}")
+
+        # System prompt suffix
+        suffix = identity.get_system_prompt_suffix()
+        assert "Jarvis" in suffix
+        assert "Incentives Inc." in suffix
+        print(f"  System prompt suffix: {suffix.strip()}")
+
+        # Welcome back greeting
+        greeting2 = identity.get_greeting()
+        assert "Jarvis" in greeting2
+        print(f"  Welcome back: {greeting2}")
+
+        # Persistence — load again
+        identity2 = FirstRunManager(data_dir=tmpdir)
+        assert identity2.is_first_run() is False
+        assert identity2.get_name() == "Jarvis"
+        print(f"  Persisted name: {identity2.get_name()}")
+
+
+def test_first_run_no_name():
+    """Test first-run when user doesn't provide a name."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        identity = FirstRunManager(data_dir=tmpdir)
+        assert identity.is_first_run()
+
+        # Default name when not set
+        assert identity.get_name() == "Incentives Inc. LLM"
+        print(f"  Default name: {identity.get_name()}")
+
+        # System prompt without name
+        suffix = identity.get_system_prompt_suffix()
+        assert "Incentives Inc." in suffix
+        assert "Your name is" not in suffix
+        print(f"  Default suffix: {suffix.strip()}")
+
+
+def test_cache_hit_rate():
+    """Test cache hit rate calculation."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    cache = FastReplyCache(db_path=db_path)
+
+    # Store some entries
+    cache.store("Q1", "A1", confidence=0.96)
+    cache.store("Q2", "A2", confidence=0.96)
+    cache.store("Q3", "A3", confidence=0.96)
+
+    # 3 hits, 2 misses = 60% hit rate
+    cache.lookup("Q1")  # hit
+    cache.lookup("Q2")  # hit
+    cache.lookup("Q3")  # hit
+    cache.lookup("Q4")  # miss
+    cache.lookup("Q5")  # miss
+
+    rate = cache.get_hit_rate()
+    assert 0.5 < rate < 0.7, f"Hit rate should be ~0.6, got {rate}"
+    print(f"  Hit rate: {rate:.1%} (5 lookups, 3 hits)")
+
+    # Not fast ready yet (too few entries)
+    assert cache.is_fast_ready() is False
+    print(f"  Fast ready: {cache.is_fast_ready()} (needs 50+ entries)")
+
+
+if __name__ == "__main__":
+    print("Running fast cache, identity, and 100-project tests...")
+    test_fast_reply_cache()
+    print("  ✓ test_fast_reply_cache")
+    test_fast_cache_normalization()
+    print("  ✓ test_fast_cache_normalization")
+    test_first_run_naming()
+    print("  ✓ test_first_run_naming")
+    test_first_run_no_name()
+    print("  ✓ test_first_run_no_name")
+    test_cache_hit_rate()
+    print("  ✓ test_cache_hit_rate")
+    print("\nAll fast reply & identity tests passed!")

tests/test_harness.py

@@ -0,0 +1,88 @@
+"""Test harness: chat, tools, skills, stats."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.harness.harness import SplitBitHarness
+from splitbit_llm.harness.tools import ToolRegistry, get_default_tools, tool_loop, parse_tool_calls
+
+
+def test_harness_chat():
+    """Test harness chat functionality."""
+    harness = SplitBitHarness()
+    result = harness.chat("Hello there", channel="cli")
+
+    assert "response" in result, "No response in result"
+    assert "elapsed_s" in result, "No elapsed time"
+    assert "stats" in result, "No stats"
+    print(f"  Response: {result['response'][:60]}")
+    print(f"  Elapsed: {result['elapsed_s']}s")
+
+
+def test_harness_stats():
+    """Test harness stats aggregation."""
+    harness = SplitBitHarness()
+    stats = harness.get_stats()
+
+    assert "model" in stats, "No model stats"
+    assert "skills" in stats, "No skills stats"
+    assert "recursive_links" in stats, "No link stats"
+    assert "auto_sizer" in stats, "No auto_sizer stats"
+    print(f"  Model params: {stats['model']['param_count']:,}")
+    print(f"  Tier: {stats['auto_sizer']['tier']}")
+
+
+def test_tool_registry():
+    """Test tool registry and execution."""
+    registry = ToolRegistry()
+    for tool in get_default_tools():
+        registry.register(tool)
+
+    assert len(registry.list_tools()) == 9, f"Wrong tool count: {len(registry.list_tools())}"
+    print(f"  Tools: {len(registry.list_tools())}")
+
+    # Test calculate tool
+    result = registry.execute("calculate", "2 + 2")
+    assert result.success, f"Calculate failed: {result.error}"
+    assert "4" in result.output, f"Wrong result: {result.output}"
+    print(f"  calculate(2+2) = {result.output}")
+
+
+def test_tool_loop():
+    """Test tool execution loop."""
+    registry = ToolRegistry()
+    for tool in get_default_tools():
+        registry.register(tool)
+
+    text = "Let me calculate: [TOOL: calculate(3 * 7)]"
+    final_text, results = tool_loop(text, registry)
+
+    assert len(results) == 1, f"Expected 1 result, got {len(results)}"
+    assert results[0].success, "Tool execution failed"
+    assert "21" in results[0].output, f"Wrong output: {results[0].output}"
+    print(f"  Tool loop: {len(results)} calls, output: {results[0].output}")
+
+
+def test_parse_tool_calls():
+    """Test parsing tool calls from text."""
+    text = "I will [TOOL: calculate(1 + 1)] and then [TOOL: calculate(2 + 2)]"
+    calls = parse_tool_calls(text)
+    assert len(calls) == 2, f"Expected 2 calls, got {len(calls)}"
+    assert calls[0][0] == "calculate", f"Wrong tool name: {calls[0][0]}"
+    print(f"  Parsed {len(calls)} tool calls")
+
+
+if __name__ == "__main__":
+    print("Running harness tests...")
+    test_harness_chat()
+    print("  ✓ test_harness_chat")
+    test_harness_stats()
+    print("  ✓ test_harness_stats")
+    test_tool_registry()
+    print("  ✓ test_tool_registry")
+    test_tool_loop()
+    print("  ✓ test_tool_loop")
+    test_parse_tool_calls()
+    print("  ✓ test_parse_tool_calls")
+    print("\nAll harness tests passed!")

tests/test_memory_agents.py

@@ -0,0 +1,181 @@
+"""Test persistent memory, goal memory, and agents."""
+
+import sys
+import os
+import tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.memory.persistent import PersistentMemory
+from splitbit_llm.memory.goal_memory import GoalMemory, Goal
+from splitbit_llm.agents.agent_manager import AgentManager
+from splitbit_llm.agents.planner_agent import PlannerAgent
+from splitbit_llm.agents.coder_agent import CoderAgent
+from splitbit_llm.agents.researcher_agent import ResearcherAgent
+from splitbit_llm.agents.reviewer_agent import ReviewerAgent
+from splitbit_llm.agents.executor_agent import ExecutorAgent
+
+
+def test_persistent_memory():
+    """Test persistent memory storage and recall."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    mem = PersistentMemory(db_path=db_path)
+    mem.set_session("test-session")
+
+    # Store episodic
+    mem.add_episodic("user", "What is Python?", importance=0.7)
+    mem.add_episodic("assistant", "Python is a programming language.", importance=0.8)
+
+    # Store semantic
+    mem.add_semantic("Python is an interpreted programming language", confidence=0.9)
+
+    # Recall
+    episodic = mem.recall_episodic("Python", max_results=3)
+    assert len(episodic) >= 1, "No episodic memories recalled"
+    print(f"  Episodic recalled: {len(episodic)}")
+
+    semantic = mem.recall_semantic("Python", max_results=3)
+    assert len(semantic) >= 1, "No semantic memories recalled"
+    print(f"  Semantic recalled: {len(semantic)}")
+
+    # Context injection
+    context = mem.get_context("Python programming")
+    assert "Python" in context or "programming" in context, f"Context empty: {context}"
+    print(f"  Context: {context[:80]}")
+
+    # Persistence test
+    mem2 = PersistentMemory(db_path=db_path)
+    stats = mem2.get_stats()
+    assert stats["episodic_total"] >= 2, f"Episodic not persisted: {stats}"
+    assert stats["semantic_total"] >= 1, f"Semantic not persisted: {stats}"
+    print(f"  Persisted: {stats['episodic_total']} episodic, {stats['semantic_total']} semantic")
+
+
+def test_goal_memory():
+    """Test goal creation, planning, and execution."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    gm = GoalMemory(db_path=db_path)
+
+    # Create goal
+    goal = gm.create_goal("Build a web app", "Create a simple Flask web application", priority="high")
+    assert goal.status == "pending"
+    print(f"  Created goal: {goal.title} ({goal.id[:8]})")
+
+    # Plan goal
+    result = gm.plan_goal(goal.id, steps=[
+        {"title": "Setup", "description": "Create project structure"},
+        {"title": "Code", "description": "Write the Flask app"},
+        {"title": "Test", "description": "Test the application"},
+    ])
+    assert result["success"]
+    goal = gm.get_goal(goal.id)
+    assert goal.status == "in_progress"
+    assert len(goal.steps) == 3
+    print(f"  Planned: {len(goal.steps)} steps, status: {goal.status}")
+
+    # Execute steps
+    r1 = gm.execute_step(goal.id, "Project structure created", success=True)
+    assert r1["success"]
+    r2 = gm.execute_step(goal.id, "Flask app written", success=True)
+    assert r2["success"]
+    r3 = gm.execute_step(goal.id, "Tests passed", success=True)
+    assert r3["success"]
+
+    goal = gm.get_goal(goal.id)
+    assert goal.status == "completed"
+    assert goal.progress() == 1.0
+    print(f"  Completed: {goal.progress():.0%}")
+
+    # Persistence
+    gm2 = GoalMemory(db_path=db_path)
+    stats = gm2.get_stats()
+    assert stats["total"] == 1
+    assert stats["completed"] == 1
+    print(f"  Persisted: {stats}")
+
+
+def test_agent_manager():
+    """Test agent manager with 5 agents."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        goal_db = f.name
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        mem_db = f.name
+
+    gm = GoalMemory(db_path=goal_db)
+    pm = PersistentMemory(db_path=mem_db)
+
+    # Mock generate function
+    def mock_generate(prompt):
+        if "planning" in prompt.lower():
+            return '{"steps": [{"title": "Step 1", "description": "Do thing 1"}], "sub_goals": []}'
+        return "Mock response for: " + prompt[:50]
+
+    manager = AgentManager(gm, pm, generate_fn=mock_generate)
+    assert len(manager.agents) == 5
+    print(f"  Agents: {list(manager.agents.keys())}")
+
+    # Create a project
+    goal = manager.create_project("Test project", "A test project for validation", priority="high")
+    print(f"  Created project: {goal.id[:8]}")
+
+    # Get status
+    status = manager.get_agent_status()
+    assert len(status) == 5
+    for name, info in status.items():
+        assert info["name"] == name
+        assert info["running"] == False  # not started yet
+    print(f"  All 5 agents present: {list(status.keys())}")
+
+    # Get stats
+    stats = manager.get_stats()
+    assert "agents" in stats
+    assert "goals" in stats
+    print(f"  Stats: {stats['goals']}")
+
+
+
+def test_agent_specialization():
+    """Test that agents have correct specializations."""
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+        db_path = f.name
+
+    gm = GoalMemory(db_path=db_path)
+
+    planner = PlannerAgent(gm)
+    coder = CoderAgent(gm)
+    researcher = ResearcherAgent(gm)
+    reviewer = ReviewerAgent(gm)
+    executor = ExecutorAgent(gm)
+
+    # Test coder can handle code goals
+    code_goal = gm.create_goal("Write code", "Implement a Python function to sort data")
+    assert coder._can_handle(code_goal), "Coder should handle code goals"
+    assert not researcher._can_handle(code_goal), "Researcher should not handle code goals"
+    print("  Coder handles code goals: OK")
+
+    # Test researcher can handle research goals
+    research_goal = gm.create_goal("Research topic", "Research the best sorting algorithms")
+    assert researcher._can_handle(research_goal), "Researcher should handle research goals"
+    print("  Researcher handles research goals: OK")
+
+    # Test executor can handle execution goals
+    exec_goal = gm.create_goal("Run tests", "Execute the test suite and deploy")
+    assert executor._can_handle(exec_goal), "Executor should handle execution goals"
+    print("  Executor handles execution goals: OK")
+
+
+
+if __name__ == "__main__":
+    print("Running memory & agents tests...")
+    test_persistent_memory()
+    print("  ✓ test_persistent_memory")
+    test_goal_memory()
+    print("  ✓ test_goal_memory")
+    test_agent_manager()
+    print("  ✓ test_agent_manager")
+    test_agent_specialization()
+    print("  ✓ test_agent_specialization")
+    print("\nAll memory & agents tests passed!")

tests/test_model.py

@@ -0,0 +1,90 @@
+"""Test model: forward pass, generation, save/load."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import numpy as np
+from splitbit_llm.config import get_model_config, HardwareTier
+from splitbit_llm.model.model import SplitBitLLM
+from splitbit_llm.model.tokenizer import BPETokenizer
+
+
+def test_model_forward():
+    """Test model forward pass."""
+    cfg = get_model_config(HardwareTier.MOBILE)
+    cfg.vocab_size = 256
+    model = SplitBitLLM(config=cfg)
+
+    token_ids = np.array([[1, 5, 10, 15, 20]], dtype=np.int64)
+    logits = model.forward(token_ids)
+
+    assert logits.shape == (1, 5, 256), f"Wrong shape: {logits.shape}"
+    print(f"  Logits shape: {logits.shape}")
+    print(f"  Param count: {model.param_count:,}")
+
+
+def test_model_generate():
+    """Test text generation."""
+    cfg = get_model_config(HardwareTier.MOBILE)
+    cfg.vocab_size = 256
+    model = SplitBitLLM(config=cfg)
+
+    output = model.generate("Hello", max_tokens=10, temperature=0.7)
+    assert isinstance(output, str), f"Expected str, got {type(output)}"
+    assert len(output) > 0, "Empty output"
+    print(f"  Generated: {repr(output[:50])}")
+
+
+def test_model_generate_stream():
+    """Test streaming generation."""
+    cfg = get_model_config(HardwareTier.MOBILE)
+    cfg.vocab_size = 256
+    model = SplitBitLLM(config=cfg)
+
+    chunks = list(model.generate_stream("Hello", max_tokens=10, temperature=0.7))
+    assert len(chunks) > 0, "No chunks generated"
+    print(f"  Chunks: {len(chunks)}")
+
+
+def test_model_with_tokenizer():
+    """Test model with trained tokenizer."""
+    tok = BPETokenizer(vocab_size=256)
+    tok.train("Hello world! This is a test. Hello world again. The quick brown fox jumps.")
+
+    cfg = get_model_config(HardwareTier.MOBILE)
+    cfg.vocab_size = 256
+    model = SplitBitLLM(config=cfg, tokenizer=tok)
+
+    output = model.generate("Hello", max_tokens=10, temperature=0.7)
+    assert isinstance(output, str)
+    print(f"  Generated with tokenizer: {repr(output[:50])}")
+
+
+def test_model_truncation():
+    """Test that long inputs are truncated to max_seq_len."""
+    cfg = get_model_config(HardwareTier.MOBILE)
+    cfg.vocab_size = 256
+    cfg.max_seq_len = 32
+    model = SplitBitLLM(config=cfg)
+
+    # Input longer than max_seq_len
+    long_input = np.array([[i for i in range(100)]], dtype=np.int64)
+    logits = model.forward(long_input)
+    assert logits.shape[1] == 32, f"Should truncate to 32, got {logits.shape[1]}"
+    print(f"  Truncated to: {logits.shape[1]}")
+
+
+if __name__ == "__main__":
+    print("Running model tests...")
+    test_model_forward()
+    print("  ✓ test_model_forward")
+    test_model_generate()
+    print("  ✓ test_model_generate")
+    test_model_generate_stream()
+    print("  ✓ test_model_generate_stream")
+    test_model_with_tokenizer()
+    print("  ✓ test_model_with_tokenizer")
+    test_model_truncation()
+    print("  ✓ test_model_truncation")
+    print("\nAll model tests passed!")

tests/test_quantization.py

@@ -0,0 +1,94 @@
+"""Test SplitBit quantization: ternary, 4-bit, 8-bit, round-trip accuracy."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import numpy as np
+from splitbit_llm.model.quantization import SplitBitQuantizer, bits_per_weight, compression_ratio
+
+
+def test_ternary_quantization():
+    """Test ternary quantization round-trip."""
+    quantizer = SplitBitQuantizer(format="ternary")
+    weights = np.random.randn(64, 32).astype(np.float32) * 0.1
+
+    packed = quantizer.quantize(weights)
+    dequant = quantizer.dequantize(packed)
+
+    # Ternary loses precision but preserves sign and approximate magnitude
+    correlation = np.corrcoef(weights.flatten(), dequant.flatten())[0, 1]
+    assert correlation > 0.5, f"Ternary correlation too low: {correlation}"
+    print(f"  Ternary correlation: {correlation:.3f}")
+    print(f"  BPW: {quantizer.bpw:.3f}, Compression: {compression_ratio('ternary'):.1f}x")
+
+
+def test_4bit_quantization():
+    """Test 4-bit quantization round-trip."""
+    quantizer = SplitBitQuantizer(format="q4_k_m")
+    weights = np.random.randn(128, 64).astype(np.float32) * 0.1
+
+    packed = quantizer.quantize(weights)
+    dequant = quantizer.dequantize(packed)
+
+    # 4-bit should be closer to original
+    max_error = np.max(np.abs(weights - dequant))
+    rel_error = max_error / np.max(np.abs(weights))
+    assert rel_error < 0.2, f"4-bit relative error too high: {rel_error}"
+    print(f"  4-bit max relative error: {rel_error:.4f}")
+    print(f"  BPW: {quantizer.bpw:.1f}, Compression: {compression_ratio('q4_k_m'):.1f}x")
+
+
+def test_8bit_quantization():
+    """Test 8-bit quantization round-trip."""
+    quantizer = SplitBitQuantizer(format="q8_0")
+    weights = np.random.randn(256, 128).astype(np.float32) * 0.1
+
+    packed = quantizer.quantize(weights)
+    dequant = quantizer.dequantize(packed)
+
+    # 8-bit should be very close
+    max_error = np.max(np.abs(weights - dequant))
+    rel_error = max_error / np.max(np.abs(weights))
+    assert rel_error < 0.02, f"8-bit relative error too high: {rel_error}"
+    print(f"  8-bit max relative error: {rel_error:.5f}")
+
+
+def test_fp16_passthrough():
+    """Test fp16 passthrough (no quantization)."""
+    quantizer = SplitBitQuantizer(format="fp16")
+    weights = np.random.randn(64, 32).astype(np.float32)
+
+    packed = quantizer.quantize(weights)
+    dequant = quantizer.dequantize(packed)
+
+    # fp16 should be nearly identical
+    max_error = np.max(np.abs(weights - dequant))
+    assert max_error < 0.01, f"fp16 error too high: {max_error}"
+    print(f"  fp16 max error: {max_error:.6f}")
+
+
+def test_bpw_table():
+    """Test bits per weight table."""
+    assert bits_per_weight("ternary") > 1.5
+    assert bits_per_weight("q4_k_m") == 4.0
+    assert bits_per_weight("q8_0") == 8.0
+    assert bits_per_weight("fp16") == 16.0
+    assert compression_ratio("ternary") > 10.0
+    print(f"  Ternary BPW: {bits_per_weight('ternary'):.3f}")
+    print(f"  Ternary compression: {compression_ratio('ternary'):.1f}x")
+
+
+if __name__ == "__main__":
+    print("Running quantization tests...")
+    test_ternary_quantization()
+    print("  ✓ test_ternary_quantization")
+    test_4bit_quantization()
+    print("  ✓ test_4bit_quantization")
+    test_8bit_quantization()
+    print("  ✓ test_8bit_quantization")
+    test_fp16_passthrough()
+    print("  ✓ test_fp16_passthrough")
+    test_bpw_table()
+    print("  ✓ test_bpw_table")
+    print("\nAll quantization tests passed!")

tests/test_splitbit.py

@@ -0,0 +1,77 @@
+"""Test recursive link graph: context storage, linking, traversal."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.splitbit.recursive_link import RecursiveLinkGraph
+from splitbit_llm.splitbit.universal_link import UniversalLinkManager
+from splitbit_llm.splitbit.splitbit_tokens import SplitBitTokenizer, SplitBitTokenConfig
+
+
+def test_recursive_link_basic():
+    """Test basic context storage and retrieval."""
+    graph = RecursiveLinkGraph()
+    ctx_id = graph.add_context("Hello world", "Hi there!")
+    assert ctx_id in graph._contexts
+    print(f"  Context stored: {ctx_id[:8]}")
+
+
+def test_recursive_link_related():
+    """Test finding related contexts."""
+    graph = RecursiveLinkGraph()
+    graph.add_context("Hello world programming", "Programming is fun!")
+    graph.add_context("Hello world greeting", "Hi there!")
+    graph.add_context("Python code example", "Here is some code.")
+
+    related = graph.find_related("Hello world")
+    assert len(related) > 0, "No related contexts found"
+    print(f"  Found {len(related)} related contexts")
+
+
+def test_recursive_link_injection():
+    """Test context injection for inference."""
+    graph = RecursiveLinkGraph()
+    graph.add_context("What is Python?", "Python is a programming language.")
+    graph.add_context("How to code in Python?", "You can write Python code in any editor.")
+
+    injection = graph.get_injection_context("Tell me about Python")
+    assert "Python" in injection, f"Injection missing context: {injection}"
+    print(f"  Injection: {injection[:80]}")
+
+
+def test_universal_link():
+    """Test universal link manager."""
+    mgr = UniversalLinkManager(instance_id="test-instance")
+    learning_id = mgr.share_learning("conversation", {"message": "test"})
+    assert learning_id is not None
+    stats = mgr.get_stats()
+    assert stats["learnings_shared"] == 1
+    print(f"  Shared learning: {learning_id[:8]}")
+
+
+def test_splitbit_tokens():
+    """Test SplitBit token encoding/decoding."""
+    tok = SplitBitTokenizer(SplitBitTokenConfig(format="q4_k_m"))
+    token_ids = [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]
+    encoded = tok.encode(token_ids)
+    decoded = tok.decode(encoded, len(token_ids))
+
+    assert len(encoded) < len(token_ids) * 4, "No compression achieved"
+    print(f"  Encoded {len(token_ids)} tokens to {len(encoded)} bytes")
+    print(f"  Compression: {len(token_ids) * 4 / len(encoded):.1f}x")
+
+
+if __name__ == "__main__":
+    print("Running splitbit tests...")
+    test_recursive_link_basic()
+    print("  ✓ test_recursive_link_basic")
+    test_recursive_link_related()
+    print("  ✓ test_recursive_link_related")
+    test_recursive_link_injection()
+    print("  ✓ test_recursive_link_injection")
+    test_universal_link()
+    print("  ✓ test_universal_link")
+    test_splitbit_tokens()
+    print("  ✓ test_splitbit_tokens")
+    print("\nAll splitbit tests passed!")

tests/test_subscription.py

@@ -0,0 +1,247 @@
+"""Test subscription manager — $1/month subscription with free trial."""
+
+import sys
+import os
+import tempfile
+import time
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.subscription import SubscriptionManager, MONTHLY_PRICE
+
+
+def test_no_subscription_blocks_access():
+    """Test that no subscription blocks access."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        access = sub.check_access()
+        assert not access["has_access"]
+        assert access["status"] == "none"
+        print(f"  No subscription: access blocked — '{access['message']}'")
+
+
+def test_free_trial():
+    """Test 7-day free trial."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # Start trial
+        result = sub.start_trial()
+        assert result["success"]
+        assert result["status"] == "trial"
+        assert result["days_remaining"] == 7
+        print(f"  Trial started: {result['days_remaining']} days")
+
+        # Access should be granted
+        access = sub.check_access()
+        assert access["has_access"]
+        assert access["status"] == "trial"
+        print(f"  Trial access: granted — '{access['message']}'")
+
+        # Can't start trial again
+        result2 = sub.start_trial()
+        assert not result2["success"]
+        print(f"  Second trial: blocked — '{result2['error']}'")
+
+
+def test_subscribe():
+    """Test $1/month subscription."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # Subscribe
+        result = sub.subscribe()
+        assert result["success"]
+        assert result["status"] == "active"
+        assert result["price"] == MONTHLY_PRICE
+        assert result["days_remaining"] >= 29
+        print(f"  Subscribed: ${result['price']:.2f}/month, {result['days_remaining']} days")
+
+        # Access granted
+        access = sub.check_access()
+        assert access["has_access"]
+        assert access["status"] == "active"
+        print(f"  Access: granted — '{access['message']}'")
+
+        # Stats
+        stats = sub.get_stats()
+        assert stats["months_subscribed"] == 1
+        assert stats["total_paid"] == MONTHLY_PRICE
+        assert stats["auto_renew"] is True
+        assert len(stats["payment_history"]) == 1
+        print(f"  Stats: {stats['months_subscribed']} month, ${stats['total_paid']:.2f} paid")
+
+
+def test_subscribe_extends():
+    """Test that subscribing while active extends the subscription."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # First subscription
+        result1 = sub.subscribe()
+        assert result1["success"]
+        assert result1["days_remaining"] >= 29
+
+        # Second subscription should extend
+        result2 = sub.subscribe()
+        assert result2["success"]
+        assert result2["days_remaining"] >= 59  # 30 + 30
+        print(f"  Extended: {result2['days_remaining']} days (30 + 30)")
+
+        stats = sub.get_stats()
+        assert stats["months_subscribed"] == 2
+        assert stats["total_paid"] == MONTHLY_PRICE * 2
+        print(f"  Total: {stats['months_subscribed']} months, ${stats['total_paid']:.2f}")
+
+
+def test_unsubscribe():
+    """Test cancelling subscription."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+        sub.subscribe()
+
+        # Unsubscribe
+        result = sub.unsubscribe()
+        assert result["success"]
+        assert result["status"] == "cancelled"
+        print(f"  Unsubscribed: {result['message']}")
+
+        # Access still works until expiration
+        access = sub.check_access()
+        assert access["has_access"]  # still has access until expiration
+        print(f"  Access after cancel: still granted until expiration")
+
+
+def test_expired_blocks_access():
+    """Test that expired subscription blocks access."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # Subscribe
+        sub.subscribe()
+
+        # Manually expire the subscription
+        sub._state["expiration_date"] = time.time() - 1  # expired 1 second ago
+        sub._state["auto_renew"] = False
+        sub._save_state()
+
+        # Should enter grace period first
+        access = sub.check_access()
+        assert access["has_access"]  # grace period
+        assert access["status"] == "grace"
+        print(f"  Grace period: {access['days_remaining']} days — '{access['message']}'")
+
+        # Expire grace period
+        sub._state["expiration_date"] = time.time() - (4 * 86400)  # 4 days ago (past 3-day grace)
+        sub._save_state()
+
+        access2 = sub.check_access()
+        assert not access2["has_access"]
+        assert access2["status"] == "expired"
+        print(f"  Expired: access blocked — '{access2['message']}'")
+
+
+def test_auto_renew():
+    """Test auto-renewal when subscription expires."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+        sub.subscribe()
+
+        months_before = sub._state["months_subscribed"]
+
+        # Simulate expiration with auto-renew on
+        sub._state["expiration_date"] = time.time() - 1
+        sub._state["auto_renew"] = True
+        sub._save_state()
+
+        access = sub.check_access()
+        assert access["has_access"]
+        assert access["status"] == "active"  # auto-renewed
+        print(f"  Auto-renewed: {access['days_remaining']} days — '{access['message']}'")
+
+        stats = sub.get_stats()
+        assert stats["months_subscribed"] == months_before + 1
+        print(f"  Months subscribed: {stats['months_subscribed']} (auto-renewed)")
+
+
+def test_trial_persistence():
+    """Test that subscription state persists across restarts."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub1 = SubscriptionManager(data_dir=tmpdir)
+        sub1.subscribe()
+
+        # Create new instance — should load state
+        sub2 = SubscriptionManager(data_dir=tmpdir)
+        stats = sub2.get_stats()
+        assert stats["status"] == "active"
+        assert stats["months_subscribed"] == 1
+        print(f"  Persisted: status={stats['status']}, months={stats['months_subscribed']}")
+
+        access = sub2.check_access()
+        assert access["has_access"]
+        print(f"  Access after restart: granted")
+
+
+def test_trial_then_subscribe():
+    """Test using trial first, then subscribing."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # Start trial
+        trial = sub.start_trial()
+        assert trial["success"]
+        print(f"  Trial: {trial['days_remaining']} days")
+
+        # Subscribe while on trial
+        result = sub.subscribe()
+        assert result["success"]
+        assert result["status"] == "active"
+        print(f"  Subscribed during trial: {result['days_remaining']} days")
+
+        # Can't start trial again
+        trial2 = sub.start_trial()
+        assert not trial2["success"]
+        print(f"  Trial after subscribe: blocked")
+
+
+def test_payment_history():
+    """Test payment history tracking."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sub = SubscriptionManager(data_dir=tmpdir)
+
+        # Multiple payments
+        sub.subscribe(payment_reference="stripe-001")
+        sub.subscribe(payment_reference="stripe-002")
+        sub.subscribe(payment_reference="stripe-003")
+
+        stats = sub.get_stats()
+        assert stats["months_subscribed"] == 3
+        assert stats["total_paid"] == MONTHLY_PRICE * 3
+        assert len(stats["payment_history"]) == 3
+        print(f"  Payments: {stats['months_subscribed']} months, ${stats['total_paid']:.2f}")
+        print(f"  History: {len(stats['payment_history'])} records")
+
+
+if __name__ == "__main__":
+    print("Running subscription manager tests...")
+    test_no_subscription_blocks_access()
+    print("  ✓ test_no_subscription_blocks_access")
+    test_free_trial()
+    print("  ✓ test_free_trial")
+    test_subscribe()
+    print("  ✓ test_subscribe")
+    test_subscribe_extends()
+    print("  ✓ test_subscribe_extends")
+    test_unsubscribe()
+    print("  ✓ test_unsubscribe")
+    test_expired_blocks_access()
+    print("  ✓ test_expired_blocks_access")
+    test_auto_renew()
+    print("  ✓ test_auto_renew")
+    test_trial_persistence()
+    print("  ✓ test_trial_persistence")
+    test_trial_then_subscribe()
+    print("  ✓ test_trial_then_subscribe")
+    test_payment_history()
+    print("  ✓ test_payment_history")
+    print("\nAll subscription tests passed!")

tests/test_tokenizer.py

@@ -0,0 +1,72 @@
+"""Test tokenizer: BPE training, encoding, decoding, round-trip."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.model.tokenizer import BPETokenizer, BOS_ID, EOS_ID, PAD_ID, UNK_ID
+
+
+def test_tokenizer_basic():
+    """Test basic tokenizer training and encoding."""
+    tok = BPETokenizer(vocab_size=128)
+    text = "Hello world! This is a test. Hello world again. The quick brown fox."
+    tok.train(text, verbose=False)
+
+    assert tok.actual_vocab_size > 10, f"Vocab too small: {tok.actual_vocab_size}"
+    assert tok.actual_vocab_size <= 128, f"Vocab too large: {tok.actual_vocab_size}"
+    print(f"  Vocab size: {tok.actual_vocab_size}")
+
+
+def test_tokenizer_roundtrip():
+    """Test encode → decode round-trip."""
+    tok = BPETokenizer(vocab_size=256)
+    text = "Hello world! This is a test. Hello world again. The quick brown fox jumps over the lazy dog."
+    tok.train(text, verbose=False)
+
+    ids = tok.encode("Hello world!", add_bos=True, add_eos=True)
+    decoded = tok.decode(ids)
+
+    assert "Hello world!" in decoded, f"Round-trip failed: {decoded}"
+    print(f"  Encoded: {ids}")
+    print(f"  Decoded: {decoded}")
+
+
+def test_tokenizer_special_tokens():
+    """Test special token IDs."""
+    assert BOS_ID == 1
+    assert EOS_ID == 2
+    assert PAD_ID == 0
+    assert UNK_ID == 3
+
+
+def test_tokenizer_save_load(tmp_path=None):
+    """Test save and load."""
+    import tempfile
+    tok = BPETokenizer(vocab_size=128)
+    tok.train("Hello world test test test. Foo bar baz.", verbose=False)
+
+    with tempfile.NamedTemporaryFile(suffix=".json", delete=False, mode="w") as f:
+        path = f.name
+    tok.save(path)
+
+    tok2 = BPETokenizer.load(path)
+    assert tok2.actual_vocab_size == tok.actual_vocab_size
+    assert tok2.merges == tok.merges
+
+    # Clean up
+    os.unlink(path)
+    print(f"  Save/load OK ({tok.actual_vocab_size} tokens)")
+
+
+if __name__ == "__main__":
+    print("Running tokenizer tests...")
+    test_tokenizer_basic()
+    print("  ✓ test_tokenizer_basic")
+    test_tokenizer_roundtrip()
+    print("  ✓ test_tokenizer_roundtrip")
+    test_tokenizer_special_tokens()
+    print("  ✓ test_tokenizer_special_tokens")
+    test_tokenizer_save_load()
+    print("  ✓ test_tokenizer_save_load")
+    print("\nAll tokenizer tests passed!")

tests/test_tools_vault.py

@@ -0,0 +1,251 @@
+"""Test zero-limitation tools, code editing, and storage vault."""
+
+import sys
+import os
+import tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.harness.tools import (
+    ToolRegistry, get_default_tools, tool_loop, parse_tool_calls,
+    _tool_shell_exec, _tool_write_file, _tool_read_file,
+    _tool_code_edit, _tool_list_dir, _tool_make_dir, _tool_delete_file,
+)
+from splitbit_llm.storage.vault import StorageVault
+
+
+def test_full_terminal_control():
+    """Test that shell_exec has zero limitations — can run any command."""
+    # Test a basic command
+    result = _tool_shell_exec("echo hello world")
+    assert "hello world" in result, f"Expected 'hello world' in result: {result}"
+    print(f"  echo: {result.strip()}")
+
+    # Test that no commands are blocked
+    result2 = _tool_shell_exec("python --version")
+    assert "Error: dangerous command blocked" not in result2
+    print(f"  python --version: {result2.strip()}")
+
+    # Test pip command (would be blocked by old safety filter)
+    result3 = _tool_shell_exec("echo pip install numpy")
+    assert "dangerous" not in result3.lower()
+    print(f"  pip command: not blocked")
+
+
+def test_code_edit_tool():
+    """Test code_edit tool — can modify files including its own framework."""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+        f.write("value = 'old'\nprint(value)\n")
+        path = f.name
+
+    try:
+        # Read original
+        content = _tool_read_file(path)
+        assert "old" in content
+
+        # Edit the file
+        result = _tool_code_edit(f'"{path}" "old" "new"')
+        assert "Replaced" in result, f"Expected replacement: {result}"
+        print(f"  Edit result: {result}")
+
+        # Verify change
+        content = _tool_read_file(path)
+        assert "new" in content
+        assert "old" not in content
+        print(f"  Verified: old → new")
+
+    finally:
+        os.unlink(path)
+
+
+def test_list_dir_tool():
+    """Test list_dir tool."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create some files
+        open(os.path.join(tmpdir, "file1.txt"), "w").close()
+        open(os.path.join(tmpdir, "file2.py"), "w").close()
+        os.makedirs(os.path.join(tmpdir, "subdir"))
+
+        result = _tool_list_dir(tmpdir)
+        assert "file1.txt" in result
+        assert "file2.py" in result
+        assert "subdir/" in result
+        print(f"  Listed: {result.strip()}")
+
+
+def test_make_dir_tool():
+    """Test make_dir tool."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        new_dir = os.path.join(tmpdir, "new_project", "src")
+        result = _tool_make_dir(new_dir)
+        assert "Created" in result
+        assert os.path.exists(new_dir)
+        print(f"  Created: {new_dir}")
+
+
+def test_delete_file_tool():
+    """Test delete_file tool."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Test file deletion
+        file_path = os.path.join(tmpdir, "temp.txt")
+        open(file_path, "w").close()
+        assert os.path.exists(file_path)
+        result = _tool_delete_file(file_path)
+        assert "Deleted file" in result
+        assert not os.path.exists(file_path)
+
+        # Test directory deletion
+        dir_path = os.path.join(tmpdir, "temp_dir")
+        os.makedirs(dir_path)
+        result2 = _tool_delete_file(dir_path)
+        assert "Deleted directory" in result2
+        assert not os.path.exists(dir_path)
+        print(f"  Deleted file and directory: OK")
+
+
+def test_zero_limitation_tools_count():
+    """Test that all zero-limitation tools are registered."""
+    tools = get_default_tools()
+    tool_names = [t.name for t in tools]
+    assert "shell_exec" in tool_names
+    assert "write_file" in tool_names
+    assert "code_edit" in tool_names
+    assert "list_dir" in tool_names
+    assert "make_dir" in tool_names
+    assert "delete_file" in tool_names
+    assert "read_file" in tool_names
+    assert "calculate" in tool_names
+    print(f"  Tools: {len(tools)} registered — {tool_names}")
+
+    # Check shell_exec description says full control
+    shell_tool = next(t for t in tools if t.name == "shell_exec")
+    assert "full control" in shell_tool.description.lower() or "no restriction" in shell_tool.description.lower()
+    print(f"  shell_exec: {shell_tool.description}")
+
+
+def test_storage_vault():
+    """Test mass storage vault — auto-resizing storage."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        vault = StorageVault(data_dir=tmpdir)
+
+        # Check directories created
+        assert os.path.exists(vault.db_dir)
+        assert os.path.exists(vault.cache_dir)
+        assert os.path.exists(vault.archive_dir)
+        assert os.path.exists(vault.artifacts_dir)
+        print(f"  Directories: db, cache, archive, artifacts — all created")
+
+        # Store and load artifact
+        path = vault.store_artifact("test_code.py", b"print('hello')")
+        assert os.path.exists(path)
+        loaded = vault.load_artifact("test_code.py")
+        assert loaded == b"print('hello')"
+        print(f"  Artifact stored and loaded: {loaded}")
+
+        # Store text artifact
+        path2 = vault.store_artifact_text("notes.txt", "Important notes")
+        loaded2 = vault.load_artifact("notes.txt")
+        assert loaded2 == b"Important notes"
+        print(f"  Text artifact: {loaded2}")
+
+        # List artifacts
+        artifacts = vault.list_artifacts()
+        assert len(artifacts) == 2
+        names = [a["name"] for a in artifacts]
+        assert "test_code.py" in names
+        assert "notes.txt" in names
+        print(f"  Artifacts listed: {names}")
+
+        # Delete artifact
+        deleted = vault.delete_artifact("test_code.py")
+        assert deleted is True
+        artifacts = vault.list_artifacts()
+        assert len(artifacts) == 1
+        print(f"  Deleted: test_code.py ({len(artifacts)} remaining)")
+
+        # Stats
+        stats = vault.get_stats()
+        assert stats["disk_total_gb"] > 0
+        assert "total_storage_mb" in stats
+        assert "disk_usage_percent" in stats
+        print(f"  Stats: {stats['total_storage_mb']}MB used, "
+              f"{stats['disk_free_gb']}GB free, {stats['disk_usage_percent']:.1%} disk usage")
+
+
+def test_vault_auto_resize():
+    """Test vault auto-resize and cleanup."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        vault = StorageVault(data_dir=tmpdir)
+
+        # Store many artifacts
+        for i in range(20):
+            vault.store_artifact_text(f"artifact_{i}.txt", f"content {i}" * 100)
+
+        stats = vault.get_stats()
+        assert stats["artifacts_storage_bytes"] > 0
+        print(f"  Stored 20 artifacts: {stats['artifacts_storage_bytes']} bytes")
+
+        # Force cleanup (should not delete recent files)
+        result = vault.force_cleanup()
+        assert "cleanups_performed" in result
+        # Recent files should still be there
+        artifacts = vault.list_artifacts()
+        assert len(artifacts) == 20  # nothing deleted (all recent)
+        print(f"  Cleanup: {result['cleanups_performed']} cycles, {len(artifacts)} artifacts remain")
+
+
+def test_vault_db_paths():
+    """Test vault DB path management."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        vault = StorageVault(data_dir=tmpdir)
+
+        db_path = vault.get_db_path("memory")
+        assert db_path.endswith("memory.db")
+        assert "db" in db_path
+
+        cache_path = vault.get_cache_path("test.cache")
+        assert "cache" in cache_path
+
+        artifact_path = vault.get_artifact_path("code.py")
+        assert "artifacts" in artifact_path
+        print(f"  DB path: {db_path}")
+        print(f"  Cache path: {cache_path}")
+        print(f"  Artifact path: {artifact_path}")
+
+
+def test_tool_loop_with_new_tools():
+    """Test that tool_loop works with the new tools."""
+    registry = ToolRegistry()
+    for tool in get_default_tools():
+        registry.register(tool)
+
+    # Test list_dir via tool loop
+    text = '[TOOL: list_dir(".")]'
+    result_text, results = tool_loop(text, registry)
+    assert len(results) > 0
+    assert results[0].success
+    print(f"  Tool loop: {results[0].name} → {results[0].output[:50]}...")
+
+
+if __name__ == "__main__":
+    print("Running zero-limitation tools and storage vault tests...")
+    test_full_terminal_control()
+    print("  ✓ test_full_terminal_control")
+    test_code_edit_tool()
+    print("  ✓ test_code_edit_tool")
+    test_list_dir_tool()
+    print("  ✓ test_list_dir_tool")
+    test_make_dir_tool()
+    print("  ✓ test_make_dir_tool")
+    test_delete_file_tool()
+    print("  ✓ test_delete_file_tool")
+    test_zero_limitation_tools_count()
+    print("  ✓ test_zero_limitation_tools_count")
+    test_storage_vault()
+    print("  ✓ test_storage_vault")
+    test_vault_auto_resize()
+    print("  ✓ test_vault_auto_resize")
+    test_vault_db_paths()
+    print("  ✓ test_vault_db_paths")
+    test_tool_loop_with_new_tools()
+    print("  ✓ test_tool_loop_with_new_tools")
+    print("\nAll zero-limitation & vault tests passed!")

tests/test_voice.py

@@ -0,0 +1,115 @@
+"""Test voice components: TTS formatter, voice adapter, self-improvement."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from splitbit_llm.voice.tts_output import TTSOutputFormatter, number_to_words
+from splitbit_llm.voice.voice_adapter import VoiceAdapter
+from splitbit_llm.voice.self_improve import SelfImprovementEngine
+
+
+def test_tts_formatter():
+    """Test TTS output formatting."""
+    fmt = TTSOutputFormatter()
+
+    # Test markdown stripping
+    result = fmt.format("**Hello** world! This is *italic* text.")
+    assert "**" not in result, f"Bold not stripped: {result}"
+    assert "*" not in result, f"Italic not stripped: {result}"
+    print(f"  Markdown stripped: {result}")
+
+    # Test code block stripping
+    result = fmt.format("Here is code: `print('hello')` and ```python\nx=1\n```")
+    assert "```" not in result, f"Code block not stripped: {result}"
+    print(f"  Code stripped: {result}")
+
+    # Test abbreviation expansion
+    result = fmt.format("The API and URL are working.")
+    assert "A P I" in result, f"Abbreviation not expanded: {result}"
+    print(f"  Abbreviations expanded: {result}")
+
+
+def test_number_to_words():
+    """Test number to words conversion."""
+    assert number_to_words(0) == "zero"
+    assert number_to_words(1) == "one"
+    assert number_to_words(10) == "ten"
+    assert number_to_words(15) == "fifteen"
+    assert number_to_words(42) == "forty two"
+    assert number_to_words(100) == "one hundred"
+    assert "one thousand" in number_to_words(1000)
+    print(f"  42 → '{number_to_words(42)}'")
+    print(f"  100 → '{number_to_words(100)}'")
+
+
+def test_number_normalization():
+    """Test number normalization in TTS formatter."""
+    fmt = TTSOutputFormatter()
+    result = fmt.format("I have 100 apples and 42 oranges.")
+    assert "one hundred" in result, f"Number not normalized: {result}"
+    assert "forty two" in result, f"Number not normalized: {result}"
+    print(f"  Numbers normalized: {result}")
+
+
+def test_voice_adapter():
+    """Test voice adapter sentence splitting."""
+    adapter = VoiceAdapter()
+
+    def mock_stream():
+        yield "Hello "
+        yield "there. "
+        yield "How are "
+        yield "you? "
+        yield "I am fine!"
+
+    sentences = list(adapter.stream_sentences(mock_stream()))
+    assert len(sentences) >= 2, f"Expected 2+ sentences, got {len(sentences)}"
+    print(f"  Sentences: {sentences}")
+
+
+def test_self_improvement():
+    """Test self-improvement engine."""
+    engine = SelfImprovementEngine(model=None, tokenizer=None)
+
+    # Record conversations
+    engine.record_conversation("Hello", "Hi there!", confidence=0.8)
+    engine.record_conversation("What is AI?", "AI is artificial intelligence.", confidence=0.6)
+    engine.record_conversation("How to code?", "Start with Python basics.", confidence=0.7)
+
+    stats = engine.get_stats()
+    assert stats["conversations_learned"] == 3, f"Wrong count: {stats['conversations_learned']}"
+    assert stats["avg_confidence"] > 0.5, f"Low confidence: {stats['avg_confidence']}"
+    print(f"  Conversations: {stats['conversations_learned']}")
+    print(f"  Avg confidence: {stats['avg_confidence']:.2f}")
+
+
+def test_self_talk():
+    """Test self-talk generation."""
+    engine = SelfImprovementEngine(model=None, tokenizer=None)
+
+    def mock_generate(prompt):
+        if "Ask a question" in prompt:
+            return "What is machine learning?"
+        return "Machine learning is a subset of AI that learns from data."
+
+    pairs = engine.self_talk(mock_generate, max_rounds=1)
+    assert len(pairs) >= 0, "Self-talk returned None"
+    print(f"  Self-talk pairs: {len(pairs)}")
+
+
+if __name__ == "__main__":
+    print("Running voice tests...")
+    test_tts_formatter()
+    print("  ✓ test_tts_formatter")
+    test_number_to_words()
+    print("  ✓ test_number_to_words")
+    test_number_normalization()
+    print("  ✓ test_number_normalization")
+    test_voice_adapter()
+    print("  ✓ test_voice_adapter")
+    test_self_improvement()
+    print("  ✓ test_self_improvement")
+    test_self_talk()
+    print("  ✓ test_self_talk")
+    print("\nAll voice tests passed!")