@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/backup.py

@@ -0,0 +1,215 @@
+"""`omega backup` + `omega restore` — disaster-recovery for an OmegaOS deployment.
+
+What we back up by default:
+
+  * ``Agentik_Runtime/``       (event log, audits, telegram history, sessions)
+  * ``Agentik_Extra/etc/secrets/``  (encrypted vault — the .age files +
+                                      the .vault-key)
+  * ``Agentik_SSOT/``           (operator-edited skills, audits, charters,
+                                  webhooks — anything modified post-install)
+  * ``Agentik_Coding/projects.json`` (project registry)
+
+What we do NOT back up:
+
+  * The engine venv (regenerated by re-running install.sh)
+  * MCP binaries (installed by step 40, idempotent)
+  * Cache + tmp dirs
+
+The bundle is a tar.gz at ``~/omega-backup-<timestamp>.tar.gz`` by
+default. When the operator passes ``--encrypt``, the tarball is then
+piped through ``age -r <pub>`` so the bundle itself is at-rest
+encrypted. The recipient defaults to the operator's existing
+``.vault-pub`` so they need no extra key management.
+
+``omega backup verify <path>`` extracts the bundle into a temp dir and
+re-runs ``omega doctor`` against it. Pass = the backup actually
+restores; fail = the bundle is corrupt or incomplete.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+BACKUP_ROOTS = [
+    "Agentik_Runtime",
+    "Agentik_Extra/etc/secrets",
+    "Agentik_SSOT",
+    "Agentik_Coding/projects.json",
+]
+
+
+@dataclass
+class BackupResult:
+    bundle: Path
+    bytes: int
+    encrypted: bool
+    duration_s: float
+    detail: str = ""
+
+
+@dataclass
+class RestoreResult:
+    bundle: Path
+    target: Path
+    files: int
+    duration_s: float
+    detail: str = ""
+
+
+def _have(binary: str) -> bool:
+    return shutil.which(binary) is not None
+
+
+def backup(
+    omega_home: str | Path,
+    *,
+    out_dir: str | Path | None = None,
+    encrypt: bool = False,
+    recipient_path: str | Path | None = None,
+) -> BackupResult:
+    """Create a tarball of the live tree's recoverable subset."""
+    home = Path(omega_home)
+    if not home.is_dir():
+        raise FileNotFoundError(f"OMEGA_HOME not found: {home}")
+    out_dir = Path(out_dir) if out_dir else Path.home()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    ts = int(time.time())
+    bundle = out_dir / f"omega-backup-{ts}.tar.gz"
+
+    start = time.time()
+    with tarfile.open(bundle, "w:gz") as tar:
+        for relpath in BACKUP_ROOTS:
+            full = home / relpath
+            if not full.exists():
+                continue
+            tar.add(full, arcname=relpath)
+    elapsed = time.time() - start
+
+    if encrypt:
+        if not _have("age"):
+            raise RuntimeError("age not on PATH — install it or drop --encrypt")
+        rec_file = (
+            Path(recipient_path) if recipient_path
+            else home / "Agentik_Extra" / "etc" / "secrets" / ".vault-pub"
+        )
+        if not rec_file.exists():
+            raise RuntimeError(
+                f"no recipient public key at {rec_file} — provide --recipient-path"
+            )
+        recipient = rec_file.read_text().strip()
+        enc_bundle = bundle.with_suffix(bundle.suffix + ".age")
+        with bundle.open("rb") as inp, enc_bundle.open("wb") as out:
+            proc = subprocess.run(
+                ["age", "-r", recipient], stdin=inp, stdout=out,
+                check=False, capture_output=False, timeout=600,
+            )
+        if proc.returncode != 0:
+            raise RuntimeError(f"age encrypt exit {proc.returncode}")
+        bundle.unlink()           # drop the plaintext tarball
+        bundle = enc_bundle
+
+    return BackupResult(
+        bundle=bundle, bytes=bundle.stat().st_size,
+        encrypted=encrypt, duration_s=round(elapsed, 2),
+        detail=f"{len(BACKUP_ROOTS)} root(s) archived",
+    )
+
+
+def restore(
+    bundle: str | Path,
+    *,
+    target: str | Path,
+    age_identity: str | Path | None = None,
+) -> RestoreResult:
+    """Restore a bundle into ``target`` (typically ``$OMEGA_HOME``)."""
+    bundle = Path(bundle)
+    if not bundle.exists():
+        raise FileNotFoundError(f"bundle not found: {bundle}")
+    target = Path(target)
+    target.mkdir(parents=True, exist_ok=True)
+
+    start = time.time()
+    # If encrypted, decrypt to a temp file first.
+    tar_source: Path = bundle
+    cleanup_tmp: Path | None = None
+    if bundle.suffix == ".age":
+        if not _have("age"):
+            raise RuntimeError("age not on PATH — cannot decrypt bundle")
+        identity = (
+            Path(age_identity) if age_identity
+            else target / "Agentik_Extra" / "etc" / "secrets" / ".vault-key"
+        )
+        if not identity.exists():
+            raise RuntimeError(
+                f"no age identity at {identity} — provide --identity"
+            )
+        cleanup_tmp = Path(tempfile.mkstemp(suffix=".tar.gz")[1])
+        with cleanup_tmp.open("wb") as out:
+            proc = subprocess.run(
+                ["age", "-d", "-i", str(identity), str(bundle)],
+                stdout=out, check=False, timeout=600,
+            )
+        if proc.returncode != 0:
+            cleanup_tmp.unlink(missing_ok=True)
+            raise RuntimeError(f"age decrypt exit {proc.returncode}")
+        tar_source = cleanup_tmp
+
+    try:
+        with tarfile.open(tar_source, "r:gz") as tar:
+            members = tar.getmembers()
+            for m in members:
+                # Reject absolute paths + path traversal.
+                if m.name.startswith("/") or ".." in m.name.split("/"):
+                    raise RuntimeError(f"unsafe path in bundle: {m.name}")
+            tar.extractall(path=target)
+            files = sum(1 for m in members if m.isfile())
+    finally:
+        if cleanup_tmp is not None:
+            cleanup_tmp.unlink(missing_ok=True)
+
+    return RestoreResult(
+        bundle=bundle, target=target, files=files,
+        duration_s=round(time.time() - start, 2),
+        detail=f"{files} file(s) extracted",
+    )
+
+
+def verify(
+    bundle: str | Path,
+    *,
+    age_identity: str | Path | None = None,
+) -> dict:
+    """Restore the bundle into a temp dir + run a minimal sanity check.
+
+    Returns ``{ok: bool, files: int, detail: str}``. We do NOT run the
+    full ``omega doctor`` here because that would touch the operator's
+    real environment; we just confirm the bundle extracts cleanly and
+    looks like an OmegaOS tree.
+    """
+    bundle = Path(bundle)
+    with tempfile.TemporaryDirectory() as td:
+        result = restore(bundle, target=td, age_identity=age_identity)
+        # Smoke check: the well-known subset should be in there.
+        target = Path(td)
+        missing = [
+            root for root in BACKUP_ROOTS
+            if not (target / root).exists()
+        ]
+        if missing:
+            return {
+                "ok": False,
+                "files": result.files,
+                "detail": f"missing in bundle: {missing}",
+            }
+        return {
+            "ok": True,
+            "files": result.files,
+            "detail": f"all {len(BACKUP_ROOTS)} root(s) present + extracted",
+        }

package/omega/Agentik_Engine/omega_engine/cadence.py

@@ -0,0 +1,158 @@
+"""cadence — recurring / scheduled execution.
+
+The Agentik OS native equivalent of a "run this every N" beat. Takes a
+trigger spec and an intent, persists a charter to
+``Agentik_Orchestration/autonomous/cadence-<id>.yaml`` that the existing
+``AutonomousSupervisor`` picks up at its next tick.
+
+Three trigger types:
+  * ``cron <expr>`` — standard 5-field cron (``*/5 * * * *``)
+  * ``delay <seconds>`` — fire once after ``seconds`` from now
+  * ``self`` — let the agent self-pace (the supervisor still ticks, but the
+    agent decides whether to act)
+
+Why this exists:
+  Claude Code's bundled ``/loop`` schedules a prompt in the editor. We
+  re-implement it as an engine primitive so OmegaOS supervises the beat
+  itself — surviving Claude Code sessions, daemons, the whole system.
+"""
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+VALID_TRIGGERS = {"cron", "delay", "self"}
+
+
+@dataclass
+class CadenceCharter:
+    id: str
+    trigger_type: str                       # "cron" | "delay" | "self"
+    schedule: str                           # cron expr, delay-secs, or "self"
+    intent: str
+    role: str = "worker"
+    enabled: bool = True
+    description: str = ""
+
+    def to_yaml_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "description": self.description or self.intent,
+            "enabled": self.enabled,
+            "trigger": {"type": self.trigger_type, "schedule": self.schedule},
+            "role": self.role,
+            "spec": {"intent": self.intent},
+        }
+
+
+def schedule_cadence(
+    intent: str,
+    trigger_type: str,
+    schedule: str,
+    *,
+    omega_home: str | Path | None = None,
+    charter_id: str | None = None,
+    role: str = "worker",
+    description: str | None = None,
+) -> Path:
+    """Persist a charter to the orchestration tree.
+
+    Args:
+        intent: the natural-language thing to do at each beat.
+        trigger_type: "cron" | "delay" | "self".
+        schedule: trigger-type-specific spec — a cron expression, a
+            delay-in-seconds, or the literal "self".
+        omega_home: ``$OMEGA_HOME`` (defaults to env or ``~/Omega``).
+        charter_id: stable id; one is generated if not given.
+        role: provider role to use for each beat (default ``worker``).
+        description: optional human description; defaults to the intent.
+
+    Returns: the path to the persisted charter YAML.
+    """
+    if trigger_type not in VALID_TRIGGERS:
+        raise ValueError(
+            f"trigger_type must be one of {VALID_TRIGGERS}, got {trigger_type!r}"
+        )
+    if trigger_type == "cron" and not schedule.strip():
+        raise ValueError("cron trigger requires a non-empty schedule")
+    if trigger_type == "delay":
+        try:
+            int(schedule)
+        except ValueError as exc:
+            raise ValueError(f"delay schedule must be an integer (seconds), got {schedule!r}") from exc
+
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    cid = charter_id or "cadence-" + uuid.uuid4().hex[:8]
+
+    target_dir = home / "Agentik_Orchestration" / "autonomous"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    charter = CadenceCharter(
+        id=cid, trigger_type=trigger_type, schedule=schedule,
+        intent=intent, role=role, enabled=True,
+        description=description or intent,
+    )
+    target = target_dir / f"{cid}.yaml"
+    target.write_text(yaml.safe_dump(charter.to_yaml_dict(),
+                                      sort_keys=False, default_flow_style=False))
+    return target
+
+
+def list_cadences(omega_home: str | Path | None = None) -> list[dict[str, Any]]:
+    """Return one summary dict per scheduled cadence on disk."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous"
+    out: list[dict[str, Any]] = []
+    if not target.is_dir():
+        return out
+    for path in sorted(target.glob("cadence-*.yaml")):
+        try:
+            data = yaml.safe_load(path.read_text()) or {}
+        except yaml.YAMLError:
+            continue
+        out.append({
+            "id": data.get("id", path.stem),
+            "enabled": bool(data.get("enabled", True)),
+            "trigger": data.get("trigger") or {},
+            "intent": ((data.get("spec") or {}).get("intent")
+                       or data.get("description") or ""),
+            "path": str(path),
+        })
+    return out
+
+
+def disable_cadence(charter_id: str, *,
+                    omega_home: str | Path | None = None) -> bool:
+    """Set ``enabled: false`` on a cadence charter. Returns True if changed."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous" / f"{charter_id}.yaml"
+    if not target.exists():
+        return False
+    data = yaml.safe_load(target.read_text()) or {}
+    if not data.get("enabled", True):
+        return False
+    data["enabled"] = False
+    target.write_text(yaml.safe_dump(data, sort_keys=False,
+                                      default_flow_style=False))
+    return True
+
+
+def remove_cadence(charter_id: str, *,
+                   omega_home: str | Path | None = None) -> bool:
+    """Delete a cadence charter. Returns True if it existed."""
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    target = home / "Agentik_Orchestration" / "autonomous" / f"{charter_id}.yaml"
+    if not target.exists():
+        return False
+    target.unlink()
+    return True

package/omega/Agentik_Engine/omega_engine/classifier.py

@@ -0,0 +1,215 @@
+"""Task-complexity classifier — picks the right model for the job.
+
+The current router sends every task to one provider with one model. That
+wastes money on a tiny refactor (Sonnet/Opus when Haiku would do) and
+risks quality on a hard architectural task (Haiku when we needed Opus).
+
+This module classifies a task description into one of three buckets:
+
+  * ``simple``    — tiny change, formatting, rename, one-line fix
+  * ``moderate``  — implement a feature, fix a bug with context
+  * ``complex``   — design, architecture, multi-file refactor, security
+
+The classifier is a heuristic-first ladder:
+
+  1. **Hard signals** — keywords + length + file count. Returns
+     immediately when confident.
+  2. **Soft signals** — accumulates a score, picks the bucket above a
+     threshold.
+  3. **Optional LLM refinement** — when ``llm_router`` is provided and
+     the heuristic is uncertain, ask a Haiku call to decide. ~1 token
+     of cost; mostly free because Haiku is cheap.
+
+Returns ``(bucket, confidence, reason)`` so the router can log WHY a
+model was chosen — important for cost transparency.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+BUCKETS = ("simple", "moderate", "complex")
+
+
+@dataclass
+class Classification:
+    bucket: str               # "simple" | "moderate" | "complex"
+    confidence: str            # "low" | "medium" | "high"
+    reason: str
+    suggested_model: str       # e.g. "haiku" | "sonnet" | "opus"
+
+
+# Keywords. Order matters — complex wins ties.
+_COMPLEX_KEYWORDS = {
+    "architecture", "redesign", "refactor", "migration", "audit",
+    "security", "performance", "concurrency", "race condition",
+    "investigate", "analyze", "diagnose", "debug deep",
+    "build a", "design a", "implement a system",
+}
+_MODERATE_KEYWORDS = {
+    "implement", "build", "add a feature", "fix the bug",
+    "add support for", "wire up", "integrate", "extract",
+}
+_SIMPLE_KEYWORDS = {
+    "rename", "format", "lint", "fix typo", "fix a typo",
+    "update the readme", "add a comment", "change the message",
+    "bump version", "one-line", "remove unused",
+}
+
+# File-count signals (extracted from typical intents like "all 12 files")
+_FILE_COUNT_RE = re.compile(r"(\d+)\s+(?:file|tests?)", re.IGNORECASE)
+
+
+def _has_any(text: str, keywords: set[str]) -> bool:
+    t = text.lower()
+    return any(k in t for k in keywords)
+
+
+def _score(text: str) -> tuple[int, int, int]:
+    """Return (simple_score, moderate_score, complex_score)."""
+    t = text.lower()
+    s = sum(1 for k in _SIMPLE_KEYWORDS if k in t)
+    m = sum(1 for k in _MODERATE_KEYWORDS if k in t)
+    c = sum(1 for k in _COMPLEX_KEYWORDS if k in t)
+    return s, m, c
+
+
+def _suggest_model(bucket: str) -> str:
+    return {"simple": "haiku", "moderate": "sonnet", "complex": "opus"}.get(
+        bucket, "sonnet",
+    )
+
+
+def classify(
+    task_description: str,
+    *,
+    role: str = "worker",
+    llm_router=None,
+) -> Classification:
+    """Pick the right complexity bucket + model for a task.
+
+    Heuristic chain:
+
+      a) Always-complex roles (architect, oracle planning) get bumped up.
+      b) Hard signal: explicit complex keyword present → complex.
+      c) Hard signal: explicit simple keyword present + short text → simple.
+      d) Length-based fallback: long descriptions are usually complex.
+      e) When still uncertain AND llm_router is provided, ask a Haiku
+         classification call.
+    """
+    text = (task_description or "").strip()
+    if not text:
+        return Classification(
+            "simple", "high",
+            "empty task → trivially simple", _suggest_model("simple"),
+        )
+
+    # (a) Role-driven floor
+    if role in ("architect", "smith"):
+        # Architecture + reflection always need depth
+        return Classification(
+            "complex", "high",
+            f"role={role!r} → architecture/reflection task",
+            _suggest_model("complex"),
+        )
+    if role in ("oracle", "manager", "aisb"):
+        # Planning roles need solid reasoning but not always Opus
+        return Classification(
+            "moderate", "medium",
+            f"role={role!r} → dispatcher; sonnet is the sweet spot",
+            _suggest_model("moderate"),
+        )
+
+    # (b) Hard complex signals
+    s_score, m_score, c_score = _score(text)
+    if c_score >= 2 or (c_score >= 1 and len(text) > 400):
+        return Classification(
+            "complex", "high",
+            f"{c_score} complex keyword(s) + length={len(text)}",
+            _suggest_model("complex"),
+        )
+
+    # File-count signal
+    fc = _FILE_COUNT_RE.search(text)
+    if fc and int(fc.group(1)) >= 5:
+        return Classification(
+            "complex", "high",
+            f"task mentions {fc.group(1)}+ files",
+            _suggest_model("complex"),
+        )
+
+    # (c) Hard simple signals
+    if s_score >= 1 and len(text) < 250 and c_score == 0:
+        return Classification(
+            "simple", "high",
+            f"{s_score} simple keyword(s), short text",
+            _suggest_model("simple"),
+        )
+
+    # (d) Moderate keyword wins over a short-text "simple" guess —
+    # "implement X" is moderate even when phrased tersely.
+    word_count = len(text.split())
+    if m_score > 0:
+        return Classification(
+            "moderate", "medium" if m_score >= 2 else "low",
+            f"{m_score} moderate keyword(s)",
+            _suggest_model("moderate"),
+        )
+
+    # (e) Length-based fallback
+    if word_count > 80:
+        return Classification(
+            "complex", "medium",
+            f"long description ({word_count} words)",
+            _suggest_model("complex"),
+        )
+    if word_count < 12:
+        return Classification(
+            "simple", "medium",
+            f"short description ({word_count} words)",
+            _suggest_model("simple"),
+        )
+
+    # (f) Uncertain — moderate by default, or ask Haiku to break the tie
+    if llm_router is not None:
+        try:
+            return _llm_refine(text, llm_router)
+        except Exception:  # noqa: BLE001
+            pass
+
+    return Classification(
+        "moderate", "low",
+        f"no strong signal ({word_count} words, scores={s_score}/{m_score}/{c_score})",
+        _suggest_model("moderate"),
+    )
+
+
+def _llm_refine(text: str, router) -> Classification:
+    """Last-resort Haiku call for ambiguous cases. ~1 token cost."""
+    from omega_engine.provider import AgentRequest
+    prompt = (
+        "Classify this task into one of: simple, moderate, complex.\n"
+        "  simple   = trivial change, no design decisions\n"
+        "  moderate = implement/fix with context, single domain\n"
+        "  complex  = architecture, security, cross-cutting, multi-file\n\n"
+        f"TASK: {text[:1500]}\n\n"
+        "Reply with EXACTLY one word: simple, moderate, or complex."
+    )
+    provider = router.resolve("classifier")
+    result = provider.run(AgentRequest(
+        role="classifier", prompt=prompt,
+        context={"classifier": True},
+    ))
+    raw = (result.text or "").strip().lower().split()
+    bucket = "moderate"
+    for w in raw:
+        if w in BUCKETS:
+            bucket = w
+            break
+    return Classification(
+        bucket, "high",
+        "LLM-refined (Haiku 1-token call)",
+        _suggest_model(bucket),
+    )