arkaos 2.1.0 → 2.1.2

package/VERSION

@@ -1 +1 @@
-2.1.0
+2.1.2

package/core/knowledge/ingest.py

@@ -119,6 +119,22 @@ class IngestEngine:
 
         progress(100, f"Done — {count} chunks indexed")
 
+        # Record token usage in budget
+        try:
+            from core.budget.manager import BudgetManager
+            from pathlib import Path as BudgetPath
+            budget_mgr = BudgetManager(storage_path=BudgetPath.home() / ".arkaos" / "budget-usage.json")
+            tokens_est = len(text) // 4  # ~1 token per 4 chars
+            budget_mgr.record_usage(
+                agent_id="kb-indexer",
+                tokens=tokens_est,
+                tier=2,
+                department="kb",
+                description=f"ingest-{source_type}: {source[:60]}",
+            )
+        except Exception:
+            pass
+
         return IngestResult(
             source=source,
             source_type=source_type,

package/core/personas/__init__.py

@@ -0,0 +1,6 @@
+"""Persona system — create, store, and clone personas as agents."""
+
+from core.personas.schema import Persona
+from core.personas.manager import PersonaManager
+
+__all__ = ["Persona", "PersonaManager"]

package/core/personas/manager.py

@@ -0,0 +1,102 @@
+"""Persona manager — CRUD operations and cloning to agents."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from core.personas.schema import Persona
+
+
+class PersonaManager:
+    """Manages persona lifecycle: create, store, list, clone to agent."""
+
+    def __init__(self, storage_path: str | Path = "") -> None:
+        self._personas: dict[str, Persona] = {}
+        self._storage_path = Path(storage_path) if storage_path else None
+        if self._storage_path and self._storage_path.exists():
+            self._load()
+
+    def create(self, persona: Persona) -> Persona:
+        """Create a new persona."""
+        persona.created_at = datetime.now().isoformat()
+        persona.updated_at = persona.created_at
+        self._personas[persona.id] = persona
+        self._save()
+        return persona
+
+    def get(self, persona_id: str) -> Optional[Persona]:
+        return self._personas.get(persona_id)
+
+    def list_all(self) -> list[Persona]:
+        return list(self._personas.values())
+
+    def update(self, persona_id: str, updates: dict) -> Optional[Persona]:
+        persona = self._personas.get(persona_id)
+        if not persona:
+            return None
+        for key, value in updates.items():
+            if hasattr(persona, key):
+                setattr(persona, key, value)
+        persona.updated_at = datetime.now().isoformat()
+        self._save()
+        return persona
+
+    def delete(self, persona_id: str) -> bool:
+        if persona_id in self._personas:
+            del self._personas[persona_id]
+            self._save()
+            return True
+        return False
+
+    def clone_to_agent(
+        self,
+        persona_id: str,
+        department: str = "strategy",
+        tier: int = 2,
+        agents_dir: str | Path = "",
+    ) -> Optional[str]:
+        """Clone a persona to an ArkaOS agent YAML file.
+
+        Returns the agent ID if successful, None if persona not found.
+        """
+        persona = self._personas.get(persona_id)
+        if not persona:
+            return None
+
+        agent_data = persona.to_agent_yaml(department=department, tier=tier)
+        agent_id = agent_data["id"]
+
+        if agents_dir:
+            output_dir = Path(agents_dir)
+            output_dir.mkdir(parents=True, exist_ok=True)
+            output_path = output_dir / f"{agent_id}.yaml"
+            with open(output_path, "w") as f:
+                yaml.dump(agent_data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+        # Track the clone
+        persona.cloned_to_agents.append(agent_id)
+        persona.updated_at = datetime.now().isoformat()
+        self._save()
+
+        return agent_id
+
+    def _save(self) -> None:
+        if self._storage_path is None:
+            return
+        self._storage_path.parent.mkdir(parents=True, exist_ok=True)
+        data = {pid: p.model_dump(mode="json") for pid, p in self._personas.items()}
+        with open(self._storage_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def _load(self) -> None:
+        if self._storage_path is None or not self._storage_path.exists():
+            return
+        content = self._storage_path.read_text().strip()
+        if not content:
+            return
+        data = json.loads(content)
+        for pid, pdata in data.items():
+            self._personas[pid] = Persona.model_validate(pdata)

package/core/personas/schema.py

@@ -0,0 +1,127 @@
+"""Persona schema — models for persona creation and cloning."""
+
+from datetime import datetime
+from typing import Optional, Any
+
+from pydantic import BaseModel, Field
+
+
+class PersonaDISC(BaseModel):
+    primary: str = "C"
+    secondary: str = "S"
+    communication_style: str = ""
+    under_pressure: str = ""
+    motivator: str = ""
+
+
+class PersonaEnneagram(BaseModel):
+    type: int = 5
+    wing: int = 6
+    core_motivation: str = ""
+    core_fear: str = ""
+    subtype: str = "self-preservation"
+
+
+class PersonaBigFive(BaseModel):
+    openness: int = 50
+    conscientiousness: int = 50
+    extraversion: int = 50
+    agreeableness: int = 50
+    neuroticism: int = 50
+
+
+class PersonaCommunication(BaseModel):
+    tone: str = ""
+    vocabulary_level: str = "specialist"
+    preferred_format: str = ""
+    avoid: list[str] = Field(default_factory=list)
+
+
+class Persona(BaseModel):
+    """A persona based on a real person or archetype."""
+    id: str
+    name: str
+    title: str = ""                     # e.g., "Business Strategy", "Growth Marketing"
+    tagline: str = ""                   # e.g., "The Natural Commander with emotional depth"
+    source: str = ""                    # e.g., "Alex Hormozi", "Naval Ravikant"
+    avatar_url: str = ""
+
+    # Behavioral DNA
+    disc: PersonaDISC = Field(default_factory=PersonaDISC)
+    enneagram: PersonaEnneagram = Field(default_factory=PersonaEnneagram)
+    big_five: PersonaBigFive = Field(default_factory=PersonaBigFive)
+    mbti: str = "INTJ"
+
+    # Knowledge
+    mental_models: list[str] = Field(default_factory=list)
+    expertise_domains: list[str] = Field(default_factory=list)
+    frameworks: list[str] = Field(default_factory=list)
+    key_quotes: list[str] = Field(default_factory=list)
+
+    # Communication
+    communication: PersonaCommunication = Field(default_factory=PersonaCommunication)
+
+    # Metadata
+    created_at: str = ""
+    updated_at: str = ""
+    cloned_to_agents: list[str] = Field(default_factory=list)
+
+    def to_agent_yaml(self, department: str = "strategy", tier: int = 2) -> dict:
+        """Convert persona to an ArkaOS agent YAML structure."""
+        agent_id = f"persona-{self.id}"
+        return {
+            "id": agent_id,
+            "name": self.name,
+            "role": self.title or f"{self.source} Persona",
+            "department": department,
+            "tier": tier,
+            "behavioral_dna": {
+                "disc": {
+                    "primary": self.disc.primary,
+                    "secondary": self.disc.secondary,
+                    "communication_style": self.disc.communication_style,
+                    "under_pressure": self.disc.under_pressure,
+                    "motivator": self.disc.motivator,
+                },
+                "enneagram": {
+                    "type": self.enneagram.type,
+                    "wing": self.enneagram.wing,
+                    "core_motivation": self.enneagram.core_motivation,
+                    "core_fear": self.enneagram.core_fear,
+                    "subtype": self.enneagram.subtype,
+                },
+                "big_five": {
+                    "openness": self.big_five.openness,
+                    "conscientiousness": self.big_five.conscientiousness,
+                    "extraversion": self.big_five.extraversion,
+                    "agreeableness": self.big_five.agreeableness,
+                    "neuroticism": self.big_five.neuroticism,
+                },
+                "mbti": {"type": self.mbti},
+            },
+            "mental_models": {
+                "primary": self.mental_models[:3],
+                "secondary": self.mental_models[3:6],
+            },
+            "authority": {
+                "veto": False,
+                "approve_budget": False,
+                "approve_architecture": False,
+                "orchestrate": False,
+                "delegates_to": [],
+                "escalates_to": None,
+            },
+            "expertise": {
+                "domains": self.expertise_domains[:5],
+                "frameworks": self.frameworks[:5],
+                "depth": "advanced",
+                "years_equivalent": 10,
+            },
+            "communication": {
+                "language": "en",
+                "tone": self.communication.tone,
+                "vocabulary_level": self.communication.vocabulary_level,
+                "preferred_format": self.communication.preferred_format,
+                "avoid": self.communication.avoid,
+            },
+        }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "2.1.0"
+version = "2.1.2"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}