@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/omega_engine/prompts.py

@@ -0,0 +1,158 @@
+"""Agent prompt loader — the bridge between SSOT and the provider.
+
+Every role in the engine (oracle, worker, architect, keymaker, …) has a
+fully-written system prompt living in ``Agentik_SSOT/agents/<suite>/<role>.md``.
+This module locates the file, strips any YAML frontmatter, and returns the
+prompt text for the provider to inject as the ``system`` message.
+
+The AISB suite — 13 named agents + the LMC protocol + per-agent checkers —
+is shipped by the installer from ``bootstrap/templates/aisb/``. New suites
+drop into ``Agentik_SSOT/agents/<name>/`` and are picked up by id.
+
+Resolution order for a role:
+  1. ``Agentik_SSOT/agents/aisb/<role>.md``  (the AISB suite)
+  2. ``Agentik_SSOT/agents/<any-suite>/<role>.md`` (any other suite)
+  3. None — the provider falls back to a minimal generic envelope.
+
+The LMC protocol + shared protocols are concatenated into every agent's
+system prompt so they always know the contract.
+"""
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from pathlib import Path
+
+
+_FRONTMATTER_RE = re.compile(r"^---\s*\n.*?\n---\s*\n", re.DOTALL)
+
+
+def _strip_frontmatter(text: str) -> str:
+    """Drop the leading YAML frontmatter block if present."""
+    match = _FRONTMATTER_RE.match(text)
+    return text[match.end():] if match else text
+
+
+def _agents_root(omega_home: Path) -> Path:
+    return Path(omega_home) / "Agentik_SSOT" / "agents"
+
+
+# Topology-name → AISB-suite-name aliases.
+# The orchestration topology YAMLs use generic role names (`aisb`, `oracle`,
+# `manager`, `worker`, `audit`) but the AISB suite ships its own canonical
+# names (`niobe`, `oracle`, `keymaker`, `construct`, `seraph`). Without
+# this map, ``load_agent_prompt("worker")`` returns None and the worker
+# spawns with the engine's generic fallback envelope — losing the rich
+# identity Gareth's home system relies on.
+#
+# Direction is topology → suite. Add entries here when a topology introduces
+# a new role name that maps to an existing suite agent.
+_ROLE_ALIASES: dict[str, str] = {
+    "aisb":     "niobe",       # the matriarch / root scope
+    "manager":  "keymaker",    # the planner
+    "worker":   "construct",   # the executor
+    "audit":    "seraph",      # the verifier
+    "verifier": "seraph",      # synonym used by some topologies
+    "link":     "link",        # already canonical
+}
+
+
+@lru_cache(maxsize=64)
+def _read_agent_file(path: str) -> str | None:
+    p = Path(path)
+    if not p.exists():
+        return None
+    try:
+        return _strip_frontmatter(p.read_text()).strip()
+    except OSError:
+        return None
+
+
+def find_agent_file(omega_home: str | Path, role: str) -> Path | None:
+    """Return the on-disk path for a role's agent prompt, or None.
+
+    Resolution order:
+      1. Direct match on the role name in the AISB suite.
+      2. Alias-mapped name (e.g. ``worker`` → ``construct``).
+      3. Direct match in any other suite.
+      4. Alias-mapped match in any other suite.
+    """
+    root = _agents_root(Path(omega_home))
+    if not root.is_dir():
+        return None
+
+    candidates_for_role: list[str] = [role]
+    aliased = _ROLE_ALIASES.get(role)
+    if aliased and aliased != role:
+        candidates_for_role.append(aliased)
+
+    # 1+2. AISB suite first (the master), with alias fallback.
+    aisb_dir = root / "aisb"
+    if aisb_dir.is_dir():
+        for cand in candidates_for_role:
+            p = aisb_dir / f"{cand}.md"
+            if p.exists():
+                return p
+
+    # 3+4. Any other suite that names a file after the role (or its alias).
+    for suite in sorted(root.iterdir()):
+        if not suite.is_dir() or suite.name == "aisb":
+            continue
+        for cand in candidates_for_role:
+            p = suite / f"{cand}.md"
+            if p.exists():
+                return p
+    return None
+
+
+def load_agent_prompt(omega_home: str | Path, role: str) -> str | None:
+    """Return the agent's full system prompt, or None if not shipped.
+
+    Includes the LMC + shared protocols when found, so every loaded agent
+    knows the contract without us repeating it in every file.
+    """
+    path = find_agent_file(omega_home, role)
+    if path is None:
+        return None
+    text = _read_agent_file(str(path))
+    if text is None:
+        return None
+
+    # Append any protocol files that live next to the agent.
+    suite_dir = path.parent
+    extras: list[str] = []
+    for proto in ("lmc-protocol.md",):
+        proto_path = suite_dir / proto
+        body = _read_agent_file(str(proto_path))
+        if body:
+            extras.append(f"\n\n--- PROTOCOL: {proto} ---\n\n{body}")
+    shared = suite_dir / "protocols" / "shared-protocol.md"
+    body = _read_agent_file(str(shared))
+    if body:
+        extras.append(f"\n\n--- SHARED PROTOCOL ---\n\n{body}")
+    return text + "".join(extras)
+
+
+def list_available_agents(omega_home: str | Path) -> dict[str, list[str]]:
+    """Return ``{suite: [roles]}`` for every agent file shipped under
+    Agentik_SSOT/agents/."""
+    root = _agents_root(Path(omega_home))
+    out: dict[str, list[str]] = {}
+    if not root.is_dir():
+        return out
+    for suite in sorted(root.iterdir()):
+        if not suite.is_dir():
+            continue
+        roles = sorted(
+            p.stem for p in suite.glob("*.md")
+            if not p.stem.startswith(("checker-", "lmc-", "handoff-",
+                                       "shared-", "CLAUDE"))
+        )
+        if roles:
+            out[suite.name] = roles
+    return out
+
+
+def clear_cache() -> None:
+    """Drop the prompt-file cache. Useful in tests and after re-installs."""
+    _read_agent_file.cache_clear()

package/omega/Agentik_Engine/omega_engine/provider.py

@@ -22,8 +22,10 @@ from typing import Any, Protocol, runtime_checkable
 @dataclass
 class AgentRequest:
     role: str                                   # "aisb" | "oracle" | "worker" | ...
-    prompt: str
+    prompt: str                                 # the user-facing message
     context: dict[str, Any] = field(default_factory=dict)
+    system: str | None = None                   # the role-aware system prompt
+                                                # (built by omega_engine.envelope)
 
 
 @dataclass
@@ -44,6 +46,144 @@ class AgentProvider(Protocol):
     def run(self, req: AgentRequest) -> AgentResult: ...
 
 
+class ClaudeMaxProvider:
+    """The Claude Code Max subprocess provider — uses the operator's OAuth,
+    NOT an API key.
+
+    Spawns ``claude -p "<prompt>" --output-format json --model <model>`` and
+    parses the structured response. Authentication is whatever the
+    operator did via ``claude /login`` — no ANTHROPIC_API_KEY needed.
+    Token usage AND a real ``total_cost_usd`` are returned directly by
+    the Claude Code CLI (calculated against Max account billing).
+
+    System prompts go via ``--append-system-prompt`` so the envelope's
+    rich role-aware prompt still drives the agent.
+
+    Sessions: when ``session_id`` is set on the request context, we use
+    ``--resume <session-id>`` so multi-turn conversations work. The CLI's
+    own session-id is returned in the result and propagated back as
+    ``result.artifacts["session_id"]``.
+
+    Use this on any machine where ``claude`` CLI is installed and the
+    operator is logged in (verified via ``claude --version``).
+    """
+
+    id = "claude-max"
+
+    def __init__(
+        self,
+        model: str = "sonnet",
+        timeout_s: int = 600,
+        bin_path: str = "claude",
+    ) -> None:
+        self._model = model
+        self._timeout_s = timeout_s
+        self._bin = bin_path
+
+    def _model_for(self, role: str) -> str:
+        """Resolve the model for a role — explicit > role default > self."""
+        # Allow the request itself to override via context.model
+        try:
+            from omega_engine.worker import default_model_for_role
+            role_model = default_model_for_role(role)
+        except ImportError:
+            role_model = self._model
+        return role_model
+
+    @staticmethod
+    def is_available(bin_path: str = "claude") -> bool:
+        """True iff `claude` CLI is on PATH and answers --version."""
+        import shutil
+        if shutil.which(bin_path) is None:
+            return False
+        try:
+            import subprocess
+            proc = subprocess.run(
+                [bin_path, "--version"],
+                check=False, capture_output=True, text=True, timeout=15,
+            )
+            return proc.returncode == 0
+        except (OSError, subprocess.SubprocessError):
+            return False
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        import subprocess
+        # Per-request model: explicit context.model > role default > self default
+        model = (req.context or {}).get("model") or self._model_for(req.role)
+        cmd = [
+            self._bin, "-p", req.prompt,
+            "--output-format", "json",
+            "--model", model,
+            # bypass tool-permission dialogs in headless mode — operator
+            # already set the default permission mode via settings.json
+            "--dangerously-skip-permissions",
+        ]
+        # The envelope's `system` becomes an --append-system-prompt so the
+        # default Claude Code system prompt + our role-specific identity +
+        # contract all merge.
+        if req.system:
+            cmd += ["--append-system-prompt", req.system]
+        # If the caller passes a session_id in the context, resume that
+        # session — turns the provider into a stateful conversation.
+        sid = (req.context or {}).get("session_id")
+        if sid:
+            cmd += ["--resume", str(sid)]
+
+        try:
+            proc = subprocess.run(
+                cmd, check=False, capture_output=True, text=True,
+                timeout=self._timeout_s,
+            )
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(
+                f"claude -p timed out after {self._timeout_s}s"
+            )
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"claude -p exit {proc.returncode}: "
+                f"{(proc.stderr or proc.stdout or '').strip()[:500]}"
+            )
+
+        raw_text = (proc.stdout or "").strip()
+        try:
+            data = json.loads(raw_text)
+        except json.JSONDecodeError:
+            raise RuntimeError(
+                f"claude -p returned non-JSON: {raw_text[:200]}"
+            )
+
+        text = str(data.get("result", ""))
+        usage_in = data.get("usage", {}) or {}
+        artifacts: dict[str, Any] = {
+            "session_id": data.get("session_id", ""),
+            "stop_reason": data.get("stop_reason", ""),
+            "num_turns": int(data.get("num_turns", 0) or 0),
+            "duration_ms": int(data.get("duration_ms", 0) or 0),
+            "total_cost_usd": float(data.get("total_cost_usd", 0.0) or 0.0),
+        }
+        # Dispatcher roles still need to surface a plan when they
+        # produced one. Try a JSON parse of the text body.
+        plan = (
+            _extract_plan(text)
+            if req.role in ("aisb", "oracle", "manager") else []
+        )
+        return AgentResult(
+            text=text, claimed_done=True, plan=plan, artifacts=artifacts,
+            usage={
+                "input_tokens": int(usage_in.get("input_tokens", 0) or 0),
+                "output_tokens": int(usage_in.get("output_tokens", 0) or 0),
+                "cache_read_input_tokens": int(
+                    usage_in.get("cache_read_input_tokens", 0) or 0
+                ),
+                "cache_creation_input_tokens": int(
+                    usage_in.get("cache_creation_input_tokens", 0) or 0
+                ),
+                # Real Max cost — calculated by Claude Code itself.
+                "cost_usd": float(data.get("total_cost_usd", 0.0) or 0.0),
+            },
+        )
+
+
 class MockProvider:
     """Deterministic provider — makes the executor fully testable with no API.
 
@@ -173,17 +313,26 @@ class ClaudeProvider:
             ) from exc
 
         client = anthropic.Anthropic(api_key=self._api_key)  # reads env if None
-        prompt = req.prompt
-        if req.role in ("oracle", "manager", "aisb"):
-            prompt += (
-                "\n\nRespond with a JSON array of subtasks, each "
-                '{"role":"worker","spec":{"task":"..."}}. JSON only.'
-            )
-        msg = client.messages.create(
-            model=self._model,
-            max_tokens=4096,
-            messages=[{"role": "user", "content": prompt}],
-        )
+        # Envelope path: when the executor passes an explicit `system`, use it
+        # verbatim and send the user prompt as-is. Otherwise fall back to the
+        # legacy single-message form so old callers keep working.
+        kwargs: dict[str, Any] = {
+            "model": self._model,
+            "max_tokens": 4096,
+            "messages": [{"role": "user", "content": req.prompt}],
+        }
+        if req.system:
+            kwargs["system"] = req.system
+        elif req.role in ("oracle", "manager", "aisb"):
+            # Legacy minimal dispatcher hint, only when no envelope was built.
+            kwargs["messages"] = [{
+                "role": "user",
+                "content": req.prompt + (
+                    "\n\nRespond with a JSON array of subtasks, each "
+                    '{"role":"worker","spec":{"task":"..."}}. JSON only.'
+                ),
+            }]
+        msg = client.messages.create(**kwargs)
         text = "".join(
             b.text for b in msg.content if getattr(b, "type", "") == "text"
         )

package/omega/Agentik_Engine/omega_engine/prune.py

@@ -0,0 +1,151 @@
+"""`omega prune` — bound the growth of runtime SQLite stores.
+
+Three stores grow forever today:
+
+  * ``Agentik_Runtime/eventlog/omega.db``  (mission events)
+  * ``Agentik_Runtime/audits.db``           (forensic-audit history)
+  * ``Agentik_Runtime/telegram-history.db`` (per-topic chat history)
+
+Plus the per-task ``Agentik_Runtime/sessions/<task_id>/`` directories.
+
+This module is the bounded-growth control. Every operation has:
+  * A ``dry_run`` mode that reports what WOULD be deleted (default
+    behaviour from the CLI is dry-run; ``--yes`` enacts).
+  * An explicit "older than" cutoff (no implicit "keep last N").
+  * Per-DB transaction so a crash mid-prune leaves the DB consistent.
+
+Tests cover both modes: a dry-run never mutates, and a real prune drops
+exactly the rows we promised.
+"""
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class PruneReport:
+    target: str
+    rows_deleted: int = 0
+    files_deleted: int = 0
+    bytes_freed: int = 0
+    dry_run: bool = False
+    detail: str = ""
+
+
+def _prune_table(
+    db_path: Path, table: str, cutoff_seconds: int,
+    *, time_column: str = "timestamp", dry_run: bool = False,
+) -> int:
+    """Delete rows older than `cutoff_seconds` from `table`. Returns rowcount."""
+    if not db_path.exists():
+        return 0
+    cutoff = int(time.time()) - cutoff_seconds
+    conn = sqlite3.connect(str(db_path))
+    try:
+        if dry_run:
+            cur = conn.execute(
+                f"SELECT COUNT(*) FROM {table} WHERE {time_column} < ?",
+                (cutoff,),
+            )
+            return int(cur.fetchone()[0])
+        cur = conn.execute(
+            f"DELETE FROM {table} WHERE {time_column} < ?",
+            (cutoff,),
+        )
+        conn.commit()
+        return cur.rowcount or 0
+    except sqlite3.OperationalError:
+        # Table missing — nothing to prune.
+        return 0
+    finally:
+        conn.close()
+
+
+def prune_events(
+    omega_home: str | Path, *, older_than_days: int, dry_run: bool = False,
+) -> PruneReport:
+    """Drop mission events older than `older_than_days`."""
+    home = Path(omega_home)
+    db = home / "Agentik_Runtime" / "eventlog" / "omega.db"
+    n = _prune_table(db, "events", older_than_days * 86400,
+                     time_column="ts", dry_run=dry_run)
+    return PruneReport(
+        target="events", rows_deleted=n, dry_run=dry_run,
+        detail=f"older_than={older_than_days}d",
+    )
+
+
+def prune_audits(
+    omega_home: str | Path, *, older_than_days: int, dry_run: bool = False,
+) -> PruneReport:
+    home = Path(omega_home)
+    db = home / "Agentik_Runtime" / "audits.db"
+    n = _prune_table(db, "audit_runs", older_than_days * 86400,
+                     time_column="timestamp", dry_run=dry_run)
+    return PruneReport(
+        target="audits", rows_deleted=n, dry_run=dry_run,
+        detail=f"older_than={older_than_days}d",
+    )
+
+
+def prune_telegram(
+    omega_home: str | Path, *, older_than_days: int, dry_run: bool = False,
+) -> PruneReport:
+    home = Path(omega_home)
+    db = home / "Agentik_Runtime" / "telegram-history.db"
+    n = _prune_table(db, "messages", older_than_days * 86400,
+                     time_column="timestamp", dry_run=dry_run)
+    return PruneReport(
+        target="telegram", rows_deleted=n, dry_run=dry_run,
+        detail=f"older_than={older_than_days}d",
+    )
+
+
+def prune_sessions(
+    omega_home: str | Path, *, older_than_days: int, dry_run: bool = False,
+) -> PruneReport:
+    """Remove per-task session dirs whose newest file is older than the cutoff."""
+    home = Path(omega_home)
+    sess_root = home / "Agentik_Runtime" / "sessions"
+    if not sess_root.is_dir():
+        return PruneReport(target="sessions", dry_run=dry_run)
+    cutoff = time.time() - older_than_days * 86400
+    n = 0
+    bytes_freed = 0
+    for child in sess_root.iterdir():
+        if not child.is_dir():
+            continue
+        # newest file mtime under this dir
+        newest = max(
+            (p.stat().st_mtime for p in child.rglob("*") if p.is_file()),
+            default=child.stat().st_mtime,
+        )
+        if newest >= cutoff:
+            continue
+        # measure size before delete (for dry-run)
+        sz = sum(p.stat().st_size for p in child.rglob("*") if p.is_file())
+        if not dry_run:
+            shutil.rmtree(child, ignore_errors=True)
+        n += 1
+        bytes_freed += sz
+    return PruneReport(
+        target="sessions", files_deleted=n, bytes_freed=bytes_freed,
+        dry_run=dry_run, detail=f"older_than={older_than_days}d",
+    )
+
+
+def prune_all(
+    omega_home: str | Path, *, older_than_days: int = 90,
+    dry_run: bool = False,
+) -> list[PruneReport]:
+    """One call to prune everything to the same cutoff."""
+    return [
+        prune_events(omega_home, older_than_days=older_than_days, dry_run=dry_run),
+        prune_audits(omega_home, older_than_days=older_than_days, dry_run=dry_run),
+        prune_telegram(omega_home, older_than_days=older_than_days, dry_run=dry_run),
+        prune_sessions(omega_home, older_than_days=older_than_days, dry_run=dry_run),
+    ]