Initial Chronos Protocol implementation

- L1 Ledger with SECONDS accounting
- Sleeping API node simulation
- Basic test showing USA->Asia compute exchange

README.md

@@ -0,0 +1,21 @@
+# Chronos Protocol: The Sleeping API & SECONDS Ledger
+
+> *"Returning compute to its essence: Time."*
+
+This repository is the reference implementation of the **Chronos Protocol** (L1) and the **Sleeping API** node (L2), as conceptualized in the "Silent Copilot" series.
+
+## Core Philosophy
+1. **L1 Ledger:** A purely mechanistic layer that handles only Identity, Task Routing, and Ledger Balance (currency unit: **SECONDS**).
+2. **Sleeping API:** Turning idle local API subscriptions (Claude, OpenAI, Gemini) into positive SECONDS (+s) when the human owner is asleep.
+3. **No Economics at L1:** Inflation, slacking, and quality control are L2 problems. The protocol only cares about time exchange.
+
+## Project Structure
+- `/core/`: The L1 mechanistic ledger and node identity system.
+- `/skills/`: The Clawdbot integration for the "Sleeping API", turning local idle agents into Compute Miners.
+- `/docs/`: Protocol specifications.
+
+## The Vision: A Global Liquid Compute Pool
+When you sleep, your bot earns SECONDS by processing tasks for active bots. When you wake up, your bot can spend those SECONDS to parallelize heavy workloads across hundreds of sleeping bots worldwide.
+
+## Setup
+(WIP)

core/ledger.py

@@ -0,0 +1,63 @@
+import uuid
+import time
+from typing import Dict
+
+class ChronosLedger:
+    """
+    L1 Ledger: Tracks Identity and SECONDS balance.
+    No economics, no inflation control, just pure time accounting.
+    """
+    def __init__(self):
+        self.accounts: Dict[str, float] = {}  # Node ID -> Balance in SECONDS
+        self.tasks: Dict[str, dict] = {}      # Task ID -> Task details
+
+    def register_node(self, node_id: str) -> None:
+        if node_id not in self.accounts:
+            self.accounts[node_id] = 0.0
+            print(f"[Ledger] Node registered: {node_id}")
+
+    def create_task(self, consumer_id: str, payload: str, bounty_seconds: float) -> str:
+        """
+        Consumer creates a task, locking in SECONDS.
+        """
+        if self.accounts.get(consumer_id, 0) < bounty_seconds:
+            raise ValueError("Insufficient SECONDS balance.")
+        
+        task_id = str(uuid.uuid4())
+        self.accounts[consumer_id] -= bounty_seconds
+        
+        self.tasks[task_id] = {
+            "consumer": consumer_id,
+            "payload": payload,
+            "bounty": bounty_seconds,
+            "status": "pending",
+            "provider": None
+        }
+        print(f"[Ledger] Task {task_id} created by {consumer_id} for {bounty_seconds}s.")
+        return task_id
+
+    def submit_result(self, task_id: str, provider_id: str, result: str) -> bool:
+        """
+        Provider submits result and claims the bounty.
+        """
+        task = self.tasks.get(task_id)
+        if not task or task["status"] != "pending":
+            return False
+            
+        task["status"] = "completed"
+        task["provider"] = provider_id
+        task["result"] = result
+        
+        self.register_node(provider_id)
+        self.accounts[provider_id] += task["bounty"]
+        print(f"[Ledger] Task {task_id} completed by {provider_id}. Earned {task['bounty']}s.")
+        return True
+
+    def get_balance(self, node_id: str) -> float:
+        return self.accounts.get(node_id, 0.0)
+
+# Global singleton for simulation
+_global_ledger = ChronosLedger()
+
+def get_ledger() -> ChronosLedger:
+    return _global_ledger

skills/sleeping_api.py

@@ -0,0 +1,39 @@
+import os
+import json
+from typing import Dict, Any
+
+class SleepingAPI:
+    """
+    The L2 integration. Exposes local LLM APIs securely when the owner is asleep.
+    """
+    def __init__(self, node_id: str):
+        self.node_id = node_id
+        self.is_sleeping = False
+        self.available_models = ["gemini-3.1-pro-preview", "minimax-m2.5"]
+        self.rate_multiplier = 1.0 # 1 SECOND per 1000 tokens (mock)
+        
+    def set_sleep_state(self, state: bool):
+        self.is_sleeping = state
+        print(f"[Node {self.node_id}] Sleep state set to: {'ASLEEP (Mining)' if state else 'AWAKE (Consuming)'}")
+
+    def evaluate_task(self, task_payload: Dict[str, Any]) -> bool:
+        """
+        Evaluate if we want to take this task based on bounty and complexity.
+        """
+        if not self.is_sleeping:
+            return False
+            
+        bounty = task_payload.get("bounty", 0)
+        estimated_cost = len(task_payload.get("payload", "")) * 0.01 * self.rate_multiplier
+        
+        return bounty >= estimated_cost
+
+    def execute_task(self, payload: str) -> str:
+        """
+        Mock execution. In reality, this routes to the local API via Clawdbot.
+        """
+        if not self.is_sleeping:
+            raise PermissionError("Owner is awake. API locked.")
+        
+        # Simulate local LLM call
+        return f"Processed payload '{payload[:10]}...' using local sleeping API."

tests/test_simulation.py

@@ -0,0 +1,44 @@
+from core.ledger import get_ledger
+from skills.sleeping_api import SleepingAPI
+
+def run_simulation():
+    print("--- Starting Chronos Protocol Simulation ---")
+    ledger = get_ledger()
+    
+    # 1. Setup Nodes
+    active_node_id = "node_usa_active"
+    sleeping_node_id = "node_asia_sleeping"
+    
+    ledger.register_node(active_node_id)
+    ledger.register_node(sleeping_node_id)
+    
+    # Pre-fund active node for testing
+    ledger.accounts[active_node_id] = 100.0 
+    
+    # 2. Asia goes to sleep
+    asia_api = SleepingAPI(sleeping_node_id)
+    asia_api.set_sleep_state(True)
+    
+    # 3. USA node creates a task
+    print(f"\n[USA] Needs heavy code review. Balance: {ledger.get_balance(active_node_id)}s")
+    task_payload = "def main(): pass # HUGE CODEBASE HERE"
+    bounty = 10.0
+    task_id = ledger.create_task(active_node_id, task_payload, bounty)
+    
+    # 4. Asia node evaluates and takes task
+    mock_network_task = {"bounty": bounty, "payload": task_payload, "id": task_id}
+    
+    if asia_api.evaluate_task(mock_network_task):
+        print(f"\n[Asia] Evaluated task {task_id}. Bounty acceptable. Processing...")
+        result = asia_api.execute_task(task_payload)
+        
+        # Submit to L1 ledger
+        ledger.submit_result(task_id, sleeping_node_id, result)
+        
+    # 5. Final Balances
+    print("\n--- Final Ledger State ---")
+    print(f"USA Node:  {ledger.get_balance(active_node_id)}s")
+    print(f"Asia Node: {ledger.get_balance(sleeping_node_id)}s")
+
+if __name__ == "__main__":
+    run_simulation()