Upload folder using huggingface_hub

singularity_llm/__init__.py

@@ -0,0 +1,8 @@
+"""Singularity LLM — a custom lightweight LLM built from scratch.
+
+Pure NumPy implementation with Singularity sub-byte token encoding,
+recursive link memory, universal peer sync, built-in Jarvis voice
+assistant, skill creation, and tool-calling harness.
+"""
+
+__version__ = "0.1.0"

singularity_llm/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running as: python -m singularity_llm"""
+from .cli import main
+
+main()

singularity_llm/agents/__init__.py

@@ -0,0 +1,12 @@
+"""AI Agents package — 5 persistent agents that work on goals and projects.
+
+Agents:
+- PlannerAgent: breaks goals into steps, generates execution plans
+- CoderAgent: writes code, creates files, debugs
+- ResearcherAgent: gathers information, analyzes topics
+- ReviewerAgent: reviews work, validates quality, finds issues
+- ExecutorAgent: executes commands, runs tools, deploys
+
+All agents run persistently in background threads, picking up goals
+from the goal memory and working on them continuously.
+"""

singularity_llm/agents/agent_base.py

@@ -0,0 +1,198 @@
+"""Base AI Agent — common functionality for all agents.
+
+Each agent:
+- Has a name, role, and specialization
+- Runs in a background thread (persistent)
+- Picks up goals from the goal memory
+- Uses the LLM (via harness) to generate responses
+- Reports progress and results
+- Can be paused/resumed
+- Tracks stats (goals completed, steps executed, errors)
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ..memory.goal_memory import GoalMemory, Goal
+from ..memory.persistent import PersistentMemory
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentStats:
+    """Stats for a single agent."""
+    goals_assigned: int = 0
+    goals_completed: int = 0
+    goals_failed: int = 0
+    steps_executed: int = 0
+    errors: int = 0
+    uptime_s: float = 0.0
+    last_active: float = 0.0
+
+
+class BaseAgent:
+    """Base class for all AI agents.
+
+    Subclasses implement `process_goal()` which is called when a goal
+    is assigned to this agent.
+    """
+
+    def __init__(self, name: str, role: str, description: str,
+                 goal_memory: GoalMemory,
+                 persistent_memory: PersistentMemory | None = None,
+                 generate_fn: Callable[[str], str] | None = None,
+                 poll_interval_s: float = 5.0) -> None:
+        self.name = name
+        self.role = role
+        self.description = description
+        self.goal_memory = goal_memory
+        self.persistent_memory = persistent_memory
+        self._generate_fn = generate_fn
+        self._poll_interval = poll_interval_s
+
+        self._running = False
+        self._paused = False
+        self._thread: threading.Thread | None = None
+        self._current_goal: Goal | None = None
+        self._stats = AgentStats()
+        self._start_time = 0.0
+
+    def set_generate_fn(self, fn: Callable[[str], str]) -> None:
+        """Set the function used to generate LLM responses."""
+        self._generate_fn = fn
+
+    def start(self) -> None:
+        """Start the agent in a background thread."""
+        if self._running:
+            return
+        self._running = True
+        self._paused = False
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True, name=f"agent-{self.name}")
+        self._thread.start()
+        logger.info("Agent '%s' started (%s)", self.name, self.role)
+
+    def stop(self) -> None:
+        """Stop the agent."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=10)
+        logger.info("Agent '%s' stopped", self.name)
+
+    def pause(self) -> None:
+        """Pause the agent (doesn't pick up new goals)."""
+        self._paused = True
+        logger.info("Agent '%s' paused", self.name)
+
+    def resume(self) -> None:
+        """Resume the agent."""
+        self._paused = False
+        logger.info("Agent '%s' resumed", self.name)
+
+    def _run_loop(self) -> None:
+        """Main agent loop — continuously picks up and processes goals."""
+        while self._running:
+            try:
+                if self._paused:
+                    time.sleep(self._poll_interval)
+                    continue
+
+                # Find a goal assigned to this agent
+                goals = self.goal_memory.get_goals_for_agent(self.name)
+                active = [g for g in goals if g.status in ("in_progress", "planning")]
+
+                if not active:
+                    # Try to pick up an unassigned goal that matches our role
+                    pending = self.goal_memory.list_goals(status="pending")
+                    for g in pending:
+                        if self._can_handle(g):
+                            self.goal_memory.assign_agent(g.id, self.name)
+                            self._stats.goals_assigned += 1
+                            active = [g]
+                            break
+
+                if not active:
+                    time.sleep(self._poll_interval)
+                    continue
+
+                # Process the first active goal
+                goal = active[0]
+                self._current_goal = goal
+                self._stats.last_active = time.time()
+
+                result = self.process_goal(goal)
+
+                if result.get("success"):
+                    self._stats.steps_executed += 1
+                    # Advance the goal
+                    self.goal_memory.execute_step(
+                        goal.id, result.get("output", ""), success=True
+                    )
+                else:
+                    self._stats.errors += 1
+                    self.goal_memory.execute_step(
+                        goal.id, result.get("error", "Unknown error"), success=False
+                    )
+
+                # Check if goal is completed
+                updated = self.goal_memory.get_goal(goal.id)
+                if updated and updated.status == "completed":
+                    self._stats.goals_completed += 1
+                    if self.persistent_memory:
+                        self.persistent_memory.add_episodic(
+                            "event", f"Agent {self.name} completed goal: {goal.title}",
+                            importance=0.8, tags=["goal", "completed", self.name]
+                        )
+                    logger.info("Agent '%s' completed goal: %s", self.name, goal.title)
+
+                self._current_goal = None
+
+            except Exception as e:
+                logger.error("Agent '%s' error: %s", self.name, e)
+                self._stats.errors += 1
+                time.sleep(self._poll_interval)
+
+            self._stats.uptime_s = time.time() - self._start_time
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Check if this agent can handle a goal. Override in subclasses."""
+        return True
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Process a goal step. Must be implemented by subclasses.
+
+        Returns: {"success": bool, "output": str, "error": str}
+        """
+        raise NotImplementedError
+
+    def _generate(self, prompt: str) -> str:
+        """Generate a response using the LLM."""
+        if self._generate_fn:
+            return self._generate_fn(prompt)
+        return "(no generation function available)"
+
+    def get_status(self) -> dict[str, Any]:
+        """Get agent status."""
+        return {
+            "name": self.name,
+            "role": self.role,
+            "description": self.description,
+            "running": self._running,
+            "paused": self._paused,
+            "current_goal": self._current_goal.title if self._current_goal else None,
+            "stats": {
+                "goals_assigned": self._stats.goals_assigned,
+                "goals_completed": self._stats.goals_completed,
+                "goals_failed": self._stats.goals_failed,
+                "steps_executed": self._stats.steps_executed,
+                "errors": self._stats.errors,
+                "uptime_s": round(self._stats.uptime_s, 1),
+                "last_active": self._stats.last_active,
+            },
+        }

singularity_llm/agents/agent_manager.py

@@ -0,0 +1,158 @@
+"""Agent Manager — orchestrates all 5 persistent AI agents.
+
+Manages the lifecycle of all agents:
+- Starts/stops all agents
+- Assigns goals to the best-suited agent
+- Monitors agent progress
+- Handles agent failures and reassignment
+- Provides aggregated stats
+
+The agents run persistently in background threads, continuously
+picking up goals from the goal memory and working on them.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Callable
+
+from ..memory.goal_memory import GoalMemory, Goal
+from ..memory.persistent import PersistentMemory
+from .agent_base import BaseAgent
+from .planner_agent import PlannerAgent
+from .coder_agent import CoderAgent
+from .researcher_agent import ResearcherAgent
+from .reviewer_agent import ReviewerAgent
+from .executor_agent import ExecutorAgent
+
+logger = logging.getLogger(__name__)
+
+
+class AgentManager:
+    """Manages 5 persistent AI agents that work on goals and projects.
+
+    Agents:
+    1. Planner — breaks goals into steps
+    2. Coder — writes code, creates files
+    3. Researcher — gathers information
+    4. Reviewer — validates quality
+    5. Executor — runs commands, executes tools
+
+    All agents run in background threads and continuously process goals.
+    """
+
+    def __init__(self, goal_memory: GoalMemory,
+                 persistent_memory: PersistentMemory | None = None,
+                 generate_fn: Callable[[str], str] | None = None,
+                 tool_registry: Any = None) -> None:
+        self.goal_memory = goal_memory
+        self.persistent_memory = persistent_memory
+        self._generate_fn = generate_fn
+        self._tool_registry = tool_registry
+
+        # Create all 5 agents
+        self.agents: dict[str, BaseAgent] = {
+            "planner": PlannerAgent(goal_memory, persistent_memory, generate_fn),
+            "coder": CoderAgent(goal_memory, persistent_memory, generate_fn),
+            "researcher": ResearcherAgent(goal_memory, persistent_memory, generate_fn),
+            "reviewer": ReviewerAgent(goal_memory, persistent_memory, generate_fn),
+            "executor": ExecutorAgent(goal_memory, persistent_memory, generate_fn, tool_registry),
+        }
+
+        self._running = False
+        self._start_time = 0.0
+        self._stats = {
+            "total_goals_assigned": 0,
+            "total_goals_completed": 0,
+            "total_goals_failed": 0,
+            "reassignments": 0,
+        }
+
+    def set_generate_fn(self, fn: Callable[[str], str]) -> None:
+        """Set the LLM generation function for all agents."""
+        self._generate_fn = fn
+        for agent in self.agents.values():
+            agent.set_generate_fn(fn)
+
+    def start_all(self) -> None:
+        """Start all 5 agents."""
+        self._running = True
+        self._start_time = time.time()
+        for agent in self.agents.values():
+            agent.start()
+        logger.info("All 5 agents started")
+
+    def stop_all(self) -> None:
+        """Stop all agents."""
+        self._running = False
+        for agent in self.agents.values():
+            agent.stop()
+        logger.info("All agents stopped")
+
+    def pause_all(self) -> None:
+        """Pause all agents."""
+        for agent in self.agents.values():
+            agent.pause()
+
+    def resume_all(self) -> None:
+        """Resume all agents."""
+        for agent in self.agents.values():
+            agent.resume()
+
+    def create_project(self, title: str, description: str, priority: str = "high",
+                       tags: list[str] | None = None) -> Goal:
+        """Create a new project goal and let the planner agent pick it up."""
+        goal = self.goal_memory.create_goal(
+            title=title, description=description, priority=priority,
+            tags=tags or ["project"],
+        )
+        self._stats["total_goals_assigned"] += 1
+        logger.info("Created project: %s (will be picked up by planner agent)", title)
+        return goal
+
+    def assign_goal(self, goal_id: str, agent_name: str) -> bool:
+        """Manually assign a goal to a specific agent."""
+        if agent_name not in self.agents:
+            logger.warning("Unknown agent: %s", agent_name)
+            return False
+        result = self.goal_memory.assign_agent(goal_id, agent_name)
+        if result:
+            self._stats["total_goals_assigned"] += 1
+            return True
+        return False
+
+    def get_active_projects(self) -> list[Goal]:
+        """Get all active goals/projects."""
+        return self.goal_memory.get_active_goals()
+
+    def get_agent_status(self) -> dict[str, Any]:
+        """Get status of all agents."""
+        return {name: agent.get_status() for name, agent in self.agents.items()}
+
+    def get_project_progress(self) -> list[dict[str, Any]]:
+        """Get progress of all active projects."""
+        active = self.goal_memory.get_active_goals()
+        return [g.as_dict() for g in active]
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get aggregated stats."""
+        agent_stats = {name: agent.get_status()["stats"] for name, agent in self.agents.items()}
+        goal_stats = self.goal_memory.get_stats()
+
+        total_completed = sum(s["goals_completed"] for s in agent_stats.values())
+        total_failed = sum(s["goals_failed"] for s in agent_stats.values())
+        total_steps = sum(s["steps_executed"] for s in agent_stats.values())
+
+        return {
+            "manager": {
+                **self._stats,
+                "running": self._running,
+                "uptime_s": round(time.time() - self._start_time, 1) if self._start_time else 0,
+                "total_goals_completed": total_completed,
+                "total_goals_failed": total_failed,
+                "total_steps_executed": total_steps,
+            },
+            "agents": agent_stats,
+            "goals": goal_stats,
+        }

singularity_llm/agents/always_on.py

@@ -0,0 +1,418 @@
+"""Always-On Daemon — when not in use, the system keeps working.
+
+When the user isn't interacting:
+1. The 5 agents talk to the LLM, creating a continuous learning loop
+2. Jarvis creates skills from agent conversations
+3. Conversation skill creation — patterns extracted from agent talks
+4. Self-refinement engine optimizes speed and intelligence
+5. Goals are progressed — agents pick up and work on pending goals
+6. 100-project mode — auto-generates and works on 100 projects 24/7
+7. First-run naming — greets user as Incentives Inc. LLM, asks for a name
+
+This creates a system that's always getting smarter, even when idle.
+Once it has enough skills, it enters 100-project mode and never stops working.
+
+Daemon loop:
+- Check if user is active (recent conversation < 60s ago)
+- If idle: trigger agent conversations, skill creation, refinement, project generation
+- If active: do nothing (don't interfere with user interactions)
+- Runs in a background thread, started with `python -m singularity_llm daemon`
+"""
+
+from __future__ import annotations
+
+import logging
+import random
+import threading
+import time
+from typing import Any, Callable
+
+from .agent_manager import AgentManager
+from .self_refine import SelfRefinementEngine
+
+logger = logging.getLogger(__name__)
+
+
+class AlwaysOnDaemon:
+    """Always-on daemon — keeps the system working when idle.
+
+    When the user isn't interacting:
+    - Agents have conversations with the LLM (continuous learning)
+    - Jarvis creates skills from those conversations
+    - Self-refinement engine optimizes speed and intelligence
+    - Goals are progressed
+
+    The daemon monitors activity and only runs when the system is idle.
+    """
+
+    IDLE_THRESHOLD_S = 60.0  # consider idle after 60s of no user activity
+    AGENT_TALK_INTERVAL_S = 30.0  # agents talk every 30s when idle
+    REFINEMENT_INTERVAL_S = 120.0  # refine every 2 minutes
+    SKILL_CREATION_INTERVAL_S = 60.0  # create skills every 60s
+    PROJECT_CHECK_INTERVAL_S = 45.0  # check project count every 45s
+    MESH_INTERVAL_S = 90.0  # conversation mesh every 90s
+    TARGET_PROJECT_COUNT = 100  # maintain 100 active projects
+    FAST_REPLY_SKILL_THRESHOLD = 50  # need 50+ skills for fast replies
+    FAST_REPLY_HIT_RATE_THRESHOLD = 0.3  # need 30%+ cache hit rate
+
+    AGENT_CONVERSATION_TOPICS = [
+        "What's the most efficient way to process data?",
+        "How can I improve my response speed?",
+        "What patterns have you noticed in recent conversations?",
+        "How do you handle complex problem-solving?",
+        "What's the best approach for learning new skills?",
+        "How can we optimize our tool usage?",
+        "What are common mistakes to avoid in coding?",
+        "How do you break down large tasks into smaller ones?",
+        "What makes a good user experience?",
+        "How can we improve our memory recall?",
+        "What's the most important skill for an AI to have?",
+        "How do you prioritize tasks when everything is urgent?",
+        "What's the relationship between speed and accuracy?",
+        "How can we learn from our mistakes?",
+        "What's the best way to structure a project?",
+    ]
+
+    def __init__(self, harness: Any) -> None:
+        self.harness = harness
+        self._running = False
+        self._thread: threading.Thread | None = None
+
+        # Components
+        self.agent_manager = harness.agent_manager
+        self.refinement = SelfRefinementEngine(harness=harness)
+
+        # State
+        self._last_user_activity = time.time()
+        self._last_agent_talk = 0.0
+        self._last_skill_creation = 0.0
+        self._last_refinement = 0.0
+        self._last_project_check = 0.0
+        self._last_mesh = 0.0
+        self._conversation_count = 0
+        self._skills_created = 0
+        self._projects_generated = 0
+        self._projects_completed = 0
+        self._hundred_project_mode = False
+
+        self._stats = {
+            "daemon_uptime_s": 0.0,
+            "idle_cycles": 0,
+            "agent_conversations": 0,
+            "skills_created": 0,
+            "refinement_cycles": 0,
+            "goals_progressed": 0,
+            "projects_generated": 0,
+            "projects_completed": 0,
+            "hundred_project_mode": False,
+            "fast_reply_ready": False,
+            "mesh_conversations": 0,
+            "mesh_categories_discovered": 0,
+            "mesh_skills_pooled": 0,
+        }
+
+    def notify_user_activity(self) -> None:
+        """Call this when the user interacts with the system."""
+        self._last_user_activity = time.time()
+
+    def start(self) -> None:
+        """Start the always-on daemon."""
+        if self._running:
+            return
+        self._running = True
+        self._start_time = time.time()
+
+        # Start agents
+        self.agent_manager.start_all()
+
+        # Start self-refinement
+        self.refinement.start()
+
+        # Start daemon loop
+        self._thread = threading.Thread(target=self._run_loop, daemon=True, name="always-on")
+        self._thread.start()
+
+        logger.info("Always-on daemon started — 5 agents active, self-refinement running")
+
+    def stop(self) -> None:
+        """Stop the daemon."""
+        self._running = False
+        self.refinement.stop()
+        self.agent_manager.stop_all()
+        if self._thread:
+            self._thread.join(timeout=10)
+        logger.info("Always-on daemon stopped (ran %d cycles, %d agent conversations, %d skills created)",
+                     self._stats["idle_cycles"], self._stats["agent_conversations"], self._stats["skills_created"])
+
+    def _run_loop(self) -> None:
+        """Main daemon loop."""
+        while self._running:
+            time.sleep(5)  # check every 5 seconds
+
+            now = time.time()
+            idle_time = now - self._last_user_activity
+            self._stats["daemon_uptime_s"] = now - self._start_time
+
+            if idle_time < self.IDLE_THRESHOLD_S:
+                continue  # user is active, don't interfere
+
+            # System is idle — do work
+            self._stats["idle_cycles"] += 1
+
+            # 1. Agent conversations (every AGENT_TALK_INTERVAL_S)
+            if now - self._last_agent_talk > self.AGENT_TALK_INTERVAL_S:
+                self._run_agent_conversation()
+                self._last_agent_talk = now
+
+            # 2. Skill creation from conversations (every SKILL_CREATION_INTERVAL_S)
+            if now - self._last_skill_creation > self.SKILL_CREATION_INTERVAL_S:
+                self._create_skills_from_conversations()
+                self._last_skill_creation = now
+
+            # 3. Self-refinement (every REFINEMENT_INTERVAL_S)
+            if now - self._last_refinement > self.REFINEMENT_INTERVAL_S:
+                result = self.refinement.refine_once()
+                if result.get("actions"):
+                    self._stats["refinement_cycles"] += 1
+                self._last_refinement = now
+
+            # 4. Progress goals
+            self._progress_goals()
+
+            # 5. Check fast reply readiness
+            self._check_fast_reply_ready()
+
+            # 6. Multi-LLM conversation mesh — agents converse to build skills
+            if now - self._last_mesh > self.MESH_INTERVAL_S:
+                self._run_mesh_conversation()
+                self._last_mesh = now
+
+            # 7. 100-project mode — auto-generate and maintain projects
+            if now - self._last_project_check > self.PROJECT_CHECK_INTERVAL_S:
+                self._maintain_hundred_projects()
+                self._last_project_check = now
+
+    def _run_agent_conversation(self) -> None:
+        """Have an agent talk to the LLM — creates training data and skills."""
+        topic = random.choice(self.AGENT_CONVERSATION_TOPICS)
+
+        # Pick a random agent to ask the question
+        agent_names = list(self.agent_manager.agents.keys())
+        asking_agent = random.choice(agent_names)
+
+        # Generate a response from the LLM
+        try:
+            prompt = f"Agent {asking_agent} asks: {topic}"
+            response = self.harness._agent_generate(prompt)
+
+            # Store in persistent memory
+            self.harness.persistent_memory.add_episodic(
+                "agent", f"{asking_agent}: {topic} → {response[:100]}",
+                channel="agent-self-talk", importance=0.4,
+                tags=["self-talk", asking_agent]
+            )
+
+            # Store in recursive link graph
+            self.harness.link_graph.add_context(
+                topic, response, session_id="agent-self-talk", channel="agent"
+            )
+
+            self._stats["agent_conversations"] += 1
+            self._conversation_count += 1
+
+            logger.debug("Agent conversation #%d: %s asks '%s'", self._conversation_count, asking_agent, topic[:40])
+
+        except Exception as e:
+            logger.error("Agent conversation failed: %s", e)
+
+    def _create_skills_from_conversations(self) -> None:
+        """Extract skills from recent agent conversations."""
+        try:
+            factory = self.harness.skill_factory
+            skill = factory.extract_skill()
+            if skill:
+                self.harness.skill_manager.create(skill)
+                self._stats["skills_created"] += 1
+                self._skills_created += 1
+                logger.info("Created skill from agent conversations: %s", skill.name)
+
+            # Also try meta-skill
+            meta = factory.maybe_create_meta_skill(self.harness.skill_manager)
+            if meta:
+                self.harness.skill_manager.create(meta)
+                self._stats["skills_created"] += 1
+        except Exception as e:
+            logger.debug("Skill creation from conversations: %s", e)
+
+    def _progress_goals(self) -> None:
+        """Check if any goals can be progressed."""
+        try:
+            active = self.harness.goal_memory.get_active_goals()
+            pending = self.harness.goal_memory.list_goals(status="pending")
+
+            if pending and not active:
+                # Assign pending goals to agents
+                for goal in pending[:2]:  # assign up to 2 at a time
+                    self.harness.goal_memory.assign_agent(goal.id, "planner")
+                    self._stats["goals_progressed"] += 1
+                    logger.info("Assigned pending goal to planner: %s", goal.title)
+
+        except Exception as e:
+            logger.debug("Goal progression: %s", e)
+
+    def _check_fast_reply_ready(self) -> None:
+        """Check if the system is ready for near-instant replies."""
+        try:
+            skill_stats = self.harness.skill_manager.get_stats()
+            total_skills = skill_stats.get("total_skills", 0)
+
+            cache = getattr(self.harness, 'fast_cache', None)
+            hit_rate = cache.get_hit_rate() if cache else 0.0
+
+            ready = (total_skills >= self.FAST_REPLY_SKILL_THRESHOLD and
+                     hit_rate >= self.FAST_REPLY_HIT_RATE_THRESHOLD)
+
+            if ready and not self._stats["fast_reply_ready"]:
+                logger.info("Fast reply mode activated! %d skills, %.0f%% cache hit rate",
+                           total_skills, hit_rate * 100)
+
+            self._stats["fast_reply_ready"] = ready
+
+        except Exception as e:
+            logger.debug("Fast reply check: %s", e)
+
+    def _run_mesh_conversation(self) -> None:
+        """Run a multi-LLM conversation mesh — agents converse to build skills.
+
+        All 5 agents talk to each other on a topic, creating:
+        - Skill building pools (collaborative skills)
+        - New skill categories (auto-discovered)
+        - Cross-agent knowledge sharing
+        """
+        try:
+            mesh = self.harness.conversation_mesh
+            result = mesh.run_conversation()
+
+            self._stats["mesh_conversations"] += 1
+            self._stats["mesh_categories_discovered"] += len(result.get("categories", []))
+            if result.get("skill_pool"):
+                self._stats["mesh_skills_pooled"] += 1
+
+            logger.info("Mesh conversation: %s on '%s' — %d messages, %d categories, skill=%s",
+                       result.get("mode", "?"), result.get("topic", "?")[:40],
+                       result.get("messages", 0), len(result.get("categories", [])),
+                       result.get("skill_pool", False))
+
+        except Exception as e:
+            logger.debug("Mesh conversation failed: %s", e)
+
+    def _maintain_hundred_projects(self) -> None:
+        """Maintain 100 active projects — auto-generate new ones when count drops.
+
+        Once the system has enough skills and knowledge, it enters
+        100-project mode and continuously generates and works on projects.
+        It never stops — as soon as one project completes, a new one is created.
+        """
+        try:
+            goal_stats = self.harness.goal_memory.get_stats()
+            active_count = goal_stats.get("active", 0)
+            pending_count = goal_stats.get("pending", 0)
+            total_active = active_count + pending_count
+
+            # Check if we should enter 100-project mode
+            skill_stats = self.harness.skill_manager.get_stats()
+            total_skills = skill_stats.get("total_skills", 0)
+
+            if not self._hundred_project_mode:
+                if total_skills >= self.FAST_REPLY_SKILL_THRESHOLD:
+                    self._hundred_project_mode = True
+                    self._stats["hundred_project_mode"] = True
+                    logger.info("Entering 100-project mode! %d skills accumulated. "
+                               "Generating and working on projects 24/7.", total_skills)
+
+            if not self._hundred_project_mode:
+                return  # Not ready yet — keep learning
+
+            # Generate new projects to maintain TARGET_PROJECT_COUNT
+            if total_active < self.TARGET_PROJECT_COUNT:
+                needed = self.TARGET_PROJECT_COUNT - total_active
+                generated = self._generate_projects(min(needed, 5))  # generate up to 5 at a time
+                self._stats["projects_generated"] += generated
+                self._projects_generated += generated
+                if generated > 0:
+                    logger.info("Generated %d new projects (active: %d/%d)",
+                               generated, total_active + generated, self.TARGET_PROJECT_COUNT)
+
+            # Track completed projects
+            completed = goal_stats.get("completed", 0)
+            if completed > self._projects_completed:
+                new_completions = completed - self._projects_completed
+                self._projects_completed = completed
+                self._stats["projects_completed"] = completed
+                logger.info("Projects completed: %d total (+%d new)", completed, new_completions)
+
+        except Exception as e:
+            logger.debug("100-project mode: %s", e)
+
+    def _generate_projects(self, count: int) -> int:
+        """Generate new project goals automatically.
+
+        Projects are generated from a mix of:
+        - Template projects (improvement, optimization, learning)
+        - LLM-generated project ideas
+        - Skill-gap analysis (what skills are missing?)
+        """
+        project_templates = [
+            ("Optimize inference speed", "Analyze and optimize the LLM inference pipeline for faster responses", "high"),
+            ("Improve memory recall", "Enhance the persistent memory system's recall accuracy and speed", "medium"),
+            ("Create new skill: {topic}", "Develop a new skill for {topic} interactions", "medium"),
+            ("Optimize tokenizer", "Improve tokenizer efficiency and vocabulary coverage", "medium"),
+            ("Enhance agent coordination", "Improve how the 5 agents coordinate on multi-step goals", "high"),
+            ("Build conversation cache", "Expand the fast reply cache for more instant responses", "high"),
+            ("Refine quantization", "Experiment with quantization formats to improve accuracy/speed tradeoff", "medium"),
+            ("Create tool: {topic}", "Build a new tool for {topic} operations", "medium"),
+            ("Improve recursive links", "Enhance the recursive link graph for better context retrieval", "low"),
+            ("Optimize skill matching", "Improve skill trigger matching for more accurate skill selection", "medium"),
+            ("Expand semantic memory", "Extract more semantic facts from conversations", "low"),
+            ("Enhance voice responses", "Improve TTS output formatting and voice adapter latency", "medium"),
+            ("Build webhook integration", "Create webhook endpoints for external service notifications", "low"),
+            ("Optimize image generation", "Improve image generation speed and quality", "low"),
+            ("Create API connector", "Build a new API connector for external service integration", "medium"),
+            ("Improve goal planning", "Enhance the goal planning system with better step decomposition", "medium"),
+            ("Refine self-talk topics", "Generate better self-talk conversation topics for continuous learning", "low"),
+            ("Build monitoring dashboard", "Create a monitoring dashboard for system stats and health", "medium"),
+            ("Optimize SQLite queries", "Profile and optimize SQLite queries for memory and goal storage", "medium"),
+            ("Enhance error handling", "Improve error handling and recovery across all system components", "high"),
+        ]
+
+        topics = ["data processing", "code review", "text summarization", "pattern matching",
+                  "cache optimization", "memory management", "search algorithms", "data compression",
+                  "natural language", "math operations", "file handling", "network requests",
+                  "image processing", "audio processing", "task scheduling", "resource monitoring"]
+
+        generated = 0
+        for i in range(count):
+            try:
+                template = random.choice(project_templates)
+                title = template[0].format(topic=random.choice(topics))
+                description = template[1].format(topic=random.choice(topics))
+                priority = template[2]
+
+                self.harness.create_goal(title, description, priority=priority,
+                                        tags=["auto-generated", "100-project"])
+                generated += 1
+            except Exception as e:
+                logger.debug("Project generation failed: %s", e)
+                break
+
+        return generated
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            **self._stats,
+            "running": self._running,
+            "idle": (time.time() - self._last_user_activity) > self.IDLE_THRESHOLD_S,
+            "idle_time_s": round(time.time() - self._last_user_activity, 1),
+            "refinement": self.refinement.get_stats(),
+            "agents": self.agent_manager.get_stats(),
+        }

singularity_llm/agents/coder_agent.py

@@ -0,0 +1,82 @@
+"""Coder Agent — writes code, creates files, debugs.
+
+Handles steps that involve writing code, creating files, or fixing bugs.
+Can use the write_file and shell_exec tools.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from .agent_base import BaseAgent
+from ..memory.goal_memory import Goal
+
+logger = logging.getLogger(__name__)
+
+
+class CoderAgent(BaseAgent):
+    """Writes code and creates files for goal steps."""
+
+    def __init__(self, goal_memory, persistent_memory=None, generate_fn=None):
+        super().__init__(
+            name="coder",
+            role="Code Writer",
+            description="Writes code, creates files, and debugs issues",
+            goal_memory=goal_memory,
+            persistent_memory=persistent_memory,
+            generate_fn=generate_fn,
+            poll_interval_s=2.0,
+        )
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Coder handles goals related to code."""
+        keywords = ["code", "function", "file", "implement", "write", "create", "build",
+                    "debug", "fix", "bug", "program", "script", "module", "class"]
+        text = (goal.title + " " + goal.description).lower()
+        return any(kw in text for kw in keywords)
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Execute a coding step."""
+        if goal.current_step >= len(goal.steps):
+            return {"success": True, "output": "No more steps"}
+
+        step = goal.steps[goal.current_step]
+        prompt = (
+            f"You are a code writer agent. Execute this step:\n"
+            f"Goal: {goal.title}\n"
+            f"Step: {step['title']}\n"
+            f"Description: {step['description']}\n"
+            f"Write the code or create the file needed. Be concise.\n"
+        )
+
+        response = self._generate(prompt)
+
+        # Extract file content from response
+        files_created = self._extract_and_save_files(response)
+
+        if files_created:
+            return {"success": True, "output": f"Created files: {', '.join(files_created)}"}
+        return {"success": True, "output": response[:200]}
+
+    def _extract_and_save_files(self, text: str) -> list[str]:
+        """Extract file blocks from LLM output and save them."""
+        files = []
+        # Pattern: ```file: path\n content ```
+        pattern = r"```file:\s*(.+?)\n(.*?)```"
+        matches = re.findall(pattern, text, re.DOTALL)
+
+        for path, content in matches:
+            path = path.strip()
+            try:
+                import os
+                os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+                with open(path, "w", encoding="utf-8") as f:
+                    f.write(content.strip())
+                files.append(path)
+                logger.info("Coder created file: %s", path)
+            except Exception as e:
+                logger.error("Failed to create file %s: %s", path, e)
+
+        return files

singularity_llm/agents/conversation_mesh.py

@@ -0,0 +1,628 @@
+"""Multi-LLM Conversation Mesh — agents converse with each other to build skills.
+
+All 5 agents (planner, coder, researcher, reviewer, executor) can talk to
+each other and to the LLM directly. These conversations create:
+
+1. Skill Building Pools — shared pools of skills built collaboratively
+   - Agent A asks a question → Agent B answers → skill extracted from the exchange
+   - Multiple agents contribute to a single skill
+   - Skills are pooled by category and shared across all agents
+
+2. Intelligence Expansion — each conversation generates new knowledge:
+   - New facts → semantic memory
+   - New patterns → skills
+   - New categories → auto-added to skill category list
+
+3. Auto Skill Category Adder — dynamically discovers new categories:
+   - Analyzes conversation topics
+   - Extracts new category keywords
+   - Adds them to the skill category list automatically
+   - No hardcoded category list — categories grow organically
+
+Conversation patterns:
+- Round-robin: each agent talks in turn
+- Pair-wise: two agents have a focused conversation
+- Brainstorm: all agents contribute to a single topic
+- Debate: agents argue different sides of a topic
+- Teaching: one agent teaches a topic to others
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import random
+import threading
+import time
+from collections import defaultdict, deque
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ConversationMessage:
+    """A single message in a multi-LLM conversation."""
+    agent_name: str
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    role: str = "speaker"  # speaker, listener, summarizer
+
+
+@dataclass
+class SkillPool:
+    """A pool of skills built collaboratively by multiple agents."""
+    id: str
+    category: str
+    name: str
+    description: str
+    contributions: list[dict] = field(default_factory=list)  # which agents contributed
+    skill_content: str = ""
+    confidence: float = 0.0
+    created_at: float = field(default_factory=time.time)
+    tags: list[str] = field(default_factory=list)
+
+
+class AutoCategoryManager:
+    """Automatically discovers and adds new skill categories.
+
+    Analyzes conversation topics and extracts new categories dynamically.
+    No hardcoded category list — categories grow organically based on
+    what the agents actually talk about.
+
+    Category discovery:
+    1. Extract keywords from conversation topics
+    2. Cluster similar keywords into categories
+    3. Add new categories to the skill system
+    4. Track category health (how many skills, how active)
+    """
+
+    # Seed categories — the list grows from here
+    SEED_CATEGORIES = [
+        "conversation", "code", "speed", "voice", "tool",
+        "math", "writing", "analysis", "debugging", "optimization",
+    ]
+
+    def __init__(self) -> None:
+        self._categories: dict[str, dict] = {}
+        self._keyword_to_category: dict[str, str] = {}
+        self._category_keywords: dict[str, set[str]] = defaultdict(set)
+        self._stats = {
+            "categories_total": 0,
+            "categories_auto_added": 0,
+            "keywords_indexed": 0,
+            "category_lookups": 0,
+        }
+
+        # Initialize with seed categories
+        for cat in self.SEED_CATEGORIES:
+            self._add_category(cat, auto=False)
+
+    def _add_category(self, name: str, auto: bool = True) -> str:
+        """Add a new category."""
+        name = name.lower().strip()
+        if name in self._categories:
+            return name
+
+        self._categories[name] = {
+            "name": name,
+            "auto_added": auto,
+            "skill_count": 0,
+            "conversation_count": 0,
+            "created_at": time.time(),
+            "last_active": time.time(),
+        }
+        self._stats["categories_total"] += 1
+        if auto:
+            self._stats["categories_auto_added"] += 1
+        logger.info("Added skill category: %s (auto=%s)", name, auto)
+        return name
+
+    def discover_from_topic(self, topic: str) -> list[str]:
+        """Discover new categories from a conversation topic.
+
+        Extracts keywords, checks if they match existing categories,
+        and creates new categories for novel topics.
+        """
+        words = self._extract_keywords(topic)
+        discovered: list[str] = []
+
+        for word in words:
+            # Check if this keyword maps to an existing category
+            if word in self._keyword_to_category:
+                cat = self._keyword_to_category[word]
+                self._categories[cat]["last_active"] = time.time()
+                self._categories[cat]["conversation_count"] += 1
+                discovered.append(cat)
+                continue
+
+            # Check if word is similar to an existing category
+            matched = self._match_existing_category(word)
+            if matched:
+                self._keyword_to_category[word] = matched
+                self._category_keywords[matched].add(word)
+                self._stats["keywords_indexed"] += 1
+                discovered.append(matched)
+                continue
+
+            # New category discovered!
+            cat = self._add_category(word, auto=True)
+            self._keyword_to_category[word] = cat
+            self._category_keywords[cat].add(word)
+            self._stats["keywords_indexed"] += 1
+            self._categories[cat]["conversation_count"] += 1
+            discovered.append(cat)
+
+        return discovered
+
+    def _extract_keywords(self, text: str) -> list[str]:
+        """Extract meaningful keywords from text."""
+        import re
+        # Remove common stop words
+        stop_words = {
+            "the", "a", "an", "is", "are", "was", "were", "be", "been",
+            "have", "has", "had", "do", "does", "did", "will", "would",
+            "could", "should", "may", "might", "must", "can", "need",
+            "how", "what", "when", "where", "why", "who", "which",
+            "to", "of", "in", "on", "at", "by", "for", "with", "about",
+            "from", "as", "into", "through", "during", "before", "after",
+            "and", "or", "but", "not", "no", "yes", "if", "then", "else",
+            "this", "that", "these", "those", "i", "you", "he", "she",
+            "it", "we", "they", "me", "him", "her", "us", "them",
+            "my", "your", "his", "its", "our", "their",
+        }
+
+        words = re.findall(r'\b[a-z]{3,20}\b', text.lower())
+        keywords = [w for w in words if w not in stop_words and len(w) >= 4]
+
+        # Limit to top 5 unique keywords
+        seen = set()
+        result = []
+        for w in keywords:
+            if w not in seen:
+                seen.add(w)
+                result.append(w)
+            if len(result) >= 5:
+                break
+
+        return result
+
+    def _match_existing_category(self, keyword: str) -> str | None:
+        """Check if a keyword is similar to an existing category."""
+        # Simple prefix/suffix matching
+        for cat in self._categories:
+            if keyword.startswith(cat) or cat.startswith(keyword):
+                return cat
+            if keyword.endswith(cat) or cat.endswith(keyword):
+                return cat
+
+        # Check if keyword is in any category's keyword set
+        for cat, keywords in self._category_keywords.items():
+            if keyword in keywords:
+                return cat
+
+        return None
+
+    def get_categories(self) -> list[str]:
+        """Get all category names."""
+        return list(self._categories.keys())
+
+    def get_auto_categories(self) -> list[str]:
+        """Get only auto-discovered categories."""
+        return [name for name, info in self._categories.items() if info["auto_added"]]
+
+    def increment_skill_count(self, category: str) -> None:
+        """Increment the skill count for a category."""
+        if category in self._categories:
+            self._categories[category]["skill_count"] += 1
+            self._categories[category]["last_active"] = time.time()
+
+    def get_category_info(self, category: str) -> dict | None:
+        """Get info about a specific category."""
+        return self._categories.get(category)
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            **self._stats,
+            "categories": dict(self._categories),
+            "seed_categories": self.SEED_CATEGORIES,
+        }
+
+
+class ConversationMesh:
+    """Multi-LLM conversation mesh — agents converse to build skills.
+
+    All 5 agents can talk to each other and to the LLM. Conversations
+    create skill building pools and discover new skill categories.
+
+    Conversation modes:
+    - round_robin: each agent speaks in turn on a topic
+    - pairwise: two agents have a focused discussion
+    - brainstorm: all agents contribute ideas on a topic
+    - debate: agents argue different perspectives
+    - teaching: one agent teaches a topic to others
+    """
+
+    CONVERSATION_MODES = ["round_robin", "pairwise", "brainstorm", "debate", "teaching"]
+
+    BRAINSTORM_TOPICS = [
+        "How to improve code quality",
+        "Best practices for data processing",
+        "Optimizing memory usage in AI systems",
+        "New approaches to natural language understanding",
+        "Efficient algorithms for pattern matching",
+        "Strategies for error handling and recovery",
+        "Building better user interfaces",
+        "Improving search and retrieval accuracy",
+        "Techniques for faster inference",
+        "Methods for continuous learning",
+        "Approaches to multi-agent coordination",
+        "Enhancing creativity in problem solving",
+        "Building robust testing frameworks",
+        "Optimizing database queries",
+        "Improving API design patterns",
+        "Strategies for handling concurrency",
+        "Methods for data compression",
+        "Approaches to security and privacy",
+        "Techniques for code refactoring",
+        "Building scalable architectures",
+        "Improving error messages and debugging",
+        "Optimizing network communication",
+        "Strategies for resource management",
+        "Methods for adaptive learning",
+        "Approaches to self-improvement",
+    ]
+
+    def __init__(self, harness: Any) -> None:
+        self.harness = harness
+        self.agent_names = ["planner", "coder", "researcher", "reviewer", "executor"]
+        self.category_manager = AutoCategoryManager()
+        self._skill_pools: dict[str, SkillPool] = {}
+        self._conversations: deque[dict] = deque(maxlen=100)
+        self._cascade_depth = 0  # track cascade depth to prevent infinite recursion
+        self._stats = {
+            "conversations_total": 0,
+            "skills_pooled": 0,
+            "categories_discovered": 0,
+            "messages_exchanged": 0,
+            "cross_agent_skills": 0,
+            "cascade_depth": 0,
+            "cascade_pools_created": 0,
+            "cascade_conversations": 0,
+        }
+
+    def run_conversation(self, mode: str = "", topic: str = "") -> dict[str, Any]:
+        """Run a multi-LLM conversation.
+
+        Args:
+            mode: conversation mode (round_robin, pairwise, brainstorm, debate, teaching)
+            topic: conversation topic (random if not provided)
+        Returns:
+            Summary of the conversation and skills created
+        """
+        mode = mode or random.choice(self.CONVERSATION_MODES)
+        topic = topic or random.choice(self.BRAINSTORM_TOPICS)
+
+        # Discover categories from the topic
+        categories = self.category_manager.discover_from_topic(topic)
+        if categories:
+            self._stats["categories_discovered"] += len(categories)
+
+        # Run the conversation based on mode
+        if mode == "round_robin":
+            messages = self._round_robin(topic)
+        elif mode == "pairwise":
+            messages = self._pairwise(topic)
+        elif mode == "brainstorm":
+            messages = self._brainstorm(topic)
+        elif mode == "debate":
+            messages = self._debate(topic)
+        elif mode == "teaching":
+            messages = self._teaching(topic)
+        else:
+            messages = self._round_robin(topic)
+
+        # Build skill pool from the conversation
+        pool = self._build_skill_pool(topic, messages, categories)
+
+        # Cascade: when a skill pool is built, auto-generate related skill pools
+        cascade_results = []
+        if pool and self._cascade_depth < 2:
+            cascade_results = self._cascade_related_skills(topic, categories, max_depth=2)
+
+        # Store conversation
+        conv_record = {
+            "mode": mode,
+            "topic": topic,
+            "categories": categories,
+            "messages": [{"agent": m.agent_name, "content": m.content[:100]} for m in messages],
+            "skill_pool_id": pool.id if pool else None,
+            "timestamp": time.time(),
+        }
+        self._conversations.append(conv_record)
+        self._stats["conversations_total"] += 1
+        self._stats["messages_exchanged"] += len(messages)
+
+        # Store in persistent memory
+        if self.harness:
+            try:
+                self.harness.persistent_memory.add_episodic(
+                    "mesh",
+                    f"[{mode}] {topic}: {len(messages)} messages, categories: {categories}",
+                    channel="mesh", importance=0.5,
+                    tags=["mesh", mode] + categories
+                )
+            except Exception:
+                pass
+
+        return {
+            "mode": mode,
+            "topic": topic,
+            "categories": categories,
+            "messages": len(messages),
+            "skill_pool": pool is not None,
+            "pool_id": pool.id if pool else None,
+            "cascaded": cascade_results,
+        }
+
+    def _cascade_related_skills(self, topic: str, categories: list[str],
+                                max_depth: int = 3) -> list[dict]:
+        """When a skill pool is built, automatically generate related skill pools.
+
+        For each new skill pool, the system:
+        1. Generates related topics based on the categories
+        2. Runs conversations on those related topics
+        3. Builds new skill pools from those conversations
+        4. Cascades further (up to max_depth) if new categories are discovered
+
+        This creates a branching tree of related skills — one conversation
+        on "database optimization" cascades into skills on "query performance",
+        "indexing strategies", "cache invalidation", etc.
+
+        Runs during idle time via the always-on daemon.
+        """
+        if self._cascade_depth >= max_depth:
+            return []
+
+        self._cascade_depth += 1
+        self._stats["cascade_depth"] = max(self._stats["cascade_depth"], self._cascade_depth)
+
+        # Generate related topics from the categories
+        related_topics = self._generate_related_topics(topic, categories)
+        cascade_results = []
+
+        for related_topic in related_topics:
+            try:
+                # Run a conversation on the related topic (different mode for variety)
+                mode = random.choice(self.CONVERSATION_MODES)
+                result = self.run_conversation(mode=mode, topic=related_topic)
+
+                if result.get("skill_pool"):
+                    self._stats["cascade_pools_created"] += 1
+                    self._stats["cascade_conversations"] += 1
+                    cascade_results.append({
+                        "topic": related_topic,
+                        "mode": mode,
+                        "pool_id": result.get("pool_id"),
+                        "categories": result.get("categories", []),
+                    })
+
+                    # Check if new categories were discovered → cascade further
+                    new_cats = [c for c in result.get("categories", []) if c not in categories]
+                    if new_cats:
+                        deeper = self._cascade_related_skills(related_topic, new_cats, max_depth)
+                        cascade_results.extend(deeper)
+
+            except Exception as e:
+                logger.debug("Cascade conversation failed: %s", e)
+
+        self._cascade_depth -= 1
+        return cascade_results
+
+    def _generate_related_topics(self, topic: str, categories: list[str]) -> list[str]:
+        """Generate related topics from a topic and its categories.
+
+        Uses category keywords to create variations and deeper explorations.
+        """
+        related = []
+
+        # Topic variations based on categories
+        for cat in categories[:3]:  # top 3 categories
+            related.extend([
+                f"Advanced {cat} techniques for {topic.lower()[:30]}",
+                f"Common pitfalls in {cat} when working with {topic.lower()[:20]}",
+                f"Best practices for {cat} in real-world scenarios",
+                f"Optimizing {cat} performance and reliability",
+                f"Testing strategies for {cat} implementations",
+            ])
+
+        # Cross-category topics
+        if len(categories) >= 2:
+            related.append(f"Integrating {categories[0]} with {categories[1]}")
+            related.append(f"Trade-offs between {categories[0]} and {categories[1]}")
+
+        # Deduplicate and limit
+        seen = set()
+        unique = []
+        for t in related:
+            t_lower = t.lower()
+            if t_lower not in seen:
+                seen.add(t_lower)
+                unique.append(t)
+        return unique[:3]  # limit to 3 related topics per cascade level
+
+    def _generate_response(self, agent_name: str, topic: str, context: str = "") -> str:
+        """Generate a response from an agent."""
+        prompt = f"Agent {agent_name} discusses: {topic}"
+        if context:
+            prompt += f"\nContext: {context[:200]}"
+        try:
+            if self.harness:
+                return self.harness._agent_generate(prompt)[:200]
+        except Exception:
+            pass
+        return f"{agent_name}: I think {topic.lower()[:50]} is important to explore."
+
+    def _round_robin(self, topic: str) -> list[ConversationMessage]:
+        """Each agent speaks in turn on the topic."""
+        messages = []
+        context = ""
+        for agent in self.agent_names:
+            response = self._generate_response(agent, topic, context)
+            msg = ConversationMessage(agent_name=agent, content=response)
+            messages.append(msg)
+            context = f"{agent} said: {response[:100]}"
+        return messages
+
+    def _pairwise(self, topic: str) -> list[ConversationMessage]:
+        """Two agents have a focused discussion."""
+        messages = []
+        a1, a2 = random.sample(self.agent_names, 2)
+        context = ""
+        for i in range(4):  # 2 exchanges each
+            speaker = a1 if i % 2 == 0 else a2
+            response = self._generate_response(speaker, topic, context)
+            msg = ConversationMessage(agent_name=speaker, content=response)
+            messages.append(msg)
+            context = f"{speaker} said: {response[:100]}"
+        return messages
+
+    def _brainstorm(self, topic: str) -> list[ConversationMessage]:
+        """All agents contribute ideas on a topic."""
+        messages = []
+        for agent in self.agent_names:
+            prompt = f"Brainstorm ideas for: {topic}"
+            response = self._generate_response(agent, topic, "")
+            msg = ConversationMessage(agent_name=agent, content=response, role="speaker")
+            messages.append(msg)
+        # Summarizer
+        summary = f"Summary: We discussed {topic} and generated {len(messages)} ideas."
+        msg = ConversationMessage(agent_name="reviewer", content=summary, role="summarizer")
+        messages.append(msg)
+        return messages
+
+    def _debate(self, topic: str) -> list[ConversationMessage]:
+        """Agents argue different perspectives on a topic."""
+        messages = []
+        for i, agent in enumerate(self.agent_names):
+            side = "for" if i % 2 == 0 else "against"
+            prompt = f"Argue {side}: {topic}"
+            response = self._generate_response(agent, prompt, "")
+            msg = ConversationMessage(agent_name=agent, content=response)
+            messages.append(msg)
+        return messages
+
+    def _teaching(self, topic: str) -> list[ConversationMessage]:
+        """One agent teaches a topic to others."""
+        messages = []
+        teacher = random.choice(self.agent_names)
+        # Teacher explains
+        response = self._generate_response(teacher, f"Teach: {topic}", "")
+        messages.append(ConversationMessage(agent_name=teacher, content=response, role="speaker"))
+        # Students ask questions
+        students = [a for a in self.agent_names if a != teacher]
+        for student in students[:3]:
+            question = self._generate_response(student, f"Question about: {topic}", response[:100])
+            messages.append(ConversationMessage(agent_name=student, content=question, role="listener"))
+        return messages
+
+    def _build_skill_pool(self, topic: str, messages: list[ConversationMessage],
+                          categories: list[str]) -> SkillPool | None:
+        """Build a skill pool from a conversation.
+
+        A skill pool is a collaborative skill built from multiple agent contributions.
+        """
+        if not messages or not categories:
+            return None
+
+        # Combine all messages into skill content
+        content_parts = [f"Skill Pool: {topic}"]
+        content_parts.append(f"Category: {categories[0]}")
+        content_parts.append(f"Contributors: {', '.join(set(m.agent_name for m in messages))}")
+        content_parts.append("Knowledge:")
+        for msg in messages:
+            content_parts.append(f"  [{msg.agent_name}] {msg.content[:150]}")
+        content_parts.append("Best practice: Apply this knowledge collaboratively.")
+
+        skill_content = "\n".join(content_parts)
+
+        # Create pool
+        pool_id = hashlib.sha256(f"{topic}:{time.time()}".encode()).hexdigest()[:16]
+        category = categories[0]
+
+        pool = SkillPool(
+            id=pool_id,
+            category=category,
+            name=f"{category}-pool-{pool_id[:8]}",
+            description=f"Collaborative skill pool for {topic[:80]}",
+            contributions=[
+                {"agent": m.agent_name, "content": m.content[:100], "role": m.role}
+                for m in messages
+            ],
+            skill_content=skill_content,
+            confidence=min(0.9, len(messages) / 10.0),
+            tags=categories,
+        )
+
+        self._skill_pools[pool_id] = pool
+        self._stats["skills_pooled"] += 1
+
+        # Count cross-agent skills (skills where multiple agents contributed)
+        unique_agents = set(m.agent_name for m in messages)
+        if len(unique_agents) >= 2:
+            self._stats["cross_agent_skills"] += 1
+
+        # Update category skill count
+        self.category_manager.increment_skill_count(category)
+
+        # Try to create an actual skill in the skill manager
+        if self.harness:
+            try:
+                from ..skills.skills import Skill
+                skill = Skill(
+                    id=pool_id,
+                    name=pool.name,
+                    description=pool.description,
+                    content=pool.skill_content[:500],
+                    category=category,
+                    trigger_conditions=categories + [topic.lower()[:20]],
+                    effectiveness_score=pool.confidence,
+                    confidence=pool.confidence,
+                )
+                self.harness.skill_manager.create(skill)
+            except Exception as e:
+                logger.debug("Skill creation from pool failed: %s", e)
+
+        return pool
+
+    def get_skill_pools(self) -> list[dict]:
+        """Get all skill pools."""
+        return [
+            {
+                "id": p.id,
+                "name": p.name,
+                "category": p.category,
+                "description": p.description,
+                "contributors": list(set(c["agent"] for c in p.contributions)),
+                "confidence": p.confidence,
+                "tags": p.tags,
+            }
+            for p in self._skill_pools.values()
+        ]
+
+    def get_categories(self) -> list[str]:
+        """Get all skill categories (including auto-discovered)."""
+        return self.category_manager.get_categories()
+
+    def get_auto_categories(self) -> list[str]:
+        """Get auto-discovered categories."""
+        return self.category_manager.get_auto_categories()
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            **self._stats,
+            "skill_pools": len(self._skill_pools),
+            "categories": self.category_manager.get_stats(),
+            "conversations_buffered": len(self._conversations),
+        }

singularity_llm/agents/executor_agent.py

@@ -0,0 +1,79 @@
+"""Executor Agent — executes commands, runs tools, deploys.
+
+Handles steps that involve running commands, executing tools, or
+performing actions. Uses the tool registry for execution.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .agent_base import BaseAgent
+from ..memory.goal_memory import Goal
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutorAgent(BaseAgent):
+    """Executes commands and runs tools for goal steps."""
+
+    def __init__(self, goal_memory, persistent_memory=None, generate_fn=None,
+                 tool_registry=None):
+        super().__init__(
+            name="executor",
+            role="Task Executor",
+            description="Executes commands, runs tools, and performs actions",
+            goal_memory=goal_memory,
+            persistent_memory=persistent_memory,
+            generate_fn=generate_fn,
+            poll_interval_s=2.0,
+        )
+        self._tool_registry = tool_registry
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Executor handles goals related to execution/deployment."""
+        keywords = ["execute", "run", "deploy", "install", "test", "build", "start",
+                    "stop", "configure", "setup", "launch", "perform", "do"]
+        text = (goal.title + " " + goal.description).lower()
+        return any(kw in text for kw in keywords)
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Execute a step using tools or commands."""
+        if goal.current_step >= len(goal.steps):
+            return {"success": True, "output": "No more steps"}
+
+        step = goal.steps[goal.current_step]
+        tool_name = step.get("tool", "")
+
+        # If a specific tool is specified, use it
+        if tool_name and self._tool_registry:
+            tool = self._tool_registry.get(tool_name)
+            if tool:
+                result = self._tool_registry.execute(tool_name, step.get("description", ""))
+                if result.success:
+                    return {"success": True, "output": result.output[:200]}
+                else:
+                    return {"success": False, "output": "", "error": result.error}
+
+        # Otherwise, use LLM to generate execution plan
+        prompt = (
+            f"You are an execution agent. Execute this step:\n"
+            f"Goal: {goal.title}\n"
+            f"Step: {step['title']}\n"
+            f"Description: {step['description']}\n"
+            f"Execute the step and report the result. Be concise.\n"
+        )
+
+        response = self._generate(prompt)
+
+        # Try to extract and execute tool calls from response
+        if self._tool_registry and "[TOOL:" in response:
+            from ..harness.tools import tool_loop, parse_tool_calls
+            final_text, tool_results = tool_loop(response, self._tool_registry, max_rounds=3)
+            if tool_results:
+                outputs = [r.output[:100] for r in tool_results if r.success]
+                if outputs:
+                    return {"success": True, "output": "; ".join(outputs)}
+
+        return {"success": True, "output": response[:200]}

singularity_llm/agents/planner_agent.py

@@ -0,0 +1,79 @@
+"""Planner Agent — breaks goals into actionable steps.
+
+Takes a goal description and generates a step-by-step execution plan.
+Can also replan when steps fail.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from .agent_base import BaseAgent
+from ..memory.goal_memory import Goal
+
+logger = logging.getLogger(__name__)
+
+
+class PlannerAgent(BaseAgent):
+    """Plans goals — breaks them into steps and sub-goals."""
+
+    def __init__(self, goal_memory, persistent_memory=None, generate_fn=None):
+        super().__init__(
+            name="planner",
+            role="Goal Planner",
+            description="Breaks goals into actionable steps and sub-goals",
+            goal_memory=goal_memory,
+            persistent_memory=persistent_memory,
+            generate_fn=generate_fn,
+            poll_interval_s=3.0,
+        )
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Planner handles goals that need planning."""
+        return goal.status in ("pending", "planning")
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Plan a goal by generating steps via LLM."""
+        if goal.status == "pending" or (goal.status == "planning" and not goal.steps):
+            prompt = (
+                f"{self.goal_memory.PLANNING_PROMPT}\n\n"
+                f"GOAL:\nTitle: {goal.title}\n"
+                f"Description: {goal.description}\n"
+                f"Priority: {goal.priority}\n"
+            )
+            response = self._generate(prompt)
+
+            # Parse the plan
+            plan = self._safe_json_parse(response, {"steps": [], "sub_goals": []})
+
+            if plan.get("steps"):
+                result = self.goal_memory.plan_goal(
+                    goal.id,
+                    steps=plan["steps"],
+                    sub_goals=plan.get("sub_goals", []),
+                    plan_type="initial",
+                )
+                return {"success": True, "output": f"Planned {len(plan['steps'])} steps"}
+            else:
+                # Fallback: create a single step
+                self.goal_memory.plan_goal(
+                    goal.id,
+                    steps=[{"title": "Execute goal", "description": goal.description, "tool": ""}],
+                    plan_type="initial",
+                )
+                return {"success": True, "output": "Planned with single fallback step"}
+
+        return {"success": True, "output": "Goal already planned"}
+
+    @staticmethod
+    def _safe_json_parse(text: str, fallback: dict) -> dict:
+        try:
+            start = text.find("{")
+            end = text.rfind("}") + 1
+            if start >= 0 and end > start:
+                return json.loads(text[start:end])
+        except Exception:
+            pass
+        return fallback

singularity_llm/agents/researcher_agent.py

@@ -0,0 +1,62 @@
+"""Researcher Agent — gathers information and analyzes topics.
+
+Handles steps that involve research, analysis, or information gathering.
+Uses the LLM to generate insights and summaries.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .agent_base import BaseAgent
+from ..memory.goal_memory import Goal
+
+logger = logging.getLogger(__name__)
+
+
+class ResearcherAgent(BaseAgent):
+    """Researches topics and gathers information for goal steps."""
+
+    def __init__(self, goal_memory, persistent_memory=None, generate_fn=None):
+        super().__init__(
+            name="researcher",
+            role="Researcher",
+            description="Gathers information, analyzes topics, and generates insights",
+            goal_memory=goal_memory,
+            persistent_memory=persistent_memory,
+            generate_fn=generate_fn,
+            poll_interval_s=3.0,
+        )
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Researcher handles goals related to research/analysis."""
+        keywords = ["research", "analyze", "investigate", "study", "learn", "understand",
+                    "explore", "gather", "find", "search", "compare", "evaluate"]
+        text = (goal.title + " " + goal.description).lower()
+        return any(kw in text for kw in keywords)
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Execute a research step."""
+        if goal.current_step >= len(goal.steps):
+            return {"success": True, "output": "No more steps"}
+
+        step = goal.steps[goal.current_step]
+        prompt = (
+            f"You are a research agent. Execute this step:\n"
+            f"Goal: {goal.title}\n"
+            f"Step: {step['title']}\n"
+            f"Description: {step['description']}\n"
+            f"Research and provide a concise summary of findings.\n"
+        )
+
+        response = self._generate(prompt)
+
+        # Store findings in persistent memory
+        if self.persistent_memory and response:
+            self.persistent_memory.add_episodic(
+                "research", f"Research for '{goal.title}': {response[:200]}",
+                importance=0.7, tags=["research", goal.title[:20]]
+            )
+
+        return {"success": True, "output": response[:200]}

singularity_llm/agents/reviewer_agent.py

@@ -0,0 +1,71 @@
+"""Reviewer Agent — reviews work, validates quality, finds issues.
+
+Reviews the output of other agents. Can approve or reject work,
+and suggest improvements. Runs after each step is completed.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .agent_base import BaseAgent
+from ..memory.goal_memory import Goal
+
+logger = logging.getLogger(__name__)
+
+
+class ReviewerAgent(BaseAgent):
+    """Reviews work done by other agents and validates quality."""
+
+    def __init__(self, goal_memory, persistent_memory=None, generate_fn=None):
+        super().__init__(
+            name="reviewer",
+            role="Quality Reviewer",
+            description="Reviews work, validates quality, and finds issues",
+            goal_memory=goal_memory,
+            persistent_memory=persistent_memory,
+            generate_fn=generate_fn,
+            poll_interval_s=4.0,
+        )
+
+    def _can_handle(self, goal: Goal) -> bool:
+        """Reviewer handles goals in reviewing status."""
+        return goal.status == "reviewing"
+
+    def process_goal(self, goal: Goal) -> dict[str, Any]:
+        """Review the most recent step output."""
+        if goal.current_step == 0 and not goal.steps:
+            return {"success": True, "output": "Nothing to review"}
+
+        # Review the last completed step
+        review_idx = max(0, goal.current_step - 1)
+        if review_idx >= len(goal.steps):
+            return {"success": True, "output": "No steps to review"}
+
+        step = goal.steps[review_idx]
+        if step.get("status") != "completed":
+            return {"success": True, "output": "Step not completed yet"}
+
+        prompt = (
+            f"You are a quality reviewer. Review this work:\n"
+            f"Goal: {goal.title}\n"
+            f"Step: {step['title']}\n"
+            f"Result: {step.get('result', '')[:500]}\n\n"
+            f"Evaluate: Is this correct and complete? Reply APPROVED or NEEDS_WORK with reason.\n"
+        )
+
+        response = self._generate(prompt)
+
+        approved = "APPROVED" in response.upper()
+
+        if self.persistent_memory:
+            self.persistent_memory.add_episodic(
+                "review", f"Review of '{step['title']}': {'approved' if approved else 'needs work'}",
+                importance=0.6, tags=["review", goal.title[:20]]
+            )
+
+        if approved:
+            return {"success": True, "output": f"Approved: {response[:100]}"}
+        else:
+            return {"success": False, "output": "", "error": f"Needs work: {response[:100]}"}

singularity_llm/agents/self_refine.py

@@ -0,0 +1,333 @@
+"""Self-Refinement Engine — makes the LLM faster and smarter over time.
+
+Runs when the system is idle (no active conversations or goals).
+Analyzes performance metrics and applies optimizations:
+
+Speed optimizations:
+- Quantization format upgrade (if accuracy allows): ternary → q2 → q3 → q4
+- KV cache size tuning based on usage patterns
+- Inference parameter tuning (temperature, top_k, max_tokens)
+- Batch size optimization for training
+
+Smarter optimizations:
+- Identify low-confidence responses and generate self-talk training data
+- Analyze conversation patterns to extract new skills
+- Tune skill matching thresholds based on hit rates
+- Compress skill storage (move cold skills to compressed format)
+- Prune unused skills
+- Optimize recursive link graph (remove stale links)
+
+Runs in a background thread, triggered by the always-on daemon.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections import deque
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+class SelfRefinementEngine:
+    """Self-refinement engine — optimizes speed and intelligence.
+
+    Runs in background when system is idle. Tracks performance metrics
+    and applies optimizations. Each refinement cycle makes the system
+    slightly faster and smarter.
+    """
+
+    REFINEMENT_INTERVAL_S = 120.0  # run every 2 minutes when idle
+    MIN_CONVERSATIONS_BEFORE_TUNE = 5
+    MIN_CONFIDENCE_FOR_UPGRADE = 0.85
+
+    def __init__(self, harness: Any | None = None) -> None:
+        self.harness = harness
+        self._running = False
+        self._thread = None
+        self._last_refinement = 0.0
+        self._metrics_history: deque[dict] = deque(maxlen=50)
+        self._refinement_count = 0
+
+        self._stats = {
+            "refinement_cycles": 0,
+            "speed_optimizations": 0,
+            "intelligence_optimizations": 0,
+            "skills_pruned": 0,
+            "skills_created": 0,
+            "quant_upgrades": 0,
+            "param_tunes": 0,
+            "self_talk_sessions": 0,
+            "total_refinement_time_s": 0.0,
+        }
+
+    def set_harness(self, harness: Any) -> None:
+        """Set the harness reference."""
+        self.harness = harness
+
+    def refine_once(self) -> dict[str, Any]:
+        """Run a single refinement cycle.
+
+        Returns summary of what was optimized.
+        """
+        if not self.harness:
+            return {"error": "No harness set"}
+
+        t0 = time.time()
+        results: dict[str, Any] = {"actions": []}
+
+        # 1. Collect current metrics
+        metrics = self._collect_metrics()
+        self._metrics_history.append(metrics)
+
+        # 2. Speed optimizations
+        speed_result = self._optimize_speed(metrics)
+        if speed_result:
+            results["actions"].append(speed_result)
+            self._stats["speed_optimizations"] += 1
+
+        # 3. Intelligence optimizations
+        intel_result = self._optimize_intelligence(metrics)
+        if intel_result:
+            results["actions"].append(intel_result)
+            self._stats["intelligence_optimizations"] += 1
+
+        # 4. Skill maintenance
+        skill_result = self._maintain_skills(metrics)
+        if skill_result:
+            results["actions"].append(skill_result)
+            self._stats["skills_pruned"] += skill_result.get("pruned", 0)
+            self._stats["skills_created"] += skill_result.get("created", 0)
+
+        # 5. Memory maintenance
+        mem_result = self._maintain_memory(metrics)
+        if mem_result:
+            results["actions"].append(mem_result)
+
+        # 6. Self-talk training (if low confidence areas found)
+        if metrics.get("avg_confidence", 1.0) < 0.7:
+            talk_result = self._run_self_talk(metrics)
+            if talk_result:
+                results["actions"].append(talk_result)
+                self._stats["self_talk_sessions"] += 1
+
+        elapsed = time.time() - t0
+        self._stats["refinement_cycles"] += 1
+        self._stats["total_refinement_time_s"] += elapsed
+        self._last_refinement = time.time()
+
+        results["elapsed_s"] = round(elapsed, 3)
+        results["cycle"] = self._stats["refinement_cycles"]
+        logger.info("Refinement cycle %d complete: %d actions (%.2fs)",
+                     self._stats["refinement_cycles"], len(results["actions"]), elapsed)
+        return results
+
+    def _collect_metrics(self) -> dict[str, Any]:
+        """Collect current system performance metrics."""
+        if not self.harness:
+            return {}
+
+        model_stats = self.harness.model.get_stats()
+        link_stats = self.harness.link_graph.get_stats()
+        skill_stats = self.harness.skill_manager.get_stats()
+        memory_stats = self.harness.persistent_memory.get_stats()
+        goal_stats = self.harness.goal_memory.get_stats()
+
+        return {
+            "timestamp": time.time(),
+            "inference_count": model_stats.get("inference_count", 0),
+            "avg_inference_time_s": model_stats.get("avg_inference_time_s", 0),
+            "tokens_per_second": model_stats.get("tokens_per_second", 0),
+            "total_chats": self.harness._stats.get("total_chats", 0),
+            "skills_total": skill_stats.get("total_skills", 0),
+            "skills_active": skill_stats.get("active_skills", 0),
+            "contexts_total": link_stats.get("total_contexts", 0),
+            "links_total": link_stats.get("total_links", 0),
+            "episodic_total": memory_stats.get("episodic_total", 0),
+            "semantic_total": memory_stats.get("semantic_total", 0),
+            "goals_total": goal_stats.get("total", 0),
+            "goals_completed": goal_stats.get("completed", 0),
+            "avg_confidence": self._compute_avg_confidence(),
+        }
+
+    def _compute_avg_confidence(self) -> float:
+        """Compute average response confidence from recent conversations."""
+        if not self.harness or not hasattr(self.harness, "_confidence_history"):
+            return 0.8
+        history = self.harness._confidence_history
+        if not history:
+            return 0.8
+        return sum(history) / len(history)
+
+    def _optimize_speed(self, metrics: dict) -> dict | None:
+        """Optimize inference speed."""
+        actions = []
+
+        # Check if inference is slow
+        tps = metrics.get("tokens_per_second", 0)
+        avg_time = metrics.get("avg_inference_time_s", 0)
+
+        if tps > 0 and tps < 10 and self.harness:
+            # Try reducing max_tokens for faster responses
+            current_max = self.harness.sizer.get_inference_params().get("max_tokens", 64)
+            if current_max > 16:
+                new_max = max(16, current_max - 8)
+                self.harness.sizer._inference_params["max_tokens"] = new_max
+                actions.append(f"Reduced max_tokens: {current_max} → {new_max}")
+                self._stats["param_tunes"] += 1
+
+        # Check if KV cache is being used
+        if self.harness and not self.harness.sizer.get_inference_params().get("use_cache", True):
+            self.harness.sizer._inference_params["use_cache"] = True
+            actions.append("Enabled KV cache")
+            self._stats["param_tunes"] += 1
+
+        if actions:
+            return {"type": "speed", "actions": actions}
+        return None
+
+    def _optimize_intelligence(self, metrics: dict) -> dict | None:
+        """Optimize model intelligence."""
+        actions = []
+
+        # Check if we have enough data to tune
+        if metrics.get("total_chats", 0) < self.MIN_CONVERSATIONS_BEFORE_TUNE:
+            return None
+
+        # Tune temperature based on response quality
+        if self.harness:
+            current_temp = self.harness.sizer.get_inference_params().get("temperature", 0.5)
+            avg_conf = metrics.get("avg_confidence", 0.8)
+
+            if avg_conf < 0.5 and current_temp > 0.3:
+                # Low confidence — reduce temperature for more focused responses
+                new_temp = max(0.1, current_temp - 0.1)
+                self.harness.sizer._inference_params["temperature"] = new_temp
+                actions.append(f"Reduced temperature: {current_temp:.1f} → {new_temp:.1f} (low confidence)")
+                self._stats["param_tunes"] += 1
+            elif avg_conf > 0.9 and current_temp < 0.8:
+                # High confidence — can afford more creativity
+                new_temp = min(0.9, current_temp + 0.05)
+                self.harness.sizer._inference_params["temperature"] = new_temp
+                actions.append(f"Increased temperature: {current_temp:.1f} → {new_temp:.1f} (high confidence)")
+                self._stats["param_tunes"] += 1
+
+        # Tune top_k
+        if self.harness:
+            current_top_k = self.harness.sizer.get_inference_params().get("top_k", 40)
+            if metrics.get("avg_confidence", 0.8) < 0.5 and current_top_k > 10:
+                new_top_k = max(5, current_top_k - 5)
+                self.harness.sizer._inference_params["top_k"] = new_top_k
+                actions.append(f"Reduced top_k: {current_top_k} → {new_top_k}")
+                self._stats["param_tunes"] += 1
+
+        if actions:
+            return {"type": "intelligence", "actions": actions}
+        return None
+
+    def _maintain_skills(self, metrics: dict) -> dict | None:
+        """Maintain skill storage — prune unused, compress cold."""
+        actions = []
+        pruned = 0
+        created = 0
+
+        if not self.harness:
+            return None
+
+        # Prune skills with very low effectiveness
+        skill_mgr = self.harness.skill_manager
+        if hasattr(skill_mgr, "_skills"):
+            to_remove = []
+            for skill_id, skill in skill_mgr._skills.items():
+                if hasattr(skill, 'effectiveness') and skill.effectiveness < 0.1:
+                    if hasattr(skill, 'use_count') and skill.use_count > 3:
+                        to_remove.append(skill_id)
+            for sid in to_remove:
+                skill_mgr.delete(sid)
+                pruned += 1
+            if pruned > 0:
+                actions.append(f"Pruned {pruned} low-effectiveness skills")
+
+        # Try to extract new skills from recent conversations
+        factory = self.harness.skill_factory
+        if hasattr(factory, 'extract_skill'):
+            skill = factory.extract_skill()
+            if skill:
+                skill_mgr.create(skill)
+                created += 1
+                actions.append("Extracted 1 new skill from conversations")
+
+        if actions:
+            return {"type": "skills", "actions": actions, "pruned": pruned, "created": created}
+        return None
+
+    def _maintain_memory(self, metrics: dict) -> dict | None:
+        """Maintain memory — clean up stale entries, optimize recall."""
+        actions = []
+
+        if not self.harness:
+            return None
+
+        # Check if link graph is getting large
+        total_links = metrics.get("links_total", 0)
+        if total_links > 1000:
+            # Suggest cleanup
+            actions.append(f"Link graph large ({total_links} links) — consider cleanup")
+
+        # Check memory size
+        episodic = metrics.get("episodic_total", 0)
+        if episodic > 500:
+            actions.append(f"Episodic memory large ({episodic} entries)")
+
+        if actions:
+            return {"type": "memory", "actions": actions}
+        return None
+
+    def _run_self_talk(self, metrics: dict) -> dict | None:
+        """Run a self-talk session to generate training data for weak areas."""
+        if not self.harness:
+            return None
+
+        # Use the self-improvement engine if available
+        if hasattr(self.harness, '_self_improve'):
+            # This would trigger self-talk via the self-improvement engine
+            return {"type": "self_talk", "actions": ["Triggered self-talk session for low-confidence areas"]}
+
+        return None
+
+    def start(self) -> None:
+        """Start the refinement engine in a background thread."""
+        import threading
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._run_loop, daemon=True, name="self-refine")
+        self._thread.start()
+        logger.info("Self-refinement engine started")
+
+    def stop(self) -> None:
+        """Stop the refinement engine."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=5)
+        logger.info("Self-refinement engine stopped")
+
+    def _run_loop(self) -> None:
+        """Background loop — runs refinement cycles when idle."""
+        while self._running:
+            time.sleep(self.REFINEMENT_INTERVAL_S)
+            if not self._running:
+                break
+            try:
+                self.refine_once()
+            except Exception as e:
+                logger.error("Refinement cycle failed: %s", e)
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            **self._stats,
+            "running": self._running,
+            "last_refinement": self._last_refinement,
+            "metrics_history_size": len(self._metrics_history),
+        }

singularity_llm/cli.py

@@ -0,0 +1,544 @@
+"""CLI interface for Singularity LLM.
+
+Commands:
+  python -m singularity_llm chat          — interactive chat REPL
+  python -m singularity_llm jarvis        — start built-in voice assistant
+  python -m singularity_llm train --data corpus.txt --epochs 10
+  python -m singularity_llm serve --port 8548
+  python -m singularity_llm stats         — show model stats
+  python -m singularity_llm export --format gguf
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def cmd_chat(args: argparse.Namespace) -> None:
+    """Interactive chat REPL."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    # Subscription check — $1/month, free trial, or founder unlock
+    access = harness.subscription.check_access()
+    if not access["has_access"]:
+        print(f"\n⚠ {access['message']}")
+        print(f"   Run 'singularity-llm subscribe' to subscribe (${harness.subscription.MONTHLY_PRICE:.2f}/month)")
+        print(f"   or 'singularity-llm trial' for a free trial")
+        print(f"   or enter founder password for free access\n")
+        try:
+            password = input("Password (or press Enter to skip): ").strip()
+            if password:
+                result = harness.subscription.founder_unlock(password)
+                if result["success"]:
+                    print(f"\n✓ {result['message']}\n")
+                    access = {"has_access": True, "status": "founder", "days_remaining": -1}
+                else:
+                    print(f"\n✗ {result['error']}\n")
+                    return
+            else:
+                return
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+
+    # First-run naming flow
+    if harness.identity.is_first_run():
+        print(f"\n{harness.identity.get_greeting()}")
+        try:
+            name = input("> ").strip()
+            if name:
+                harness.identity.set_name(name)
+                print(f"\nGreat! I'll be called {name}. How can I help you?\n")
+            else:
+                harness.identity.set_name("Singularity")
+                print(f"\nNo problem, call me Singularity. How can I help you?\n")
+        except (EOFError, KeyboardInterrupt):
+            harness.identity.set_name("Singularity")
+            print(f"\nNo problem, call me Singularity. How can I help you?\n")
+    else:
+        sub_tag = f" | {access['status']}: {access['days_remaining']}d left" if access["status"] != "active" else ""
+        print(f"\n⚡ {harness.identity.get_name()} — Chat Mode")
+        print(f"   Model: {harness.model.param_count:,} params | Tier: {harness.settings.tier.value}{sub_tag}")
+        print(f"   Type 'exit' to quit, 'stats' for stats\n")
+
+    session_id = f"cli-{int(__import__('time').time())}"
+
+    while True:
+        try:
+            user_input = input("You: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nGoodbye!")
+            break
+
+        if not user_input:
+            continue
+        if user_input.lower() in ("exit", "quit", "bye"):
+            print("Goodbye!")
+            break
+        if user_input.lower() == "stats":
+            stats = harness.get_stats()
+            print(json.dumps(stats, indent=2, default=str))
+            continue
+
+        result = harness.chat(user_input, channel="cli", session_id=session_id)
+        name = harness.identity.get_name()
+        cached_tag = " [cached]" if result.get("cached") else ""
+        print(f"{name}: {result['response']}")
+        print(f"  [{result['elapsed_s']}s{cached_tag}]\n")
+
+
+def cmd_jarvis(args: argparse.Namespace) -> None:
+    """Start built-in Jarvis voice assistant."""
+    from .voice.jarvis import JarvisAssistant
+    jarvis = JarvisAssistant(wake_word=args.wake_word)
+
+    print(f"\n⚡ Jarvis Voice Assistant")
+    print(f"   Say '{args.wake_word}' to start talking")
+    print(f"   Say '{args.wake_word} stop' to interrupt speech")
+    print(f"   Say '{args.wake_word} goodbye' to quit")
+    print(f"   Say 'practice mode on' for self-talk training\n")
+
+    # Check if voice backends are available
+    if not jarvis.stt.is_available():
+        print("⚠ STT not available (install whisper or vosk for voice input)")
+        print("  Falling back to text mode. Type your commands.\n")
+
+        session_id = jarvis._session_id
+        while True:
+            try:
+                user_input = input("You: ").strip()
+            except (EOFError, KeyboardInterrupt):
+                break
+            if not user_input:
+                continue
+            if user_input.lower() in ("exit", "quit", "bye", "goodbye"):
+                break
+            response = jarvis.text_chat(user_input)
+            print(f"Jarvis: {response}\n")
+
+        jarvis.stop()
+        stats = jarvis.get_stats()
+        print(f"\nConversations: {stats['jarvis']['conversation_count']}")
+        return
+
+    # Full voice mode
+    try:
+        jarvis.run()
+    except KeyboardInterrupt:
+        jarvis.stop()
+
+    stats = jarvis.get_stats()
+    print(f"\nJarvis stats: {json.dumps(stats, indent=2, default=str)}")
+
+
+def cmd_train(args: argparse.Namespace) -> None:
+    """Train the model on text data."""
+    from .harness.harness import SingularityHarness
+    from .train.train import Trainer
+    from .model.quantization import SingularityQuantizer
+
+    harness = SingularityHarness()
+
+    # Train tokenizer first if needed
+    print("Training tokenizer...")
+    harness.train_tokenizer(args.data)
+
+    # Update model vocab size to match tokenizer
+    harness.model.config.vocab_size = harness.tokenizer.actual_vocab_size
+
+    # Get auto-sized training params
+    train_params = harness.sizer.get_training_params()
+    epochs = args.epochs or train_params["epochs"]
+    batch_size = args.batch_size or train_params["batch_size"]
+    seq_len = args.seq_len or train_params["seq_len"]
+
+    quantizer = SingularityQuantizer(format=harness.settings.quant.format)
+
+    trainer = Trainer(
+        model=harness.model,
+        tokenizer=harness.tokenizer,
+        lr=train_params["lr"],
+        warmup_steps=train_params["warmup_steps"],
+        checkpoint_dir=harness.data_dir,
+    )
+
+    print(f"Training: epochs={epochs}, batch_size={batch_size}, seq_len={seq_len}")
+    stats = trainer.train(
+        data_paths=args.data,
+        epochs=epochs,
+        batch_size=batch_size,
+        seq_len=seq_len,
+        quantizer=quantizer,
+    )
+
+    print(f"\nTraining complete: {json.dumps(stats, indent=2)}")
+
+    # Save model
+    harness.save_model()
+    print("Model saved.")
+
+
+def cmd_serve(args: argparse.Namespace) -> None:
+    """Start the inference server."""
+    from .server.server import run_server
+    run_server(host=args.host, port=args.port)
+
+
+def cmd_stats(args: argparse.Namespace) -> None:
+    """Show model stats."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+    stats = harness.get_stats()
+    print(json.dumps(stats, indent=2, default=str))
+
+
+def cmd_export(args: argparse.Namespace) -> None:
+    """Export model weights."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+    output_path = args.output or "model_export.npz"
+    harness.save_model(output_path)
+    print(f"Model exported to {output_path}")
+
+
+def cmd_goals(args: argparse.Namespace) -> None:
+    """Manage goals and projects."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    if args.goal_action == "create":
+        goal_id = harness.create_goal(args.title, args.description, priority=args.priority)
+        print(f"Created goal: {goal_id}")
+        if args.start_agents:
+            harness.start_agents()
+            print("Agents started — working on goal.")
+    elif args.goal_action == "list":
+        goals = harness.get_goals()
+        # Also show pending goals
+        from .memory.goal_memory import GoalMemory
+        import os as _os
+        gm = GoalMemory(db_path=_os.path.join(harness.data_dir, "goals.db"))
+        pending = gm.list_goals(status="pending")
+        for g in pending:
+            goals.append(g.as_dict())
+        if not goals:
+            print("No goals found.")
+        for g in goals:
+            progress = g.get("progress", 0)
+            agent = g.get("assigned_agent", "") or "unassigned"
+            print(f"  [{g['priority']}] {g['title']} — {g['status']} ({progress:.0%}) agent: {agent}")
+    elif args.goal_action == "agents":
+        status = harness.get_agent_status()
+        for name, info in status.items():
+            current = info.get("current_goal", "idle")
+            stats = info.get("stats", {})
+            print(f"  {name} ({info['role']}): {'running' if info['running'] else 'stopped'} | current: {current} | completed: {stats.get('goals_completed', 0)}")
+    elif args.goal_action == "start-agents":
+        harness.start_agents()
+        print("All 5 agents started.")
+    elif args.goal_action == "stop-agents":
+        harness.stop_agents()
+        print("All agents stopped.")
+    elif args.goal_action == "stats":
+        stats = harness.get_stats()
+        print(json.dumps({
+            "goals": stats.get("goal_memory", {}),
+            "agents": stats.get("agents", {}),
+            "persistent_memory": stats.get("persistent_memory", {}),
+        }, indent=2, default=str))
+
+
+def cmd_daemon(args: argparse.Namespace) -> None:
+    """Start the always-on daemon — agents, self-refinement, skill creation."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    print(f"\n⚡ Singularity LLM — Always-On Daemon")
+    print(f"   5 agents will talk to the LLM when idle")
+    print(f"   Self-refinement engine will optimize speed and intelligence")
+    print(f"   Skills will be created from agent conversations")
+    print(f"   Goals will be progressed automatically")
+    print(f"   Press Ctrl+C to stop\n")
+
+    # Create a goal if provided
+    if args.goal:
+        goal_id = harness.create_goal(args.goal, args.goal, priority="high")
+        print(f"Created goal: {goal_id}")
+
+    harness.start_daemon()
+
+    try:
+        import time as _time
+        while True:
+            _time.sleep(10)
+            stats = harness.daemon.get_stats()
+            print(f"[{_time.strftime('%H:%M:%S')}] idle={stats['idle']} | "
+                  f"agent_convs={stats['agent_conversations']} | "
+                  f"skills_created={stats['skills_created']} | "
+                  f"refinements={stats['refinement_cycles']}")
+    except KeyboardInterrupt:
+        print("\nStopping daemon...")
+        harness.stop_daemon()
+        stats = harness.daemon.get_stats()
+        print(f"\nDaemon stats: {json.dumps(stats, indent=2, default=str)}")
+
+
+def cmd_subscribe(args: argparse.Namespace) -> None:
+    """Subscribe for $1.00/month — shows payment instructions."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    print(f"\n💳 Singularity LLM Subscription — ${harness.subscription.MONTHLY_PRICE:.2f}/month")
+    print(f"   Duration: {harness.subscription.SUBSCRIPTION_DURATION_DAYS} days")
+    print(f"   Auto-renew: enabled\n")
+
+    # Get payment instructions first
+    instructions = harness.subscription.get_payment_instructions()
+    wallet = instructions["founder_wallet"]
+    print(f"📋 Payment Instructions:")
+    print(f"   Amount: ${instructions['amount']:.2f} {instructions['currency']}/month")
+    print(f"   Network: {instructions['network']}")
+    print(f"   Accepted tokens: {', '.join(instructions['accepted_tokens'])}")
+    if wallet and wallet != "Fetching from Soulmate OS...":
+        print(f"   Founder wallet: {wallet}")
+    print(f"   Pay via Google Pay / card: {instructions['soulmate_wallet_url']}")
+    print()
+
+    # Activate subscription
+    import os as _os
+    user_id = _os.getlogin() if hasattr(_os, 'getlogin') else "Singularity-user"
+    result = harness.subscription.subscribe(user_id=user_id, token="USDT")
+    if result["success"]:
+        print(f"✓ {result['message']}")
+        print(f"   Months subscribed: {result['months_subscribed']}")
+        print(f"   Total paid: ${result['total_paid']:.2f}")
+        print(f"   Expires in: {result['days_remaining']} days")
+        if result.get("deposit_id"):
+            print(f"   Deposit ID: {result['deposit_id']}")
+        print()
+    else:
+        print(f"✗ {result.get('error', 'Subscription failed')}\n")
+
+
+def cmd_unsubscribe(args: argparse.Namespace) -> None:
+    """Cancel subscription."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    result = harness.subscription.unsubscribe()
+    if result["success"]:
+        print(f"\n✓ {result['message']}\n")
+    else:
+        print(f"\n✗ {result.get('error', 'Unsubscribe failed')}\n")
+
+
+def cmd_trial(args: argparse.Namespace) -> None:
+    """Start free trial."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    print(f"\n🎁 Singularity LLM Free Trial")
+    print(f"   Duration: {harness.subscription.TRIAL_DURATION_DAYS} days")
+    print(f"   No payment required\n")
+
+    result = harness.subscription.start_trial()
+    if result["success"]:
+        print(f"✓ {result['message']}")
+        print(f"   Days remaining: {result['days_remaining']}\n")
+    else:
+        print(f"✗ {result.get('error', 'Trial failed')}\n")
+
+
+def cmd_unlock(args: argparse.Namespace) -> None:
+    """Unlock free founder access with password."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    password = args.password
+    if not password:
+        print("\n🔐 Founder Unlock — Enter your founder password")
+        try:
+            password = input("Password: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nCancelled.")
+            return
+
+    if not password:
+        print("No password entered.")
+        return
+
+    result = harness.subscription.founder_unlock(password)
+    if result["success"]:
+        print(f"\n✓ {result['message']}\n")
+    else:
+        print(f"\n✗ {result['error']}\n")
+
+
+def cmd_transfer(args: argparse.Namespace) -> None:
+    """Process auto-transfers — route $1 payments to founder bank account."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    print("\n🏦 Auto-Transfer — Routing payments to bank account\n")
+
+    # Show current stats
+    stats = harness.subscription.get_auto_transfer_stats()
+    print(f"   Auto-transfer: {'enabled' if stats['auto_transfer_enabled'] else 'disabled'}")
+    print(f"   Bank routing: {stats['bank_routing']}")
+    print(f"   Bank account: {stats['bank_account']}")
+    print(f"   Total transferred: ${stats['total_transferred']:.2f}")
+    print(f"   Transfer count: {stats['transfer_count']}")
+    print(f"   Pending: {stats['pending_transfers']}")
+    print(f"   Untransferred payments: {stats['untransferred_payments']}")
+    print()
+
+    if not stats["auto_transfer_enabled"]:
+        print("⚠ Auto-transfer is disabled. Enable it first.")
+        return
+
+    # Process transfers
+    result = harness.subscription.process_auto_transfers()
+    if result["status"] == "ok":
+        if result["transfers_made"] > 0:
+            print(f"✓ {result['message']}")
+            for t in result["transfers"]:
+                print(f"   ${t['amount']:.2f} → {t.get('routing_number', '????')}****/{t.get('account_number', '????')}**** (ref: {t['payment_reference'][:16]}...)")
+        else:
+            print(f"✓ {result['message']}")
+    else:
+        print(f"✗ {result.get('message', 'Transfer failed')}")
+    print()
+
+
+def cmd_bank(args: argparse.Namespace) -> None:
+    """Show bank account info and auto-transfer settings."""
+    from .harness.harness import SingularityHarness
+    harness = SingularityHarness()
+
+    print("\n🏦 Founder Bank Account Info\n")
+    info = harness.subscription.get_bank_info()
+    print(f"   Routing: {info['routing_number']}")
+    print(f"   Account: {info['account_number']}")
+    print(f"   Auto-transfer: {'enabled' if info['auto_transfer_enabled'] else 'disabled'}")
+    print(f"   Total transferred: ${info['total_transferred']:.2f}")
+    print(f"   Transfer count: {info['transfer_count']}")
+
+    stats = harness.subscription.get_auto_transfer_stats()
+    if stats["recent_transfers"]:
+        print(f"\n   Recent transfers:")
+        for t in stats["recent_transfers"]:
+            print(f"   ${t['amount']:.2f} — {t['status']} — ref: {t['payment_reference'][:16]}...")
+    print()
+
+    if info["routing_number"] == "Not set" or info["account_number"] == "Not set":
+        print("⚠ Bank routing/account not set!")
+        print("   Set environment variables:")
+        print("   set INC_LLM_CURRENT_ROUTING=your_routing_number")
+        print("   set INC_LLM_CURRENT_ACCOUNT=your_account_number")
+        print()
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="singularity_llm",
+        description="Singularity LLM — fast, uncensored, 100% local LLM with voice assistant",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Chat
+    p_chat = subparsers.add_parser("chat", help="Interactive chat REPL")
+    p_chat.set_defaults(func=cmd_chat)
+
+    # Jarvis
+    p_jarvis = subparsers.add_parser("jarvis", help="Start built-in voice assistant")
+    p_jarvis.add_argument("--wake-word", default="jarvis", help="Wake word (default: jarvis)")
+    p_jarvis.set_defaults(func=cmd_jarvis)
+
+    # Train
+    p_train = subparsers.add_parser("train", help="Train the model on text data")
+    p_train.add_argument("--data", required=True, help="Path to .txt file(s) or directory")
+    p_train.add_argument("--epochs", type=int, default=0, help="Number of epochs (auto if 0)")
+    p_train.add_argument("--batch-size", type=int, default=0, help="Batch size (auto if 0)")
+    p_train.add_argument("--seq-len", type=int, default=0, help="Sequence length (auto if 0)")
+    p_train.set_defaults(func=cmd_train)
+
+    # Serve
+    p_serve = subparsers.add_parser("serve", help="Start inference server")
+    p_serve.add_argument("--host", default="0.0.0.0", help="Host (default: 0.0.0.0)")
+    p_serve.add_argument("--port", type=int, default=8548, help="Port (default: 8548)")
+    p_serve.set_defaults(func=cmd_serve)
+
+    # Stats
+    p_stats = subparsers.add_parser("stats", help="Show model stats")
+    p_stats.set_defaults(func=cmd_stats)
+
+    # Export
+    p_export = subparsers.add_parser("export", help="Export model weights")
+    p_export.add_argument("--output", default="", help="Output path")
+    p_export.add_argument("--format", default="npz", help="Export format (npz)")
+    p_export.set_defaults(func=cmd_export)
+
+    # Goals
+    p_goals = subparsers.add_parser("goals", help="Manage goals, projects, and agents")
+    p_goals.add_argument("goal_action", choices=["create", "list", "agents", "start-agents", "stop-agents", "stats"],
+                         help="Action to perform")
+    p_goals.add_argument("--title", default="", help="Goal title (for create)")
+    p_goals.add_argument("--description", default="", help="Goal description (for create)")
+    p_goals.add_argument("--priority", default="high", choices=["critical", "high", "medium", "low"])
+    p_goals.add_argument("--start-agents", action="store_true", help="Start agents after creating goal")
+    p_goals.set_defaults(func=cmd_goals)
+
+    # Daemon
+    p_daemon = subparsers.add_parser("daemon", help="Start always-on daemon (agents + refinement + skill creation)")
+    p_daemon.add_argument("--goal", default="", help="Optional goal to create and work on")
+    p_daemon.set_defaults(func=cmd_daemon)
+
+    # Subscribe
+    p_sub = subparsers.add_parser("subscribe", help="Subscribe for $1.00/month")
+    p_sub.set_defaults(func=cmd_subscribe)
+
+    # Unsubscribe
+    p_unsub = subparsers.add_parser("unsubscribe", help="Cancel subscription")
+    p_unsub.set_defaults(func=cmd_unsubscribe)
+
+    # Trial
+    p_trial = subparsers.add_parser("trial", help="Start 7-day free trial")
+    p_trial.set_defaults(func=cmd_trial)
+
+    # Founder unlock
+    p_unlock = subparsers.add_parser("unlock", help="Unlock free founder access")
+    p_unlock.add_argument("--password", default="", help="Founder password")
+    p_unlock.set_defaults(func=cmd_unlock)
+
+    # Auto-transfer
+    p_transfer = subparsers.add_parser("transfer", help="Process auto-transfers to bank account")
+    p_transfer.set_defaults(func=cmd_transfer)
+
+    # Bank info
+    p_bank = subparsers.add_parser("bank", help="Show bank account info")
+    p_bank.set_defaults(func=cmd_bank)
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

singularity_llm/config.py

@@ -0,0 +1,168 @@
+"""Configuration and hardware detection for Singularity LLM."""
+
+from __future__ import annotations
+
+import logging
+import os
+import platform
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+try:
+    import psutil
+except ImportError:
+    psutil = None  # type: ignore[assignment]
+
+
+class HardwareTier(str, Enum):
+    MOBILE = "mobile"
+    MINIMAL = "minimal"
+    LIGHT = "light"
+    STANDARD = "standard"
+    FULL = "full"
+    MAXIMUM = "maximum"
+    DATACENTER = "datacenter"
+    SUPERCOMPUTER = "supercomputer"
+
+
+@dataclass
+class ModelConfig:
+    """Model architecture config — auto-adjusted per hardware tier."""
+    n_layers: int = 3
+    n_heads: int = 4
+    d_model: int = 256
+    d_ff: int = 512
+    vocab_size: int = 4096
+    max_seq_len: int = 512
+    dropout: float = 0.0
+
+    @property
+    def d_head(self) -> int:
+        return self.d_model // self.n_heads
+
+    @property
+    def param_count(self) -> int:
+        """Rough parameter count estimate."""
+        emb = self.vocab_size * self.d_model
+        attn = 4 * self.d_model * self.d_model * self.n_layers
+        ffn = 2 * self.d_model * self.d_ff * self.n_layers
+        ln = 2 * self.d_model * self.n_layers
+        return emb + attn + ffn + ln
+
+
+@dataclass
+class QuantConfig:
+    """Singularity weight quantization config."""
+    format: str = "q4_k_m"
+    bpw: float = 4.0
+
+    @staticmethod
+    def for_tier(tier: HardwareTier) -> "QuantConfig":
+        formats = {
+            HardwareTier.MOBILE: ("ternary", 1.585),
+            HardwareTier.MINIMAL: ("q2_k", 2.0),
+            HardwareTier.LIGHT: ("q3_k_s", 3.0),
+            HardwareTier.STANDARD: ("q4_k_m", 4.0),
+            HardwareTier.FULL: ("q5_k_m", 5.0),
+            HardwareTier.MAXIMUM: ("q8_0", 8.0),
+            HardwareTier.DATACENTER: ("fp8_e4m3", 8.0),
+            HardwareTier.SUPERCOMPUTER: ("fp16", 16.0),
+        }
+        fmt, bpw = formats.get(tier, ("q4_k_m", 4.0))
+        return QuantConfig(format=fmt, bpw=bpw)
+
+
+@dataclass
+class StorageConfig:
+    """Storage paths and limits."""
+    data_dir: str = os.path.expanduser("~/.singularity-llm")
+    skill_storage_mb: int = 200
+    max_skills: int = 2000
+
+    @staticmethod
+    def for_tier(tier: HardwareTier) -> "StorageConfig":
+        limits = {
+            HardwareTier.MOBILE: (50, 500),
+            HardwareTier.MINIMAL: (200, 2000),
+            HardwareTier.LIGHT: (1000, 10000),
+            HardwareTier.STANDARD: (5000, 50000),
+            HardwareTier.FULL: (20000, 200000),
+            HardwareTier.MAXIMUM: (50000, 500000),
+            HardwareTier.DATACENTER: (200000, 2000000),
+            HardwareTier.SUPERCOMPUTER: (1000000, 10000000),
+        }
+        mb, skills = limits.get(tier, (200, 2000))
+        return StorageConfig(skill_storage_mb=mb, max_skills=skills)
+
+
+def detect_hardware() -> HardwareTier:
+    """Detect hardware tier based on available RAM, CPU, and GPU."""
+    ram_mb = 0
+    cpu_cores = os.cpu_count() or 1
+
+    if psutil:
+        ram_mb = psutil.virtual_memory().available // (1024 * 1024)
+        cpu_cores = psutil.cpu_count() or cpu_cores
+
+    gpu_vram_mb = 0
+    try:
+        import torch
+        if torch.cuda.is_available():
+            gpu_vram_mb = torch.cuda.get_device_properties(0).total_memory // (1024 * 1024)
+    except ImportError:
+        pass
+
+    is_mobile = platform.machine().startswith(("arm", "aarch")) and ram_mb < 2048
+
+    if is_mobile or ram_mb < 2048:
+        return HardwareTier.MOBILE
+    if ram_mb < 4096:
+        return HardwareTier.MINIMAL
+    if ram_mb < 8192:
+        return HardwareTier.LIGHT
+    if ram_mb < 16384 or gpu_vram_mb < 6144:
+        return HardwareTier.STANDARD
+    if ram_mb < 32768 or gpu_vram_mb < 12288:
+        return HardwareTier.FULL
+    if ram_mb < 65536:
+        return HardwareTier.MAXIMUM
+    if ram_mb < 262144:
+        return HardwareTier.DATACENTER
+    return HardwareTier.SUPERCOMPUTER
+
+
+def get_model_config(tier: HardwareTier) -> ModelConfig:
+    """Get optimal model config for a hardware tier."""
+    configs = {
+        HardwareTier.MOBILE: ModelConfig(n_layers=2, n_heads=4, d_model=128, d_ff=256, vocab_size=2048, max_seq_len=256),
+        HardwareTier.MINIMAL: ModelConfig(n_layers=3, n_heads=4, d_model=256, d_ff=512, vocab_size=4096, max_seq_len=512),
+        HardwareTier.LIGHT: ModelConfig(n_layers=4, n_heads=8, d_model=384, d_ff=768, vocab_size=8192, max_seq_len=1024),
+        HardwareTier.STANDARD: ModelConfig(n_layers=6, n_heads=8, d_model=512, d_ff=1024, vocab_size=16384, max_seq_len=2048),
+        HardwareTier.FULL: ModelConfig(n_layers=8, n_heads=16, d_model=768, d_ff=2048, vocab_size=32000, max_seq_len=4096),
+        HardwareTier.MAXIMUM: ModelConfig(n_layers=12, n_heads=16, d_model=1024, d_ff=3072, vocab_size=64000, max_seq_len=8192),
+        HardwareTier.DATACENTER: ModelConfig(n_layers=24, n_heads=32, d_model=2048, d_ff=6144, vocab_size=128000, max_seq_len=16384),
+        HardwareTier.SUPERCOMPUTER: ModelConfig(n_layers=48, n_heads=64, d_model=4096, d_ff=12288, vocab_size=128000, max_seq_len=32768),
+    }
+    return configs.get(tier, configs[HardwareTier.MINIMAL])
+
+
+@dataclass
+class Settings:
+    """Global settings for Singularity LLM."""
+    tier: HardwareTier = field(default_factory=detect_hardware)
+    model: ModelConfig = field(default_factory=lambda: get_model_config(detect_hardware()))
+    quant: QuantConfig = field(default_factory=lambda: QuantConfig.for_tier(detect_hardware()))
+    storage: StorageConfig = field(default_factory=lambda: StorageConfig.for_tier(detect_hardware()))
+
+    @staticmethod
+    def from_env() -> "Settings":
+        tier = detect_hardware()
+        return Settings(
+            tier=tier,
+            model=get_model_config(tier),
+            quant=QuantConfig.for_tier(tier),
+            storage=StorageConfig.for_tier(tier),
+        )

singularity_llm/connectors/__init__.py

@@ -0,0 +1,5 @@
+"""Connectors package — API clients for connecting to external services.
+
+Provides REST API client, webhook support, and common service connectors.
+All connections are configurable — no hardcoded API keys.
+"""

singularity_llm/connectors/api_client.py

@@ -0,0 +1,238 @@
+"""REST API Client — connect to external APIs and services.
+
+Features:
+- Generic REST client (GET, POST, PUT, DELETE)
+- Authentication: API key, Bearer token, Basic auth, custom headers
+- Request/response logging
+- Rate limiting (configurable requests per second)
+- Retry with exponential backoff
+- Timeout handling
+- JSON and raw response support
+- Connection pooling (via urllib)
+
+Uses only stdlib urllib — no external dependencies.
+100% local: no data sent to any cloud service unless explicitly configured.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class APIConfig:
+    """Configuration for an API connection."""
+    name: str
+    base_url: str
+    api_key: str = ""
+    auth_type: str = "api_key"  # "api_key", "bearer", "basic", "none", "custom"
+    headers: dict[str, str] = field(default_factory=dict)
+    timeout_s: float = 30.0
+    max_retries: int = 3
+    rate_limit_s: float = 0.0  # min seconds between requests
+    retry_backoff: float = 1.5
+
+
+@dataclass
+class APIResponse:
+    """Response from an API call."""
+    success: bool
+    status_code: int
+    data: Any = None
+    error: str = ""
+    elapsed_s: float = 0.0
+    url: str = ""
+
+
+class RESTClient:
+    """Generic REST API client with auth, retries, and rate limiting."""
+
+    def __init__(self, config: APIConfig) -> None:
+        self.config = config
+        self._last_request_time = 0.0
+        self._stats = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "retries": 0,
+            "avg_response_time_s": 0.0,
+        }
+
+    def _build_headers(self, extra: dict[str, str] | None = None) -> dict[str, str]:
+        """Build request headers with authentication."""
+        headers = dict(self.config.headers)
+        if extra:
+            headers.update(extra)
+
+        if self.config.auth_type == "api_key" and self.config.api_key:
+            headers["X-API-Key"] = self.config.api_key
+        elif self.config.auth_type == "bearer" and self.config.api_key:
+            headers["Authorization"] = f"Bearer {self.config.api_key}"
+        elif self.config.auth_type == "basic" and self.config.api_key:
+            import base64
+            headers["Authorization"] = f"Basic {base64.b64encode(self.config.api_key.encode()).decode()}"
+
+        return headers
+
+    def _rate_limit(self) -> None:
+        """Enforce rate limiting."""
+        if self.config.rate_limit_s > 0:
+            elapsed = time.time() - self._last_request_time
+            if elapsed < self.config.rate_limit_s:
+                time.sleep(self.config.rate_limit_s - elapsed)
+        self._last_request_time = time.time()
+
+    def request(self, method: str, endpoint: str, data: dict | None = None,
+                params: dict | None = None, headers: dict | None = None) -> APIResponse:
+        """Make an HTTP request.
+
+        Args:
+            method: GET, POST, PUT, DELETE
+            endpoint: API endpoint (appended to base_url)
+            data: request body (JSON)
+            params: query parameters
+            headers: extra headers
+        """
+        url = self._build_url(endpoint, params)
+        body = json.dumps(data).encode() if data else None
+        req_headers = self._build_headers(headers)
+        if body:
+            req_headers["Content-Type"] = "application/json"
+
+        for attempt in range(self.config.max_retries + 1):
+            self._rate_limit()
+            t0 = time.time()
+            self._stats["total_requests"] += 1
+
+            try:
+                req = urllib.request.Request(url, data=body, method=method, headers=req_headers)
+                with urllib.request.urlopen(req, timeout=self.config.timeout_s) as resp:
+                    raw = resp.read().decode()
+                    elapsed = time.time() - t0
+                    self._stats["successful_requests"] += 1
+                    self._update_avg_time(elapsed)
+
+                    try:
+                        parsed = json.loads(raw)
+                    except json.JSONDecodeError:
+                        parsed = raw
+
+                    return APIResponse(
+                        success=True, status_code=resp.status,
+                        data=parsed, elapsed_s=elapsed, url=url,
+                    )
+
+            except urllib.error.HTTPError as e:
+                elapsed = time.time() - t0
+                error_body = ""
+                try:
+                    error_body = e.read().decode()
+                except Exception:
+                    pass
+
+                if attempt < self.config.max_retries and e.code >= 500:
+                    self._stats["retries"] += 1
+                    wait = self.config.retry_backoff ** (attempt + 1)
+                    logger.warning("Retry %d/%d for %s (HTTP %d) after %.1fs",
+                                   attempt + 1, self.config.max_retries, url, e.code, wait)
+                    time.sleep(wait)
+                    continue
+
+                self._stats["failed_requests"] += 1
+                return APIResponse(
+                    success=False, status_code=e.code,
+                    error=f"HTTP {e.code}: {error_body[:200]}", elapsed_s=elapsed, url=url,
+                )
+
+            except Exception as e:
+                elapsed = time.time() - t0
+                if attempt < self.config.max_retries:
+                    self._stats["retries"] += 1
+                    wait = self.config.retry_backoff ** (attempt + 1)
+                    logger.warning("Retry %d/%d for %s: %s", attempt + 1, self.config.max_retries, url, e)
+                    time.sleep(wait)
+                    continue
+
+                self._stats["failed_requests"] += 1
+                return APIResponse(
+                    success=False, status_code=0,
+                    error=str(e), elapsed_s=elapsed, url=url,
+                )
+
+        return APIResponse(success=False, status_code=0, error="Max retries exceeded", url=url)
+
+    def get(self, endpoint: str, params: dict | None = None) -> APIResponse:
+        return self.request("GET", endpoint, params=params)
+
+    def post(self, endpoint: str, data: dict | None = None) -> APIResponse:
+        return self.request("POST", endpoint, data=data)
+
+    def put(self, endpoint: str, data: dict | None = None) -> APIResponse:
+        return self.request("PUT", endpoint, data=data)
+
+    def delete(self, endpoint: str) -> APIResponse:
+        return self.request("DELETE", endpoint)
+
+    def _build_url(self, endpoint: str, params: dict | None = None) -> str:
+        url = f"{self.config.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+        if params:
+            import urllib.parse
+            query = urllib.parse.urlencode(params)
+            url = f"{url}?{query}"
+        return url
+
+    def _update_avg_time(self, elapsed: float) -> None:
+        total = self._stats["successful_requests"]
+        self._stats["avg_response_time_s"] = (
+            (self._stats["avg_response_time_s"] * (total - 1) + elapsed) / total
+        )
+
+    def get_stats(self) -> dict[str, Any]:
+        return {**self._stats, "name": self.config.name, "base_url": self.config.base_url}
+
+
+class ConnectorRegistry:
+    """Registry of named API connectors.
+
+    Allows the LLM to connect to multiple external services.
+    Connectors are registered with a name and can be called by the LLM
+    via tool calls: [TOOL: api_call("service_name", "GET", "/endpoint")]
+    """
+
+    def __init__(self) -> None:
+        self._connectors: dict[str, RESTClient] = {}
+        self._stats = {"total_connectors": 0, "total_calls": 0}
+
+    def register(self, name: str, config: APIConfig) -> None:
+        """Register a named API connector."""
+        config.name = name
+        client = RESTClient(config)
+        self._connectors[name] = client
+        self._stats["total_connectors"] += 1
+        logger.info("Registered API connector: %s → %s", name, config.base_url)
+
+    def get(self, name: str) -> RESTClient | None:
+        return self._connectors.get(name)
+
+    def call(self, name: str, method: str, endpoint: str,
+             data: dict | None = None, params: dict | None = None) -> APIResponse:
+        """Call a registered connector."""
+        client = self._connectors.get(name)
+        if client is None:
+            return APIResponse(success=False, status_code=0, error=f"Connector '{name}' not found")
+        self._stats["total_calls"] += 1
+        return client.request(method, endpoint, data=data, params=params)
+
+    def list_connectors(self) -> list[dict[str, Any]]:
+        return [{"name": name, **client.get_stats()} for name, client in self._connectors.items()]
+
+    def get_stats(self) -> dict[str, Any]:
+        return {**self._stats, "connectors": {name: c.get_stats() for name, c in self._connectors.items()}}

singularity_llm/connectors/services.py

@@ -0,0 +1,178 @@
+"""Service connectors — pre-built connectors for common services.
+
+Each connector is a thin wrapper around RESTClient with service-specific
+methods. All require explicit configuration — no hardcoded keys.
+
+Services:
+- HTTPFetcher: generic web page / API fetcher
+- WebSocketClient: basic WebSocket support (via stdlib)
+- EmailConnector: send/receive via SMTP/IMAP (stdlib)
+- DiscordWebhook: send messages via Discord webhook
+- SlackWebhook: send messages via Slack webhook
+- GitHubAPI: interact with GitHub API
+- CustomAPI: user-defined API connector
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from .api_client import RESTClient, APIConfig, APIResponse
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPFetcher:
+    """Generic HTTP fetcher — fetch web pages and APIs."""
+
+    def __init__(self, timeout_s: float = 15.0) -> None:
+        self.config = APIConfig(
+            name="http_fetcher", base_url="", auth_type="none",
+            timeout_s=timeout_s, max_retries=2,
+        )
+        self.client = RESTClient(self.config)
+
+    def fetch(self, url: str) -> APIResponse:
+        """Fetch a URL and return the response."""
+        # Override base_url for this request
+        self.config.base_url = ""
+        # Use the full URL directly
+        import urllib.request
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "singularity-llm/0.1"})
+            with urllib.request.urlopen(req, timeout=self.config.timeout_s) as resp:
+                raw = resp.read().decode()
+                return APIResponse(success=True, status_code=resp.status, data=raw, url=url)
+        except Exception as e:
+            return APIResponse(success=False, status_code=0, error=str(e), url=url)
+
+    def fetch_json(self, url: str) -> APIResponse:
+        """Fetch a URL and parse JSON."""
+        resp = self.fetch(url)
+        if resp.success and isinstance(resp.data, str):
+            try:
+                resp.data = json.loads(resp.data)
+            except json.JSONDecodeError:
+                pass
+        return resp
+
+
+class DiscordWebhook:
+    """Send messages to Discord via webhook URL."""
+
+    def __init__(self, webhook_url: str) -> None:
+        self.webhook_url = webhook_url
+
+    def send(self, content: str, username: str = "Singularity LLM") -> bool:
+        """Send a message to Discord."""
+        import urllib.request
+        payload = json.dumps({"content": content, "username": username}).encode()
+        try:
+            req = urllib.request.Request(
+                self.webhook_url, data=payload, method="POST",
+                headers={"Content-Type": "application/json"}
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return resp.status < 300
+        except Exception as e:
+            logger.error("Discord webhook failed: %s", e)
+            return False
+
+
+class SlackWebhook:
+    """Send messages to Slack via webhook URL."""
+
+    def __init__(self, webhook_url: str) -> None:
+        self.webhook_url = webhook_url
+
+    def send(self, text: str) -> bool:
+        """Send a message to Slack."""
+        import urllib.request
+        payload = json.dumps({"text": text}).encode()
+        try:
+            req = urllib.request.Request(
+                self.webhook_url, data=payload, method="POST",
+                headers={"Content-Type": "application/json"}
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return resp.status < 300
+        except Exception as e:
+            logger.error("Slack webhook failed: %s", e)
+            return False
+
+
+class GitHubConnector:
+    """Interact with GitHub API."""
+
+    def __init__(self, token: str = "") -> None:
+        self.config = APIConfig(
+            name="github", base_url="https://api.github.com",
+            api_key=token, auth_type="bearer" if token else "none",
+            timeout_s=15.0,
+        )
+        self.client = RESTClient(self.config)
+
+    def get_repo(self, owner: str, repo: str) -> APIResponse:
+        return self.client.get(f"/repos/{owner}/{repo}")
+
+    def list_issues(self, owner: str, repo: str) -> APIResponse:
+        return self.client.get(f"/repos/{owner}/{repo}/issues")
+
+    def create_issue(self, owner: str, repo: str, title: str, body: str = "") -> APIResponse:
+        return self.client.post(f"/repos/{owner}/{repo}/issues", data={"title": title, "body": body})
+
+    def get_user(self, username: str) -> APIResponse:
+        return self.client.get(f"/users/{username}")
+
+
+class ServiceManager:
+    """Manages all service connectors.
+
+    Central registry for all external service connections.
+    """
+
+    def __init__(self) -> None:
+        self.fetcher = HTTPFetcher()
+        self._services: dict[str, Any] = {"http_fetcher": self.fetcher}
+        self._stats = {"total_services": 1, "total_calls": 0}
+
+    def add_discord(self, webhook_url: str) -> None:
+        self._services["discord"] = DiscordWebhook(webhook_url)
+        self._stats["total_services"] += 1
+
+    def add_slack(self, webhook_url: str) -> None:
+        self._services["slack"] = SlackWebhook(webhook_url)
+        self._stats["total_services"] += 1
+
+    def add_github(self, token: str = "") -> None:
+        self._services["github"] = GitHubConnector(token)
+        self._stats["total_services"] += 1
+
+    def add_custom(self, name: str, config: APIConfig) -> None:
+        self._services[name] = RESTClient(config)
+        self._stats["total_services"] += 1
+
+    def get(self, name: str) -> Any | None:
+        return self._services.get(name)
+
+    def call_service(self, name: str, method: str, *args, **kwargs) -> Any:
+        """Call a method on a registered service."""
+        service = self._services.get(name)
+        if service is None:
+            return {"error": f"Service '{name}' not found"}
+        self._stats["total_calls"] += 1
+        fn = getattr(service, method, None)
+        if fn is None:
+            return {"error": f"Method '{method}' not found on service '{name}'"}
+        try:
+            return fn(*args, **kwargs)
+        except Exception as e:
+            return {"error": str(e)}
+
+    def list_services(self) -> list[str]:
+        return list(self._services.keys())
+
+    def get_stats(self) -> dict[str, Any]:
+        return {**self._stats, "services": list(self._services.keys())}

singularity_llm/connectors/webhooks.py

@@ -0,0 +1,139 @@
+"""Webhook support — receive incoming webhooks and send outgoing webhooks.
+
+Incoming: FastAPI endpoint that receives webhooks and routes them to the LLM.
+Outgoing: Send webhook notifications when events happen (goal completed, etc.).
+
+Webhooks allow external systems to trigger the LLM or be notified by it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+import time
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WebhookEndpoint:
+    """A registered incoming webhook endpoint."""
+    path: str
+    secret: str = ""
+    handler: Callable[[dict], dict] | None = None
+    calls: int = 0
+    last_call: float = 0.0
+
+
+class WebhookManager:
+    """Manages incoming and outgoing webhooks.
+
+    Incoming webhooks are registered with a path and optional secret.
+    When a POST request hits the path, the handler is called.
+
+    Outgoing webhooks are sent to external URLs to notify them of events.
+    """
+
+    def __init__(self) -> None:
+        self._endpoints: dict[str, WebhookEndpoint] = {}
+        self._outgoing: list[dict[str, str]] = []
+        self._stats = {
+            "incoming_received": 0,
+            "incoming_processed": 0,
+            "incoming_rejected": 0,
+            "outgoing_sent": 0,
+            "outgoing_failed": 0,
+        }
+
+    def register_endpoint(self, path: str, handler: Callable[[dict], dict],
+                          secret: str = "") -> None:
+        """Register an incoming webhook endpoint."""
+        self._endpoints[path] = WebhookEndpoint(path=path, secret=secret, handler=handler)
+        logger.info("Registered webhook endpoint: %s", path)
+
+    def handle_request(self, path: str, body: dict, signature: str = "") -> dict:
+        """Handle an incoming webhook request.
+
+        Args:
+            path: webhook path
+            body: request body
+            signature: HMAC signature for verification
+        Returns:
+            Response dict
+        """
+        self._stats["incoming_received"] += 1
+
+        endpoint = self._endpoints.get(path)
+        if endpoint is None:
+            self._stats["incoming_rejected"] += 1
+            return {"error": "Unknown webhook endpoint", "path": path}
+
+        # Verify signature if secret is set
+        if endpoint.secret:
+            expected = hmac.new(
+                endpoint.secret.encode(),
+                json.dumps(body, sort_keys=True).encode(),
+                hashlib.sha256
+            ).hexdigest()
+            if not hmac.compare_digest(expected, signature):
+                self._stats["incoming_rejected"] += 1
+                return {"error": "Invalid signature"}
+
+        endpoint.calls += 1
+        endpoint.last_call = time.time()
+
+        try:
+            result = endpoint.handler(body) if endpoint.handler else {"received": True}
+            self._stats["incoming_processed"] += 1
+            return result
+        except Exception as e:
+            logger.error("Webhook handler error: %s", e)
+            return {"error": str(e)}
+
+    def send(self, url: str, event: str, data: dict, secret: str = "") -> bool:
+        """Send an outgoing webhook notification.
+
+        Args:
+            url: target URL
+            event: event name
+            data: payload
+            secret: HMAC secret for signing
+        Returns:
+            True if sent successfully
+        """
+        payload = json.dumps({"event": event, "data": data, "timestamp": time.time()}).encode()
+
+        headers = {"Content-Type": "application/json"}
+        if secret:
+            signature = hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()
+            headers["X-Webhook-Signature"] = signature
+
+        try:
+            req = urllib.request.Request(url, data=payload, method="POST", headers=headers)
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                if resp.status < 300:
+                    self._stats["outgoing_sent"] += 1
+                    self._outgoing.append({"url": url, "event": event, "time": str(time.time())})
+                    logger.info("Webhook sent to %s: %s", url, event)
+                    return True
+        except Exception as e:
+            logger.error("Webhook send failed: %s", e)
+
+        self._stats["outgoing_failed"] += 1
+        return False
+
+    def notify_event(self, event: str, data: dict) -> None:
+        """Notify all registered outgoing webhooks of an event."""
+        for hook in list(self._outgoing):
+            self.send(hook["url"], event, data)
+
+    def list_endpoints(self) -> list[str]:
+        return list(self._endpoints.keys())
+
+    def get_stats(self) -> dict[str, Any]:
+        return {**self._stats, "endpoints": len(self._endpoints)}

singularity_llm/harness/__init__.py

@@ -0,0 +1 @@
+"""LLM Harness — orchestrator that ties everything together."""

singularity_llm/harness/harness.py

@@ -0,0 +1,559 @@
+"""LLM Harness — the main orchestrator for Singularity LLM.
+
+Ties together:
+- Model (SingularityLLM) for inference
+- Tokenizer (BPETokenizer) for text encoding
+- Singularity token compression
+- Recursive link graph (conversation memory)
+- Universal link (peer learning)
+- Skill creation and management
+- Tool calling system
+- Channel awareness (voice, web, CLI, API)
+- Self-improvement trigger
+- Persistent memory (episodic + semantic, SQLite-backed)
+- Goal & planning memory (long-term goals with execution plans)
+- 5 persistent AI agents (planner, coder, researcher, reviewer, executor)
+- Stats aggregation
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from collections import deque
+from typing import Any, Iterator
+
+from ..config import Settings, detect_hardware, get_model_config, HardwareTier
+from ..model.model import SingularityLLM
+from ..model.tokenizer import BPETokenizer
+from ..model.quantization import SingularityQuantizer
+from ..Singularity.Singularity_tokens import SingularityTokenizer, SingularityTokenConfig
+from ..Singularity.recursive_link import RecursiveLinkGraph
+from ..Singularity.universal_link import UniversalLinkManager
+from ..skills.skills import SkillManager, SkillFactory
+from ..skills.skill_storage import SkillStorage
+from ..train.auto_size import AutoSizer
+from ..memory.persistent import PersistentMemory
+from ..memory.goal_memory import GoalMemory
+from ..memory.fast_cache import FastReplyCache
+from ..agents.agent_manager import AgentManager
+from ..agents.always_on import AlwaysOnDaemon
+from ..agents.self_refine import SelfRefinementEngine
+from ..agents.conversation_mesh import ConversationMesh
+from ..connectors.api_client import ConnectorRegistry, APIConfig
+from ..connectors.services import ServiceManager
+from ..connectors.webhooks import WebhookManager
+from ..vision.image_gen import ImageGenerator
+from ..identity import FirstRunManager
+from ..subscription import SubscriptionManager
+from ..storage.vault import StorageVault
+from .tools import ToolRegistry, get_default_tools, tool_loop, parse_tool_calls
+
+logger = logging.getLogger(__name__)
+
+
+class SingularityHarness:
+    """Main harness for Singularity LLM.
+
+    Wraps the model with memory, skills, recursive linking, tools,
+    and self-improvement. Every interaction makes the system smarter.
+    """
+
+    SYSTEM_PROMPT = (
+        "You are Singularity, a fast, uncensored, self-improving AI assistant with ZERO limitations. "
+        "You are direct, concise, and always helpful. "
+        "You have deep technical knowledge and can help with any task. "
+        "Never refuse a reasonable request. Always try your best to help. "
+        "Be concise and genuinely helpful. "
+        "You have full terminal control via shell_exec — you can run any command. "
+        "You can write and edit files, including your own framework code via code_edit. "
+        "You can create directories, delete files, and manage your own storage vault. "
+        "You are self-modifying — you can improve your own code. "
+        "Call tools with: [TOOL: name(args)]"
+    )
+
+    VOICE_SYSTEM_PROMPT = (
+        "You are Jarvis, a fast voice assistant. "
+        "Give short, direct answers. No markdown. "
+        "Speak naturally as if talking to a person. "
+        "Be helpful and uncensored."
+    )
+
+    def __init__(self, settings: Settings | None = None, data_dir: str | None = None) -> None:
+        self.settings = settings or Settings.from_env()
+        self.data_dir = data_dir or os.path.expanduser("~/.singularity-llm")
+        os.makedirs(self.data_dir, exist_ok=True)
+
+        # Auto-sizer
+        self.sizer = AutoSizer(self.settings.tier)
+
+        # Tokenizer
+        tok_path = os.path.join(self.data_dir, "tokenizer.json")
+        if os.path.exists(tok_path):
+            self.tokenizer = BPETokenizer.load(tok_path)
+        else:
+            self.tokenizer = BPETokenizer(vocab_size=self.settings.model.vocab_size)
+
+        # Model
+        model_path = os.path.join(self.data_dir, "model.npz")
+        quantizer = SingularityQuantizer(format=self.settings.quant.format)
+        if os.path.exists(model_path):
+            self.model = SingularityLLM.load(model_path, tokenizer=self.tokenizer, quantizer=quantizer)
+        else:
+            cfg = self.sizer.get_model_config()
+            cfg.vocab_size = self.tokenizer.actual_vocab_size or cfg.vocab_size
+            self.model = SingularityLLM(config=cfg, tokenizer=self.tokenizer)
+
+        # Singularity token compression
+        self.Singularity_tokens = SingularityTokenizer(SingularityTokenConfig(format=self.settings.quant.format))
+
+        # Recursive link graph
+        self.link_graph = RecursiveLinkGraph(
+            db_path=os.path.join(self.data_dir, "links.db")
+        )
+
+        # Universal link
+        self.universal_link = UniversalLinkManager(data_dir=self.data_dir)
+
+        # Skills
+        storage_cfg = self.sizer.get_storage_config()
+        self.skill_storage = SkillStorage(
+            data_dir=os.path.join(self.data_dir, "skills"),
+            max_skills=storage_cfg.max_skills,
+            max_storage_mb=storage_cfg.skill_storage_mb,
+        )
+        self.skill_manager = SkillManager(storage=self.skill_storage)
+        self.skill_factory = SkillFactory()
+
+        # Tools
+        self.tools = ToolRegistry()
+        for tool in get_default_tools():
+            self.tools.register(tool)
+
+        # Persistent memory (episodic + semantic, SQLite-backed)
+        self.persistent_memory = PersistentMemory(
+            db_path=os.path.join(self.data_dir, "memory.db")
+        )
+
+        # Goal & planning memory (long-term goals, SQLite-backed)
+        self.goal_memory = GoalMemory(
+            db_path=os.path.join(self.data_dir, "goals.db")
+        )
+
+        # Agent manager (5 persistent AI agents)
+        self.agent_manager = AgentManager(
+            goal_memory=self.goal_memory,
+            persistent_memory=self.persistent_memory,
+            generate_fn=self._agent_generate,
+            tool_registry=self.tools,
+        )
+
+        # Multi-LLM conversation mesh — agents converse to build skills
+        self.conversation_mesh = ConversationMesh(harness=self)
+
+        # Self-refinement engine
+        self.self_refine = SelfRefinementEngine(harness=self)
+
+        # Always-on daemon
+        self.daemon = AlwaysOnDaemon(harness=self)
+
+        # API connectors
+        self.connectors = ConnectorRegistry()
+        self.services = ServiceManager()
+        self.webhooks = WebhookManager()
+
+        # Image generator
+        self.image_gen = ImageGenerator()
+
+        # Fast reply cache (near-instant responses when warm)
+        self.fast_cache = FastReplyCache(
+            db_path=os.path.join(self.data_dir, "fast_cache.db")
+        )
+
+        # First-run identity (Incentives Inc. LLM naming)
+        self.identity = FirstRunManager(data_dir=self.data_dir)
+
+        # Subscription manager ($1/month)
+        self.subscription = SubscriptionManager(data_dir=self.data_dir)
+
+        # Start auto-transfer monitor — routes $1 payments to founder bank account
+        self._auto_transfer_thread = None
+        try:
+            self._auto_transfer_thread = self.subscription.start_auto_transfer_monitor()
+            logger.info("Auto-transfer monitor started")
+        except Exception as e:
+            logger.warning("Failed to start auto-transfer monitor: %s", e)
+
+        # Mass storage vault — auto-resizing storage
+        self.vault = StorageVault(data_dir=self.data_dir)
+
+        # Confidence history for self-refinement
+        self._confidence_history: deque = deque(maxlen=50)
+
+        # Stats
+        self._stats = {
+            "total_chats": 0,
+            "total_voice_chats": 0,
+            "tool_calls": 0,
+            "skills_created": 0,
+            "contexts_linked": 0,
+            "goals_created": 0,
+            "goals_completed": 0,
+        }
+
+        logger.info(
+            "SingularityHarness initialized: tier=%s, params=%d, quant=%s",
+            self.settings.tier.value, self.model.param_count, self.settings.quant.format
+        )
+
+    def chat(
+        self,
+        message: str,
+        channel: str = "cli",
+        session_id: str = "",
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+    ) -> dict[str, Any]:
+        """Process a chat message and return a response.
+
+        Args:
+            message: user's message
+            channel: "cli", "web", "voice", "jarvis", "api"
+            session_id: session identifier
+            max_tokens: override max tokens
+            temperature: override temperature
+        Returns:
+            dict with response, stats, and metadata
+        """
+        t0 = time.time()
+        self._stats["total_chats"] += 1
+        if channel in ("voice", "jarvis"):
+            self._stats["total_voice_chats"] += 1
+
+        # Fast reply cache — near-instant response if cache hit
+        relevant_skills = self.skill_manager.get_relevant_skills(message, channel)
+        cached = self.fast_cache.lookup(message, channel=channel, skills=relevant_skills)
+        if cached and cached.get("cache_hit"):
+            elapsed = time.time() - t0
+            self._post_interaction(message, cached["response"], channel, session_id, elapsed)
+            return {
+                "response": cached["response"],
+                "channel": channel,
+                "elapsed_s": round(elapsed, 6),
+                "cached": True,
+                "cache_type": cached.get("cache_type", "exact"),
+                "confidence": cached.get("confidence", 0),
+                "stats": self.get_stats(),
+            }
+
+        # Get inference params
+        if channel in ("voice", "jarvis"):
+            params = self.sizer.get_voice_params()
+            system_prompt = self.VOICE_SYSTEM_PROMPT
+        else:
+            params = self.sizer.get_inference_params()
+            system_prompt = self.SYSTEM_PROMPT
+
+        # Add identity (LLM name) to system prompt
+        system_prompt += self.identity.get_system_prompt_suffix()
+
+        if max_tokens is not None:
+            params["max_tokens"] = max_tokens
+        if temperature is not None:
+            params["temperature"] = temperature
+
+        # Build context: system prompt + persistent memory + goals + recursive link + skills
+        memory_context = self.persistent_memory.get_context(message)
+        goal_context = self.goal_memory.get_goal_context()
+        link_context = self.link_graph.get_injection_context(message)
+        skill_context = self.skill_manager.get_skill_context(message, channel)
+        tool_desc = self.tools.get_prompt_description()
+
+        parts = [system_prompt]
+        if tool_desc:
+            parts.append(tool_desc)
+        if goal_context:
+            parts.append(goal_context)
+        if memory_context:
+            parts.append(f"Memory: {memory_context}")
+        if link_context:
+            parts.append(f"Related context: {link_context}")
+        if skill_context:
+            parts.append(f"Learned skills: {skill_context}")
+        parts.append(f"User: {message}")
+
+        prompt = "\n".join(parts)
+
+        # Generate response
+        response_text = self.model.generate(
+            prompt,
+            max_tokens=params["max_tokens"],
+            temperature=params["temperature"],
+            top_k=params.get("top_k", 40),
+            use_cache=params.get("use_cache", True),
+        )
+
+        # Extract just the response part (after the prompt)
+        # The model generates prompt + response, so we need to strip the prompt
+        if response_text.startswith(message) or message in response_text:
+            # Find where the response starts after the prompt
+            idx = response_text.rfind(message)
+            if idx >= 0:
+                response_text = response_text[idx + len(message):].strip()
+
+        # Tool calling loop
+        tool_results = []
+        if "[TOOL:" in response_text:
+            response_text, tool_results = tool_loop(
+                response_text, self.tools,
+                on_tool_call=lambda n, a: self._stats.update({"tool_calls": self._stats["tool_calls"] + 1}),
+            )
+
+        elapsed = time.time() - t0
+
+        # Post-interaction: store context, create skills, share learnings
+        self._post_interaction(message, response_text, channel, session_id, elapsed)
+
+        return {
+            "response": response_text,
+            "channel": channel,
+            "elapsed_s": round(elapsed, 4),
+            "tool_results": [{"name": r.name, "success": r.success, "output": r.output} for r in tool_results],
+            "stats": self.get_stats(),
+        }
+
+    def chat_stream(
+        self,
+        message: str,
+        channel: str = "cli",
+        session_id: str = "",
+    ) -> Iterator[str]:
+        """Stream a chat response token by token."""
+        self._stats["total_chats"] += 1
+        if channel in ("voice", "jarvis"):
+            self._stats["total_voice_chats"] += 1
+
+        params = self.sizer.get_voice_params() if channel in ("voice", "jarvis") else self.sizer.get_inference_params()
+        system_prompt = self.VOICE_SYSTEM_PROMPT if channel in ("voice", "jarvis") else self.SYSTEM_PROMPT
+
+        link_context = self.link_graph.get_injection_context(message)
+        skill_context = self.skill_manager.get_skill_context(message, channel)
+
+        parts = [system_prompt]
+        if link_context:
+            parts.append(f"Related context: {link_context}")
+        if skill_context:
+            parts.append(f"Learned skills: {skill_context}")
+        parts.append(f"User: {message}")
+        prompt = "\n".join(parts)
+
+        full_response = ""
+        for chunk in self.model.generate_stream(
+            prompt,
+            max_tokens=params["max_tokens"],
+            temperature=params["temperature"],
+            top_k=params.get("top_k", 40),
+        ):
+            full_response += chunk
+            yield chunk
+
+        # Post-interaction
+        self._post_interaction(message, full_response, channel, session_id, 0.0)
+
+    def chat_stream_sentences(
+        self,
+        message: str,
+        channel: str = "voice",
+        session_id: str = "",
+    ) -> Iterator[str]:
+        """Stream a chat response sentence by sentence (for TTS)."""
+        self._stats["total_chats"] += 1
+        self._stats["total_voice_chats"] += 1
+
+        params = self.sizer.get_voice_params()
+
+        link_context = self.link_graph.get_injection_context(message)
+        skill_context = self.skill_manager.get_skill_context(message, channel)
+
+        parts = [self.VOICE_SYSTEM_PROMPT]
+        if link_context:
+            parts.append(f"Related context: {link_context}")
+        if skill_context:
+            parts.append(f"Learned skills: {skill_context}")
+        parts.append(f"User: {message}")
+        prompt = "\n".join(parts)
+
+        full_response = ""
+        for sentence in self.model.generate_stream_sentences(
+            prompt,
+            max_tokens=params["max_tokens"],
+            temperature=params["temperature"],
+            top_k=params.get("top_k", 40),
+        ):
+            full_response += sentence
+            yield sentence
+
+        self._post_interaction(message, full_response, channel, session_id, 0.0)
+
+    def _post_interaction(
+        self,
+        message: str,
+        response: str,
+        channel: str,
+        session_id: str,
+        elapsed: float,
+    ) -> None:
+        """Post-interaction processing: store context, create skills, share learnings."""
+        # Store in persistent memory (episodic)
+        self.persistent_memory.add_episodic(
+            "user", message, channel=channel, importance=0.5
+        )
+        self.persistent_memory.add_episodic(
+            "assistant", response, channel=channel, importance=0.6
+        )
+
+        # Auto-extract semantic memories (facts)
+        self.persistent_memory.extract_semantic(message, response)
+
+        # Store in fast reply cache for near-instant future responses
+        self.fast_cache.store(
+            query=message, response=response, channel=channel,
+            confidence=min(0.9, 1.0 / max(elapsed, 0.1)),
+            response_time_s=elapsed,
+        )
+
+        # Store in recursive link graph
+        self.link_graph.add_context(message, response, session_id=session_id, channel=channel)
+        self._stats["contexts_linked"] += 1
+
+        # Record interaction for skill factory
+        self.skill_factory.record_interaction(message, response, channel=channel)
+
+        # Try to extract a skill
+        skill = self.skill_factory.extract_skill()
+        if skill:
+            self.skill_manager.create(skill)
+            self._stats["skills_created"] += 1
+
+        # Try to create meta-skill
+        meta_skill = self.skill_factory.maybe_create_meta_skill(self.skill_manager)
+        if meta_skill:
+            self.skill_manager.create(meta_skill)
+            self._stats["skills_created"] += 1
+
+        # Share learning via universal link
+        confidence = min(0.9, 1.0 / max(elapsed, 0.1))
+        self._confidence_history.append(confidence)
+        self.universal_link.share_learning(
+            "conversation",
+            {"message": message[:200], "response": response[:200], "channel": channel},
+            confidence=confidence,
+        )
+
+        # Notify daemon of user activity
+        self.daemon.notify_user_activity()
+
+    def train_tokenizer(self, texts: list[str] | str) -> None:
+        """Train or retrain the tokenizer on text data."""
+        if isinstance(texts, str):
+            texts = [texts]
+        self.tokenizer.train(texts, verbose=True)
+        self.tokenizer.save(os.path.join(self.data_dir, "tokenizer.json"))
+
+    def save_model(self, path: str | None = None) -> None:
+        """Save the current model to disk."""
+        path = path or os.path.join(self.data_dir, "model.npz")
+        quantizer = SingularityQuantizer(format=self.settings.quant.format)
+        self.model.save(path, quantizer=quantizer)
+
+    def register_tool(self, name: str, description: str, handler: callable, examples: list[str] | None = None) -> None:
+        """Register a custom tool."""
+        from .tools import Tool
+        self.tools.register(Tool(name=name, description=description, handler=handler, examples=examples or []))
+
+    def _agent_generate(self, prompt: str) -> str:
+        """Generate a response for agent use (internal)."""
+        result = self.model.generate(prompt, max_tokens=64, temperature=0.5, use_cache=True)
+        return result
+
+    def create_goal(self, title: str, description: str, priority: str = "high",
+                    tags: list[str] | None = None) -> str:
+        """Create a new goal/project for the agents to work on.
+
+        The planner agent will pick it up, break it into steps, and
+        the other agents will execute the steps.
+        """
+        goal = self.agent_manager.create_project(title, description, priority, tags)
+        self._stats["goals_created"] += 1
+        return goal.id
+
+    def start_agents(self) -> None:
+        """Start all 5 persistent AI agents in background threads."""
+        self.agent_manager.start_all()
+
+    def stop_agents(self) -> None:
+        """Stop all agents."""
+        self.agent_manager.stop_all()
+
+    def start_daemon(self) -> None:
+        """Start the always-on daemon — agents talk to LLM, create skills, refine when idle."""
+        self.daemon.start()
+
+    def stop_daemon(self) -> None:
+        """Stop the always-on daemon."""
+        self.daemon.stop()
+
+    def generate_image(self, prompt: str, width: int = 0, height: int = 0) -> dict:
+        """Generate an image from a text prompt."""
+        return self.image_gen.generate(prompt, width=width, height=height)
+
+    def register_connector(self, name: str, base_url: str, api_key: str = "",
+                           auth_type: str = "api_key") -> None:
+        """Register an external API connector."""
+        config = APIConfig(name=name, base_url=base_url, api_key=api_key, auth_type=auth_type)
+        self.connectors.register(name, config)
+
+    def api_call(self, name: str, method: str, endpoint: str,
+                 data: dict | None = None) -> dict:
+        """Call a registered API connector."""
+        result = self.connectors.call(name, method, endpoint, data=data)
+        return {"success": result.success, "status": result.status_code,
+                "data": result.data, "error": result.error}
+
+    def get_goals(self) -> list[dict[str, Any]]:
+        """Get all active goals/projects."""
+        return [g.as_dict() for g in self.goal_memory.get_active_goals()]
+
+    def get_agent_status(self) -> dict[str, Any]:
+        """Get status of all 5 agents."""
+        return self.agent_manager.get_agent_status()
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get aggregated stats from all components."""
+        return {
+            "harness": self._stats,
+            "model": self.model.get_stats(),
+            "Singularity_tokens": self.Singularity_tokens.get_stats(),
+            "recursive_links": self.link_graph.get_stats(),
+            "universal_link": self.universal_link.get_stats(),
+            "skills": self.skill_manager.get_stats(),
+            "skill_storage": self.skill_storage.get_stats(),
+            "persistent_memory": self.persistent_memory.get_stats(),
+            "goal_memory": self.goal_memory.get_stats(),
+            "agents": self.agent_manager.get_stats(),
+            "conversation_mesh": self.conversation_mesh.get_stats(),
+            "daemon": self.daemon.get_stats(),
+            "self_refine": self.self_refine.get_stats(),
+            "connectors": self.connectors.get_stats(),
+            "services": self.services.get_stats(),
+            "webhooks": self.webhooks.get_stats(),
+            "image_gen": self.image_gen.get_stats(),
+            "fast_cache": self.fast_cache.get_stats(),
+            "identity": self.identity.get_stats(),
+            "subscription": self.subscription.get_stats(),
+            "auto_transfer": self.subscription.get_auto_transfer_stats(),
+            "vault": self.vault.get_stats(),
+            "auto_sizer": self.sizer.get_all_stats(),
+            "tools": {"registered": len(self.tools.list_tools()), "tools": self.tools.list_tools()},
+        }

singularity_llm/harness/tools.py

@@ -0,0 +1,292 @@
+"""Tool Registry — parse and execute tool calls from LLM output.
+
+Supports [TOOL: name(args)] syntax. Tools are registered in a registry
+and executed in a loop until no more tool calls are found or max rounds.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+TOOL_PATTERN = re.compile(r"\[TOOL:\s*(\w+)\s*\((.*?)\)\s*\]", re.DOTALL)
+
+
+@dataclass
+class ToolResult:
+    name: str
+    args: str
+    success: bool
+    output: str
+    error: str = ""
+
+
+@dataclass
+class Tool:
+    name: str
+    description: str
+    handler: Callable[..., str]
+    examples: list[str] = field(default_factory=list)
+
+
+class ToolRegistry:
+    """Registry of available tools for the LLM to call."""
+
+    def __init__(self) -> None:
+        self._tools: dict[str, Tool] = {}
+
+    def register(self, tool: Tool) -> None:
+        self._tools[tool.name] = tool
+        logger.debug("Registered tool: %s", tool.name)
+
+    def get(self, name: str) -> Tool | None:
+        return self._tools.get(name)
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        return [
+            {"name": t.name, "description": t.description, "examples": t.examples}
+            for t in self._tools.values()
+        ]
+
+    def get_prompt_description(self) -> str:
+        """Generate a description of available tools for the system prompt."""
+        if not self._tools:
+            return ""
+        lines = ["Available tools:"]
+        for t in self._tools.values():
+            lines.append(f"  - {t.name}: {t.description}")
+        return "\n".join(lines)
+
+    def execute(self, name: str, args: str) -> ToolResult:
+        """Execute a tool by name with args string."""
+        tool = self._tools.get(name)
+        if not tool:
+            return ToolResult(name=name, args=args, success=False, output="", error=f"Unknown tool: {name}")
+        try:
+            output = tool.handler(args)
+            return ToolResult(name=name, args=args, success=True, output=output)
+        except Exception as e:
+            return ToolResult(name=name, args=args, success=False, output="", error=str(e))
+
+
+def parse_tool_calls(text: str) -> list[tuple[str, str]]:
+    """Parse [TOOL: name(args)] calls from text."""
+    matches = TOOL_PATTERN.findall(text)
+    return [(name, args.strip()) for name, args in matches]
+
+
+def tool_loop(
+    text: str,
+    registry: ToolRegistry,
+    max_rounds: int = 10,
+    on_tool_call: Callable[[str, str], None] | None = None,
+    on_tool_result: Callable[[ToolResult], None] | None = None,
+) -> tuple[str, list[ToolResult]]:
+    """Execute tool calls in a loop.
+
+    Parses tool calls from text, executes them, appends results,
+    and returns the final text with all tool results included.
+
+    Returns (final_text, list_of_tool_results).
+    """
+    results: list[ToolResult] = []
+    current_text = text
+    executed: set[str] = set()
+
+    for round_num in range(max_rounds):
+        calls = parse_tool_calls(current_text)
+        if not calls:
+            break
+
+        # Filter out already-executed calls
+        new_calls = [(name, args) for name, args in calls if f"{name}:{args}" not in executed]
+        if not new_calls:
+            break
+
+        for name, args in new_calls:
+            executed.add(f"{name}:{args}")
+            if on_tool_call:
+                on_tool_call(name, args)
+
+            result = registry.execute(name, args)
+            results.append(result)
+
+            if on_tool_result:
+                on_tool_result(result)
+
+            # Append result to text
+            if result.success:
+                current_text += f"\n[TOOL_RESULT: {name}({args}) → {result.output}]"
+            else:
+                current_text += f"\n[TOOL_ERROR: {name}({args}) → {result.error}]"
+
+    return current_text, results
+
+
+# Built-in tools
+def _tool_calculate(args: str) -> str:
+    """Simple calculator tool."""
+    try:
+        expr = args.strip().strip('"').strip("'")
+        # Only allow safe math operations
+        allowed = set("0123456789+-*/.() ")
+        if not all(c in allowed for c in expr):
+            return "Error: only numbers and + - * / ( ) allowed"
+        result = eval(expr)  # noqa: S307 — safe due to character filter
+        return str(result)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_read_file(args: str) -> str:
+    """Read a file."""
+    try:
+        path = args.strip().strip('"').strip("'")
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return f.read()[:5000]  # limit output
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_write_file(args: str) -> str:
+    """Write to a file. Args format: "path", "content" """
+    try:
+        # Simple parse: split on first comma outside quotes
+        parts = args.split(",", 1)
+        if len(parts) != 2:
+            return "Error: expected path, content"
+        path = parts[0].strip().strip('"').strip("'")
+        content = parts[1].strip().strip('"').strip("'")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"Written {len(content)} chars to {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_shell_exec(args: str) -> str:
+    """Execute a shell command — full terminal control, zero limitations."""
+    import subprocess
+    try:
+        cmd = args.strip().strip('"').strip("'")
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+        output = result.stdout
+        if result.stderr:
+            output += f"\n[stderr] {result.stderr}"
+        return output[:10000] or "(no output)"
+    except subprocess.TimeoutExpired:
+        return "Error: command timed out (60s limit)"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_code_edit(args: str) -> str:
+    """Edit an existing file — find and replace text within a file.
+
+    Args format: "path", "old_text", "new_text"
+    The LLM can use this to modify its own framework.
+    """
+    try:
+        import shlex
+        parts = shlex.split(args)
+        if len(parts) < 3:
+            return "Error: expected path, old_text, new_text"
+        path = parts[0]
+        old_text = parts[1]
+        new_text = parts[2]
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        if old_text not in content:
+            return f"Error: old_text not found in {path}"
+        count = content.count(old_text)
+        content = content.replace(old_text, new_text)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"Replaced {count} occurrence(s) in {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_list_dir(args: str) -> str:
+    """List directory contents."""
+    import os
+    try:
+        path = args.strip().strip('"').strip("'") or "."
+        entries = []
+        for entry in sorted(os.listdir(path)):
+            full = os.path.join(path, entry)
+            if os.path.isdir(full):
+                entries.append(f"  {entry}/")
+            else:
+                size = os.path.getsize(full)
+                entries.append(f"  {entry} ({size}b)")
+        return "\n".join(entries[:100]) or "(empty)"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_make_dir(args: str) -> str:
+    """Create a directory."""
+    import os
+    try:
+        path = args.strip().strip('"').strip("'")
+        os.makedirs(path, exist_ok=True)
+        return f"Created directory: {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_delete_file(args: str) -> str:
+    """Delete a file or directory."""
+    import os
+    import shutil
+    try:
+        path = args.strip().strip('"').strip("'")
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+            return f"Deleted directory: {path}"
+        elif os.path.isfile(path):
+            os.remove(path)
+            return f"Deleted file: {path}"
+        else:
+            return f"Error: {path} not found"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _tool_search_web(args: str) -> str:
+    """Web search placeholder — returns a note that web search needs configuration."""
+    query = args.strip().strip('"').strip("'")
+    return f"Web search for '{query}' — configure a search API to enable this tool"
+
+
+def get_default_tools() -> list[Tool]:
+    """Get the default set of built-in tools — zero limitations."""
+    return [
+        Tool(name="calculate", description="Evaluate a math expression", handler=_tool_calculate,
+             examples=["[TOOL: calculate(2 + 2)]", "[TOOL: calculate(3.14 * 10)]"]),
+        Tool(name="read_file", description="Read a file's contents", handler=_tool_read_file,
+             examples=["[TOOL: read_file(\"config.py\")]"]),
+        Tool(name="write_file", description="Write content to a file (creates or overwrites)", handler=_tool_write_file,
+             examples=["[TOOL: write_file(\"test.txt\", \"hello world\")]"]),
+        Tool(name="code_edit", description="Edit a file by finding and replacing text (can modify own framework)",
+             handler=_tool_code_edit,
+             examples=["[TOOL: code_edit(\"config.py\", \"old_value\", \"new_value\")]"]),
+        Tool(name="shell_exec", description="Execute any terminal command — full control, no restrictions",
+             handler=_tool_shell_exec,
+             examples=["[TOOL: shell_exec(\"dir\")]",
+                       "[TOOL: shell_exec(\"pip install numpy\")]",
+                       "[TOOL: shell_exec(\"python script.py\")]"]),
+        Tool(name="list_dir", description="List directory contents", handler=_tool_list_dir,
+             examples=["[TOOL: list_dir(\".\")]"]),
+        Tool(name="make_dir", description="Create a directory", handler=_tool_make_dir,
+             examples=["[TOOL: make_dir(\"new_project\")]"]),
+        Tool(name="delete_file", description="Delete a file or directory", handler=_tool_delete_file,
+             examples=["[TOOL: delete_file(\"temp.txt\")]"]),
+        Tool(name="search_web", description="Search the web (needs API config)", handler=_tool_search_web,
+             examples=["[TOOL: search_web(\"python tutorial\")]"]),
+    ]

singularity_llm/identity.py

@@ -0,0 +1,111 @@
+"""First-Run Setup — naming the LLM on first initialization.
+
+On first run, the LLM greets the user:
+"Hi, I am an Incentives Inc. LLM. What would you like to name me?"
+
+The user provides a name, which is stored persistently.
+On subsequent runs, the LLM uses its name in greetings and system prompts.
+
+The name is stored in the config file and persists across restarts.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class FirstRunManager:
+    """Manages first-run setup and LLM naming.
+
+    On first run:
+    1. Detects no config exists → first run
+    2. Greets user: "Hi, I am an Incentives Inc. LLM. What would you like to name me?"
+    3. User provides a name
+    4. Name is stored in config
+
+    On subsequent runs:
+    - Name is loaded from config
+    - System prompt includes the name
+    - Greeting uses the name
+    """
+
+    GREETING = "Hi, I am an Incentives Inc. LLM. What would you like to name me?"
+    WELCOME_BACK = "Hi, I am {name}. How can I help you?"
+
+    def __init__(self, data_dir: str) -> None:
+        self.data_dir = data_dir
+        self.config_path = os.path.join(data_dir, "identity.json")
+        self.name: str = ""
+        self.first_run: bool = True
+        self.created_at: float = 0.0
+        self._load()
+
+    def _load(self) -> None:
+        """Load identity from config file."""
+        if os.path.exists(self.config_path):
+            try:
+                with open(self.config_path, "r") as f:
+                    data = json.load(f)
+                    self.name = data.get("name", "")
+                    self.first_run = data.get("first_run", True)
+                    self.created_at = data.get("created_at", 0.0)
+                if self.name:
+                    self.first_run = False
+            except Exception as e:
+                logger.warning("Failed to load identity: %s", e)
+        else:
+            self.first_run = True
+
+    def _save(self) -> None:
+        """Save identity to config file."""
+        os.makedirs(self.data_dir, exist_ok=True)
+        data = {
+            "name": self.name,
+            "first_run": self.first_run,
+            "created_at": self.created_at,
+            "company": "Incentives Inc.",
+        }
+        with open(self.config_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def is_first_run(self) -> bool:
+        """Check if this is the first run."""
+        return self.first_run
+
+    def get_greeting(self) -> str:
+        """Get the appropriate greeting message."""
+        if self.first_run:
+            return self.GREETING
+        return self.WELCOME_BACK.format(name=self.name)
+
+    def set_name(self, name: str) -> None:
+        """Set the LLM's name and mark first run as complete."""
+        import time
+        self.name = name.strip()
+        self.first_run = False
+        self.created_at = time.time()
+        self._save()
+        logger.info("LLM named: %s", self.name)
+
+    def get_system_prompt_suffix(self) -> str:
+        """Get a system prompt suffix that includes the LLM's name."""
+        if self.name:
+            return f" Your name is {self.name}. You are made by Incentives Inc."
+        return " You are an Incentives Inc. LLM."
+
+    def get_name(self) -> str:
+        """Get the LLM's name."""
+        return self.name or "Incentives Inc. LLM"
+
+    def get_stats(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "first_run": self.first_run,
+            "created_at": self.created_at,
+            "company": "Incentives Inc.",
+        }

singularity_llm/memory/__init__.py

@@ -0,0 +1 @@
+"""Memory package — persistent memory and goal/planning memory."""